modern-pdf-lib 0.22.9 → 0.26.0

package/dist/{pdfDocument-pmRXryVI.cjs → pdfDocument-D9uYNSb-.cjs}

@@ -1,11 +1,11 @@
-const require_pdfPage = require('./pdfPage-Cd8jOJp6.cjs');
+const require_pdfPage = require('./pdfPage-C_tjEjj1.cjs');
 const require_pdfObjects = require('./pdfObjects-1veop1_d.cjs');
-const require_pdfCatalog = require('./pdfCatalog-CYy4NXEY.cjs');
-const require_libdeflateWasm = require('./libdeflateWasm-BdiDEJOj.cjs');
+const require_pdfCatalog = require('./pdfCatalog-Bqq4FiLn.cjs');
+const require_libdeflateWasm = require('./libdeflateWasm-DLw-I1CY.cjs');
 const require_fontSubset = require('./fontSubset-5SLWMmEw.cjs');
-const require_pngEmbed = require('./pngEmbed-D4X4ZN-3.cjs');
+const require_pngEmbed = require('./pngEmbed-CTn9IeNB.cjs');
 const require_fflateAdapter = require('./fflateAdapter-LTAeAhaD.cjs');
-const require_pdfForm = require('./pdfForm-9gd40uz9.cjs');
+const require_pdfForm = require('./pdfForm-BpqDGp29.cjs');
 const require_streamDecode = require('./streamDecode-CvgErkFu.cjs');
 let fflate = require("fflate");
 
@@ -15,16 +15,17 @@ let fflate = require("fflate");
 *
 * Binary serialization of a PDF document to a single `Uint8Array`.
 *
-* Produces a valid PDF 1.7 file:
+* Produces a valid PDF 1.7 (or 2.0 when encryption V=5) file:
 *
-* 1. `%PDF-1.7` header + binary comment
-* 2. Indirect-object bodies
+* 1. `%PDF-1.7` (or `%PDF-2.0`) header + binary comment
+* 2. Indirect-object bodies (optionally encrypted)
 * 3. Cross-reference table
-* 4. Trailer dictionary (`/Size`, `/Root`, `/Info`)
+* 4. Trailer dictionary (`/Size`, `/Root`, `/Info`, `/Encrypt`, `/ID`)
 * 5. `startxref` pointer
 * 6. `%%EOF`
 *
-* Supports optional FlateDecode compression for streams via `fflate`.
+* Supports optional FlateDecode compression for streams via `fflate`
+* and optional encryption via a {@link PdfEncryptionHandler}.
 */
 /**
 * Growable byte buffer used during serialization.  All writes go
@@ -74,32 +75,48 @@ var PdfWriter = class {
 	compressionLevel;
 	useWasm;
 	objectStreamThreshold;
-	constructor(registry, structure, options) {
+	encryptionHandler;
+	/**
+	* When encryption is active, the /Encrypt dict is registered as an
+	* indirect object.  Its reference is stored here for the trailer.
+	*/
+	encryptDictRef;
+	constructor(registry, structure, options, encryptionHandler) {
 		this.registry = registry;
 		this.structure = structure;
 		this.compress = options?.compress ?? true;
 		this.compressionLevel = options?.compressionLevel ?? 6;
 		this.useWasm = options?.useWasm ?? false;
 		this.objectStreamThreshold = options?.objectStreamThreshold ?? Infinity;
+		this.encryptionHandler = encryptionHandler;
 	}
 	/**
 	* Produce the complete PDF file as a `Uint8Array`.
+	*
+	* When an encryption handler is present, all string and stream
+	* objects are encrypted and the /Encrypt dictionary + /ID array
+	* are added to the trailer.
 	*/
