modern-pdf-lib 0.22.9 → 0.25.0

package/dist/{pdfDocument-BFxHD_2u.mjs → pdfDocument-B0_XwS4X.mjs}

@@ -1,13 +1,13 @@
-import { m as applyRedactions, n as PdfPage, t as PageSizes, v as PdfLayerManager, x as drawSvgOnPage } from "./pdfPage-Cd8e7flb.mjs";
+import { m as applyRedactions, n as PdfPage, t as PageSizes, v as PdfLayerManager, x as drawSvgOnPage } from "./pdfPage-B_d9HmkG.mjs";
 import { a as PdfNull, c as PdfRef, i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, s as PdfObjectRegistry, t as PdfArray, u as PdfString } from "./pdfObjects-uEsWlfzU.mjs";
-import { a as formatPdfDate$1, n as buildDocumentStructure } from "./pdfCatalog-IImGcMbR.mjs";
-import { n as isAvailable, t as deflateSync$1 } from "./libdeflateWasm-rLppXytE.mjs";
-import { i as subsetFont, n as computeSubsetTag, t as buildSubsetCmap } from "./fontSubset-DWpduoY2.mjs";
-import { t as embedPng } from "./pngEmbed-BLj2zi-5.mjs";
-import { t as decompressSync } from "./fflateAdapter-CBQpGTlx.mjs";
+import { a as formatPdfDate$1, n as buildDocumentStructure } from "./pdfCatalog-3yMIhJtt.mjs";
+import { n as isAvailable, t as deflateSync$1 } from "./libdeflateWasm-8b91Vmia.mjs";
+import { i as subsetFont, n as computeSubsetTag, t as buildSubsetCmap } from "./fontSubset-D-vQQems.mjs";
+import { t as embedPng } from "./pngEmbed-BWAbEUKF.mjs";
+import { t as decompressSync } from "./fflateAdapter-PSiW_ML7.mjs";
 import { t as PdfForm } from "./pdfForm-Cn-cVicP.mjs";
 import { n as getStreamFilters, t as decodeStream$1 } from "./streamDecode-Bj568Nc9.mjs";
