modern-pdf-lib 0.35.0 → 0.37.0

package/dist/{src-BlUlmYsU.mjs → src-DGxzt-jG.mjs}

@@ -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 PdfDict();
+	dict.set("/ShadingType", PdfNumber.of(shadingType));
+	dict.set("/ColorSpace", common.colorSpace);
+	dict.set("/BitsPerCoordinate", PdfNumber.of(common.bitsPerCoordinate));
+	dict.set("/BitsPerComponent", PdfNumber.of(common.bitsPerComponent));
+	if (includeFlag) dict.set("/BitsPerFlag", PdfNumber.of(common.bitsPerFlag));
+	dict.set("/Decode", 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 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", 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 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 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 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() {
@@ -32943,6 +35213,6 @@ async function initWasm(options) {
 	wasmInitialized = true;
 }
 //#endregion
-export { inspectEncryption as $, PdfStampAnnotation as $a, createAssociatedFile as $i, extractTables as $n, professionalPreset as $r, signDeferred as $t, buildSoftMaskNone as A, addFieldLock as Aa, canDirectEmbed as Ai, evaluateFunction as An, MissingOnValueCheckError as Ar, TrustStore as At, redactRegions as B, findExistingSignatures as Ba, injectJpegMetadata as Bi, labToRgb as Bn, replaceTemplateVariables as Br, addVisibilityAction as Bt, tagTableHeaderCell as C, optimizeIncrementalSave as Ca, computeCode39CheckDigit as Ci, STANDARD_SPOT_FUNCTIONS as Cn, parseXmpMetadata$1 as Co, FieldAlreadyExistsError as Cr, summarizeBitDepth as Ct, buildImageSoftMask as D, addCounterSignature as Da, encodeCode128Values as Di, buildType5Halftone as Dn, ChangeTracker as Do, InvalidColorError as Dr, decodeTileRegion as Dt, buildColorKeyMask as E, hasLtvData as Ea, encodeCode128 as Ei, buildType1Halftone as En, buildSeparationColorSpace as Eo, ForeignPageError as Er, decodeTile as Et, attachAssociatedFiles as F, buildDocMdpReference as Fa, webpToPng as Fi, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as Fn, StreamingParseError as Fr, extractOcspUrl as Ft, extractImages as G, parseTimestampResponse as Ga, recompressImage as Gi, MATHML_NAMESPACE as Gn, estimateTextWidth as Gr, formatDate as Gt, compareImages as H, saveIncrementalWithSignaturePreservation as Ha, downscaleImage as Hi, SARIF_SCHEMA_URI as Hn, toRoman as Hr, validateFieldValue as Ht, registerEmbeddedFile as I, getCertificationLevel as Ia, convertTiffCmykToRgb as Ii, buildDocTimeStampDict as In, UnexpectedFieldTypeError as Ir, createSandbox as It, renderPageToCanvas as J, PdfFileAttachmentAnnotation as Ja, generatePdfAXmp as Ji, buildNamespacesArray as Jn, wrapText$2 as Jr, formatNumber$1 as Jt, generateThumbnail as K, requestTimestamp as Ka, applyRedaction as Ki, PDF2_NAMESPACE as Kn, shrinkFontSize as Kr, parseAcrobatDate as Kt, RenderCache as L, setCertificationLevel as La, embedTiffCmyk as Li, buildCalGray as Ln, applyHeaderFooter as Lr, getFieldValue as Lt, buildUnencryptedWrapper as M, getFieldLocks as Ma, encodePngFromPixels as Mi, buildCollection as Mn, PluginError as Mr, extractCrlUrls as Mt, attachOutputIntents as N, detectModifications as Na, recompressWebP as Ni, reconstructLines as Nn, RemovePageFromEmptyDocumentError as Nr, isCertificateRevoked as Nt, buildStencilMask as O, getCounterSignatures as Oa, valuesToModules as Oi, identityTransferFunction as On, saveDocumentIncremental as Oo, InvalidFieldNamePartError as Or, parseTileInfo as Ot, buildPageOutputIntent as P, MdpPermission as Pa, webpToJpeg as Pi, reconstructParagraphs as Pn, RichTextFieldReadError as Pr, checkCertificateStatus as Pt, interpretPage as Q, PdfInkAnnotation as Qa, buildAfArray as Qi, buildDPartRoot as Qn, minimalPreset as Qr, readWoffHeader as Qt, computeTileGrid as R, validateSignatureChain as Ra, isCmykTiff as Ri, buildCalRGB as Rn, applyHeaderFooterToPage as Rr, resolveFieldReference as Rt, tagTableDataCell as S, findChangedObjects as Sa, code39ToOperators as Si, validateBoxGeometry as Sn, createXmpStream as So, ExceededMaxLengthError as Sr, offsetSignedToUnsigned as St, buildBlackPointCompensationExtGState as T, embedLtvData as Ta, code128ToOperators as Ti, buildThresholdHalftone as Tn, buildDeviceNColorSpace as To, FontNotEmbeddedError as Tr, assembleTiles as Tt, comparePages as U, validateByteRangeIntegrity as Ua, estimateJpegQuality as Ui, toJsonReport as Un, applyOverflow as Ur, AFSpecial_Format as Ut, applyOcr as V, parseExistingTrailer as Va, analyzeJpegMarkers as Vi, DEFAULT_SARIF_TOOL_NAME as Vn, toAlpha as Vr, setFieldVisibility as Vt, extractFonts as W, buildTimestampRequest as Wa, optimizeImage as Wi, toSarif as Wn, ellipsisText as Wr, AFDate_FormatEx as Wt, renderPageToImage as X, PdfPopupAnnotation as Xa, countOccurrences as Xi, buildRequirement as Xn, applyTablePreset as Xr, isWoff as Xt, rasterize as Y, PdfCaretAnnotation as Ya, generatePdfAXmpBytes as Yi, buildPieceInfo as Yn, applyPreset as Yr, decodeWoff as Yt, interpretContentStream as Z, PdfRedactAnnotation as Za, stripProhibitedFeatures as Zi, buildRequirements as Zn, borderedPreset as Zr, isWoff2 as Zt, tagLink as _, delinearizePdf as _a, ean8ToOperators as _i, renderCodeFrame as _n, generateStrikeOutAppearance as _o, flattenFields as _r, enforcePdfX as _t, assembleFacturX as a, isValidLevel as aa, readEan8 as ai, renderToPdf as an, PdfHighlightAnnotation as ao, StreamingPdfParser as ar, verifyOfflineRevocation as at, tagParagraph as b, linearizePdf as ba, encodeItf as bi, buildGtsPdfxVersion as bn, PdfTextAnnotation as bo, CombedTextLayoutError as br, getComponentDepths as bt, buildWtpdfIdentificationXmp as c, generateZapfDingbatsToUnicodeCmap as ca, encodePdf417 as ci, splitByScript as cn, PdfUnderlineAnnotation as co, validatePdfUa as cr, validateExtendedKeyUsage as ct, autoTagPage as d, SRGB_ICC_PROFILE as da, encodeDataMatrix as di, buildPdfA4Xmp as dn, generateFreeTextAppearance as do, processBatch as dr, validateCertificateChain as dt, extractXmpMetadata as ea, stripedPreset as ei, createWorkerPool as en, PdfCircleAnnotation as eo, tableToCsv as er, verifyRedactions as et, buildPdfUa2Xmp as f, generateSrgbIccProfile as fa, calculateUpcCheckDigit as fi, pdfA4Rules as fn, generateHighlightAppearance as fo, addBookmark as fr, findHyphenationPoints as ft, tagHeading as g, validatePdfA as ga, ean13ToOperators as gi, levenshtein as gn, generateSquigglyAppearance as go, flattenField as gr, buildPdfXOutputIntent as gt, tagFigure as h, enforcePdfA as ha, calculateEanCheckDigit as hi, didYouMean as hn, generateSquareAppearance as ho, removeBookmark as hr, layoutTextFlow as ht, validateEn16931 as i, getSupportedLevels as ia, readEan13 as ii, h as in, PdfSquareAnnotation as io, timestampPlugin as ir, extractEmbeddedRevocationData as it, buildEncryptedPayload as j, buildFieldLockDict as ja, embedTiffDirect as ji, markdownToPdf as jn, NoSuchFieldError as jr, downloadCrl as jt, buildSoftMaskGroupExtGState as k, diffSignedContent as ka, PdfWorker as ki, nameHalftone as kn, saveIncremental as ko, InvalidPageSizeError as kr, verifySignatureDetailed as kt, convertPdfAConformanceXmp as l, getToUnicodeCmap as la, pdf417ToOperators as li, generateOrderX as ln, PdfFreeTextAnnotation as lo, batchFlatten as lr, validateKeyUsage as lt, LIST_NUMBERING_KEY as m, flattenTransparency as ma, upcAToOperators as mi, sampleShadingColor as mn, generateLineAppearance as mo, removeAllBookmarks as mr, layoutParagraph as mt, detectFacturXProfile as n, validateXmpMetadata as na, readCode128 as ni, buildVtDpm as nn, PdfPolyLineAnnotation as no, accessibilityPlugin as nr, scanPdfThreats as nt, buildFacturXXmp as o, generateSymbolToUnicodeCmap as oa, calculateBarcodeDimensions as oi, createRangeFetcher as on, PdfSquigglyAnnotation as oo, PdfDocumentBuilder as or, EKU_OIDS as ot, validatePdfUa2 as p, detectTransparency as pa, encodeUpcA as pi, buildFunctionShading as pn, generateInkAppearance as po, getBookmarks as pr, layoutColumns as pt, renderDisplayListToCanvas as q, searchTextItems as qa, enforcePdfAFull as qi, buildNamespace as qn, truncateText as qr, AFNumber_Format as qt, parseCiiXml as r, getProfile as ra, readCode39 as ri, gtsPdfVtVersion as rn, PdfPolygonAnnotation as ro, metadataPlugin as rr, buildCertPath as rt, buildPdfRIdentificationXmp as s, generateWinAnsiToUnicodeCmap as sa, renderStyledBarcode as si, resolveFallback as sn, PdfStrikeOutAnnotation as so, enforcePdfUa as sr, validateCertificatePolicy as st, initWasm as t, parseXmpMetadata as ta, readBarcode as ti, buildPdfVtDParts as tn, PdfLineAnnotation as to, tableToJson as tr, sanitizePdf as tt, preflightPdfA as u, buildOutputIntent as ua, dataMatrixToOperators as ui, generateXRechnungCii as un, generateCircleAppearance as uo, batchMerge as ur, buildCertificateChain as ut, tagList as v, getLinearizationInfo as va, encodeEan13 as vi, generateCiiXml as vn, generateUnderlineAppearance as vo, flattenForm as vr, validatePdfX as vt, tagTableRow as w, buildDssDictionary as wa, encodeCode39 as wi, buildSampledTransferFunction as wn, PDFOperator as wo, FieldExistsAsNonTerminalError as wr, upscale8To16 as wt, tagTable as x, computeObjectHash as xa, itfToOperators as xi, buildPdfX6OutputIntent as xn, buildXmpMetadata as xo, EncryptedPdfError as xr, normalizeComponentDepth as xt, tagListItem as y, isLinearized as ya, encodeEan8 as yi, buildBoxDict as yn, PdfLinkAnnotation as yo, BatchProcessingError as yr, downscale16To8 as yt, renderPageTile as z, appendIncrementalUpdate as za, extractJpegMetadata as zi, buildLab as zn, formatDate$1 as zr, setFieldValue as zt };
+export { hslToRgb as $, getFieldLocks as $a, encodePngFromPixels as $i, buildCollection as $n, PluginError as $r, extractCrlUrls as $t, buildSoftMaskNone as A, getToUnicodeCmap as Aa, pdf417ToOperators as Ai, generateOrderX as An, PdfFreeTextAnnotation as Ao, batchFlatten as Ar, validateKeyUsage as At, redactRegions as B, isLinearized as Ba, encodeEan8 as Bi, buildBoxDict as Bn, PdfLinkAnnotation as Bo, BatchProcessingError as Br, downscale16To8 as Bt, tagTableHeaderCell as C, validateXmpMetadata as Ca, readCode128 as Ci, buildVtDpm as Cn, PdfPolyLineAnnotation as Co, accessibilityPlugin as Cr, scanPdfThreats as Ct, buildImageSoftMask as D, generateSymbolToUnicodeCmap as Da, calculateBarcodeDimensions as Di, createRangeFetcher as Dn, PdfSquigglyAnnotation as Do, PdfDocumentBuilder as Dr, EKU_OIDS as Dt, buildColorKeyMask as E, isValidLevel as Ea, readEan8 as Ei, renderToPdf as En, PdfHighlightAnnotation as Eo, StreamingPdfParser as Er, verifyOfflineRevocation as Et, attachAssociatedFiles as F, flattenTransparency as Fa, upcAToOperators as Fi, sampleShadingColor as Fn, generateLineAppearance as Fo, removeAllBookmarks as Fr, layoutParagraph as Ft, extractImages as G, buildDssDictionary as Ga, encodeCode39 as Gi, buildSampledTransferFunction as Gn, PDFOperator as Go, FieldExistsAsNonTerminalError as Gr, upscale8To16 as Gt, compareImages as H, computeObjectHash as Ha, itfToOperators as Hi, buildPdfX6OutputIntent as Hn, buildXmpMetadata as Ho, EncryptedPdfError as Hr, normalizeComponentDepth as Ht, registerEmbeddedFile as I, enforcePdfA as Ia, calculateEanCheckDigit as Ii, didYouMean as In, generateSquareAppearance as Io, removeBookmark as Ir, layoutTextFlow as It, renderPageToCanvas as J, addCounterSignature as Ja, encodeCode128Values as Ji, buildType5Halftone as Jn, ChangeTracker as Jo, InvalidColorError as Jr, decodeTileRegion as Jt, generateThumbnail as K, embedLtvData as Ka, code128ToOperators as Ki, buildThresholdHalftone as Kn, buildDeviceNColorSpace as Ko, FontNotEmbeddedError as Kr, assembleTiles as Kt, RenderCache as L, validatePdfA as La, ean13ToOperators as Li, levenshtein as Ln, generateSquigglyAppearance as Lo, flattenField as Lr, buildPdfXOutputIntent as Lt, buildUnencryptedWrapper as M, SRGB_ICC_PROFILE as Ma, encodeDataMatrix as Mi, buildPdfA4Xmp as Mn, generateFreeTextAppearance as Mo, processBatch as Mr, validateCertificateChain as Mt, attachOutputIntents as N, generateSrgbIccProfile as Na, calculateUpcCheckDigit as Ni, pdfA4Rules as Nn, generateHighlightAppearance as No, addBookmark as Nr, findHyphenationPoints as Nt, buildStencilMask as O, generateWinAnsiToUnicodeCmap as Oa, renderStyledBarcode as Oi, resolveFallback as On, PdfStrikeOutAnnotation as Oo, enforcePdfUa as Or, validateCertificatePolicy as Ot, buildPageOutputIntent as P, detectTransparency as Pa, encodeUpcA as Pi, buildFunctionShading as Pn, generateInkAppearance as Po, getBookmarks as Pr, layoutColumns as Pt, interpretPage as Q, buildFieldLockDict as Qa, embedTiffDirect as Qi, markdownToPdf as Qn, NoSuchFieldError as Qr, downloadCrl as Qt, computeTileGrid as R, delinearizePdf as Ra, ean8ToOperators as Ri, renderCodeFrame as Rn, generateStrikeOutAppearance as Ro, flattenFields as Rr, enforcePdfX as Rt, tagTableDataCell as S, parseXmpMetadata as Sa, readBarcode as Si, buildPdfVtDParts as Sn, PdfLineAnnotation as So, tableToJson as Sr, sanitizePdf as St, buildBlackPointCompensationExtGState as T, getSupportedLevels as Ta, readEan13 as Ti, h as Tn, PdfSquareAnnotation as To, timestampPlugin as Tr, extractEmbeddedRevocationData as Tt, comparePages as U, findChangedObjects as Ua, code39ToOperators as Ui, validateBoxGeometry as Un, createXmpStream as Uo, ExceededMaxLengthError as Ur, offsetSignedToUnsigned as Ut, applyOcr as V, linearizePdf as Va, encodeItf as Vi, buildGtsPdfxVersion as Vn, PdfTextAnnotation as Vo, CombedTextLayoutError as Vr, getComponentDepths as Vt, extractFonts as W, optimizeIncrementalSave as Wa, computeCode39CheckDigit as Wi, STANDARD_SPOT_FUNCTIONS as Wn, parseXmpMetadata$1 as Wo, FieldAlreadyExistsError as Wr, summarizeBitDepth as Wt, renderPageToImage as X, diffSignedContent as Xa, PdfWorker as Xi, nameHalftone as Xn, saveIncremental as Xo, InvalidPageSizeError as Xr, verifySignatureDetailed as Xt, rasterize as Y, getCounterSignatures as Ya, valuesToModules as Yi, identityTransferFunction as Yn, saveDocumentIncremental as Yo, InvalidFieldNamePartError as Yr, parseTileInfo as Yt, interpretContentStream as Z, addFieldLock as Za, canDirectEmbed as Zi, evaluateFunction as Zn, MissingOnValueCheckError as Zr, TrustStore as Zt, tagLink as _, countOccurrences as _a, applyTablePreset as _i, isWoff as _n, PdfPopupAnnotation as _o, buildRequirement as _r, resolveInstanceCoordinates as _t, assembleFacturX as a, isCmykTiff as aa, applyHeaderFooterToPage as ai, resolveFieldReference as an, validateSignatureChain as ao, buildCalRGB as ar, xyzToRgb as at, tagParagraph as b, createAssociatedFile as ba, professionalPreset as bi, signDeferred as bn, PdfStampAnnotation as bo, extractTables as br, inspectEncryption as bt, buildWtpdfIdentificationXmp as c, analyzeJpegMarkers as ca, toAlpha as ci, setFieldVisibility as cn, parseExistingTrailer as co, DEFAULT_SARIF_TOOL_NAME as cr, xyzToLab as ct, autoTagPage as d, optimizeImage as da, ellipsisText as di, AFDate_FormatEx as dn, buildTimestampRequest as do, toSarif as dr, buildLatticeFormGouraudShading as dt, recompressWebP as ea, RemovePageFromEmptyDocumentError as ei, isCertificateRevoked as en, detectModifications as eo, reconstructLines as er, hsvToRgb as et, buildPdfUa2Xmp as f, recompressImage as fa, estimateTextWidth as fi, formatDate as fn, parseTimestampResponse as fo, MATHML_NAMESPACE as fr, buildTensorPatchShading as ft, tagHeading as g, generatePdfAXmpBytes as ga, applyPreset as gi, decodeWoff as gn, PdfCaretAnnotation as go, buildPieceInfo as gr, parseVariableFont as gt, tagFigure as h, generatePdfAXmp as ha, wrapText$2 as hi, formatNumber$1 as hn, PdfFileAttachmentAnnotation as ho, buildNamespacesArray as hr, normalizeAxisCoordinate as ht, validateEn16931 as i, embedTiffCmyk as ia, applyHeaderFooter as ii, getFieldValue as in, setCertificationLevel as io, buildCalGray as ir, rgbToXyz as it, buildEncryptedPayload as j, buildOutputIntent as ja, dataMatrixToOperators as ji, generateXRechnungCii as jn, generateCircleAppearance as jo, batchMerge as jr, buildCertificateChain as jt, buildSoftMaskGroupExtGState as k, generateZapfDingbatsToUnicodeCmap as ka, encodePdf417 as ki, splitByScript as kn, PdfUnderlineAnnotation as ko, validatePdfUa as kr, validateExtendedKeyUsage as kt, convertPdfAConformanceXmp as l, downscaleImage as la, toRoman as li, validateFieldValue as ln, saveIncrementalWithSignaturePreservation as lo, SARIF_SCHEMA_URI as lr, buildCoonsPatchShading as lt, LIST_NUMBERING_KEY as m, enforcePdfAFull as ma, truncateText as mi, AFNumber_Format as mn, searchTextItems as mo, buildNamespace as mr, parseColorFont as mt, detectFacturXProfile as n, webpToPng as na, StreamingParseError as ni, extractOcspUrl as nn, buildDocMdpReference as no, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as nr, rgbToHsv as nt, buildFacturXXmp as o, extractJpegMetadata as oa, formatDate$1 as oi, setFieldValue as on, appendIncrementalUpdate as oo, buildLab as or, deviceRgbToXyz as ot, validatePdfUa2 as p, applyRedaction as pa, shrinkFontSize as pi, parseAcrobatDate as pn, requestTimestamp as po, PDF2_NAMESPACE as pr, getColorGlyphLayers as pt, renderDisplayListToCanvas as q, hasLtvData as qa, encodeCode128 as qi, buildType1Halftone as qn, buildSeparationColorSpace as qo, ForeignPageError as qr, decodeTile as qt, parseCiiXml as r, convertTiffCmykToRgb as ra, UnexpectedFieldTypeError as ri, createSandbox as rn, getCertificationLevel as ro, buildDocTimeStampDict as rr, rgbToLab as rt, buildPdfRIdentificationXmp as s, injectJpegMetadata as sa, replaceTemplateVariables as si, addVisibilityAction as sn, findExistingSignatures as so, labToRgb as sr, parseIccTransform as st, initWasm as t, webpToJpeg as ta, RichTextFieldReadError as ti, checkCertificateStatus as tn, MdpPermission as to, reconstructParagraphs as tr, rgbToHsl as tt, preflightPdfA as u, estimateJpegQuality as ua, applyOverflow as ui, AFSpecial_Format as un, validateByteRangeIntegrity as uo, toJsonReport as ur, buildFreeFormGouraudShading as ut, tagList as v, stripProhibitedFeatures as va, borderedPreset as vi, isWoff2 as vn, PdfRedactAnnotation as vo, buildRequirements as vr, reorderVisual as vt, tagTableRow as w, getProfile as wa, readCode39 as wi, gtsPdfVtVersion as wn, PdfPolygonAnnotation as wo, metadataPlugin as wr, buildCertPath as wt, tagTable as x, extractXmpMetadata as xa, stripedPreset as xi, createWorkerPool as xn, PdfCircleAnnotation as xo, tableToCsv as xr, verifyRedactions as xt, tagListItem as y, buildAfArray as ya, minimalPreset as yi, readWoffHeader as yn, PdfInkAnnotation as yo, buildDPartRoot as yr, resolveBidi as yt, renderPageTile as z, getLinearizationInfo as za, encodeEan13 as zi, generateCiiXml as zn, generateUnderlineAppearance as zo, flattenForm as zr, validatePdfX as zt };
 
-//# sourceMappingURL=src-BlUlmYsU.mjs.map
+//# sourceMappingURL=src-DGxzt-jG.mjs.map