modern-pdf-lib 0.37.0 → 0.38.0

package/dist/{src-CbPUzRbg.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;
@@ -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;
@@ -31386,6 +31386,787 @@ function rgbToLab(r, g, b) {
 	];
 }
 //#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() {
@@ -36113,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() {
@@ -36149,6 +36936,12 @@ Object.defineProperty(exports, "detectModifications", {
 		return detectModifications;
 	}
 });
+Object.defineProperty(exports, "detectNextGenFormat", {
+	enumerable: true,
+	get: function() {
+		return detectNextGenFormat;
+	}
+});
 Object.defineProperty(exports, "detectTransparency", {
 	enumerable: true,
 	get: function() {
@@ -36377,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() {
@@ -36593,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() {
@@ -36629,6 +37470,12 @@ Object.defineProperty(exports, "h", {
 		return h;
 	}
 });
+Object.defineProperty(exports, "hasImageDecoder", {
+	enumerable: true,
+	get: function() {
+		return hasImageDecoder;
+	}
+});
 Object.defineProperty(exports, "hasLtvData", {
 	enumerable: true,
 	get: function() {
@@ -36893,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() {
@@ -36983,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() {
@@ -37307,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() {
@@ -37458,4 +38323,4 @@ Object.defineProperty(exports, "xyzToRgb", {
 	}
 });
 
-//# sourceMappingURL=src-CbPUzRbg.cjs.map
+//# sourceMappingURL=src-B0gmgVEs.cjs.map