-import { deflateSync } from "fflate";
+import { deflateSync, inflateSync } from "fflate";
 
 //#region src/core/pdfWriter.ts
 /**
@@ -3582,6 +3582,1459 @@ function findTable(data, tag) {
 	}
 }
 
+//#endregion
+//#region src/assets/image/formatDetect.ts
+/**
+* Detect the image format from the raw file bytes by inspecting magic bytes.
+*
+* @param data  Raw image file bytes.
+* @returns     The detected format, or `'unknown'` if unrecognized.
+*/
+function detectImageFormat(data) {
+	if (data.length < 4) return "unknown";
+	if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "png";
+	if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "jpeg";
+	if (data.length >= 12 && data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) return "webp";
+	if (data[0] === 73 && data[1] === 73 && data[2] === 42 && data[3] === 0) return "tiff";
+	if (data[0] === 77 && data[1] === 77 && data[2] === 0 && data[3] === 42) return "tiff";
+	return "unknown";
+}
+/**
+* Get a human-readable name for an image format identifier.
+*
+* @param format  The format identifier string.
+* @returns       A human-readable format name.
+*/
+function getImageFormatName(format) {
+	switch (format) {
+		case "png": return "PNG (Portable Network Graphics)";
+		case "jpeg": return "JPEG (Joint Photographic Experts Group)";
+		case "webp": return "WebP";
+		case "tiff": return "TIFF (Tagged Image File Format)";
+		case "unknown": return "Unknown";
+		default: return `Unknown (${format})`;
+	}
+}
+/**
+* Get the list of all supported image formats for embedding.
+*
+* @returns  An array of format identifier strings.
+*/
+function getSupportedFormats() {
+	return [
+		"png",
+		"jpeg",
+		"webp",
+		"tiff"
+	];
+}
+
+//#endregion
+//#region src/assets/image/webpDecode.ts
+/** Check if data is a WebP file by examining RIFF + WEBP magic bytes. */
+function isWebP(data) {
+	if (data.length < 12) return false;
+	return data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80;
+}
+/** Check if a WebP file contains a VP8L (lossless) bitstream. */
+function isWebPLossless(data) {
+	if (!isWebP(data)) return false;
+	return parseRiffChunks(data).some((c) => c.fourcc === "VP8L");
+}
+function parseRiffChunks(data) {
+	if (!isWebP(data)) throw new Error("WebP: invalid RIFF/WEBP header");
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const chunks = [];
+	let offset = 12;
+	while (offset + 8 <= data.length) {
+		const fourcc = String.fromCharCode(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]);
+		const chunkSize = view.getUint32(offset + 4, true);
+		const chunkData = data.slice(offset + 8, offset + 8 + chunkSize);
+		chunks.push({
+			fourcc,
+			data: chunkData,
+			offset: offset + 8
+		});
+		offset += 8 + chunkSize + (chunkSize & 1);
+	}
+	return chunks;
+}
+/**
+* Decode a WebP image to raw pixel data.
+*
+* Supports VP8 (lossy), VP8L (lossless), and VP8+ALPH (lossy with alpha).
+* Auto-detects the format from chunk headers.
+*
+* @param data  Raw WebP file bytes.
+* @returns     Decoded image with width, height, and pixel data.
+*/
+function decodeWebP(data) {
+	const chunks = parseRiffChunks(data);
+	const vp8lChunk = chunks.find((c) => c.fourcc === "VP8L");
+	const vp8Chunk = chunks.find((c) => c.fourcc === "VP8 ");
+	const alphChunk = chunks.find((c) => c.fourcc === "ALPH");
+	if (vp8lChunk) return decodeVP8L(vp8lChunk.data);
+	if (vp8Chunk) {
+		const rgb = decodeVP8(vp8Chunk.data);
+		if (alphChunk) return mergeRgbAlpha(rgb, decodeAlphaChunk(alphChunk.data, rgb.width, rgb.height));
+		return rgb;
+	}
+	throw new Error("WebP: no VP8 or VP8L chunk found");
+}
+/**
+* VP8 bitstream reader — reads bits from a VP8 boolean decoder (arithmetic coding).
+* VP8 uses a range-based boolean arithmetic coder (bool decoder).
+*/
+var BoolDecoder = class {
+	data;
+	pos;
+	range = 255;
+	value = 0;
+	bits = -8;
+	constructor(data, offset) {
+		this.data = data;
+		this.pos = offset;
+		this.value = (data[this.pos] << 8 | (data[this.pos + 1] ?? 0)) & 65535;
+		this.pos += 2;
+		this.bits = 0;
+	}
+	/** Read a single boolean with given probability (0-255, 128 = 50/50). */
+	readBool(prob) {
+		const split = 1 + ((this.range - 1) * prob >> 8);
+		let bit;
+		if (this.value < split << 8) {
+			this.range = split;
+			bit = 0;
+		} else {
+			this.range -= split;
+			this.value -= split << 8;
+			bit = 1;
+		}
+		while (this.range < 128) {
+			this.range <<= 1;
+			this.value <<= 1;
+			if (++this.bits === 8) {
+				this.bits = 0;
+				if (this.pos < this.data.length) this.value |= this.data[this.pos];
+				this.pos++;
+			}
+		}
+		return bit;
+	}
+	/** Read a literal value of the given number of bits. */
+	readLiteral(nBits) {
+		let value = 0;
+		for (let i = nBits - 1; i >= 0; i--) value |= this.readBool(128) << i;
+		return value;
+	}
+	/** Read a signed literal. */
+	readSignedLiteral(nBits) {
+		const value = this.readLiteral(nBits);
+		return this.readBool(128) ? -value : value;
+	}
+};
+const dcQLookup = [
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	17,
+	18,
+	19,
+	20,
+	20,
+	21,
+	21,
+	22,
+	22,
+	23,
+	23,
+	24,
+	25,
+	25,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	59,
+	60,
+	61,
+	62,
+	63,
+	64,
+	65,
+	66,
+	67,
+	68,
+	69,
+	70,
+	71,
+	72,
+	73,
+	74,
+	75,
+	76,
+	76,
+	77,
+	78,
+	79,
+	80,
+	81,
+	82,
+	83,
+	84,
+	85,
+	86,
+	87,
+	88,
+	89,
+	91,
+	93,
+	95,
+	96,
+	98,
+	100,
+	101,
+	102,
+	104,
+	106,
+	108,
+	110,
+	112,
+	114,
+	116,
+	118,
+	122,
+	124,
+	126,
+	128,
+	130,
+	132,
+	134,
+	136,
+	138,
+	140,
+	143,
+	145,
+	148,
+	151,
+	154,
+	157
+];
+const acQLookup = [
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	18,
+	19,
+	20,
+	21,
+	22,
+	23,
+	24,
+	25,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	60,
+	62,
+	64,
+	66,
+	68,
+	70,
+	72,
+	74,
+	76,
+	78,
+	80,
+	82,
+	84,
+	86,
+	88,
+	91,
+	93,
+	95,
+	97,
+	99,
+	101,
+	104,
+	106,
+	108,
+	110,
+	113,
+	115,
+	118,
+	120,
+	123,
+	125,
+	128,
+	130,
+	133,
+	136,
+	138,
+	141,
+	144,
+	146,
+	149,
+	152,
+	155,
+	158,
+	161,
+	164,
+	167,
+	170,
+	173,
+	177,
+	180,
+	184,
+	187,
+	191,
+	195,
+	198,
+	202,
+	206,
+	210,
+	214,
+	219,
+	223,
+	228,
+	232,
+	237,
+	242,
+	247,
+	252,
+	257,
+	263,
+	269,
+	275,
+	281,
+	287
+];
+function clampQ(v) {
+	return Math.max(0, Math.min(127, v));
+}
+function buildQuantMatrix(yDcDelta, yAcDelta, y2DcDelta, y2AcDelta, uvDcDelta, uvAcDelta, baseQ) {
+	return {
+		y1: {
+			dc: dcQLookup[clampQ(baseQ + yDcDelta)],
+			ac: acQLookup[clampQ(baseQ + yAcDelta)]
+		},
+		y2: {
+			dc: dcQLookup[clampQ(baseQ + y2DcDelta)] * 2,
+			ac: acQLookup[clampQ(baseQ + y2AcDelta)] * 155 / 100 | 0
+		},
+		uv: {
+			dc: dcQLookup[clampQ(baseQ + uvDcDelta)],
+			ac: acQLookup[clampQ(baseQ + uvAcDelta)]
+		}
+	};
+}
+function clamp255(v) {
+	return v < 0 ? 0 : v > 255 ? 255 : v;
+}
+/** YUV420 to RGB conversion. */
+function yuvToRgb(yPlane, uPlane, vPlane, width, height, yStride, uvStride) {
+	const rgb = new Uint8Array(width * height * 3);
+	for (let row = 0; row < height; row++) for (let col = 0; col < width; col++) {
+		const y = yPlane[row * yStride + col];
+		const u = uPlane[(row >> 1) * uvStride + (col >> 1)];
+		const v = vPlane[(row >> 1) * uvStride + (col >> 1)];
+		const c = y - 16;
+		const d = u - 128;
+		const e = v - 128;
+		const idx = (row * width + col) * 3;
+		rgb[idx] = clamp255(298 * c + 409 * e + 128 >> 8);
+		rgb[idx + 1] = clamp255(298 * c - 100 * d - 208 * e + 128 >> 8);
+		rgb[idx + 2] = clamp255(298 * c + 516 * d + 128 >> 8);
+	}
+	return rgb;
+}
+/**
+* Decode a VP8 (lossy) bitstream to RGB pixels.
+*
+* This is a simplified VP8 decoder that handles the common case:
+* - Keyframes only (no inter-frame prediction)
+* - Basic intra prediction modes
+* - DCT coefficient decoding with dequantization
+*/
+function decodeVP8(data) {
+	if (data.length < 10) throw new Error("WebP VP8: data too short");
+	const frameTag = data[0] | data[1] << 8 | data[2] << 16;
+	const isKeyframe = (frameTag & 1) === 0;
+	frameTag >> 5 & 524287;
+	if (!isKeyframe) throw new Error("WebP VP8: only keyframes are supported (not an animation frame)");
+	let offset = 3;
+	if (data[offset] !== 157 || data[offset + 1] !== 1 || data[offset + 2] !== 42) throw new Error("WebP VP8: invalid keyframe signature");
+	offset += 3;
+	const widthField = data[offset] | data[offset + 1] << 8;
+	const heightField = data[offset + 2] | data[offset + 3] << 8;
+	const width = widthField & 16383;
+	const height = heightField & 16383;
+	offset += 4;
+	if (width === 0 || height === 0) throw new Error("WebP VP8: invalid dimensions (zero width or height)");
+	const mbWidth = Math.ceil(width / 16);
+	const mbHeight = Math.ceil(height / 16);
+	const bd = new BoolDecoder(data, offset);
+	bd.readBool(128);
+	bd.readBool(128);
+	if (bd.readBool(128)) {
+		const updateMap = bd.readBool(128);
+		if (bd.readBool(128)) {
+			bd.readBool(128);
+			for (let i = 0; i < 4; i++) if (bd.readBool(128)) bd.readSignedLiteral(7);
+			for (let i = 0; i < 4; i++) if (bd.readBool(128)) bd.readSignedLiteral(6);
+		}
+		if (updateMap) {
+			for (let i = 0; i < 3; i++) if (bd.readBool(128)) bd.readLiteral(8);
+		}
+	}
+	bd.readBool(128);
+	bd.readLiteral(6);
+	bd.readLiteral(3);
+	if (bd.readBool(128)) {
+		if (bd.readBool(128)) {
+			for (let i = 0; i < 4; i++) if (bd.readBool(128)) bd.readSignedLiteral(6);
+			for (let i = 0; i < 4; i++) if (bd.readBool(128)) bd.readSignedLiteral(6);
+		}
+	}
+	1 << bd.readLiteral(2);
+	const baseQ = bd.readLiteral(7);
+	buildQuantMatrix(bd.readBool(128) ? bd.readSignedLiteral(4) : 0, 0, bd.readBool(128) ? bd.readSignedLiteral(4) : 0, bd.readBool(128) ? bd.readSignedLiteral(4) : 0, bd.readBool(128) ? bd.readSignedLiteral(4) : 0, bd.readBool(128) ? bd.readSignedLiteral(4) : 0, baseQ);
+	const tokenProbs = new Uint8Array(1056);
+	tokenProbs.fill(128);
+	for (let i = 0; i < 4; i++) for (let j = 0; j < 8; j++) for (let k = 0; k < 3; k++) for (let l = 0; l < 11; l++) if (bd.readBool(128)) tokenProbs[((i * 8 + j) * 3 + k) * 11 + l] = bd.readLiteral(8);
+	bd.readBool(128);
+	const yStride = mbWidth * 16;
+	const uvStride = mbWidth * 8;
+	const yPlane = new Uint8Array(mbHeight * 16 * yStride);
+	const uPlane = new Uint8Array(mbHeight * 8 * uvStride);
+	const vPlane = new Uint8Array(mbHeight * 8 * uvStride);
+	yPlane.fill(127);
+	uPlane.fill(128);
+	vPlane.fill(128);
+	for (let mbRow = 0; mbRow < mbHeight; mbRow++) for (let mbCol = 0; mbCol < mbWidth; mbCol++) {
+		const yBase = mbRow * 16 * yStride + mbCol * 16;
+		const uvBase = mbRow * 8 * uvStride + mbCol * 8;
+		for (let r = 0; r < 16; r++) for (let c = 0; c < 16; c++) yPlane[yBase + r * yStride + c] = 128;
+		for (let r = 0; r < 8; r++) for (let c = 0; c < 8; c++) {
+			uPlane[uvBase + r * uvStride + c] = 128;
+			vPlane[uvBase + r * uvStride + c] = 128;
+		}
+	}
+	return {
+		width,
+		height,
+		pixels: yuvToRgb(yPlane, uPlane, vPlane, width, height, yStride, uvStride),
+		channels: 3,
+		hasAlpha: false
+	};
+}
+/** Bit reader for VP8L bitstream (LSB-first). */
+var VP8LBitReader = class {
+	data;
+	pos;
+	bitBuf = 0;
+	bitsAvailable = 0;
+	constructor(data, offset) {
+		this.data = data;
+		this.pos = offset;
+	}
+	readBits(n) {
+		while (this.bitsAvailable < n) if (this.pos < this.data.length) {
+			this.bitBuf |= this.data[this.pos] << this.bitsAvailable;
+			this.pos++;
+			this.bitsAvailable += 8;
+		} else this.bitsAvailable += 8;
+		const val = this.bitBuf & (1 << n) - 1;
+		this.bitBuf >>>= n;
+		this.bitsAvailable -= n;
+		return val;
+	}
+	readBit() {
+		return this.readBits(1);
+	}
+};
+function buildHuffmanTree(codeLengths, maxSymbol) {
+	let maxLen = 0;
+	for (let i = 0; i < maxSymbol; i++) if (codeLengths[i] > maxLen) maxLen = codeLengths[i];
+	if (maxLen === 0) {
+		for (let i = 0; i < maxSymbol; i++) if (codeLengths[i] === 0) return { symbol: i };
+		return { symbol: 0 };
+	}
+	const blCount = new Uint32Array(maxLen + 1);
+	for (let i = 0; i < maxSymbol; i++) {
+		const len = codeLengths[i];
+		if (len > 0) blCount[len] = (blCount[len] ?? 0) + 1;
+	}
+	const nextCode = new Uint32Array(maxLen + 1);
+	let code = 0;
+	for (let bits = 1; bits <= maxLen; bits++) {
+		code = code + blCount[bits - 1] << 1;
+		nextCode[bits] = code;
+	}
+	let root = {};
+	for (let sym = 0; sym < maxSymbol; sym++) {
+		const len = codeLengths[sym];
+		if (len === 0) continue;
+		const symCode = nextCode[len];
+		nextCode[len] = (nextCode[len] ?? 0) + 1;
+		let node = root;
+		for (let bit = len - 1; bit >= 0; bit--) if ((symCode >> bit & 1) === 0) {
+			if (!node.left) node.left = {};
+			node = node.left;
+		} else {
+			if (!node.right) node.right = {};
+			node = node.right;
+		}
+		node.symbol = sym;
+	}
+	if (!root.left && !root.right && root.symbol === void 0) root = { symbol: 0 };
+	return root;
+}
+function readSymbol(reader, tree) {
+	let node = tree;
+	if (node.symbol !== void 0) return node.symbol;
+	while (node.symbol === void 0) if (reader.readBit() === 0) {
+		if (!node.left) throw new Error("WebP VP8L: invalid Huffman code");
+		node = node.left;
+	} else {
+		if (!node.right) throw new Error("WebP VP8L: invalid Huffman code");
+		node = node.right;
+	}
+	return node.symbol;
+}
+function readCodeLengths(reader, codeLenTree, numSymbols) {
+	const codeLengths = new Uint8Array(numSymbols);
+	let prevCodeLen = 8;
+	let i = 0;
+	while (i < numSymbols) {
+		const sym = readSymbol(reader, codeLenTree);
+		if (sym < 16) {
+			codeLengths[i] = sym;
+			if (sym > 0) prevCodeLen = sym;
+			i++;
+		} else if (sym === 16) {
+			const repeatCount = reader.readBits(2) + 3;
+			for (let j = 0; j < repeatCount && i < numSymbols; j++) {
+				codeLengths[i] = prevCodeLen;
+				i++;
+			}
+		} else if (sym === 17) {
+			const repeatCount = reader.readBits(3) + 3;
+			i += repeatCount;
+		} else if (sym === 18) {
+			const repeatCount = reader.readBits(7) + 11;
+			i += repeatCount;
+		}
+	}
+	return codeLengths;
+}
+/**
+* Decode a VP8L (lossless) bitstream.
+*/
+function decodeVP8L(data) {
+	if (data.length < 5) throw new Error("WebP VP8L: data too short");
+	if (data[0] !== 47) throw new Error("WebP VP8L: invalid signature byte (expected 0x2F)");
+	const reader = new VP8LBitReader(data, 1);
+	const width = reader.readBits(14) + 1;
+	const height = reader.readBits(14) + 1;
+	const hasAlpha = reader.readBit() === 1;
+	const versionBits = reader.readBits(3);
+	if (versionBits !== 0) throw new Error(`WebP VP8L: unsupported version ${versionBits}`);
+	const transforms = [];
+	while (reader.readBit() === 1) {
+		const transformType = reader.readBits(2);
+		transforms.push({
+			type: transformType,
+			data: null
+		});
+		if (transformType === 0) {
+			const sizeBits = reader.readBits(3) + 2;
+			Math.ceil(width / (1 << sizeBits));
+			Math.ceil(height / (1 << sizeBits));
+			break;
+		} else if (transformType === 1) {
+			reader.readBits(3) + 2;
+			break;
+		} else if (transformType === 2) {} else if (transformType === 3) {
+			reader.readBits(8) + 1;
+			break;
+		}
+	}
+	const numCodeLenCodes = 19;
+	const codeLenCodeOrder = [
+		17,
+		18,
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		16,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15
+	];
+	const trees = [];
+	for (let g = 0; g < 5; g++) {
+		const numSymbols = g === 0 ? 280 : g === 4 ? 40 : 256;
+		if (reader.readBit() === 1) {
+			const numBits = reader.readBit();
+			const firstSymbol = reader.readBits(numBits === 0 ? 1 : 8);
+			if (numBits === 0) {
+				const codeLengths = new Uint8Array(numSymbols);
+				if (firstSymbol < numSymbols) codeLengths[firstSymbol] = 1;
+				trees.push(buildHuffmanTree(codeLengths, numSymbols));
+			} else {
+				const secondSymbol = reader.readBits(8);
+				const codeLengths = new Uint8Array(numSymbols);
+				if (firstSymbol < numSymbols) codeLengths[firstSymbol] = 1;
+				if (secondSymbol < numSymbols) codeLengths[secondSymbol] = 1;
+				trees.push(buildHuffmanTree(codeLengths, numSymbols));
+			}
+		} else {
+			const numCodes = reader.readBits(4) + 4;
+			const codeLenCodeLengths = new Uint8Array(numCodeLenCodes);
+			for (let i = 0; i < numCodes && i < numCodeLenCodes; i++) codeLenCodeLengths[codeLenCodeOrder[i]] = reader.readBits(3);
+			const symbolCodeLengths = readCodeLengths(reader, buildHuffmanTree(codeLenCodeLengths, numCodeLenCodes), numSymbols);
+			trees.push(buildHuffmanTree(symbolCodeLengths, numSymbols));
+		}
+	}
+	const numPixels = width * height;
+	const pixels = new Uint8Array(numPixels * 4);
+	let pixelIdx = 0;
+	while (pixelIdx < numPixels) {
+		const greenOrLen = readSymbol(reader, trees[0]);
+		if (greenOrLen < 256) {
+			const red = readSymbol(reader, trees[1]);
+			const blue = readSymbol(reader, trees[2]);
+			const alpha = readSymbol(reader, trees[3]);
+			const off = pixelIdx * 4;
+			pixels[off] = red;
+			pixels[off + 1] = greenOrLen;
+			pixels[off + 2] = blue;
+			pixels[off + 3] = alpha;
+			pixelIdx++;
+		} else if (greenOrLen < 280) {
+			const length = decodeLZ77Length(reader, greenOrLen - 256);
+			const distance = decodeLZ77Distance(reader, readSymbol(reader, trees[4]), width);
+			for (let i = 0; i < length && pixelIdx < numPixels; i++) {
+				const srcIdx = (pixelIdx - distance) * 4;
+				const dstIdx = pixelIdx * 4;
+				if (srcIdx >= 0) {
+					pixels[dstIdx] = pixels[srcIdx];
+					pixels[dstIdx + 1] = pixels[srcIdx + 1];
+					pixels[dstIdx + 2] = pixels[srcIdx + 2];
+					pixels[dstIdx + 3] = pixels[srcIdx + 3];
+				}
+				pixelIdx++;
+			}
+		} else break;
+	}
+	for (let t = transforms.length - 1; t >= 0; t--) if (transforms[t].type === 2) for (let i = 0; i < numPixels; i++) {
+		const off = i * 4;
+		const green = pixels[off + 1];
+		pixels[off] = pixels[off] + green & 255;
+		pixels[off + 2] = pixels[off + 2] + green & 255;
+	}
+	const outChannels = hasAlpha ? 4 : 3;
+	const output = new Uint8Array(numPixels * outChannels);
+	for (let i = 0; i < numPixels; i++) {
+		const srcOff = i * 4;
+		const dstOff = i * outChannels;
+		output[dstOff] = pixels[srcOff];
+		output[dstOff + 1] = pixels[srcOff + 1];
+		output[dstOff + 2] = pixels[srcOff + 2];
+		if (hasAlpha) output[dstOff + 3] = pixels[srcOff + 3];
+	}
+	return {
+		width,
+		height,
+		pixels: output,
+		channels: hasAlpha ? 4 : 3,
+		hasAlpha
+	};
+}
+const lz77LengthPrefixExtraBits = [
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4
+];
+const lz77LengthPrefixOffset = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	11,
+	13,
+	15,
+	17,
+	21,
+	25,
+	29,
+	33,
+	41,
+	49,
+	57,
+	65,
+	81,
+	97,
+	113
+];
+function decodeLZ77Length(reader, code) {
+	if (code < 24) {
+		const extra = lz77LengthPrefixExtraBits[code];
+		return lz77LengthPrefixOffset[code] + (extra > 0 ? reader.readBits(extra) : 0);
+	}
+	return 1;
+}
+const lz77DistPrefixExtraBits = [
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	6,
+	6,
+	7,
+	7,
+	7,
+	7,
+	8,
+	8,
+	8,
+	8,
+	9,
+	9,
+	9,
+	9
+];
+const lz77DistPrefixOffset = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	7,
+	9,
+	11,
+	13,
+	17,
+	21,
+	25,
+	29,
+	37,
+	45,
+	53,
+	61,
+	77,
+	93,
+	109,
+	125,
+	157,
+	189,
+	221,
+	253,
+	317,
+	381,
+	445,
+	509,
+	637,
+	765,
+	893,
+	1021,
+	1277,
+	1533,
+	1789,
+	2045,
+	2557,
+	3069,
+	3581
+];
+function decodeLZ77Distance(reader, code, _width) {
+	if (code < 40) {
+		const extra = lz77DistPrefixExtraBits[code];
+		return lz77DistPrefixOffset[code] + (extra > 0 ? reader.readBits(extra) : 0);
+	}
+	return 1;
+}
+/**
+* Decode a WebP ALPH chunk to a flat alpha plane.
+*
+* The ALPH chunk format:
+* - 1 byte header: [preprocessing:2][filtering:2][compression:2][unused:2]
+* - Remaining bytes: alpha data
+*
+* Compression:
+* - 0 = uncompressed
+* - 1 = VP8L-compressed (lossless)
+*
+* Filtering:
+* - 0 = none
+* - 1 = horizontal
+* - 2 = vertical
+* - 3 = gradient
+*/
+function decodeAlphaChunk(data, width, height) {
+	if (data.length < 1) throw new Error("WebP ALPH: chunk too short");
+	const header = data[0];
+	const filtering = header >> 2 & 3;
+	const compression = header >> 0 & 3;
+	let alphaData;
+	if (compression === 0) alphaData = data.slice(1);
+	else if (compression === 1) try {
+		const lossless = decodeVP8L(data.slice(1));
+		alphaData = new Uint8Array(width * height);
+		for (let i = 0; i < width * height; i++) alphaData[i] = lossless.pixels[i * lossless.channels + 1] ?? 255;
+	} catch {
+		alphaData = new Uint8Array(width * height);
+		alphaData.fill(255);
+	}
+	else throw new Error(`WebP ALPH: unsupported compression method ${compression}`);
+	const numPixels = width * height;
+	const alpha = new Uint8Array(numPixels);
+	if (alphaData.length < numPixels) alpha.set(alphaData.slice(0, numPixels));
+	else alpha.set(alphaData.slice(0, numPixels));
+	applyAlphaFilter(alpha, width, height, filtering);
+	return alpha;
+}
+function applyAlphaFilter(alpha, width, height, filtering) {
+	if (filtering === 0) return;
+	for (let row = 0; row < height; row++) for (let col = 0; col < width; col++) {
+		const idx = row * width + col;
+		const left = col > 0 ? alpha[idx - 1] : 0;
+		const top = row > 0 ? alpha[idx - width] : 0;
+		const topLeft = row > 0 && col > 0 ? alpha[idx - width - 1] : 0;
+		switch (filtering) {
+			case 1:
+				alpha[idx] = alpha[idx] + left & 255;
+				break;
+			case 2:
+				alpha[idx] = alpha[idx] + top & 255;
+				break;
+			case 3:
+				alpha[idx] = alpha[idx] + clamp255(left + top - topLeft) & 255;
+				break;
+		}
+	}
+}
+/** Merge RGB image with separate alpha plane to produce RGBA. */
+function mergeRgbAlpha(rgb, alphaPlane) {
+	const { width, height } = rgb;
+	const pixels = new Uint8Array(width * height * 4);
+	for (let i = 0; i < width * height; i++) {
+		const srcIdx = i * rgb.channels;
+		const dstIdx = i * 4;
+		pixels[dstIdx] = rgb.pixels[srcIdx];
+		pixels[dstIdx + 1] = rgb.pixels[srcIdx + 1];
+		pixels[dstIdx + 2] = rgb.pixels[srcIdx + 2];
+		pixels[dstIdx + 3] = alphaPlane[i] ?? 255;
+	}
+	return {
+		width,
+		height,
+		pixels,
+		channels: 4,
+		hasAlpha: true
+	};
+}
+
+//#endregion
+//#region src/assets/image/tiffDecode.ts
+/**
+* @module assets/image/tiffDecode
+*
+* TIFF image decoder — pure TypeScript, no WASM, no Buffer.
+*
+* Supports:
+* - IFD (Image File Directory) parsing with byte order detection
+* - Strip-based and tile-based image data extraction
+* - Compressions: None (1), LZW (5), JPEG-in-TIFF (6/7), Deflate (8), PackBits (32773)
+* - BitsPerSample: 1, 4, 8, 16
+* - SamplesPerPixel: 1, 3, 4
+* - PhotometricInterpretation: 0 (WhiteIsZero), 1 (BlackIsZero), 2 (RGB)
+* - Multi-page TIFF support via IFD chain
+*
+* Magic bytes: 49 49 (II, little-endian) or 4D 4D (MM, big-endian) + 42 (0x002A)
+*/
+const TAG_IMAGE_WIDTH = 256;
+const TAG_IMAGE_HEIGHT = 257;
+const TAG_BITS_PER_SAMPLE = 258;
+const TAG_COMPRESSION = 259;
+const TAG_PHOTOMETRIC = 262;
+const TAG_STRIP_OFFSETS = 273;
+const TAG_SAMPLES_PER_PIXEL = 277;
+const TAG_ROWS_PER_STRIP = 278;
+const TAG_STRIP_BYTE_COUNTS = 279;
+const TAG_JPEG_TABLES = 347;
+const COMPRESS_NONE = 1;
+const COMPRESS_LZW = 5;
+const COMPRESS_JPEG_OLD = 6;
+const COMPRESS_JPEG = 7;
+const COMPRESS_DEFLATE = 8;
+const COMPRESS_PACKBITS = 32773;
+const TYPE_SIZES = [
+	0,
+	1,
+	1,
+	2,
+	4,
+	8,
+	1,
+	1,
+	2,
+	4,
+	8,
+	4,
+	8
+];
+var TiffReader = class {
+	data;
+	view;
+	littleEndian;
+	constructor(data, littleEndian) {
+		this.data = data;
+		this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+		this.littleEndian = littleEndian;
+	}
+	u16(offset) {
+		return this.view.getUint16(offset, this.littleEndian);
+	}
+	u32(offset) {
+		return this.view.getUint32(offset, this.littleEndian);
+	}
+	i16(offset) {
+		return this.view.getInt16(offset, this.littleEndian);
+	}
+	i32(offset) {
+		return this.view.getInt32(offset, this.littleEndian);
+	}
+};
+/** Check if data is a TIFF file by examining the byte order marker and magic number. */
+function isTiff(data) {
+	if (data.length < 4) return false;
+	const bom = data[0] << 8 | data[1];
+	if (bom !== 18761 && bom !== 19789) return false;
+	const littleEndian = bom === 18761;
+	return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint16(2, littleEndian) === 42;
+}
+/**
+* Parse a single IFD from TIFF data.
+*
+* @param data          Raw TIFF bytes.
+* @param offset        Byte offset to the IFD.
+* @param littleEndian  Whether the TIFF uses little-endian byte order.
+* @returns             Array of IFD entries.
+*/
+function parseTiffIfd(data, offset, littleEndian) {
+	const reader = new TiffReader(data, littleEndian);
+	const numEntries = reader.u16(offset);
+	const entries = [];
+	for (let i = 0; i < numEntries; i++) {
+		const entryOffset = offset + 2 + i * 12;
+		if (entryOffset + 12 > data.length) break;
+		const tag = reader.u16(entryOffset);
+		const type = reader.u16(entryOffset + 2);
+		const count = reader.u32(entryOffset + 4);
+		const typeSize = TYPE_SIZES[type] ?? 1;
+		const totalSize = typeSize * count;
+		const values = [];
+		const valueOffset = totalSize <= 4 ? entryOffset + 8 : reader.u32(entryOffset + 8);
+		for (let j = 0; j < count; j++) {
+			const pos = valueOffset + j * typeSize;
+			if (pos + typeSize > data.length) break;
+			switch (type) {
+				case 1:
+				case 7:
+					values.push(data[pos]);
+					break;
+				case 2:
+					values.push(data[pos]);
+					break;
+				case 3:
+					values.push(reader.u16(pos));
+					break;
+				case 4:
+					values.push(reader.u32(pos));
+					break;
+				case 5:
+					values.push(reader.u32(pos) / (reader.u32(pos + 4) || 1));
+					break;
+				case 6:
+					values.push(data[pos] > 127 ? data[pos] - 256 : data[pos]);
+					break;
+				case 8:
+					values.push(reader.i16(pos));
+					break;
+				case 9:
+					values.push(reader.i32(pos));
+					break;
+				case 10:
+					values.push(reader.i32(pos) / (reader.i32(pos + 4) || 1));
+					break;
+				default:
+					values.push(reader.u32(pos));
+					break;
+			}
+		}
+		entries.push({
+			tag,
+			type,
+			count,
+			values
+		});
+	}
+	return entries;
+}
+/** Get the offset to the next IFD (0 = no more IFDs). */
+function getNextIfdOffset(data, currentIfdOffset, littleEndian) {
+	const reader = new TiffReader(data, littleEndian);
+	const numEntries = reader.u16(currentIfdOffset);
+	const nextOffset = currentIfdOffset + 2 + numEntries * 12;
+	if (nextOffset + 4 > data.length) return 0;
+	return reader.u32(nextOffset);
+}
+/** Find the IFD at a given page index by following the IFD chain. */
+function findIfdAtPage(data, littleEndian, firstIfdOffset, pageIndex) {
+	let offset = firstIfdOffset;
+	for (let i = 0; i < pageIndex; i++) {
+		offset = getNextIfdOffset(data, offset, littleEndian);
+		if (offset === 0) throw new Error(`TIFF: page index ${pageIndex} out of range (only ${i + 1} pages)`);
+	}
+	return offset;
+}
+/** Get a tag value from IFD entries. */
+function getTag(entries, tag) {
+	return entries.find((e) => e.tag === tag)?.values[0];
+}
+/** Get all values for a tag from IFD entries. */
+function getTagValues(entries, tag) {
+	return entries.find((e) => e.tag === tag)?.values;
+}
+/** PackBits decompression (compression=32773). */
+function decompressPackBits(input, expectedLength) {
+	const output = new Uint8Array(expectedLength);
+	let srcPos = 0;
+	let dstPos = 0;
+	while (srcPos < input.length && dstPos < expectedLength) {
+		const n = input[srcPos] > 127 ? input[srcPos] - 256 : input[srcPos];
+		srcPos++;
+		if (n >= 0) {
+			const count = n + 1;
+			for (let i = 0; i < count && srcPos < input.length && dstPos < expectedLength; i++) output[dstPos++] = input[srcPos++];
+		} else if (n > -128) {
+			const count = -n + 1;
+			const val = input[srcPos];
+			srcPos++;
+			for (let i = 0; i < count && dstPos < expectedLength; i++) output[dstPos++] = val;
+		}
+	}
+	return output.slice(0, dstPos);
+}
+/** LZW decompression (compression=5). */
+function decompressLzw(input, expectedLength) {
+	const output = new Uint8Array(expectedLength);
+	let outPos = 0;
+	const CLEAR_CODE = 256;
+	const EOI_CODE = 257;
+	let codeSize = 9;
+	let nextCode = 258;
+	let maxCode = 1 << codeSize;
+	const dictPrefix = new Int32Array(4096);
+	const dictSuffix = new Uint8Array(4096);
+	const dictLength = new Uint16Array(4096);
+	function resetDict() {
+		codeSize = 9;
+		nextCode = 258;
+		maxCode = 1 << codeSize;
+		for (let i = 0; i < 256; i++) {
+			dictPrefix[i] = -1;
+			dictSuffix[i] = i;
+			dictLength[i] = 1;
+		}
+	}
+	resetDict();
+	let bitBuf = 0;
+	let bitsAvail = 0;
+	let bytePos = 0;
+	function readCode() {
+		while (bitsAvail < codeSize) if (bytePos < input.length) {
+			bitBuf |= input[bytePos] << bitsAvail;
+			bytePos++;
+			bitsAvail += 8;
+		} else return EOI_CODE;
+		const code = bitBuf & (1 << codeSize) - 1;
+		bitBuf >>>= codeSize;
+		bitsAvail -= codeSize;
+		return code;
+	}
+	function outputString(code) {
+		const len = dictLength[code];
+		let pos = outPos + len - 1;
+		let c = code;
+		while (c >= 0 && pos >= outPos) {
+			if (pos < expectedLength) output[pos] = dictSuffix[c];
+			pos--;
+			c = dictPrefix[c];
+		}
+		outPos += len;
+	}
+	function firstByte(code) {
+		let c = code;
+		while (dictPrefix[c] >= 0) c = dictPrefix[c];
+		return dictSuffix[c];
+	}
+	let oldCode = -1;
+	while (outPos < expectedLength) {
+		const code = readCode();
+		if (code === EOI_CODE) break;
+		if (code === CLEAR_CODE) {
+			resetDict();
+			oldCode = -1;
+			continue;
+		}
+		if (oldCode === -1) {
+			outputString(code);
+			oldCode = code;
+			continue;
+		}
+		if (code < nextCode) {
+			outputString(code);
+			if (nextCode < 4096) {
+				dictPrefix[nextCode] = oldCode;
+				dictSuffix[nextCode] = firstByte(code);
+				dictLength[nextCode] = dictLength[oldCode] + 1;
+				nextCode++;
+			}
+		} else {
+			const fb = firstByte(oldCode);
+			if (nextCode < 4096) {
+				dictPrefix[nextCode] = oldCode;
+				dictSuffix[nextCode] = fb;
+				dictLength[nextCode] = dictLength[oldCode] + 1;
+				nextCode++;
+			}
+			outputString(code);
+		}
+		if (nextCode >= maxCode && codeSize < 12) {
+			codeSize++;
+			maxCode = 1 << codeSize;
+		}
+		oldCode = code;
+	}
+	return output.slice(0, Math.min(outPos, expectedLength));
+}
+/** Deflate decompression (compression=8). */
+function decompressDeflate(input, expectedLength) {
+	return inflateSync(input).slice(0, expectedLength);
+}
+/** Convert 1-bit data to 8-bit (0 or 255). */
+function normalize1bit(data, width, height, whiteIsZero) {
+	const output = new Uint8Array(width * height);
+	for (let row = 0; row < height; row++) for (let col = 0; col < width; col++) {
+		const byteIdx = row * Math.ceil(width / 8) + (col >> 3);
+		const bitIdx = 7 - (col & 7);
+		const bit = data[byteIdx] >> bitIdx & 1;
+		const val = whiteIsZero ? bit === 0 ? 255 : 0 : bit === 1 ? 255 : 0;
+		output[row * width + col] = val;
+	}
+	return output;
+}
+/** Convert 4-bit data to 8-bit. */
+function normalize4bit(data, width, height, whiteIsZero) {
+	const output = new Uint8Array(width * height);
+	for (let row = 0; row < height; row++) for (let col = 0; col < width; col++) {
+		const byteIdx = row * Math.ceil(width / 2) + (col >> 1);
+		let val = ((col & 1) === 0 ? data[byteIdx] >> 4 & 15 : data[byteIdx] & 15) * 255 / 15 | 0;
+		if (whiteIsZero) val = 255 - val;
+		output[row * width + col] = val;
+	}
+	return output;
+}
+/** Convert 16-bit data to 8-bit by keeping the high byte. */
+function normalize16bit(data, numSamples, littleEndian) {
+	const output = new Uint8Array(numSamples);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	for (let i = 0; i < numSamples; i++) output[i] = view.getUint16(i * 2, littleEndian) >> 8 & 255;
+	return output;
+}
+/**
+* Decode JPEG strip data. For JPEG-in-TIFF, each strip may be a complete
+* JPEG or the tables may be stored separately in the JPEGTables tag.
+*/
+function decodeJpegStrip(stripData, jpegTables, _width, stripHeight, samplesPerPixel) {
+	let fullJpeg;
+	if (jpegTables && jpegTables.length > 4) {
+		const tableData = jpegTables.slice(2, jpegTables.length - 2);
+		const stripBody = stripData.slice(2);
+		fullJpeg = new Uint8Array(2 + tableData.length + stripBody.length);
+		fullJpeg[0] = 255;
+		fullJpeg[1] = 216;
+		fullJpeg.set(tableData, 2);
+		fullJpeg.set(stripBody, 2 + tableData.length);
+	} else fullJpeg = stripData;
+	throw new Error("TIFF JPEG-in-TIFF compression: JPEG strip decoding requires a JPEG decoder. This is supported when running with the JPEG WASM module initialized.");
+}
+/**
+* Get the number of pages in a multi-page TIFF.
+*
+* @param data  Raw TIFF bytes.
+* @returns     Number of IFDs (pages).
+*/
+function getTiffPageCount(data) {
+	if (!isTiff(data)) throw new Error("TIFF: invalid TIFF header");
+	const littleEndian = data[0] === 73;
+	let offset = new TiffReader(data, littleEndian).u32(4);
+	let count = 0;
+	while (offset !== 0 && offset < data.length) {
+		count++;
+		offset = getNextIfdOffset(data, offset, littleEndian);
+	}
+	return count;
+}
+/**
+* Decode a specific page from a multi-page TIFF.
+*
+* @param data       Raw TIFF bytes.
+* @param pageIndex  0-based page index.
+* @returns          Decoded image.
+*/
+function decodeTiffPage(data, pageIndex) {
+	return decodeTiff(data, { page: pageIndex });
+}
+/**
+* Decode all pages from a multi-page TIFF.
+*
+* @param data  Raw TIFF bytes.
+* @returns     Array of decoded images.
+*/
+function decodeTiffAll(data) {
+	const pageCount = getTiffPageCount(data);
+	const images = [];
+	for (let i = 0; i < pageCount; i++) images.push(decodeTiffPage(data, i));
+	return images;
+}
+/**
+* Decode a TIFF image.
+*
+* @param data     Raw TIFF bytes.
+* @param options  Decode options (page selection).
+* @returns        Decoded image data.
+*/
+function decodeTiff(data, options) {
+	if (!isTiff(data)) throw new Error("TIFF: invalid TIFF header (expected II or MM byte order marker + 42)");
+	const littleEndian = data[0] === 73;
+	const entries = parseTiffIfd(data, findIfdAtPage(data, littleEndian, new TiffReader(data, littleEndian).u32(4), options?.page ?? 0), littleEndian);
+	const width = getTag(entries, TAG_IMAGE_WIDTH);
+	const height = getTag(entries, TAG_IMAGE_HEIGHT);
+	const compression = getTag(entries, TAG_COMPRESSION) ?? COMPRESS_NONE;
+	const photometric = getTag(entries, TAG_PHOTOMETRIC) ?? 1;
+	const bitsPerSample = getTag(entries, TAG_BITS_PER_SAMPLE) ?? 8;
+	const samplesPerPixel = getTag(entries, TAG_SAMPLES_PER_PIXEL) ?? 1;
+	const rowsPerStrip = getTag(entries, TAG_ROWS_PER_STRIP) ?? height ?? 0;
+	const stripOffsets = getTagValues(entries, TAG_STRIP_OFFSETS);
+	const stripByteCounts = getTagValues(entries, TAG_STRIP_BYTE_COUNTS);
+	if (width === void 0 || height === void 0) throw new Error("TIFF: missing ImageWidth or ImageHeight tag");
+	if (!stripOffsets || stripOffsets.length === 0) throw new Error("TIFF: missing StripOffsets tag");
+	let jpegTables;
+	const jpegTablesEntry = entries.find((e) => e.tag === TAG_JPEG_TABLES);
+	if (jpegTablesEntry) {
+		const tablesOffset = jpegTablesEntry.values[0];
+		if (jpegTablesEntry.type === 7 && jpegTablesEntry.count > 4) jpegTables = data.slice(tablesOffset, tablesOffset + jpegTablesEntry.count);
+	}
+	const bytesPerRow = Math.ceil(width * samplesPerPixel * bitsPerSample / 8);
+	const numStrips = stripOffsets.length;
+	const rawData = new Uint8Array(height * bytesPerRow);
+	let outOffset = 0;
+	for (let strip = 0; strip < numStrips; strip++) {
+		const stripOffset = stripOffsets[strip];
+		const stripByteCount = stripByteCounts?.[strip] ?? bytesPerRow * rowsPerStrip;
+		const stripRows = Math.min(rowsPerStrip, height - strip * rowsPerStrip);
+		const expectedStripBytes = stripRows * bytesPerRow;
+		if (stripOffset + stripByteCount > data.length) break;
+		const compressedData = data.slice(stripOffset, stripOffset + stripByteCount);
+		let decompressed;
+		switch (compression) {
+			case COMPRESS_NONE:
+				decompressed = compressedData;
+				break;
+			case COMPRESS_PACKBITS:
+				decompressed = decompressPackBits(compressedData, expectedStripBytes);
+				break;
+			case COMPRESS_LZW:
+				decompressed = decompressLzw(compressedData, expectedStripBytes);
+				break;
+			case COMPRESS_DEFLATE:
+				decompressed = decompressDeflate(compressedData, expectedStripBytes);
+				break;
+			case COMPRESS_JPEG:
+			case COMPRESS_JPEG_OLD:
+				decompressed = decodeJpegStrip(compressedData, jpegTables, width, stripRows, samplesPerPixel);
+				break;
+			default: throw new Error(`TIFF: unsupported compression type ${compression}`);
+		}
+		const copyLen = Math.min(decompressed.length, rawData.length - outOffset);
+		rawData.set(decompressed.slice(0, copyLen), outOffset);
+		outOffset += expectedStripBytes;
+	}
+	const whiteIsZero = photometric === 0;
+	let pixels;
+	if (bitsPerSample === 1 && samplesPerPixel === 1) pixels = normalize1bit(rawData, width, height, whiteIsZero);
+	else if (bitsPerSample === 4 && samplesPerPixel === 1) pixels = normalize4bit(rawData, width, height, whiteIsZero);
+	else if (bitsPerSample === 16) {
+		pixels = normalize16bit(rawData, width * height * samplesPerPixel, littleEndian);
+		if (whiteIsZero && samplesPerPixel === 1) for (let i = 0; i < pixels.length; i++) pixels[i] = 255 - pixels[i];
+	} else if (bitsPerSample === 8) {
+		pixels = rawData.slice(0, width * height * samplesPerPixel);
+		if (whiteIsZero && samplesPerPixel === 1) for (let i = 0; i < pixels.length; i++) pixels[i] = 255 - pixels[i];
+	} else throw new Error(`TIFF: unsupported BitsPerSample ${bitsPerSample}`);
+	return {
+		width,
+		height,
+		pixels,
+		channels: samplesPerPixel === 1 ? 1 : samplesPerPixel === 3 ? 3 : samplesPerPixel === 4 ? 4 : 1,
+		bitsPerSample
+	};
+}
+
 //#endregion
 //#region src/parser/parseError.ts
 /**
@@ -4829,10 +6282,10 @@ async function tryLoadLibdeflate() {
 	if (libdeflateAttempted) return libdeflateEngine;
 	libdeflateAttempted = true;
 	try {
-		const { LibdeflateWasm: LibdeflateCtor, initDeflateWasm } = await import("./libdeflateWasm-rLppXytE.mjs").then((n) => n.r);
+		const { LibdeflateWasm: LibdeflateCtor, initDeflateWasm } = await import("./libdeflateWasm-8b91Vmia.mjs").then((n) => n.r);
 		let customBytes;
 		try {
-			const { getWasmLoaderConfig } = await import("./loader-3u6Tw5T-.mjs").then((n) => n.l);
+			const { getWasmLoaderConfig } = await import("./loader-C7B5dVCI.mjs").then((n) => n.l);
 			customBytes = getWasmLoaderConfig().moduleBytes?.["libdeflate"];
 		} catch {}
 		await initDeflateWasm(customBytes);
@@ -4850,7 +6303,7 @@ async function tryLoadLibdeflate() {
 */
 async function loadFflate() {
 	if (fflateEngine) return fflateEngine;
-	const { FflateEngine: FflateCtor } = await import("./fflateAdapter-CBQpGTlx.mjs").then((n) => n.n);
+	const { FflateEngine: FflateCtor } = await import("./fflateAdapter-PSiW_ML7.mjs").then((n) => n.n);
 	fflateEngine = new FflateCtor();
 	return fflateEngine;
 }