-	write() {
+	async write() {
+		if (this.encryptionHandler) {
+			const encDict = this.encryptionHandler.buildEncryptDict();
+			this.encryptDictRef = this.registry.register(encDict);
+		}
 		this.writeHeader();
 		if (this.objectStreamThreshold !== Infinity) {
-			if (this.writeBodyWithObjectStreams(this.objectStreamThreshold)) return this.buf.toUint8Array();
+			if (await this.writeBodyWithObjectStreams(this.objectStreamThreshold)) return this.buf.toUint8Array();
 			const xrefOffset = this.writeXref();
 			this.writeTrailer(xrefOffset);
 		} else {
-			this.writeBody();
+			await this.writeBody();
 			const xrefOffset = this.writeXref();
 			this.writeTrailer(xrefOffset);
 		}
 		return this.buf.toUint8Array();
 	}
 	writeHeader() {
-		this.buf.writeString("%PDF-1.7\n");
+		const version = this.encryptionHandler && this.encryptionHandler.getVersion() === 5 ? "2.0" : "1.7";
+		this.buf.writeString(`%PDF-${version}\n`);
 		this.buf.write(new Uint8Array([
 			37,
 			226,
@@ -109,11 +126,13 @@ var PdfWriter = class {
 			10
 		]));
 	}
-	writeBody() {
-		for (const entry of this.registry) this.writeIndirectObject(entry);
+	async writeBody() {
+		for (const entry of this.registry) await this.writeIndirectObject(entry);
 	}
-	writeIndirectObject(entry) {
+	async writeIndirectObject(entry) {
 		if (this.compress && entry.object.kind === "stream") this.compressStream(entry.object);
+		const isEncryptDict = this.encryptDictRef && entry.ref.objectNumber === this.encryptDictRef.objectNumber;
+		if (this.encryptionHandler && !isEncryptDict) await this.encryptEntry(entry);
 		const objNum = entry.ref.objectNumber;
 		while (this.xrefOffsets.length <= objNum) this.xrefOffsets.push(0);
 		this.xrefOffsets[objNum] = this.buf.offset;
@@ -122,6 +141,50 @@ var PdfWriter = class {
 		this.buf.writeString(`\n${entry.ref.toObjectFooter()}\n`);
 	}
 	/**
+	* Encrypt all encryptable data within an indirect object.
+	*
+	* Per the PDF spec:
+	* - Strings inside the object are encrypted with the per-object key.
+	* - Stream data is encrypted with the per-object key.
+	* - The /Encrypt dictionary itself is never encrypted.
+	* - String values in the trailer /ID array are never encrypted.
+	*/
+	async encryptEntry(entry) {
+		const handler = this.encryptionHandler;
+		const objNum = entry.ref.objectNumber;
+		const genNum = entry.ref.generationNumber;
+		if (entry.object.kind === "stream") {
+			const stream = entry.object;
+			await this.encryptDictStrings(stream.dict, objNum, genNum);
+			stream.data = await handler.encryptObject(objNum, genNum, stream.data);
+			stream.syncLength();
+		} else if (entry.object.kind === "dict") await this.encryptDictStrings(entry.object, objNum, genNum);
+	}
+	/**
+	* Recursively encrypt all PdfString values inside a PdfDict.
+	*/
+	async encryptDictStrings(dict, objNum, genNum) {
+		const handler = this.encryptionHandler;
+		for (const [key, value] of dict) if (value.kind === "string") {
+			const encrypted = await handler.encryptString(objNum, genNum, value);
+			dict.set(key, encrypted);
+		} else if (value.kind === "dict") await this.encryptDictStrings(value, objNum, genNum);
+		else if (value.kind === "array") await this.encryptArrayStrings(value, objNum, genNum);
+	}
+	/**
+	* Recursively encrypt all PdfString values inside a PdfArray.
+	*/
+	async encryptArrayStrings(arr, objNum, genNum) {
+		const handler = this.encryptionHandler;
+		const items = arr.items;
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i];
+			if (item.kind === "string") items[i] = await handler.encryptString(objNum, genNum, item);
+			else if (item.kind === "dict") await this.encryptDictStrings(item, objNum, genNum);
+			else if (item.kind === "array") await this.encryptArrayStrings(item, objNum, genNum);
+		}
+	}
+	/**
 	* Apply FlateDecode compression to a stream's data if it is not
 	* already compressed.
 	*/
@@ -159,7 +222,7 @@ var PdfWriter = class {
 	*          written in traditional format and the caller must still
 	*          emit the classic xref table and trailer.
 	*/
-	writeBodyWithObjectStreams(threshold) {
+	async writeBodyWithObjectStreams(threshold) {
 		const protectedNums = this.protectedObjectNumbers();
 		const streamEntries = [];
 		const protectedEntries = [];
@@ -168,11 +231,11 @@ var PdfWriter = class {
 		else if (protectedNums.has(entry.ref.objectNumber)) protectedEntries.push(entry);
 		else packableEntries.push(entry);
 		if (packableEntries.length < threshold) {
-			this.writeBody();
+			await this.writeBody();
 			return false;
 		}
-		for (const entry of streamEntries) this.writeIndirectObject(entry);
-		for (const entry of protectedEntries) this.writeIndirectObject(entry);
+		for (const entry of streamEntries) await this.writeIndirectObject(entry);
+		for (const entry of protectedEntries) await this.writeIndirectObject(entry);
 		const OBJS_PER_STREAM = 200;
 		const xrefEntries = /* @__PURE__ */ new Map();
 		for (let i = 0; i < this.xrefOffsets.length; i++) {
@@ -361,6 +424,11 @@ var PdfWriter = class {
 		this.buf.writeString(`/Size ${size}\n`);
 		this.buf.writeString(`/Root ${this.structure.catalogRef.objectNumber} ${this.structure.catalogRef.generationNumber} R\n`);
 		this.buf.writeString(`/Info ${this.structure.infoRef.objectNumber} ${this.structure.infoRef.generationNumber} R\n`);
+		if (this.encryptionHandler && this.encryptDictRef) {
+			this.buf.writeString(`/Encrypt ${this.encryptDictRef.objectNumber} ${this.encryptDictRef.generationNumber} R\n`);
+			const fileIdHex = this.encryptionHandler.getFileId().toHex();
+			this.buf.writeString(`/ID [<${fileIdHex}> <${fileIdHex}>]\n`);
+		}
 		this.buf.writeString(">>\n");
 		this.buf.writeString("startxref\n");
 		this.buf.writeString(`${xrefOffset}\n`);
@@ -415,13 +483,16 @@ function writeIntBE(buf, offset, width, value) {
 /**
 * Serialize a complete PDF from a registry and structure refs.
 *
-* @param registry   All registered indirect objects.
-* @param structure  Catalog / Info / Pages references.
-* @param options    Save options.
-* @returns          The raw PDF bytes.
+* @param registry            All registered indirect objects.
+* @param structure           Catalog / Info / Pages references.
+* @param options             Save options.
+* @param encryptionHandler   Optional encryption handler for encrypting
+*                            all objects and adding /Encrypt + /ID to
+*                            the trailer.
+* @returns                   The raw PDF bytes.
 */
-function serializePdf(registry, structure, options) {
-	return new PdfWriter(registry, structure, options).write();
+async function serializePdf(registry, structure, options, encryptionHandler) {
+	return new PdfWriter(registry, structure, options, encryptionHandler).write();
 }
 
 //#endregion
@@ -3582,6 +3653,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 (0, fflate.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 +6353,10 @@ async function tryLoadLibdeflate() {
 	if (libdeflateAttempted) return libdeflateEngine;
 	libdeflateAttempted = true;
 	try {
-		const { LibdeflateWasm: LibdeflateCtor, initDeflateWasm } = await Promise.resolve().then(() => require("./libdeflateWasm-BdiDEJOj.cjs")).then((n) => n.libdeflateWasm_exports);
+		const { LibdeflateWasm: LibdeflateCtor, initDeflateWasm } = await Promise.resolve().then(() => require("./libdeflateWasm-DLw-I1CY.cjs")).then((n) => n.libdeflateWasm_exports);
 		let customBytes;
 		try {
-			const { getWasmLoaderConfig } = await Promise.resolve().then(() => require("./loader-I4zdkoWc.cjs")).then((n) => n.loader_exports);
+			const { getWasmLoaderConfig } = await Promise.resolve().then(() => require("./loader-DYCH3n7d.cjs")).then((n) => n.loader_exports);
 			customBytes = getWasmLoaderConfig().moduleBytes?.["libdeflate"];
 		} catch {}
 		await initDeflateWasm(customBytes);
@@ -7889,7 +9413,7 @@ var PdfDocumentParser = class {
 		for (let i = 0; i + 1 < headerTokens.length && objEntries.length < n; i += 2) {
 			const objNum = parseInt(headerTokens[i], 10);
 			const offset = parseInt(headerTokens[i + 1], 10);
-			if (!isNaN(objNum) && !isNaN(offset)) objEntries.push({
+			if (!Number.isNaN(objNum) && !Number.isNaN(offset)) objEntries.push({
 				objNum,
 				offset
 			});
@@ -8171,7 +9695,7 @@ var PdfDocumentParser = class {
 			const name = key.startsWith("/") ? key.slice(1) : key;
 			if (name.startsWith(prefix)) {
 				const num = parseInt(name.slice(prefix.length), 10);
-				return isNaN(num) ? 0 : num;
+				return Number.isNaN(num) ? 0 : num;
 			}
 			return 0;
 		}).reduce((max, n) => Math.max(max, n), 0);
@@ -8885,12 +10409,12 @@ function parseXmpMetadata(xmpString) {
 	const createDate = extractSimpleValue(xmpString, "xmp:CreateDate");
 	if (createDate !== void 0) {
 		const parsed = new Date(createDate);
-		if (!isNaN(parsed.getTime())) result.creationDate = parsed;
+		if (!Number.isNaN(parsed.getTime())) result.creationDate = parsed;
 	}
 	const modifyDate = extractSimpleValue(xmpString, "xmp:ModifyDate");
 	if (modifyDate !== void 0) {
 		const parsed = new Date(modifyDate);
-		if (!isNaN(parsed.getTime())) result.modDate = parsed;
+		if (!Number.isNaN(parsed.getTime())) result.modDate = parsed;
 	}
 	return result;
 }
@@ -10275,7 +11799,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 +11809,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 +11918,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 +11941,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 +11951,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();
@@ -12129,6 +13664,99 @@ function parseJpegDimensions(data) {
 	throw new Error("Invalid JPEG: SOF marker not found");
 }
 
+//#endregion
+//#region src/core/pageLabels.ts
+/** Map from user-facing style names to PDF /S name values. */
+const styleToPdfName = {
+	decimal: "D",
+	roman: "r",
+	Roman: "R",
+	alpha: "a",
+	Alpha: "A"
+};
+/**
+* Symbol used to store page labels on the PdfDocument instance.
+* This avoids modifying the PdfDocument class while keeping state
+* associated with the document.
+*/
+const PAGE_LABELS_KEY = Symbol.for("modern-pdf-lib:pageLabels");
+/**
+* Set the page label ranges for the document.
+*
+* Each entry in the `labels` array defines a contiguous range of pages
+* that share a numbering style.  Ranges must be sorted by `startPage`
+* in ascending order.
+*
+* @param doc     The document to set page labels on.
+* @param labels  An array of label range definitions.
+* @throws        If `labels` is empty or ranges are not sorted.
+*/
+function setPageLabels(doc, labels) {
+	if (labels.length === 0) throw new Error("Page labels array must not be empty");
+	for (let i = 1; i < labels.length; i++) if (labels[i].startPage <= labels[i - 1].startPage) throw new Error(`Page label ranges must be sorted by startPage in ascending order. Got startPage ${labels[i].startPage} after ${labels[i - 1].startPage}.`);
+	const store = doc;
+	store[PAGE_LABELS_KEY] = labels.map((r) => ({ ...r }));
+}
+/**
+* Get the current page label ranges for the document.
+*
+* Returns `undefined` if no page labels have been set.
+*
+* @param doc  The document to read page labels from.
+* @returns    The page label ranges, or `undefined`.
+*/
+function getPageLabels(doc) {
+	const labels = doc[PAGE_LABELS_KEY];
+	if (labels === void 0) return void 0;
+	return labels.map((r) => ({ ...r }));
+}
+/**
+* Remove all page labels from the document.
+*
+* @param doc  The document to clear page labels from.
+*/
+function removePageLabels(doc) {
+	const store = doc;
+	store[PAGE_LABELS_KEY] = void 0;
+}
+/**
+* Build the `/PageLabels` number tree dictionary for inclusion in the
+* document catalog.
+*
+* This is called during document serialization (by the save pipeline)
+* to produce the PDF objects that represent the page label scheme.
+*
+* The number tree format (PDF 1.7 §7.9.7) uses a `/Nums` array of
+* alternating page-index / label-dict pairs:
+*
+* ```
+* /PageLabels << /Nums [
+*   0 << /S /r >>
+*   4 << /S /D /St 1 >>
+* ] >>
+* ```
+*
+* @param doc  The document to read page label state from.
+* @returns    The number tree entries as `[pageIndex, labelDict]` pairs,
+*             or `undefined` if no labels are set.
+*
+* @internal
+*/
+function getPageLabelEntries(doc) {
+	return doc[PAGE_LABELS_KEY];
+}
+/**
+* Map a {@link PageLabelStyle} to its PDF `/S` name value.
+*
+* @param style  The user-facing style name.
+* @returns      The PDF name value (without the leading `/`).
+*
+* @internal
+*/
+function styleToPdf(style) {
+	return styleToPdfName[style];
+}
+
 //#endregion
 //#region src/core/pdfDocument.ts
 /**
@@ -12822,12 +14450,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 require_pdfObjects.PdfDict();
+		dict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+		dict.set("/Subtype", require_pdfObjects.PdfName.of("Image"));
+		dict.set("/Width", require_pdfObjects.PdfNumber.of(decoded.width));
+		dict.set("/Height", require_pdfObjects.PdfNumber.of(decoded.height));
+		dict.set("/BitsPerComponent", require_pdfObjects.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 = (0, fflate.deflateSync)(rgb, { level: 6 });
+			const compressedAlpha = (0, fflate.deflateSync)(alpha, { level: 6 });
+			dict.set("/ColorSpace", require_pdfObjects.PdfName.of("DeviceRGB"));
+			dict.set("/Filter", require_pdfObjects.PdfName.of("FlateDecode"));
+			dict.set("/Length", require_pdfObjects.PdfNumber.of(compressedRgb.length));
+			const smaskDict = new require_pdfObjects.PdfDict();
+			smaskDict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+			smaskDict.set("/Subtype", require_pdfObjects.PdfName.of("Image"));
+			smaskDict.set("/Width", require_pdfObjects.PdfNumber.of(decoded.width));
+			smaskDict.set("/Height", require_pdfObjects.PdfNumber.of(decoded.height));
+			smaskDict.set("/BitsPerComponent", require_pdfObjects.PdfNumber.of(8));
+			smaskDict.set("/ColorSpace", require_pdfObjects.PdfName.of("DeviceGray"));
+			smaskDict.set("/Filter", require_pdfObjects.PdfName.of("FlateDecode"));
+			smaskDict.set("/Length", require_pdfObjects.PdfNumber.of(compressedAlpha.length));
+			const smaskStream = new require_pdfObjects.PdfStream(smaskDict, compressedAlpha);
+			const smaskRef = this.registry.register(smaskStream);
+			dict.set("/SMask", smaskRef);
+			const stream = new require_pdfObjects.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 = (0, fflate.deflateSync)(decoded.pixels, { level: 6 });
+		dict.set("/ColorSpace", require_pdfObjects.PdfName.of("DeviceRGB"));
+		dict.set("/Filter", require_pdfObjects.PdfName.of("FlateDecode"));
+		dict.set("/Length", require_pdfObjects.PdfNumber.of(compressedRgb.length));
+		const stream = new require_pdfObjects.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 require_pdfObjects.PdfDict();
+		dict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+		dict.set("/Subtype", require_pdfObjects.PdfName.of("Image"));
+		dict.set("/Width", require_pdfObjects.PdfNumber.of(decoded.width));
+		dict.set("/Height", require_pdfObjects.PdfNumber.of(decoded.height));
+		dict.set("/BitsPerComponent", require_pdfObjects.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 = (0, fflate.deflateSync)(rgb, { level: 6 });
+			const compressedAlpha = (0, fflate.deflateSync)(alpha, { level: 6 });
+			dict.set("/ColorSpace", require_pdfObjects.PdfName.of("DeviceRGB"));
+			dict.set("/Filter", require_pdfObjects.PdfName.of("FlateDecode"));
+			dict.set("/Length", require_pdfObjects.PdfNumber.of(compressedRgb.length));
+			const smaskDict = new require_pdfObjects.PdfDict();
+			smaskDict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+			smaskDict.set("/Subtype", require_pdfObjects.PdfName.of("Image"));
+			smaskDict.set("/Width", require_pdfObjects.PdfNumber.of(decoded.width));
+			smaskDict.set("/Height", require_pdfObjects.PdfNumber.of(decoded.height));
+			smaskDict.set("/BitsPerComponent", require_pdfObjects.PdfNumber.of(8));
+			smaskDict.set("/ColorSpace", require_pdfObjects.PdfName.of("DeviceGray"));
+			smaskDict.set("/Filter", require_pdfObjects.PdfName.of("FlateDecode"));
+			smaskDict.set("/Length", require_pdfObjects.PdfNumber.of(compressedAlpha.length));
+			const smaskStream = new require_pdfObjects.PdfStream(smaskDict, compressedAlpha);
+			const smaskRef = this.registry.register(smaskStream);
+			dict.set("/SMask", smaskRef);
+			const stream = new require_pdfObjects.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 = (0, fflate.deflateSync)(decoded.pixels, { level: 6 });
+		dict.set("/ColorSpace", require_pdfObjects.PdfName.of(colorSpace));
+		dict.set("/Filter", require_pdfObjects.PdfName.of("FlateDecode"));
+		dict.set("/Length", require_pdfObjects.PdfNumber.of(compressed.length));
+		const stream = new require_pdfObjects.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.
 	*
-	* @param imageData  Raw image file bytes (PNG or JPEG).
+	* 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, JPEG, WebP, or TIFF).
 	* @returns          An {@link ImageRef} to pass to `page.drawImage()`.
 	* @throws           If the image format cannot be detected.
 	*
@@ -12841,9 +14689,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.
@@ -13501,7 +15353,7 @@ var PdfDocument = class PdfDocument {
 		if ((options?.addDefaultPage ?? true) && this.getPageCount() === 0) this.addPage();
 		if ((options?.updateFieldAppearances ?? true) && this.form) for (const field of this.form.getFields()) field.generateAppearance();
 		const structure = this.buildStructure();
-		return serializePdf(this.registry, structure, options);
+		return serializePdf(this.registry, structure, options, this.encryptionHandler);
 	}
 	/**
 	* Serialize the document as a `ReadableStream<Uint8Array>`.
@@ -13677,6 +15529,21 @@ var PdfDocument = class PdfDocument {
 					catalogObj.set("/AA", aaDict);
 				}
 			}
+			const pageLabelRanges = getPageLabelEntries(this);
+			if (pageLabelRanges !== void 0 && pageLabelRanges.length > 0) {
+				const numsArray = new require_pdfObjects.PdfArray();
+				for (const range of pageLabelRanges) {
+					numsArray.push(require_pdfObjects.PdfNumber.of(range.startPage));
+					const labelDict = new require_pdfObjects.PdfDict();
+					labelDict.set("/S", require_pdfObjects.PdfName.of(styleToPdf(range.style)));
+					if (range.prefix !== void 0) labelDict.set("/P", require_pdfObjects.PdfString.literal(range.prefix));
+					if (range.start !== void 0) labelDict.set("/St", require_pdfObjects.PdfNumber.of(range.start));
+					numsArray.push(labelDict);
+				}
+				const pageLabelsDict = new require_pdfObjects.PdfDict();
+				pageLabelsDict.set("/Nums", numsArray);
+				catalogObj.set("/PageLabels", pageLabelsDict);
+			}
 		}
 		if (this.originalBytes !== void 0) {
 			const rootRefs = [structure.catalogRef, structure.infoRef];
@@ -13937,6 +15804,48 @@ Object.defineProperty(exports, 'decodePermissions', {
     return decodePermissions;
   }
 });
+Object.defineProperty(exports, 'decodeTiff', {
+  enumerable: true,
+  get: function () {
+    return decodeTiff;
+  }
+});
+Object.defineProperty(exports, 'decodeTiffAll', {
+  enumerable: true,
+  get: function () {
+    return decodeTiffAll;
+  }
+});
+Object.defineProperty(exports, 'decodeTiffPage', {
+  enumerable: true,
+  get: function () {
+    return decodeTiffPage;
+  }
+});
+Object.defineProperty(exports, 'decodeWebP', {
+  enumerable: true,
+  get: function () {
+    return decodeWebP;
+  }
+});
+Object.defineProperty(exports, 'detectImageFormat', {
+  enumerable: true,
+  get: function () {
+    return detectImageFormat;
+  }
+});
+Object.defineProperty(exports, 'detectKeyAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return detectKeyAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'detectNamedCurve', {
+  enumerable: true,
+  get: function () {
+    return detectNamedCurve;
+  }
+});
 Object.defineProperty(exports, 'embedPageAsFormXObject', {
   enumerable: true,
   get: function () {
@@ -14015,6 +15924,12 @@ Object.defineProperty(exports, 'encodeUtf8String', {
     return encodeUtf8String;
   }
 });
+Object.defineProperty(exports, 'extractIssuerAndSerial', {
+  enumerable: true,
+  get: function () {
+    return extractIssuerAndSerial;
+  }
+});
 Object.defineProperty(exports, 'extractMetrics', {
   enumerable: true,
   get: function () {
@@ -14039,12 +15954,42 @@ Object.defineProperty(exports, 'getAttachments', {
     return getAttachments;
   }
 });
+Object.defineProperty(exports, 'getImageFormatName', {
+  enumerable: true,
+  get: function () {
+    return getImageFormatName;
+  }
+});
+Object.defineProperty(exports, 'getPageLabels', {
+  enumerable: true,
+  get: function () {
+    return getPageLabels;
+  }
+});
 Object.defineProperty(exports, 'getSignatures', {
   enumerable: true,
   get: function () {
     return getSignatures;
   }
 });
+Object.defineProperty(exports, 'getSubtle', {
+  enumerable: true,
+  get: function () {
+    return getSubtle;
+  }
+});
+Object.defineProperty(exports, 'getSupportedFormats', {
+  enumerable: true,
+  get: function () {
+    return getSupportedFormats;
+  }
+});
+Object.defineProperty(exports, 'getTiffPageCount', {
+  enumerable: true,
+  get: function () {
+    return getTiffPageCount;
+  }
+});
 Object.defineProperty(exports, 'isAccessible', {
   enumerable: true,
   get: function () {
@@ -14057,12 +16002,30 @@ Object.defineProperty(exports, 'isOpenTypeCFF', {
     return isOpenTypeCFF;
   }
 });
+Object.defineProperty(exports, 'isTiff', {
+  enumerable: true,
+  get: function () {
+    return isTiff;
+  }
+});
 Object.defineProperty(exports, 'isTrueType', {
   enumerable: true,
   get: function () {
     return isTrueType;
   }
 });
+Object.defineProperty(exports, 'isWebP', {
+  enumerable: true,
+  get: function () {
+    return isWebP;
+  }
+});
+Object.defineProperty(exports, 'isWebPLossless', {
+  enumerable: true,
+  get: function () {
+    return isWebPLossless;
+  }
+});
 Object.defineProperty(exports, 'loadPdf', {
   enumerable: true,
   get: function () {
@@ -14087,6 +16050,12 @@ Object.defineProperty(exports, 'parseDerTlv', {
     return parseDerTlv;
   }
 });
+Object.defineProperty(exports, 'parseTiffIfd', {
+  enumerable: true,
+  get: function () {
+    return parseTiffIfd;
+  }
+});
 Object.defineProperty(exports, 'parseViewerPreferences', {
   enumerable: true,
   get: function () {
@@ -14111,12 +16080,24 @@ Object.defineProperty(exports, 'rc4', {
     return rc4;
   }
 });
+Object.defineProperty(exports, 'removePageLabels', {
+  enumerable: true,
+  get: function () {
+    return removePageLabels;
+  }
+});
 Object.defineProperty(exports, 'serializePdf', {
   enumerable: true,
   get: function () {
     return serializePdf;
   }
 });
+Object.defineProperty(exports, 'setPageLabels', {
+  enumerable: true,
+  get: function () {
+    return setPageLabels;
+  }
+});
 Object.defineProperty(exports, 'sha256', {
   enumerable: true,
   get: function () {
@@ -14153,6 +16134,12 @@ Object.defineProperty(exports, 'summarizeIssues', {
     return summarizeIssues;
   }
 });
+Object.defineProperty(exports, 'toBuffer', {
+  enumerable: true,
+  get: function () {
+    return toBuffer;
+  }
+});
 Object.defineProperty(exports, 'verifyOwnerPassword', {
   enumerable: true,
   get: function () {
@@ -14177,4 +16164,4 @@ Object.defineProperty(exports, 'verifyUserPassword', {
     return verifyUserPassword;
   }
 });
-//# sourceMappingURL=pdfDocument-pmRXryVI.cjs.map
+//# sourceMappingURL=pdfDocument-D9uYNSb-.cjs.map