modern-pdf-lib 0.36.0 → 0.38.0

package/dist/{src-MIBq9xGq.cjs → src-B0gmgVEs.cjs}

@@ -9599,7 +9599,7 @@ function readU16$1(data, offset, le) {
 * Read a 32-bit unsigned integer.
 * @internal
 */
-function readU32$1(data, offset, le) {
+function readU32$2(data, offset, le) {
 	return getView(data).getUint32(offset, le);
 }
 /**
@@ -9614,8 +9614,8 @@ function parseIfd(data, offset, le) {
 		if (entryOffset + 12 > data.length) break;
 		const tag = readU16$1(data, entryOffset, le);
 		const type = readU16$1(data, entryOffset + 2, le);
-		const cnt = readU32$1(data, entryOffset + 4, le);
-		const valueOrOffset = readU32$1(data, entryOffset + 8, le);
+		const cnt = readU32$2(data, entryOffset + 4, le);
+		const valueOrOffset = readU32$2(data, entryOffset + 8, le);
 		entries.push({
 			tag,
 			type,
@@ -9653,7 +9653,7 @@ function readOffsetArray(data, entry, le) {
 		const pos = offset + i * elementSize;
 		if (pos + elementSize > data.length) break;
 		if (entry.type === 3) values.push(readU16$1(data, pos, le));
-		else values.push(readU32$1(data, pos, le));
+		else values.push(readU32$2(data, pos, le));
 	}
 	return values;
 }
@@ -9662,13 +9662,13 @@ function readOffsetArray(data, entry, le) {
 * @internal
 */
 function findIfdOffset(data, le, page) {
-	let ifdOffset = readU32$1(data, 4, le);
+	let ifdOffset = readU32$2(data, 4, le);
 	for (let i = 0; i < page; i++) {
 		if (ifdOffset === 0 || ifdOffset + 2 > data.length) throw new Error(`TIFF page ${page} not found (only ${i} pages available)`);
 		const entryCount = readU16$1(data, ifdOffset, le);
 		const nextIfdOffset = ifdOffset + 2 + entryCount * 12;
 		if (nextIfdOffset + 4 > data.length) throw new Error(`TIFF page ${page} not found (only ${i + 1} pages available)`);
-		ifdOffset = readU32$1(data, nextIfdOffset, le);
+		ifdOffset = readU32$2(data, nextIfdOffset, le);
 		if (ifdOffset === 0) throw new Error(`TIFF page ${page} not found (only ${i + 1} pages available)`);
 	}
 	return ifdOffset;
@@ -9725,7 +9725,7 @@ function canDirectEmbed(data) {
 	if (!isLE && !isBE) return false;
 	const le = isLE;
 	if (readU16$1(data, 2, le) !== 42) return false;
-	const ifdOffset = readU32$1(data, 4, le);
+	const ifdOffset = readU32$2(data, 4, le);
 	if (ifdOffset === 0 || ifdOffset + 2 > data.length) return false;
 	const compression = getTag(parseIfd(data, ifdOffset, le), TAG_COMPRESSION, data, le) ?? 1;
 	return compression === COMPRESSION_NONE || compression === COMPRESSION_DEFLATE || compression === COMPRESSION_DEFLATE_PKZIP || compression === COMPRESSION_JPEG || compression === COMPRESSION_OLD_JPEG;
@@ -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);
@@ -25147,7 +25147,7 @@ function readU16(data, offset) {
 /**
 * Read a 32-bit big-endian unsigned integer.
 */
-function readU32(data, offset) {
+function readU32$1(data, offset) {
 	return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
 }
 /**
@@ -25158,7 +25158,7 @@ function findCodestreamStart(data) {
 	if (data.length >= 12 && data[0] === 0 && data[1] === 0 && data[2] === 0 && data[3] === 12 && data[4] === 106 && data[5] === 80) {
 		let offset = 0;
 		while (offset + 8 <= data.length) {
-			const boxLen = readU32(data, offset);
+			const boxLen = readU32$1(data, offset);
 			if (String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]) === "jp2c") return offset + 8;
 			const advance = boxLen === 0 ? data.length - offset : boxLen < 8 ? 8 : boxLen;
 			offset += advance;
@@ -25184,14 +25184,14 @@ function parseTileInfo(data) {
 	if (sizOffset < 0) throw new Error("JPEG2000 Tiles: SIZ marker (0xFF51) not found");
 	const base = sizOffset + 2;
 	if (base + 38 > data.length) throw new Error("JPEG2000 Tiles: SIZ marker segment is truncated");
-	const xsiz = readU32(data, base + 4);
-	const ysiz = readU32(data, base + 8);
-	const xosiz = readU32(data, base + 12);
-	const yosiz = readU32(data, base + 16);
-	const xtsiz = readU32(data, base + 20);
-	const ytsiz = readU32(data, base + 24);
-	const xtosiz = readU32(data, base + 28);
-	const ytosiz = readU32(data, base + 32);
+	const xsiz = readU32$1(data, base + 4);
+	const ysiz = readU32$1(data, base + 8);
+	const xosiz = readU32$1(data, base + 12);
+	const yosiz = readU32$1(data, base + 16);
+	const xtsiz = readU32$1(data, base + 20);
+	const ytsiz = readU32$1(data, base + 24);
+	const xtosiz = readU32$1(data, base + 28);
+	const ytosiz = readU32$1(data, base + 32);
 	const csiz = readU16(data, base + 36);
 	const imageWidth = xsiz - xosiz;
 	const imageHeight = ysiz - yosiz;
@@ -25231,7 +25231,7 @@ function findTileParts(data, csStart) {
 			if (offset + 12 > data.length) break;
 			const lsot = readU16(data, offset + 2);
 			const isot = readU16(data, offset + 4);
-			const psot = readU32(data, offset + 6);
+			const psot = readU32$1(data, offset + 6);
 			let sodOffset = offset + 2 + lsot;
 			while (sodOffset + 1 < data.length) {
 				if (data[sodOffset] === 255 && data[sodOffset + 1] === 147) break;
@@ -30527,168 +30527,1808 @@ function getColorGlyphLayers(fontData, glyphId, paletteIndex = 0) {
 	return layers;
 }
 //#endregion
-//#region src/render/matrix.ts
-/** The identity transform. */
-function identity() {
-	return [
-		1,
-		0,
-		0,
-		1,
-		0,
-		0
-	];
+//#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;
 }
 /**
-* Concatenate two transforms: the result applies `m` **first**, then `n`
-* (i.e. `point · m · n`). This matches the PDF `cm` operator, where the new
-* CTM is `cmMatrix × CTM`.
+* 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 multiply(m, n) {
-	return [
-		m[0] * n[0] + m[1] * n[2],
-		m[0] * n[1] + m[1] * n[3],
-		m[2] * n[0] + m[3] * n[2],
-		m[2] * n[1] + m[3] * n[3],
-		m[4] * n[0] + m[5] * n[2] + n[4],
-		m[4] * n[1] + m[5] * n[3] + n[5]
-	];
+function colorComponentCount(common) {
+	if (common.function !== void 0) return 1;
+	const colorPairs = (common.decode.length - 4) / 2;
+	return Math.max(1, Math.trunc(colorPairs));
 }
-/** Apply a transform to a point, returning the transformed `[x, y]`. */
-function applyToPoint(m, x, y) {
-	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+/**
+* 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);
+	}
 }
-/** A pure translation transform. */
-function translation(tx, ty) {
-	return [
-		1,
-		0,
-		0,
-		1,
-		tx,
-		ty
-	];
+/**
+* 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);
 }
 /**
-* The magnitude by which `m` scales lengths — the geometric mean of the
-* x- and y-axis scale factors (`sqrt(|det|)`). Used to map a user-space line
-* width to device space.
+* Pack one colour (n components) into `packer`.
+*
+* @internal
 */
-function meanScale(m) {
-	const det = m[0] * m[3] - m[1] * m[2];
-	return Math.sqrt(Math.abs(det));
+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);
+	}
 }
-//#endregion
-//#region src/render/interpreter.ts
 /**
-* @module render/interpreter
+* Build the dictionary shared by every mesh shading and set the common keys.
 *
-* Executes a parsed PDF content stream through a graphics-state machine,
-* producing a resolution-independent {@link DisplayList} (page space, y-up).
-* This is the foundation the rasterizer and Canvas adapter render from.
+* @internal
+*/
+function buildCommonDict(shadingType, common, includeFlag) {
+	const dict = new require_pdfObjects.PdfDict();
+	dict.set("/ShadingType", require_pdfObjects.PdfNumber.of(shadingType));
+	dict.set("/ColorSpace", common.colorSpace);
+	dict.set("/BitsPerCoordinate", require_pdfObjects.PdfNumber.of(common.bitsPerCoordinate));
+	dict.set("/BitsPerComponent", require_pdfObjects.PdfNumber.of(common.bitsPerComponent));
+	if (includeFlag) dict.set("/BitsPerFlag", require_pdfObjects.PdfNumber.of(common.bitsPerFlag));
+	dict.set("/Decode", require_pdfObjects.PdfArray.fromNumbers([...common.decode]));
+	if (common.function !== void 0) dict.set("/Function", common.function);
+	return dict;
+}
+/**
+* Build a free-form Gouraud-shaded triangle mesh shading
+* (ISO 32000-2 §8.7.4.5.5, /ShadingType 4).
 *
-* Supported operators: graphics state (`q`/`Q`/`cm`/`w`/`J`/`j`/`gs`), path
-* construction (`m`/`l`/`c`/`v`/`y`/`re`/`h`), path painting
-* (`f`/`F`/`f*`/`S`/`s`/`B`/`B*`/`b`/`b*`/`n`), clipping (`W`/`W*`), color
-* (`rg`/`RG`/`g`/`G`/`k`/`K`/`cs`/`CS`/`sc`/`scn`/`SC`/`SCN`), text
-* (`BT`/`ET`/`Tf`/`Td`/`TD`/`Tm`/`T*`/`Tc`/`Tw`/`Tz`/`TL`/`Ts`/`Tr`/`Tj`/`TJ`/`'`/`"`),
-* and XObjects (`Do`, recursing into form XObjects). Bézier curves are
-* flattened to polylines.
+* Each vertex is packed as `flag · x · y · colour[n]`, MSB-first, with the flag
+* `bitsPerFlag` wide.
 *
-* @packageDocumentation
+* @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 initialState$1() {
-	return {
-		ctm: identity(),
-		fill: [
-			0,
-			0,
-			0,
-			255
-		],
-		stroke: [
-			0,
-			0,
-			0,
-			255
-		],
-		lineWidth: 1,
-		lineCap: 0,
-		lineJoin: 0,
-		fillAlpha: 1,
-		strokeAlpha: 1,
-		clip: void 0,
-		font: void 0,
-		fontSize: 0,
-		charSpace: 0,
-		wordSpace: 0,
-		hScale: 1,
-		leading: 0,
-		rise: 0,
-		renderMode: 0
+function buildFreeFormGouraudShading(options) {
+	const dict = buildCommonDict(4, options, true);
+	const nColor = colorComponentCount(options);
+	const packer = new BitPacker();
+	for (const tri of options.triangles) for (const vertex of tri.vertices) {
+		packer.push(vertex.flag, options.bitsPerFlag);
+		packVertexData(packer, vertex, options, nColor);
+	}
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
+}
+/**
+* Build a lattice-form Gouraud-shaded triangle mesh shading
+* (ISO 32000-2 §8.7.4.5.6, /ShadingType 5).
+*
+* Vertices carry **no** flag; the mesh topology is implied by /VerticesPerRow.
+* Each vertex is packed as `x · y · colour[n]`, MSB-first.
+*
+* @param options - the common mesh keys (sans /BitsPerFlag) plus
+*                   /VerticesPerRow and the row-major vertex list.
+* @returns a {@link PdfStream} with /ShadingType 5 and /VerticesPerRow.
+*/
+function buildLatticeFormGouraudShading(options) {
+	const common = {
+		colorSpace: options.colorSpace,
+		bitsPerCoordinate: options.bitsPerCoordinate,
+		bitsPerComponent: options.bitsPerComponent,
+		bitsPerFlag: 8,
+		decode: options.decode,
+		function: options.function
 	};
+	const dict = buildCommonDict(5, common, false);
+	dict.set("/VerticesPerRow", require_pdfObjects.PdfNumber.of(options.verticesPerRow));
+	const nColor = colorComponentCount(common);
+	const packer = new BitPacker();
+	for (const vertex of options.vertices) packVertexData(packer, vertex, common, nColor);
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
 }
-function cloneState(s) {
-	return { ...s };
+/**
+* Build a Coons patch mesh shading
+* (ISO 32000-2 §8.7.4.5.7, /ShadingType 6).
+*
+* Each patch is packed as `flag · points · colours`. A flag-0 patch carries 12
+* control points and 4 corner colours; flags 1–3 carry 8 control points and 2
+* colours (the rest are inherited from the shared edge of the previous patch).
+*
+* @param options - the common mesh keys plus the patch list.
+* @returns a {@link PdfStream} with /ShadingType 6.
+*/
+function buildCoonsPatchShading(options) {
+	const dict = buildCommonDict(6, options, true);
+	const nColor = colorComponentCount(options);
+	const packer = new BitPacker();
+	for (const patch of options.patches) {
+		packer.push(patch.flag, options.bitsPerFlag);
+		for (const point of patch.points) packPoint(packer, point, options);
+		for (const color of patch.colors) packColor(packer, color, options, nColor);
+	}
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
 }
-function num$2(op) {
-	return typeof op === "number" ? op : 0;
+/**
+* Build a tensor-product patch mesh shading
+* (ISO 32000-2 §8.7.4.5.8, /ShadingType 7).
+*
+* Identical packing to type 6 but a flag-0 patch carries 16 control points (the
+* 4 internal tensor points in addition to the 12 boundary points) plus 4 corner
+* colours; flags 1–3 carry 12 control points and 2 colours.
+*
+* @param options - the common mesh keys plus the patch list.
+* @returns a {@link PdfStream} with /ShadingType 7.
+*/
+function buildTensorPatchShading(options) {
+	const dict = buildCommonDict(7, options, true);
+	const nColor = colorComponentCount(options);
+	const packer = new BitPacker();
+	for (const patch of options.patches) {
+		packer.push(patch.flag, options.bitsPerFlag);
+		for (const point of patch.points) packPoint(packer, point, options);
+		for (const color of patch.colors) packColor(packer, color, options, nColor);
+	}
+	const data = packer.finish();
+	return require_pdfObjects.PdfStream.fromBytes(data, dict);
 }
-function nameOf(op) {
-	if (op instanceof require_pdfObjects.PdfName) return op.value.replace(/^\//, "");
-	if (typeof op === "string") return op.replace(/^\//, "");
+//#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;
 }
-function clamp255(v) {
-	return Math.max(0, Math.min(255, Math.round(v * 255)));
+/**
+* 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;
 }
-function grayRgba(g) {
-	const v = clamp255(g);
-	return [
-		v,
-		v,
-		v,
-		255
-	];
+/**
+* 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
+	};
 }
-function rgbRgba(r, g, b) {
-	return [
-		clamp255(r),
-		clamp255(g),
-		clamp255(b),
-		255
-	];
+/**
+* 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).`);
 }
-function cmykRgba(c, m, y, k) {
-	const [r, g, b] = require_pdfDocument.cmykToRgb(c, m, y, k);
+/** 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 [
-		clamp255(r),
-		clamp255(g),
-		clamp255(b),
-		255
+		readS15Fixed16(view, tag.offset + 8),
+		readS15Fixed16(view, tag.offset + 12),
+		readS15Fixed16(view, tag.offset + 16)
 	];
 }
-/** Interpret `sc`/`scn` numeric components by arity → RGBA. */
-function componentsToRgba(comps) {
-	if (comps.length === 1) return grayRgba(comps[0]);
-	if (comps.length === 3) return rgbRgba(comps[0], comps[1], comps[2]);
-	if (comps.length === 4) return cmykRgba(comps[0], comps[1], comps[2], comps[3]);
-}
-const BEZIER_STEPS = 16;
-function flattenCubic(out, p0, p1, p2, p3) {
-	for (let i = 1; i <= BEZIER_STEPS; i++) {
-		const t = i / BEZIER_STEPS;
-		const mt = 1 - t;
-		const a = mt * mt * mt;
-		const b = 3 * mt * mt * t;
-		const c = 3 * mt * t * t;
-		const d = t * t * t;
-		out.push(a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]);
+/**
+* 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
+	];
 }
 /**
-* Execute a parsed content stream into a {@link DisplayList}.
+* CIE L\*a\*b\* nonlinearity f(t) (CIE 15:2004 §8.2.1.1):
 *
-* @param operators - Output of {@link parseContentStream}.
+* ```
+*   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/assets/image/nextGenImageDetect.ts
+/** AVIF file-level brands (AV1 Image File Format §4). */
+const AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+/** HEVC-coded HEIF brands (ISO/IEC 23008-12 Annex B). */
+const HEIC_BRANDS = /* @__PURE__ */ new Set([
+	"heic",
+	"heix",
+	"heim",
+	"heis",
+	"hevc",
+	"hevx"
+]);
+/** Generic (codec-agnostic) HEIF brands (ISO/IEC 23008-12 Annex B). */
+const HEIF_BRANDS = /* @__PURE__ */ new Set(["mif1", "msf1"]);
+/** Read a 4-byte big-endian unsigned integer at `offset`. */
+function readU32(bytes, offset) {
+	const b0 = bytes[offset] ?? 0;
+	const b1 = bytes[offset + 1] ?? 0;
+	const b2 = bytes[offset + 2] ?? 0;
+	const b3 = bytes[offset + 3] ?? 0;
+	return b0 * 16777216 + (b1 << 16 | b2 << 8 | b3);
+}
+/** Decode a 4-byte FourCC at `offset` as an ASCII string. */
+function readFourCC(bytes, offset) {
+	return String.fromCharCode(bytes[offset] ?? 0, bytes[offset + 1] ?? 0, bytes[offset + 2] ?? 0, bytes[offset + 3] ?? 0);
+}
+/**
+* Parse an ISOBMFF box header starting at `offset` (ISO/IEC 14496-12 §4.2).
+*
+* Handles the standard 32-bit `size`, the 64-bit `largesize` (`size == 1`),
+* and the to-EOF form (`size == 0`). Returns `null` on a malformed / truncated
+* header.
+*/
+function parseBoxHeader(bytes, offset, end) {
+	if (offset + 8 > end) return null;
+	let size = readU32(bytes, offset);
+	const type = readFourCC(bytes, offset + 4);
+	let headerLen = 8;
+	if (size === 1) {
+		if (offset + 16 > end) return null;
+		const high = readU32(bytes, offset + 8);
+		const low = readU32(bytes, offset + 12);
+		size = high * 4294967296 + low;
+		headerLen = 16;
+	} else if (size === 0) size = end - offset;
+	const boxEnd = offset + size;
+	if (size < headerLen || boxEnd > end) return null;
+	return {
+		type,
+		contentStart: offset + headerLen,
+		boxEnd
+	};
+}
+/**
+* Find a direct child box of a given `type` within [start, end).
+* Returns the matching {@link BoxHeader} or `null`.
+*/
+function findChildBox(bytes, start, end, type) {
+	let cursor = start;
+	while (cursor + 8 <= end) {
+		const header = parseBoxHeader(bytes, cursor, end);
+		if (header === null) return null;
+		if (header.type === type) return header;
+		if (header.boxEnd <= cursor) return null;
+		cursor = header.boxEnd;
+	}
+	return null;
+}
+/** Verify a buffer begins with the given byte sequence. */
+function startsWith(bytes, sig) {
+	if (bytes.length < sig.length) return false;
+	for (let i = 0; i < sig.length; i++) if (bytes[i] !== sig[i]) return false;
+	return true;
+}
+/** JPEG XL bare-codestream signature `FF 0A` (ISO/IEC 18181-1). */
+const JXL_CODESTREAM_SIG = [255, 10];
+/**
+* JPEG XL ISOBMFF container signature box:
+* `00 00 00 0C 'JXL ' 0D 0A 87 0A` (ISO/IEC 18181-1 / 18181-2).
+*/
+const JXL_CONTAINER_SIG = [
+	0,
+	0,
+	0,
+	12,
+	74,
+	88,
+	76,
+	32,
+	13,
+	10,
+	135,
+	10
+];
+/**
+* Inspect an ISOBMFF `ftyp` box and classify its brand set into a next-gen
+* format. Precedence: AVIF > HEIC > HEIF. Returns `null` if no brand matches.
+*/
+function classifyFtypBrands(bytes, ftyp) {
+	const brands = [];
+	if (ftyp.contentStart + 4 <= ftyp.boxEnd) brands.push(readFourCC(bytes, ftyp.contentStart));
+	for (let off = ftyp.contentStart + 8; off + 4 <= ftyp.boxEnd; off += 4) brands.push(readFourCC(bytes, off));
+	if (brands.some((b) => AVIF_BRANDS.has(b))) return "avif";
+	if (brands.some((b) => HEIC_BRANDS.has(b))) return "heic";
+	if (brands.some((b) => HEIF_BRANDS.has(b))) return "heif";
+	return null;
+}
+/** Locate the top-level `ftyp` box (it must be the first box). */
+function findFtyp(bytes) {
+	if (bytes.length < 8 || readFourCC(bytes, 4) !== "ftyp") return null;
+	return parseBoxHeader(bytes, 0, bytes.length);
+}
+/**
+* Detect a next-generation image format from raw bytes.
+*
+* Recognizes AVIF / HEIC / HEIF via the ISOBMFF `ftyp` brand set, and JPEG XL
+* via either the bare codestream signature (`FF 0A`) or the container
+* signature box (`00 00 00 0C 'JXL ' 0D 0A 87 0A`).
+*
+* @param bytes  Raw image file bytes.
+* @returns      The detected {@link NextGenFormat}, or `null` if unrecognized.
+*/
+function detectNextGenFormat(bytes) {
+	if (startsWith(bytes, JXL_CODESTREAM_SIG)) return "jpegxl";
+	if (startsWith(bytes, JXL_CONTAINER_SIG)) return "jpegxl";
+	const ftyp = findFtyp(bytes);
+	if (ftyp === null) return null;
+	return classifyFtypBrands(bytes, ftyp);
+}
+/**
+* Walk an ISOBMFF box tree to `meta` > `iprp` > `ipco` and read the first
+* `ispe` (dimensions) and `pixi` (bit depth) property boxes.
+*/
+function probeIsobmffDimensions(bytes) {
+	const result = {};
+	const ftyp = findFtyp(bytes);
+	if (ftyp === null) return result;
+	const meta = findChildBox(bytes, ftyp.boxEnd, bytes.length, "meta");
+	if (meta === null) return result;
+	const metaChildren = meta.contentStart + 4;
+	if (metaChildren > meta.boxEnd) return result;
+	const iprp = findChildBox(bytes, metaChildren, meta.boxEnd, "iprp");
+	if (iprp === null) return result;
+	const ipco = findChildBox(bytes, iprp.contentStart, iprp.boxEnd, "ipco");
+	if (ipco === null) return result;
+	const ispe = findChildBox(bytes, ipco.contentStart, ipco.boxEnd, "ispe");
+	if (ispe !== null && ispe.contentStart + 12 <= ispe.boxEnd) {
+		result.width = readU32(bytes, ispe.contentStart + 4);
+		result.height = readU32(bytes, ispe.contentStart + 8);
+	}
+	const pixi = findChildBox(bytes, ipco.contentStart, ipco.boxEnd, "pixi");
+	if (pixi !== null && pixi.contentStart + 5 <= pixi.boxEnd) {
+		const numChannels = bytes[pixi.contentStart + 4] ?? 0;
+		if (numChannels > 0 && pixi.contentStart + 5 + numChannels <= pixi.boxEnd) result.bitDepth = bytes[pixi.contentStart + 5] ?? 0;
+	}
+	return result;
+}
+const REASON_AVIF = "AVIF detected; pure-JS AV1 decoding is not bundled — decode/convert to PNG or JPEG, or register a WASM decoder.";
+const REASON_HEIC = "HEIC detected; pure-JS HEVC decoding is not bundled — decode/convert to PNG or JPEG, or register a WASM decoder.";
+const REASON_HEIF = "HEIF detected; pure-JS HEVC/AV1 decoding is not bundled — decode/convert to PNG or JPEG, or register a WASM decoder.";
+const REASON_JXL = "JPEG XL detected; pure-JS JPEG XL decoding is not bundled — decode/convert to PNG or JPEG, or register a WASM decoder.";
+/** Map a detected format to its non-decodable explanation. */
+function reasonFor(format) {
+	switch (format) {
+		case "avif": return REASON_AVIF;
+		case "heic": return REASON_HEIC;
+		case "heif": return REASON_HEIF;
+		case "jpegxl": return REASON_JXL;
+	}
+}
+/**
+* Probe a next-generation image for container metadata WITHOUT decoding pixels.
+*
+* For AVIF / HEIC / HEIF, walks the ISOBMFF box tree
+* (`meta` > `iprp` > `ipco` > `ispe`/`pixi`) to recover width, height, and
+* bit depth when present. For JPEG XL, the format is identified but dimensions
+* are not parsed (the `SizeHeader` is a packed-bit codestream field and is
+* intentionally scoped out here); only `format` is returned.
+*
+* The returned {@link NextGenImageInfo} **always** has `decodable: false`.
+* No pixel data is ever produced.
+*
+* @param bytes  Raw image file bytes.
+* @returns      A {@link NextGenImageInfo}, or `null` if not a next-gen image.
+*/
+function probeNextGenImage(bytes) {
+	const format = detectNextGenFormat(bytes);
+	if (format === null) return null;
+	const info = {
+		format,
+		decodable: false,
+		reason: reasonFor(format)
+	};
+	if (format === "jpegxl") return info;
+	const dims = probeIsobmffDimensions(bytes);
+	if (dims.width !== void 0) info.width = dims.width;
+	if (dims.height !== void 0) info.height = dims.height;
+	if (dims.bitDepth !== void 0) info.bitDepth = dims.bitDepth;
+	return info;
+}
+//#endregion
+//#region src/assets/image/imageDecoderRegistry.ts
+/**
+* The single, module-scoped decoder registry, keyed by normalized format name.
+*/
+const registry = /* @__PURE__ */ new Map();
+/**
+* Normalize a format key: trim surrounding whitespace and lowercase it, so that
+* `'AVIF'`, `' avif '`, and `'avif'` all map to the same entry.
+*
+* @param format  The caller-supplied format key.
+* @returns       The normalized key.
+*/
+function normalizeFormat(format) {
+	return format.trim().toLowerCase();
+}
+/**
+* Register a decoder for a given image format.
+*
+* If a decoder is already registered for the (normalized) format, it is
+* replaced.
+*
+* @param format   Format key, e.g. `'avif'`, `'heic'`, `'jpegxl'`. The key is
+*                 normalized (trimmed + lowercased) before storage.
+* @param decoder  The {@link ImageDecoder} that turns encoded bytes into RGBA.
+*/
+function registerImageDecoder(format, decoder) {
+	registry.set(normalizeFormat(format), decoder);
+}
+/**
+* Remove the decoder registered for a given format, if any.
+*
+* This is a no-op when no decoder is registered for the (normalized) format.
+*
+* @param format  Format key; normalized (trimmed + lowercased) before lookup.
+*/
+function unregisterImageDecoder(format) {
+	registry.delete(normalizeFormat(format));
+}
+/**
+* Report whether a decoder is currently registered for a given format.
+*
+* @param format  Format key; normalized (trimmed + lowercased) before lookup.
+* @returns       `true` if a decoder is registered, otherwise `false`.
+*/
+function hasImageDecoder(format) {
+	return registry.has(normalizeFormat(format));
+}
+/**
+* Get the decoder registered for a given format, if any.
+*
+* @param format  Format key; normalized (trimmed + lowercased) before lookup.
+* @returns       The registered {@link ImageDecoder}, or `undefined` if none.
+*/
+function getImageDecoder(format) {
+	return registry.get(normalizeFormat(format));
+}
+/**
+* Validate that a value returned by a decoder is a well-formed
+* {@link DecodedRasterImage}.
+*
+* Throws a descriptive error (naming the format) if the result is malformed:
+* not an object, non-positive-integer dimensions, a non-`Uint8Array` `rgba`, or
+* an `rgba` length that does not equal `width * height * 4`.
+*
+* @param format  Normalized format key, used only for error messages.
+* @param result  The value returned by the decoder.
+* @returns       The same value, narrowed to {@link DecodedRasterImage}.
+*/
+function validateDecodedResult(format, result) {
+	if (result === null || typeof result !== "object") throw new Error(`Image decoder for format "${format}" returned a malformed result: expected an object with { width, height, rgba }, got ${typeof result}.`);
+	const { width, height, rgba } = result;
+	if (typeof width !== "number" || !Number.isInteger(width) || width <= 0) throw new Error(`Image decoder for format "${format}" returned a malformed result: width must be a positive integer, got ${String(width)}.`);
+	if (typeof height !== "number" || !Number.isInteger(height) || height <= 0) throw new Error(`Image decoder for format "${format}" returned a malformed result: height must be a positive integer, got ${String(height)}.`);
+	if (!(rgba instanceof Uint8Array)) throw new Error(`Image decoder for format "${format}" returned a malformed result: rgba must be a Uint8Array, got ${rgba === null ? "null" : typeof rgba}.`);
+	const expected = width * height * 4;
+	if (rgba.length !== expected) throw new Error(`Image decoder for format "${format}" returned a malformed result: rgba length ${rgba.length} does not match width*height*4 = ${width}*${height}*4 = ${expected}.`);
+	return {
+		width,
+		height,
+		rgba
+	};
+}
+/**
+* Decode raw image bytes using a previously-registered decoder for `format`.
+*
+* Looks up the decoder by (normalized) format key, awaits its result, validates
+* the result shape (`rgba.length === width * height * 4`, positive-integer
+* dimensions, `Uint8Array` pixel buffer), and returns it.
+*
+* This function does **not** decode anything itself — it dispatches to the
+* consumer-supplied {@link ImageDecoder}. If no decoder is registered for the
+* format, it throws an error naming the format and explaining how to register
+* one via {@link registerImageDecoder}.
+*
+* @param format  Format key, e.g. `'avif'`; normalized before lookup.
+* @param bytes   Raw, encoded image bytes, forwarded verbatim to the decoder.
+* @returns       A validated {@link DecodedRasterImage}.
+* @throws        If no decoder is registered for the format, or if the
+*                registered decoder returns a malformed result.
+*/
+async function decodeRegisteredImage(format, bytes) {
+	const normalized = normalizeFormat(format);
+	const decoder = registry.get(normalized);
+	if (decoder === void 0) throw new Error(`No image decoder registered for format "${normalized}". This library does not bundle a decoder for this format; supply one with registerImageDecoder(${JSON.stringify(normalized)}, decoder), where decoder turns the encoded bytes into RGBA8888 ({ width, height, rgba }).`);
+	return validateDecodedResult(normalized, await decoder(bytes));
+}
+//#endregion
+//#region src/assets/image/svgFilters.ts
+/** Clamp a number to the closed interval [0, 255] and round to an integer. */
+function clamp8(v) {
+	if (v <= 0) return 0;
+	if (v >= 255) return 255;
+	return Math.round(v);
+}
+/** Allocate a transparent-black buffer of the given dimensions. */
+function allocBuffer(width, height) {
+	return {
+		width,
+		height,
+		rgba: new Uint8Array(width * height * 4)
+	};
+}
+/** Throw if two buffers differ in dimensions (an op needs them equal). */
+function assertSameSize(a, b) {
+	if (a.width !== b.width || a.height !== b.height) throw new Error(`svgFilters: buffer size mismatch (${a.width}x${a.height} vs ${b.width}x${b.height})`);
+}
+/**
+* Convert a straight RGBA8888 buffer to a premultiplied Float32Array in the
+* 0..1 range, channel order R,G,B,A. Premultiplying = colour × alpha.
+*/
+function toPremultipliedF32(src) {
+	const n = src.width * src.height;
+	const out = new Float32Array(n * 4);
+	for (let i = 0; i < n; i++) {
+		const a = src.rgba[i * 4 + 3] / 255;
+		out[i * 4 + 0] = src.rgba[i * 4 + 0] / 255 * a;
+		out[i * 4 + 1] = src.rgba[i * 4 + 1] / 255 * a;
+		out[i * 4 + 2] = src.rgba[i * 4 + 2] / 255 * a;
+		out[i * 4 + 3] = a;
+	}
+	return out;
+}
+/**
+* Convert a premultiplied Float32Array (0..1) back to a straight RGBA8888
+* RasterBuffer, un-premultiplying (colour ÷ alpha) and clamping.
+*/
+function fromPremultipliedF32(buf, width, height) {
+	const out = allocBuffer(width, height);
+	const n = width * height;
+	for (let i = 0; i < n; i++) {
+		const a = buf[i * 4 + 3];
+		if (a <= 0) {
+			out.rgba[i * 4 + 0] = 0;
+			out.rgba[i * 4 + 1] = 0;
+			out.rgba[i * 4 + 2] = 0;
+			out.rgba[i * 4 + 3] = 0;
+		} else {
+			out.rgba[i * 4 + 0] = clamp8(buf[i * 4 + 0] / a * 255);
+			out.rgba[i * 4 + 1] = clamp8(buf[i * 4 + 1] / a * 255);
+			out.rgba[i * 4 + 2] = clamp8(buf[i * 4 + 2] / a * 255);
+			out.rgba[i * 4 + 3] = clamp8(a * 255);
+		}
+	}
+	return out;
+}
+/**
+* Produce a buffer filled with a single constant colour.
+*
+* Implements `feFlood` (SVG 1.1 §15.12): every pixel is set to the given
+* straight RGBA8888 colour.
+*
+* @param width  Output width in pixels (must be > 0).
+* @param height Output height in pixels (must be > 0).
+* @param rgba   The fill colour as `[R, G, B, A]`, each 0..255.
+* @returns      A new buffer of `width × height` filled with `rgba`.
+*/
+function feFlood(width, height, rgba) {
+	if (width <= 0 || height <= 0 || !Number.isInteger(width) || !Number.isInteger(height)) throw new Error(`svgFilters.feFlood: invalid dimensions ${width}x${height}`);
+	const out = allocBuffer(width, height);
+	const r = clamp8(rgba[0]);
+	const g = clamp8(rgba[1]);
+	const b = clamp8(rgba[2]);
+	const a = clamp8(rgba[3]);
+	const n = width * height;
+	for (let i = 0; i < n; i++) {
+		out.rgba[i * 4 + 0] = r;
+		out.rgba[i * 4 + 1] = g;
+		out.rgba[i * 4 + 2] = b;
+		out.rgba[i * 4 + 3] = a;
+	}
+	return out;
+}
+/**
+* Apply a 4×5 colour matrix to every pixel.
+*
+* Implements `feColorMatrix` with `type="matrix"` (SVG 1.1 §15.10). The 20
+* values are row-major:
+*
+* ```
+* | R' |   | m0  m1  m2  m3  m4  |   | R |
+* | G' |   | m5  m6  m7  m8  m9  |   | G |
+* | B' | = | m10 m11 m12 m13 m14 | · | B |
+* | A' |   | m15 m16 m17 m18 m19 |   | A |
+* | 1  |   ( the implicit identity row )    | 1 |
+* ```
+*
+* Channels are normalised to 0..1, the matrix is applied to the **straight**
+* (un-premultiplied) `[R, G, B, A, 1]` vector, then the result is scaled back
+* to 0..255 with clamping.
+*
+* @param src    Source buffer.
+* @param matrix Exactly 20 numbers (4 rows × 5 columns).
+* @returns      A new buffer with the matrix applied.
+* @throws If `matrix` does not contain exactly 20 values.
+*/
+function feColorMatrix(src, matrix) {
+	if (matrix.length !== 20) throw new Error(`svgFilters.feColorMatrix: matrix must have 20 values, got ${matrix.length}`);
+	const m = matrix;
+	const out = allocBuffer(src.width, src.height);
+	const n = src.width * src.height;
+	for (let i = 0; i < n; i++) {
+		const r = src.rgba[i * 4 + 0] / 255;
+		const g = src.rgba[i * 4 + 1] / 255;
+		const b = src.rgba[i * 4 + 2] / 255;
+		const a = src.rgba[i * 4 + 3] / 255;
+		const nr = m[0] * r + m[1] * g + m[2] * b + m[3] * a + m[4];
+		const ng = m[5] * r + m[6] * g + m[7] * b + m[8] * a + m[9];
+		const nb = m[10] * r + m[11] * g + m[12] * b + m[13] * a + m[14];
+		const na = m[15] * r + m[16] * g + m[17] * b + m[18] * a + m[19];
+		out.rgba[i * 4 + 0] = clamp8(nr * 255);
+		out.rgba[i * 4 + 1] = clamp8(ng * 255);
+		out.rgba[i * 4 + 2] = clamp8(nb * 255);
+		out.rgba[i * 4 + 3] = clamp8(na * 255);
+	}
+	return out;
+}
+/**
+* Apply the `saturate` shorthand colour matrix.
+*
+* Implements `feColorMatrix type="saturate"` (SVG 1.1 §15.10). The luma
+* coefficients are the spec's exact constants 0.213 (R), 0.715 (G),
+* 0.072 (B). `s = 1` is the identity; `s = 0` fully desaturates each pixel to
+* its luma (so R = G = B); `s > 1` over-saturates.
+*
+* The spec saturate matrix (rows R, G, B; alpha untouched):
+* ```
+* | 0.213+0.787s  0.715-0.715s  0.072-0.072s  0  0 |
+* | 0.213-0.213s  0.715+0.285s  0.072-0.072s  0  0 |
+* | 0.213-0.213s  0.715-0.715s  0.072+0.928s  0  0 |
+* | 0            0             0             1  0 |
+* ```
+*
+* @param src Source buffer.
+* @param s   Saturation factor (0 = greyscale, 1 = identity, >1 = boosted).
+* @returns   A new buffer with the saturate matrix applied.
+*/
+function feColorMatrixSaturate(src, s) {
+	const rl = .213;
+	const gl = .715;
+	const bl = .072;
+	return feColorMatrix(src, [
+		rl + .787 * s,
+		gl - gl * s,
+		bl - bl * s,
+		0,
+		0,
+		rl - rl * s,
+		gl + .285 * s,
+		bl - bl * s,
+		0,
+		0,
+		rl - rl * s,
+		gl - gl * s,
+		bl + .928 * s,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0
+	]);
+}
+/**
+* Shift the image by an integer offset, leaving exposed edges transparent.
+*
+* Implements `feOffset` (SVG 1.1 §15.15). Pixels are copied to
+* `(x + dx, y + dy)`; destinations that fall outside the buffer are dropped
+* and exposed areas remain transparent black. `dx` / `dy` are rounded to the
+* nearest integer pixel.
+*
+* @param src Source buffer.
+* @param dx  Horizontal offset in pixels (positive = right).
+* @param dy  Vertical offset in pixels (positive = down).
+* @returns   A new buffer of the same size with the shifted content.
+*/
+function feOffset(src, dx, dy) {
+	const out = allocBuffer(src.width, src.height);
+	const idx = Math.round(dx);
+	const idy = Math.round(dy);
+	const { width, height } = src;
+	for (let y = 0; y < height; y++) {
+		const sy = y + idy;
+		if (sy < 0 || sy >= height) continue;
+		for (let x = 0; x < width; x++) {
+			const sx = x + idx;
+			if (sx < 0 || sx >= width) continue;
+			const di = (sy * width + sx) * 4;
+			const si = (y * width + x) * 4;
+			out.rgba[di + 0] = src.rgba[si + 0];
+			out.rgba[di + 1] = src.rgba[si + 1];
+			out.rgba[di + 2] = src.rgba[si + 2];
+			out.rgba[di + 3] = src.rgba[si + 3];
+		}
+	}
+	return out;
+}
+/**
+* Compute the box size `d` for the three-box-blur approximation.
+*
+* SVG 1.1 §15.17: `d = floor(s · 3 · √(2π) / 4 + 0.5)`.
+*/
+function boxBlurD(stdDev) {
+	return Math.floor(stdDev * 3 * Math.sqrt(2 * Math.PI) / 4 + .5);
+}
+/**
+* One horizontal box blur of the given (odd) length, premultiplied float
+* data, with an asymmetric left/right radius to support the even-`d` rule.
+* The window covers offsets `[-leftRadius, +rightRadius]` inclusive. Edge
+* samples are clamped (extend-edge) rather than treated as transparent so a
+* flat region stays flat.
+*/
+function boxBlurH(data, width, height, leftRadius, rightRadius) {
+	const out = new Float32Array(data.length);
+	const windowLen = leftRadius + rightRadius + 1;
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		for (let c = 0; c < 4; c++) {
+			let sum = 0;
+			for (let k = -leftRadius; k <= rightRadius; k++) {
+				const cx = k < 0 ? 0 : k >= width ? width - 1 : k;
+				sum += data[(row + cx) * 4 + c];
+			}
+			for (let x = 0; x < width; x++) {
+				out[(row + x) * 4 + c] = sum / windowLen;
+				const dropX = x - leftRadius;
+				const addX = x + rightRadius + 1;
+				const dc = dropX < 0 ? 0 : dropX >= width ? width - 1 : dropX;
+				const ac = addX < 0 ? 0 : addX >= width ? width - 1 : addX;
+				sum += data[(row + ac) * 4 + c] - data[(row + dc) * 4 + c];
+			}
+		}
+	}
+	return out;
+}
+/** One vertical box blur — the transpose of {@link boxBlurH}. */
+function boxBlurV(data, width, height, topRadius, bottomRadius) {
+	const out = new Float32Array(data.length);
+	const windowLen = topRadius + bottomRadius + 1;
+	for (let x = 0; x < width; x++) for (let c = 0; c < 4; c++) {
+		let sum = 0;
+		for (let k = -topRadius; k <= bottomRadius; k++) {
+			const cy = k < 0 ? 0 : k >= height ? height - 1 : k;
+			sum += data[(cy * width + x) * 4 + c];
+		}
+		for (let y = 0; y < height; y++) {
+			out[(y * width + x) * 4 + c] = sum / windowLen;
+			const dropY = y - topRadius;
+			const addY = y + bottomRadius + 1;
+			const dc = dropY < 0 ? 0 : dropY >= height ? height - 1 : dropY;
+			const ac = addY < 0 ? 0 : addY >= height ? height - 1 : addY;
+			sum += data[(ac * width + x) * 4 + c] - data[(dc * width + x) * 4 + c];
+		}
+	}
+	return out;
+}
+/**
+* Apply the three successive box blurs that approximate a Gaussian along one
+* axis, following the SVG 1.1 §15.17 odd/even centring rule for box size `d`.
+*
+* - `d` odd: three box blurs of size `d`, centred on the output pixel
+*   (`radius = (d-1)/2` each side).
+* - `d` even: two box blurs of size `d` (one offset left-of-centre, one
+*   right-of-centre) plus one box blur of size `d + 1` centred.
+* - `d <= 1`: identity (no perceivable blur on this axis).
+*/
+function threeBoxBlurAxis(data, width, height, d, horizontal) {
+	if (d <= 1) return data;
+	const blur = horizontal ? boxBlurH : boxBlurV;
+	if (d % 2 === 1) {
+		const r = (d - 1) / 2;
+		let cur = blur(data, width, height, r, r);
+		cur = blur(cur, width, height, r, r);
+		cur = blur(cur, width, height, r, r);
+		return cur;
+	}
+	const half = d / 2;
+	let cur = blur(data, width, height, half, half - 1);
+	cur = blur(cur, width, height, half - 1, half);
+	cur = blur(cur, width, height, half, half);
+	return cur;
+}
+/**
+* Approximate a Gaussian blur via three successive box blurs.
+*
+* Implements `feGaussianBlur` (SVG 1.1 §15.17). The blur is performed in
+* **premultiplied** colour space (the correct space for averaging colours
+* with varying alpha) and un-premultiplied on output. A standard deviation of
+* 0 on an axis is a no-op for that axis.
+*
+* The per-axis box size is `d = floor(s · 3 · √(2π) / 4 + 0.5)` with the
+* spec's odd/even centring rule.
+*
+* @param src     Source buffer.
+* @param stdDevX Standard deviation along X (>= 0).
+* @param stdDevY Standard deviation along Y; defaults to `stdDevX`.
+* @returns       A new, blurred buffer of the same size.
+* @throws If either standard deviation is negative.
+*/
+function feGaussianBlur(src, stdDevX, stdDevY) {
+	const sx = stdDevX;
+	const sy = stdDevY ?? stdDevX;
+	if (sx < 0 || sy < 0 || Number.isNaN(sx) || Number.isNaN(sy)) throw new Error(`svgFilters.feGaussianBlur: standard deviation must be >= 0 (got ${sx}, ${sy})`);
+	if (sx === 0 && sy === 0) return {
+		width: src.width,
+		height: src.height,
+		rgba: src.rgba.slice()
+	};
+	let data = toPremultipliedF32(src);
+	if (sx > 0) data = threeBoxBlurAxis(data, src.width, src.height, boxBlurD(sx), true);
+	if (sy > 0) data = threeBoxBlurAxis(data, src.width, src.height, boxBlurD(sy), false);
+	return fromPremultipliedF32(data, src.width, src.height);
+}
+/**
+* Composite two buffers with a Porter-Duff operator.
+*
+* Implements `feComposite` with operators `over`, `in`, `out`, `atop`, `xor`
+* (SVG 1.1 §15.13; Porter & Duff, SIGGRAPH 1984). The general form on
+* premultiplied colour is:
+*
+* ```
+* cr = ca · Fa + cb · Fb
+* ar = aa · Fa + ab · Fb
+* ```
+*
+* with coefficients (`aa`, `ab` = source/destination alpha):
+*
+* | op   | Fa        | Fb        |
+* | ---- | --------- | --------- |
+* | over | 1         | 1 − aa    |
+* | in   | ab        | 0         |
+* | out  | 1 − ab    | 0         |
+* | atop | ab        | 1 − aa    |
+* | xor  | 1 − ab    | 1 − aa    |
+*
+* Here `a` is the source (foreground) and `b` is the destination
+* (background). Both buffers must be the same size.
+*
+* @param a  Source (foreground) buffer.
+* @param b  Destination (background) buffer.
+* @param op Porter-Duff operator.
+* @returns  A new composited buffer of the same size.
+* @throws If the buffers differ in size.
+*/
+function feComposite(a, b, op) {
+	assertSameSize(a, b);
+	const out = allocBuffer(a.width, a.height);
+	const n = a.width * a.height;
+	for (let i = 0; i < n; i++) {
+		const aa = a.rgba[i * 4 + 3] / 255;
+		const ab = b.rgba[i * 4 + 3] / 255;
+		const ar = a.rgba[i * 4 + 0] / 255 * aa;
+		const ag = a.rgba[i * 4 + 1] / 255 * aa;
+		const abl = a.rgba[i * 4 + 2] / 255 * aa;
+		const br = b.rgba[i * 4 + 0] / 255 * ab;
+		const bg = b.rgba[i * 4 + 1] / 255 * ab;
+		const bb = b.rgba[i * 4 + 2] / 255 * ab;
+		let fa;
+		let fb;
+		switch (op) {
+			case "over":
+				fa = 1;
+				fb = 1 - aa;
+				break;
+			case "in":
+				fa = ab;
+				fb = 0;
+				break;
+			case "out":
+				fa = 1 - ab;
+				fb = 0;
+				break;
+			case "atop":
+				fa = ab;
+				fb = 1 - aa;
+				break;
+			case "xor":
+				fa = 1 - ab;
+				fb = 1 - aa;
+				break;
+			default: throw new Error(`svgFilters.feComposite: unknown operator ${String(op)}`);
+		}
+		const cr = ar * fa + br * fb;
+		const cg = ag * fa + bg * fb;
+		const cb = abl * fa + bb * fb;
+		const car = aa * fa + ab * fb;
+		if (car <= 0) {
+			out.rgba[i * 4 + 0] = 0;
+			out.rgba[i * 4 + 1] = 0;
+			out.rgba[i * 4 + 2] = 0;
+			out.rgba[i * 4 + 3] = 0;
+		} else {
+			out.rgba[i * 4 + 0] = clamp8(cr / car * 255);
+			out.rgba[i * 4 + 1] = clamp8(cg / car * 255);
+			out.rgba[i * 4 + 2] = clamp8(cb / car * 255);
+			out.rgba[i * 4 + 3] = clamp8(car * 255);
+		}
+	}
+	return out;
+}
+/**
+* Blend two buffers with one of the basic SVG 1.1 blend modes.
+*
+* Implements `feBlend` (SVG 1.1 §15.11). The spec defines the result on
+* **premultiplied** colour with `qa` = source alpha, `qb` = destination
+* alpha:
+*
+* - normal:   `cr = (1 − qa)·cb + ca`
+* - multiply: `cr = (1 − qa)·cb + (1 − qb)·ca + ca·cb`
+* - screen:   `cr = cb + ca − ca·cb`
+* - darken:   `cr = min((1 − qa)·cb + ca, (1 − qb)·ca + cb)`
+* - lighten:  `cr = max((1 − qa)·cb + ca, (1 − qb)·ca + cb)`
+*
+* with the common result alpha `ar = 1 − (1 − qa)·(1 − qb)`. Inputs `a`
+* (source) and `b` (destination) must be the same size.
+*
+* @param a    Source (top) buffer.
+* @param b    Destination (bottom) buffer.
+* @param mode Blend mode.
+* @returns    A new blended buffer of the same size.
+* @throws If the buffers differ in size.
+*/
+function feBlend(a, b, mode) {
+	assertSameSize(a, b);
+	const out = allocBuffer(a.width, a.height);
+	const n = a.width * a.height;
+	for (let i = 0; i < n; i++) {
+		const qa = a.rgba[i * 4 + 3] / 255;
+		const qb = b.rgba[i * 4 + 3] / 255;
+		const ar = 1 - (1 - qa) * (1 - qb);
+		out.rgba[i * 4 + 3] = clamp8(ar * 255);
+		for (let c = 0; c < 3; c++) {
+			const ca = a.rgba[i * 4 + c] / 255 * qa;
+			const cb = b.rgba[i * 4 + c] / 255 * qb;
+			let cr;
+			switch (mode) {
+				case "normal":
+					cr = (1 - qa) * cb + ca;
+					break;
+				case "multiply":
+					cr = (1 - qa) * cb + (1 - qb) * ca + ca * cb;
+					break;
+				case "screen":
+					cr = cb + ca - ca * cb;
+					break;
+				case "darken":
+					cr = Math.min((1 - qa) * cb + ca, (1 - qb) * ca + cb);
+					break;
+				case "lighten":
+					cr = Math.max((1 - qa) * cb + ca, (1 - qb) * ca + cb);
+					break;
+				default: throw new Error(`svgFilters.feBlend: unknown mode ${String(mode)}`);
+			}
+			if (ar <= 0) out.rgba[i * 4 + c] = 0;
+			else out.rgba[i * 4 + c] = clamp8(cr / ar * 255);
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/render/matrix.ts
+/** The identity transform. */
+function identity() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Concatenate two transforms: the result applies `m` **first**, then `n`
+* (i.e. `point · m · n`). This matches the PDF `cm` operator, where the new
+* CTM is `cmMatrix × CTM`.
+*/
+function multiply(m, n) {
+	return [
+		m[0] * n[0] + m[1] * n[2],
+		m[0] * n[1] + m[1] * n[3],
+		m[2] * n[0] + m[3] * n[2],
+		m[2] * n[1] + m[3] * n[3],
+		m[4] * n[0] + m[5] * n[2] + n[4],
+		m[4] * n[1] + m[5] * n[3] + n[5]
+	];
+}
+/** Apply a transform to a point, returning the transformed `[x, y]`. */
+function applyToPoint(m, x, y) {
+	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+/** A pure translation transform. */
+function translation(tx, ty) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		tx,
+		ty
+	];
+}
+/**
+* The magnitude by which `m` scales lengths — the geometric mean of the
+* x- and y-axis scale factors (`sqrt(|det|)`). Used to map a user-space line
+* width to device space.
+*/
+function meanScale(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	return Math.sqrt(Math.abs(det));
+}
+//#endregion
+//#region src/render/interpreter.ts
+/**
+* @module render/interpreter
+*
+* Executes a parsed PDF content stream through a graphics-state machine,
+* producing a resolution-independent {@link DisplayList} (page space, y-up).
+* This is the foundation the rasterizer and Canvas adapter render from.
+*
+* Supported operators: graphics state (`q`/`Q`/`cm`/`w`/`J`/`j`/`gs`), path
+* construction (`m`/`l`/`c`/`v`/`y`/`re`/`h`), path painting
+* (`f`/`F`/`f*`/`S`/`s`/`B`/`B*`/`b`/`b*`/`n`), clipping (`W`/`W*`), color
+* (`rg`/`RG`/`g`/`G`/`k`/`K`/`cs`/`CS`/`sc`/`scn`/`SC`/`SCN`), text
+* (`BT`/`ET`/`Tf`/`Td`/`TD`/`Tm`/`T*`/`Tc`/`Tw`/`Tz`/`TL`/`Ts`/`Tr`/`Tj`/`TJ`/`'`/`"`),
+* and XObjects (`Do`, recursing into form XObjects). Bézier curves are
+* flattened to polylines.
+*
+* @packageDocumentation
+*/
+function initialState$1() {
+	return {
+		ctm: identity(),
+		fill: [
+			0,
+			0,
+			0,
+			255
+		],
+		stroke: [
+			0,
+			0,
+			0,
+			255
+		],
+		lineWidth: 1,
+		lineCap: 0,
+		lineJoin: 0,
+		fillAlpha: 1,
+		strokeAlpha: 1,
+		clip: void 0,
+		font: void 0,
+		fontSize: 0,
+		charSpace: 0,
+		wordSpace: 0,
+		hScale: 1,
+		leading: 0,
+		rise: 0,
+		renderMode: 0
+	};
+}
+function cloneState(s) {
+	return { ...s };
+}
+function num$2(op) {
+	return typeof op === "number" ? op : 0;
+}
+function nameOf(op) {
+	if (op instanceof require_pdfObjects.PdfName) return op.value.replace(/^\//, "");
+	if (typeof op === "string") return op.replace(/^\//, "");
+}
+function clamp255(v) {
+	return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function grayRgba(g) {
+	const v = clamp255(g);
+	return [
+		v,
+		v,
+		v,
+		255
+	];
+}
+function rgbRgba(r, g, b) {
+	return [
+		clamp255(r),
+		clamp255(g),
+		clamp255(b),
+		255
+	];
+}
+function cmykRgba(c, m, y, k) {
+	const [r, g, b] = require_pdfDocument.cmykToRgb(c, m, y, k);
+	return [
+		clamp255(r),
+		clamp255(g),
+		clamp255(b),
+		255
+	];
+}
+/** Interpret `sc`/`scn` numeric components by arity → RGBA. */
+function componentsToRgba(comps) {
+	if (comps.length === 1) return grayRgba(comps[0]);
+	if (comps.length === 3) return rgbRgba(comps[0], comps[1], comps[2]);
+	if (comps.length === 4) return cmykRgba(comps[0], comps[1], comps[2], comps[3]);
+}
+const BEZIER_STEPS = 16;
+function flattenCubic(out, p0, p1, p2, p3) {
+	for (let i = 1; i <= BEZIER_STEPS; i++) {
+		const t = i / BEZIER_STEPS;
+		const mt = 1 - t;
+		const a = mt * mt * mt;
+		const b = 3 * mt * mt * t;
+		const c = 3 * mt * t * t;
+		const d = t * t * t;
+		out.push(a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]);
+	}
+}
+/**
+* Execute a parsed content stream into a {@link DisplayList}.
+*
+* @param operators - Output of {@link parseContentStream}.
 * @param options   - Page dimensions and (optional) resources/registry.
 */
 function interpretContentStream(operators, options) {
@@ -34876,6 +36516,12 @@ Object.defineProperty(exports, "buildColorKeyMask", {
 		return buildColorKeyMask;
 	}
 });
+Object.defineProperty(exports, "buildCoonsPatchShading", {
+	enumerable: true,
+	get: function() {
+		return buildCoonsPatchShading;
+	}
+});
 Object.defineProperty(exports, "buildDPartRoot", {
 	enumerable: true,
 	get: function() {
@@ -34924,6 +36570,12 @@ Object.defineProperty(exports, "buildFieldLockDict", {
 		return buildFieldLockDict;
 	}
 });
+Object.defineProperty(exports, "buildFreeFormGouraudShading", {
+	enumerable: true,
+	get: function() {
+		return buildFreeFormGouraudShading;
+	}
+});
 Object.defineProperty(exports, "buildFunctionShading", {
 	enumerable: true,
 	get: function() {
@@ -34948,6 +36600,12 @@ Object.defineProperty(exports, "buildLab", {
 		return buildLab;
 	}
 });
+Object.defineProperty(exports, "buildLatticeFormGouraudShading", {
+	enumerable: true,
+	get: function() {
+		return buildLatticeFormGouraudShading;
+	}
+});
 Object.defineProperty(exports, "buildNamespace", {
 	enumerable: true,
 	get: function() {
@@ -35056,6 +36714,12 @@ Object.defineProperty(exports, "buildStencilMask", {
 		return buildStencilMask;
 	}
 });
+Object.defineProperty(exports, "buildTensorPatchShading", {
+	enumerable: true,
+	get: function() {
+		return buildTensorPatchShading;
+	}
+});
 Object.defineProperty(exports, "buildThresholdHalftone", {
 	enumerable: true,
 	get: function() {
@@ -35230,6 +36894,12 @@ Object.defineProperty(exports, "dataMatrixToOperators", {
 		return dataMatrixToOperators;
 	}
 });
+Object.defineProperty(exports, "decodeRegisteredImage", {
+	enumerable: true,
+	get: function() {
+		return decodeRegisteredImage;
+	}
+});
 Object.defineProperty(exports, "decodeTile", {
 	enumerable: true,
 	get: function() {
@@ -35266,12 +36936,24 @@ Object.defineProperty(exports, "detectModifications", {
 		return detectModifications;
 	}
 });
+Object.defineProperty(exports, "detectNextGenFormat", {
+	enumerable: true,
+	get: function() {
+		return detectNextGenFormat;
+	}
+});
 Object.defineProperty(exports, "detectTransparency", {
 	enumerable: true,
 	get: function() {
 		return detectTransparency;
 	}
 });
+Object.defineProperty(exports, "deviceRgbToXyz", {
+	enumerable: true,
+	get: function() {
+		return deviceRgbToXyz;
+	}
+});
 Object.defineProperty(exports, "didYouMean", {
 	enumerable: true,
 	get: function() {
@@ -35488,6 +37170,48 @@ Object.defineProperty(exports, "extractXmpMetadata", {
 		return extractXmpMetadata;
 	}
 });
+Object.defineProperty(exports, "feBlend", {
+	enumerable: true,
+	get: function() {
+		return feBlend;
+	}
+});
+Object.defineProperty(exports, "feColorMatrix", {
+	enumerable: true,
+	get: function() {
+		return feColorMatrix;
+	}
+});
+Object.defineProperty(exports, "feColorMatrixSaturate", {
+	enumerable: true,
+	get: function() {
+		return feColorMatrixSaturate;
+	}
+});
+Object.defineProperty(exports, "feComposite", {
+	enumerable: true,
+	get: function() {
+		return feComposite;
+	}
+});
+Object.defineProperty(exports, "feFlood", {
+	enumerable: true,
+	get: function() {
+		return feFlood;
+	}
+});
+Object.defineProperty(exports, "feGaussianBlur", {
+	enumerable: true,
+	get: function() {
+		return feGaussianBlur;
+	}
+});
+Object.defineProperty(exports, "feOffset", {
+	enumerable: true,
+	get: function() {
+		return feOffset;
+	}
+});
 Object.defineProperty(exports, "findChangedObjects", {
 	enumerable: true,
 	get: function() {
@@ -35704,6 +37428,12 @@ Object.defineProperty(exports, "getFieldValue", {
 		return getFieldValue;
 	}
 });
+Object.defineProperty(exports, "getImageDecoder", {
+	enumerable: true,
+	get: function() {
+		return getImageDecoder;
+	}
+});
 Object.defineProperty(exports, "getLinearizationInfo", {
 	enumerable: true,
 	get: function() {
@@ -35740,12 +37470,30 @@ Object.defineProperty(exports, "h", {
 		return h;
 	}
 });
+Object.defineProperty(exports, "hasImageDecoder", {
+	enumerable: true,
+	get: function() {
+		return hasImageDecoder;
+	}
+});
 Object.defineProperty(exports, "hasLtvData", {
 	enumerable: true,
 	get: function() {
 		return hasLtvData;
 	}
 });
+Object.defineProperty(exports, "hslToRgb", {
+	enumerable: true,
+	get: function() {
+		return hslToRgb;
+	}
+});
+Object.defineProperty(exports, "hsvToRgb", {
+	enumerable: true,
+	get: function() {
+		return hsvToRgb;
+	}
+});
 Object.defineProperty(exports, "identityTransferFunction", {
 	enumerable: true,
 	get: function() {
@@ -35938,6 +37686,12 @@ Object.defineProperty(exports, "parseExistingTrailer", {
 		return parseExistingTrailer;
 	}
 });
+Object.defineProperty(exports, "parseIccTransform", {
+	enumerable: true,
+	get: function() {
+		return parseIccTransform;
+	}
+});
 Object.defineProperty(exports, "parseTileInfo", {
 	enumerable: true,
 	get: function() {
@@ -35986,6 +37740,12 @@ Object.defineProperty(exports, "preflightPdfA", {
 		return preflightPdfA;
 	}
 });
+Object.defineProperty(exports, "probeNextGenImage", {
+	enumerable: true,
+	get: function() {
+		return probeNextGenImage;
+	}
+});
 Object.defineProperty(exports, "processBatch", {
 	enumerable: true,
 	get: function() {
@@ -36076,6 +37836,12 @@ Object.defineProperty(exports, "registerEmbeddedFile", {
 		return registerEmbeddedFile;
 	}
 });
+Object.defineProperty(exports, "registerImageDecoder", {
+	enumerable: true,
+	get: function() {
+		return registerImageDecoder;
+	}
+});
 Object.defineProperty(exports, "removeAllBookmarks", {
 	enumerable: true,
 	get: function() {
@@ -36172,6 +37938,30 @@ Object.defineProperty(exports, "resolveInstanceCoordinates", {
 		return resolveInstanceCoordinates;
 	}
 });
+Object.defineProperty(exports, "rgbToHsl", {
+	enumerable: true,
+	get: function() {
+		return rgbToHsl;
+	}
+});
+Object.defineProperty(exports, "rgbToHsv", {
+	enumerable: true,
+	get: function() {
+		return rgbToHsv;
+	}
+});
+Object.defineProperty(exports, "rgbToLab", {
+	enumerable: true,
+	get: function() {
+		return rgbToLab;
+	}
+});
+Object.defineProperty(exports, "rgbToXyz", {
+	enumerable: true,
+	get: function() {
+		return rgbToXyz;
+	}
+});
 Object.defineProperty(exports, "sampleShadingColor", {
 	enumerable: true,
 	get: function() {
@@ -36376,6 +38166,12 @@ Object.defineProperty(exports, "truncateText", {
 		return truncateText;
 	}
 });
+Object.defineProperty(exports, "unregisterImageDecoder", {
+	enumerable: true,
+	get: function() {
+		return unregisterImageDecoder;
+	}
+});
 Object.defineProperty(exports, "upcAToOperators", {
 	enumerable: true,
 	get: function() {
@@ -36514,5 +38310,17 @@ Object.defineProperty(exports, "wrapText", {
 		return wrapText$2;
 	}
 });
+Object.defineProperty(exports, "xyzToLab", {
+	enumerable: true,
+	get: function() {
+		return xyzToLab;
+	}
+});
+Object.defineProperty(exports, "xyzToRgb", {
+	enumerable: true,
+	get: function() {
+		return xyzToRgb;
+	}
+});
 
-//# sourceMappingURL=src-MIBq9xGq.cjs.map
+//# sourceMappingURL=src-B0gmgVEs.cjs.map