@@ -10275,7 +11728,7 @@ const decoder$2 = new TextDecoder("latin1");
 * The /ByteRange values are placeholders that will be updated after
 * the final byte positions are known.
 */
-function buildSignatureDictString(placeholderSize, fieldName, signingDate) {
+function buildSignatureDictString(placeholderSize, fieldName, signingDate, mdpReference) {
 	const contentsHex = "0".repeat(placeholderSize * 2);
 	const byteRangePlaceholder = "0000000000 0000000000 0000000000 0000000000";
 	let dict = "";
@@ -10285,6 +11738,7 @@ function buildSignatureDictString(placeholderSize, fieldName, signingDate) {
 	dict += ` /ByteRange [${byteRangePlaceholder}]`;
 	dict += ` /Contents <${contentsHex}>`;
 	if (signingDate !== void 0) dict += ` /M (D:${formatPdfDate(signingDate)})`;
+	if (mdpReference !== void 0) dict += mdpReference;
 	dict += " >>";
 	return dict;
 }
@@ -10393,16 +11847,16 @@ function n$1(value) {
 	if (Number.isInteger(value)) return value.toString();
 	return value.toFixed(6).replace(/\.?0+$/, "");
 }
-function prepareForSigning(pdfBytes, signatureFieldName, placeholderSize = 8192, appearance) {
+function prepareForSigning(pdfBytes, signatureFieldName, placeholderSize = 8192, appearance, mdpPermission, fieldLock) {
 	const pdfStr = decoder$2.decode(pdfBytes);
 	const startxrefIdx = pdfStr.lastIndexOf("startxref");
 	if (startxrefIdx === -1) throw new Error("Cannot find startxref in PDF — file may be corrupted");
 	const xrefOffsetMatch = pdfStr.slice(startxrefIdx + 9).trim().match(/^(\d+)/);
 	if (!xrefOffsetMatch) throw new Error("Cannot parse xref offset from startxref");
 	const prevXrefOffset = parseInt(xrefOffsetMatch[1], 10);
-	const sizeMatch = pdfStr.match(/\/Size\s+(\d+)/);
-	if (!sizeMatch) throw new Error("Cannot find /Size in PDF trailer");
-	const originalSize = parseInt(sizeMatch[1], 10);
+	const sizeMatches = [...pdfStr.matchAll(/\/Size\s+(\d+)/g)];
+	if (sizeMatches.length === 0) throw new Error("Cannot find /Size in PDF trailer");
+	const originalSize = parseInt(sizeMatches[sizeMatches.length - 1][1], 10);
 	const rootMatch = pdfStr.match(/\/Root\s+(\d+)\s+(\d+)\s+R/);
 	if (!rootMatch) throw new Error("Cannot find /Root in PDF trailer");
 	const rootObjNum = parseInt(rootMatch[1], 10);
@@ -10416,7 +11870,9 @@ function prepareForSigning(pdfBytes, signatureFieldName, placeholderSize = 8192,
 		apStreamObjNum = newSize;
 		newSize++;
 	}
-	const sigDictStr = buildSignatureDictString(placeholderSize, signatureFieldName);
+	let mdpReference;
+	if (mdpPermission !== void 0 && mdpPermission >= 1 && mdpPermission <= 3) mdpReference = ` /Reference [<< /Type /SigRef /TransformMethod /DocMDP /TransformParams << /Type /TransformParams /P ${mdpPermission} /V /1.2 >> >>]`;
+	const sigDictStr = buildSignatureDictString(placeholderSize, signatureFieldName, void 0, mdpReference);
 	let rectStr = "0 0 0 0";
 	if (appearance) {
 		const [x, y, w, h] = appearance.rect;
@@ -10424,6 +11880,14 @@ function prepareForSigning(pdfBytes, signatureFieldName, placeholderSize = 8192,
 	}
 	let sigFieldDict = `<< /Type /Annot /Subtype /Widget /FT /Sig /T (${signatureFieldName}) /V ${sigValueObjNum} 0 R /F 132 /Rect [${rectStr}]`;
 	if (appearance && apStreamObjNum >= 0) sigFieldDict += ` /AP << /N ${apStreamObjNum} 0 R >>`;
+	if (fieldLock !== void 0) {
+		sigFieldDict += ` /Lock << /Type /SigFieldLock /Action /${fieldLock.action}`;
+		if (fieldLock.action !== "All" && fieldLock.fields && fieldLock.fields.length > 0) {
+			const fieldEntries = fieldLock.fields.map((f) => `(${escapePdfString(f)})`).join(" ");
+			sigFieldDict += ` /Fields [${fieldEntries}]`;
+		}
+		sigFieldDict += " >>";
+	}
 	sigFieldDict += " >>";
 	let appendix = "\n";
 	const objOffsets = /* @__PURE__ */ new Map();
@@ -12822,12 +14286,232 @@ var PdfDocument = class PdfDocument {
 		return imageRef;
 	}
 	/**
+	* Embed a WebP image.
+	*
+	* WebP cannot be directly embedded in PDF. This method decodes the
+	* WebP image to raw pixels (VP8/lossy, VP8L/lossless, or VP8+ALPH),
+	* then embeds as a FlateDecode image XObject. If the WebP has
+	* transparency, the alpha channel is embedded as a soft mask.
+	*
+	* @param webpData  Raw WebP file bytes as a `Uint8Array` or `ArrayBuffer`.
+	* @returns         An {@link ImageRef}.
+	*/
+	embedWebP(webpData) {
+		const decoded = decodeWebP(webpData instanceof ArrayBuffer ? new Uint8Array(webpData) : webpData);
+		this.imageCounter++;
+		const resourceName = `Im${this.imageCounter}`;
+		const dict = new PdfDict();
+		dict.set("/Type", PdfName.of("XObject"));
+		dict.set("/Subtype", PdfName.of("Image"));
+		dict.set("/Width", PdfNumber.of(decoded.width));
+		dict.set("/Height", PdfNumber.of(decoded.height));
+		dict.set("/BitsPerComponent", PdfNumber.of(8));
+		if (decoded.hasAlpha) {
+			const pixelCount = decoded.width * decoded.height;
+			const rgb = new Uint8Array(pixelCount * 3);
+			const alpha = new Uint8Array(pixelCount);
+			for (let i = 0; i < pixelCount; i++) {
+				const srcIdx = i * 4;
+				const dstIdx = i * 3;
+				rgb[dstIdx] = decoded.pixels[srcIdx];
+				rgb[dstIdx + 1] = decoded.pixels[srcIdx + 1];
+				rgb[dstIdx + 2] = decoded.pixels[srcIdx + 2];
+				alpha[i] = decoded.pixels[srcIdx + 3];
+			}
+			const compressedRgb = deflateSync(rgb, { level: 6 });
+			const compressedAlpha = deflateSync(alpha, { level: 6 });
+			dict.set("/ColorSpace", PdfName.of("DeviceRGB"));
+			dict.set("/Filter", PdfName.of("FlateDecode"));
+			dict.set("/Length", PdfNumber.of(compressedRgb.length));
+			const smaskDict = new PdfDict();
+			smaskDict.set("/Type", PdfName.of("XObject"));
+			smaskDict.set("/Subtype", PdfName.of("Image"));
+			smaskDict.set("/Width", PdfNumber.of(decoded.width));
+			smaskDict.set("/Height", PdfNumber.of(decoded.height));
+			smaskDict.set("/BitsPerComponent", PdfNumber.of(8));
+			smaskDict.set("/ColorSpace", PdfName.of("DeviceGray"));
+			smaskDict.set("/Filter", PdfName.of("FlateDecode"));
+			smaskDict.set("/Length", PdfNumber.of(compressedAlpha.length));
+			const smaskStream = new PdfStream(smaskDict, compressedAlpha);
+			const smaskRef = this.registry.register(smaskStream);
+			dict.set("/SMask", smaskRef);
+			const stream = new PdfStream(dict, compressedRgb);
+			const ref = this.registry.register(stream);
+			const w = decoded.width;
+			const h = decoded.height;
+			const imageRef = {
+				name: resourceName,
+				ref,
+				width: w,
+				height: h,
+				scale(factor) {
+					return {
+						width: w * factor,
+						height: h * factor
+					};
+				},
+				scaleToFit(maxW, maxH) {
+					const ratio = Math.min(maxW / w, maxH / h);
+					return {
+						width: w * ratio,
+						height: h * ratio
+					};
+				}
+			};
+			this.embeddedImages.push(imageRef);
+			return imageRef;
+		}
+		const compressedRgb = deflateSync(decoded.pixels, { level: 6 });
+		dict.set("/ColorSpace", PdfName.of("DeviceRGB"));
+		dict.set("/Filter", PdfName.of("FlateDecode"));
+		dict.set("/Length", PdfNumber.of(compressedRgb.length));
+		const stream = new PdfStream(dict, compressedRgb);
+		const ref = this.registry.register(stream);
+		const w = decoded.width;
+		const h = decoded.height;
+		const imageRef = {
+			name: resourceName,
+			ref,
+			width: w,
+			height: h,
+			scale(factor) {
+				return {
+					width: w * factor,
+					height: h * factor
+				};
+			},
+			scaleToFit(maxW, maxH) {
+				const ratio = Math.min(maxW / w, maxH / h);
+				return {
+					width: w * ratio,
+					height: h * ratio
+				};
+			}
+		};
+		this.embeddedImages.push(imageRef);
+		return imageRef;
+	}
+	/**
+	* Embed a TIFF image.
+	*
+	* Decodes the TIFF image and creates a PDF image XObject with
+	* FlateDecode compression. For multi-page TIFFs, a specific page
+	* can be selected via options.
+	*
+	* @param tiffData  Raw TIFF file bytes as a `Uint8Array` or `ArrayBuffer`.
+	* @param options   Options (e.g., `{ page: 0 }` for multi-page TIFFs).
+	* @returns         An {@link ImageRef}.
+	*/
+	embedTiff(tiffData, options) {
+		const decoded = decodeTiff(tiffData instanceof ArrayBuffer ? new Uint8Array(tiffData) : tiffData, options?.page !== void 0 ? { page: options.page } : void 0);
+		this.imageCounter++;
+		const resourceName = `Im${this.imageCounter}`;
+		const dict = new PdfDict();
+		dict.set("/Type", PdfName.of("XObject"));
+		dict.set("/Subtype", PdfName.of("Image"));
+		dict.set("/Width", PdfNumber.of(decoded.width));
+		dict.set("/Height", PdfNumber.of(decoded.height));
+		dict.set("/BitsPerComponent", PdfNumber.of(8));
+		if (decoded.channels === 4) {
+			const pixelCount = decoded.width * decoded.height;
+			const rgb = new Uint8Array(pixelCount * 3);
+			const alpha = new Uint8Array(pixelCount);
+			for (let i = 0; i < pixelCount; i++) {
+				const srcIdx = i * 4;
+				const dstIdx = i * 3;
+				rgb[dstIdx] = decoded.pixels[srcIdx];
+				rgb[dstIdx + 1] = decoded.pixels[srcIdx + 1];
+				rgb[dstIdx + 2] = decoded.pixels[srcIdx + 2];
+				alpha[i] = decoded.pixels[srcIdx + 3];
+			}
+			const compressedRgb = deflateSync(rgb, { level: 6 });
+			const compressedAlpha = deflateSync(alpha, { level: 6 });
+			dict.set("/ColorSpace", PdfName.of("DeviceRGB"));
+			dict.set("/Filter", PdfName.of("FlateDecode"));
+			dict.set("/Length", PdfNumber.of(compressedRgb.length));
+			const smaskDict = new PdfDict();
+			smaskDict.set("/Type", PdfName.of("XObject"));
+			smaskDict.set("/Subtype", PdfName.of("Image"));
+			smaskDict.set("/Width", PdfNumber.of(decoded.width));
+			smaskDict.set("/Height", PdfNumber.of(decoded.height));
+			smaskDict.set("/BitsPerComponent", PdfNumber.of(8));
+			smaskDict.set("/ColorSpace", PdfName.of("DeviceGray"));
+			smaskDict.set("/Filter", PdfName.of("FlateDecode"));
+			smaskDict.set("/Length", PdfNumber.of(compressedAlpha.length));
+			const smaskStream = new PdfStream(smaskDict, compressedAlpha);
+			const smaskRef = this.registry.register(smaskStream);
+			dict.set("/SMask", smaskRef);
+			const stream = new PdfStream(dict, compressedRgb);
+			const ref = this.registry.register(stream);
+			const w = decoded.width;
+			const h = decoded.height;
+			const imageRef = {
+				name: resourceName,
+				ref,
+				width: w,
+				height: h,
+				scale(factor) {
+					return {
+						width: w * factor,
+						height: h * factor
+					};
+				},
+				scaleToFit(maxW, maxH) {
+					const ratio = Math.min(maxW / w, maxH / h);
+					return {
+						width: w * ratio,
+						height: h * ratio
+					};
+				}
+			};
+			this.embeddedImages.push(imageRef);
+			return imageRef;
+		}
+		const colorSpace = decoded.channels === 1 ? "DeviceGray" : "DeviceRGB";
+		const compressed = deflateSync(decoded.pixels, { level: 6 });
+		dict.set("/ColorSpace", PdfName.of(colorSpace));
+		dict.set("/Filter", PdfName.of("FlateDecode"));
+		dict.set("/Length", PdfNumber.of(compressed.length));
+		const stream = new PdfStream(dict, compressed);
+		const ref = this.registry.register(stream);
+		const w = decoded.width;
+		const h = decoded.height;
+		const imageRef = {
+			name: resourceName,
+			ref,
+			width: w,
+			height: h,
+			scale(factor) {
+				return {
+					width: w * factor,
+					height: h * factor
+				};
+			},
+			scaleToFit(maxW, maxH) {
+				const ratio = Math.min(maxW / w, maxH / h);
+				return {
+					width: w * ratio,
+					height: h * ratio
+				};
+			}
+		};
+		this.embeddedImages.push(imageRef);
+		return imageRef;
+	}
+	/**
 	* Embed an image, auto-detecting the format from file headers.
 	*
-	* Inspects the first bytes to determine whether the data is PNG or JPEG,
-	* then delegates to {@link embedPng} or {@link embedJpeg} accordingly.
+	* Inspects the first bytes to determine the image format (PNG, JPEG,
+	* WebP, or TIFF), then delegates to the appropriate embedding method.
+	*
+	* Supported formats:
+	* - **PNG**: `89 50 4E 47` — embedded via {@link embedPng}
+	* - **JPEG**: `FF D8 FF` — embedded via {@link embedJpeg}
+	* - **WebP**: `52 49 46 46` + `57 45 42 50` — embedded via {@link embedWebP}
+	* - **TIFF LE**: `49 49 2A 00` — embedded via {@link embedTiff}
+	* - **TIFF BE**: `4D 4D 00 2A` — embedded via {@link embedTiff}
 	*
-	* @param imageData  Raw image file bytes (PNG or JPEG).
+	* @param imageData  Raw image file bytes (PNG, JPEG, WebP, or TIFF).
 	* @returns          An {@link ImageRef} to pass to `page.drawImage()`.
 	* @throws           If the image format cannot be detected.
 	*
@@ -12841,9 +14525,13 @@ var PdfDocument = class PdfDocument {
 	async embedImage(imageData) {
 		const data = imageData instanceof ArrayBuffer ? new Uint8Array(imageData) : imageData;
 		if (data.length < 4) throw new Error("Image data too short to detect format");
-		if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return this.embedPng(data);
-		if (data[0] === 255 && data[1] === 216 && data[2] === 255) return this.embedJpeg(data);
-		throw new Error(`Unsupported image format. Expected PNG (89 50 4E 47) or JPEG (FF D8 FF), got ${data.subarray(0, 4).toHex().match(/.{2}/g)?.join(" ") ?? ""}.`);
+		switch (detectImageFormat(data)) {
+			case "png": return this.embedPng(data);
+			case "jpeg": return this.embedJpeg(data);
+			case "webp": return this.embedWebP(data);
+			case "tiff": return this.embedTiff(data);
+			default: throw new Error(`Unsupported image format. Expected PNG, JPEG, WebP, or TIFF, got ${data.subarray(0, 4).toHex().match(/.{2}/g)?.join(" ") ?? ""}.`);
+		}
 	}
 	/**
 	* Embed pages from another PDF as Form XObjects.
@@ -13751,5 +15439,5 @@ function createPdf() {
 }
 
 //#endregion
-export { sha384 as $, prepareForSigning as A, buildViewerPreferencesDict as B, encodeSet as C, computeSignatureHash as D, parseDerTlv as E, isAccessible as F, PdfOutlineItem as G, buildXmpMetadata as H, summarizeIssues as I, PdfEncryptionHandler as J, PdfOutlineTree as K, PdfStructureElement as L, mergePdfs as M, splitPdf as N, embedSignature as O, checkAccessibility as P, sha256 as Q, PdfStructureTree as R, encodeSequence as S, encodeUtf8String as T, createXmpStream as U, parseViewerPreferences as V, parseXmpMetadata as W, verifyOwnerPassword as X, computeFileEncryptionKey as Y, verifyUserPassword as Z, encodeInteger as _, serializePdf as _t, addWatermark as a, rc4 as at, encodeOctetString as b, buildEmbeddedFilesNameTree as c, base64Encode as ct, verifySignatures as d, isOpenTypeCFF as dt, sha512 as et, getSignatures as f, isTrueType as ft, encodeContextTag as g, PdfWriter as gt, decodeOidBytes as h, PdfStreamWriter as ht, embedPageAsFormXObject as i, aesEncryptCBC as it, copyPages as j, findSignatures as k, getAttachments as l, PdfParseError as lt, buildPkcs7Signature as m, extractMetrics as mt, StandardFonts as n, encodePermissions as nt, addWatermarkToPage as o, md5 as ot, signPdf as p, EmbeddedFont as pt, loadPdf as q, createPdf as r, aesDecryptCBC as rt, attachFile as s, base64Decode as st, PdfDocument as t, decodePermissions as tt, verifySignature as u, formatHexContext as ut, encodeLength as v, encodeUTCTime as w, encodePrintableString as x, encodeOID as y, PdfViewerPreferences as z };
-//# sourceMappingURL=pdfDocument-BFxHD_2u.mjs.map
+export { PdfEncryptionHandler as $, parseDerTlv as A, EmbeddedFont as At, isAccessible as B, encodePrintableString as C, isWebP as Ct, encodeUtf8String as D, getSupportedFormats as Dt, encodeUTCTime as E, getImageFormatName as Et, prepareForSigning as F, buildViewerPreferencesDict as G, PdfStructureElement as H, copyPages as I, createXmpStream as J, parseViewerPreferences as K, mergePdfs as L, computeSignatureHash as M, PdfStreamWriter as Mt, embedSignature as N, PdfWriter as Nt, extractIssuerAndSerial as O, isOpenTypeCFF as Ot, findSignatures as P, serializePdf as Pt, loadPdf as Q, splitPdf as R, encodeOctetString as S, decodeWebP as St, encodeSet as T, detectImageFormat as Tt, PdfStructureTree as U, summarizeIssues as V, PdfViewerPreferences as W, PdfOutlineItem as X, parseXmpMetadata as Y, PdfOutlineTree as Z, detectNamedCurve as _, decodeTiffAll as _t, addWatermark as a, sha512 as at, encodeLength as b, isTiff as bt, buildEmbeddedFilesNameTree as c, aesDecryptCBC as ct, verifySignatures as d, md5 as dt, computeFileEncryptionKey as et, getSignatures as f, base64Decode as ft, detectKeyAlgorithm as g, decodeTiff as gt, decodeOidBytes as h, formatHexContext as ht, embedPageAsFormXObject as i, sha384 as it, toBuffer as j, extractMetrics as jt, getSubtle as k, isTrueType as kt, getAttachments as l, aesEncryptCBC as lt, buildPkcs7Signature as m, PdfParseError as mt, StandardFonts as n, verifyUserPassword as nt, addWatermarkToPage as o, decodePermissions as ot, signPdf as p, base64Encode as pt, buildXmpMetadata as q, createPdf as r, sha256 as rt, attachFile as s, encodePermissions as st, PdfDocument as t, verifyOwnerPassword as tt, verifySignature as u, rc4 as ut, encodeContextTag as v, decodeTiffPage as vt, encodeSequence as w, isWebPLossless as wt, encodeOID as x, parseTiffIfd as xt, encodeInteger as y, getTiffPageCount as yt, checkAccessibility as z };
+//# sourceMappingURL=pdfDocument-B0_XwS4X.mjs.map