modern-pdf-lib 0.36.0 → 0.38.0

package/dist/{src-4wfgzZvz.mjs → src-DlRTrvWg.mjs}

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