@cj-tech-master/excelts 9.1.0 → 9.2.0

package/dist/iife/excelts.iife.js

@@ -1,11 +1,14 @@
 /*!
-* @cj-tech-master/excelts v9.1.0
+* @cj-tech-master/excelts v9.2.0
 * Zero-dependency TypeScript toolkit — Excel (XLSX), PDF, CSV, Markdown, XML, ZIP/TAR, and streaming.
 * (c) 2026 cjnoname
 * Released under the MIT License
 */
 var ExcelTS = (function(exports) {
 	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+	//#endregion
 	//#region src/utils/errors.ts
 	/**
 	* Base class for all library errors.
@@ -4805,7 +4808,660 @@ var ExcelTS = (function(exports) {
 		return cell.text;
 	}
 	//#endregion
+	//#region src/utils/crypto.browser.ts
+	function gf2(a) {
+		return a < 128 ? a << 1 : a << 1 ^ 283;
+	}
+	function aesKeyExpansion(key) {
+		const nk = key.length / 4;
+		const nr = nk + 6;
+		const w = [];
+		for (let i = 0; i < nk; i++) w.push(new Uint8Array([
+			key[4 * i],
+			key[4 * i + 1],
+			key[4 * i + 2],
+			key[4 * i + 3]
+		]));
+		for (let i = nk; i < 4 * (nr + 1); i++) {
+			const temp = new Uint8Array(w[i - 1]);
+			if (i % nk === 0) {
+				const t0 = temp[0];
+				temp[0] = SBOX[temp[1]] ^ RCON[i / nk - 1];
+				temp[1] = SBOX[temp[2]];
+				temp[2] = SBOX[temp[3]];
+				temp[3] = SBOX[t0];
+			} else if (nk > 6 && i % nk === 4) {
+				temp[0] = SBOX[temp[0]];
+				temp[1] = SBOX[temp[1]];
+				temp[2] = SBOX[temp[2]];
+				temp[3] = SBOX[temp[3]];
+			}
+			const word = new Uint8Array(4);
+			for (let j = 0; j < 4; j++) word[j] = w[i - nk][j] ^ temp[j];
+			w.push(word);
+		}
+		return w;
+	}
+	function aesEncryptBlock(block, roundKeys) {
+		const nr = roundKeys.length / 4 - 1;
+		const state = new Uint8Array(16);
+		state.set(block);
+		for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) state[4 * c + r] ^= roundKeys[c][r];
+		for (let round = 1; round < nr; round++) {
+			for (let i = 0; i < 16; i++) state[i] = SBOX[state[i]];
+			let tmp;
+			tmp = state[1];
+			state[1] = state[5];
+			state[5] = state[9];
+			state[9] = state[13];
+			state[13] = tmp;
+			tmp = state[2];
+			state[2] = state[10];
+			state[10] = tmp;
+			tmp = state[6];
+			state[6] = state[14];
+			state[14] = tmp;
+			tmp = state[15];
+			state[15] = state[11];
+			state[11] = state[7];
+			state[7] = state[3];
+			state[3] = tmp;
+			for (let c = 0; c < 4; c++) {
+				const s0 = state[4 * c];
+				const s1 = state[4 * c + 1];
+				const s2 = state[4 * c + 2];
+				const s3 = state[4 * c + 3];
+				state[4 * c] = gf2(s0) ^ gf2(s1) ^ s1 ^ s2 ^ s3;
+				state[4 * c + 1] = s0 ^ gf2(s1) ^ gf2(s2) ^ s2 ^ s3;
+				state[4 * c + 2] = s0 ^ s1 ^ gf2(s2) ^ gf2(s3) ^ s3;
+				state[4 * c + 3] = gf2(s0) ^ s0 ^ s1 ^ s2 ^ gf2(s3);
+			}
+			const keyOffset = round * 4;
+			for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) state[4 * c + r] ^= roundKeys[keyOffset + c][r];
+		}
+		for (let i = 0; i < 16; i++) state[i] = SBOX[state[i]];
+		let tmp;
+		tmp = state[1];
+		state[1] = state[5];
+		state[5] = state[9];
+		state[9] = state[13];
+		state[13] = tmp;
+		tmp = state[2];
+		state[2] = state[10];
+		state[10] = tmp;
+		tmp = state[6];
+		state[6] = state[14];
+		state[14] = tmp;
+		tmp = state[15];
+		state[15] = state[11];
+		state[11] = state[7];
+		state[7] = state[3];
+		state[3] = tmp;
+		for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) state[4 * c + r] ^= roundKeys[nr * 4 + c][r];
+		return state;
+	}
+	function aesCbcEncrypt(plaintext, key, iv) {
+		const padLen = 16 - plaintext.length % 16;
+		const padded = new Uint8Array(plaintext.length + padLen);
+		padded.set(plaintext);
+		for (let i = plaintext.length; i < padded.length; i++) padded[i] = padLen;
+		const roundKeys = aesKeyExpansion(key);
+		const numBlocks = padded.length / 16;
+		const output = new Uint8Array(padded.length);
+		let prevBlock = iv;
+		for (let b = 0; b < numBlocks; b++) {
+			const block = new Uint8Array(16);
+			for (let i = 0; i < 16; i++) block[i] = padded[b * 16 + i] ^ prevBlock[i];
+			const encrypted = aesEncryptBlock(block, roundKeys);
+			output.set(encrypted, b * 16);
+			prevBlock = encrypted;
+		}
+		return output;
+	}
+	function aesCbcEncryptRaw(plaintext, key, iv) {
+		if (plaintext.length % 16 !== 0) throw new Error("aesCbcEncryptRaw: plaintext length must be a multiple of 16");
+		const roundKeys = aesKeyExpansion(key);
+		const numBlocks = plaintext.length / 16;
+		const output = new Uint8Array(plaintext.length);
+		let prevBlock = iv;
+		for (let b = 0; b < numBlocks; b++) {
+			const block = new Uint8Array(16);
+			for (let i = 0; i < 16; i++) block[i] = plaintext[b * 16 + i] ^ prevBlock[i];
+			const encrypted = aesEncryptBlock(block, roundKeys);
+			output.set(encrypted, b * 16);
+			prevBlock = encrypted;
+		}
+		return output;
+	}
+	function aesEcbEncrypt(block, key) {
+		return aesEncryptBlock(block, aesKeyExpansion(key));
+	}
+	function rotr32(x, n) {
+		return (x >>> n | x << 32 - n) >>> 0;
+	}
+	function sha256(input) {
+		const msgLen = input.length;
+		const paddedLen = Math.ceil((msgLen + 9) / 64) * 64;
+		const padded = new Uint8Array(paddedLen);
+		padded.set(input);
+		padded[msgLen] = 128;
+		const bitLen = msgLen * 8;
+		const view = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+		view.setUint32(paddedLen - 8, 0, false);
+		view.setUint32(paddedLen - 4, bitLen, false);
+		let h0 = SHA256_H[0];
+		let h1 = SHA256_H[1];
+		let h2 = SHA256_H[2];
+		let h3 = SHA256_H[3];
+		let h4 = SHA256_H[4];
+		let h5 = SHA256_H[5];
+		let h6 = SHA256_H[6];
+		let h7 = SHA256_H[7];
+		const w = new Uint32Array(64);
+		for (let offset = 0; offset < paddedLen; offset += 64) {
+			for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4, false);
+			for (let i = 16; i < 64; i++) {
+				const s0 = rotr32(w[i - 15], 7) ^ rotr32(w[i - 15], 18) ^ w[i - 15] >>> 3;
+				const s1 = rotr32(w[i - 2], 17) ^ rotr32(w[i - 2], 19) ^ w[i - 2] >>> 10;
+				w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+			}
+			let a = h0;
+			let b = h1;
+			let c = h2;
+			let d = h3;
+			let e = h4;
+			let f = h5;
+			let g = h6;
+			let h = h7;
+			for (let i = 0; i < 64; i++) {
+				const S1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+				const ch = e & f ^ ~e & g;
+				const temp1 = h + S1 + ch + SHA256_K[i] + w[i] >>> 0;
+				const temp2 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+				h = g;
+				g = f;
+				f = e;
+				e = d + temp1 >>> 0;
+				d = c;
+				c = b;
+				b = a;
+				a = temp1 + temp2 >>> 0;
+			}
+			h0 = h0 + a >>> 0;
+			h1 = h1 + b >>> 0;
+			h2 = h2 + c >>> 0;
+			h3 = h3 + d >>> 0;
+			h4 = h4 + e >>> 0;
+			h5 = h5 + f >>> 0;
+			h6 = h6 + g >>> 0;
+			h7 = h7 + h >>> 0;
+		}
+		const result = new Uint8Array(32);
+		const resultView = new DataView(result.buffer);
+		resultView.setUint32(0, h0, false);
+		resultView.setUint32(4, h1, false);
+		resultView.setUint32(8, h2, false);
+		resultView.setUint32(12, h3, false);
+		resultView.setUint32(16, h4, false);
+		resultView.setUint32(20, h5, false);
+		resultView.setUint32(24, h6, false);
+		resultView.setUint32(28, h7, false);
+		return result;
+	}
+	/**
+	* Generate cryptographically secure random bytes.
+	* Uses crypto.getRandomValues (available in all modern browsers).
+	*/
+	function randomBytes(length) {
+		const bytes = new Uint8Array(length);
+		globalThis.crypto.getRandomValues(bytes);
+		return bytes;
+	}
+	/**
+	* Compute a hash digest using Web Crypto API.
+	*
+	* NOTE: In the browser, this is async. The Node.js version is sync.
+	* For callers that need sync hashing, use `sha256()` or `md5()` directly.
+	*
+	* @param algorithm - Hash algorithm name (e.g., "SHA-256", "SHA-512", "SHA-1").
+	* @param data - Data to hash
+	* @returns The digest bytes
+	*/
+	async function hashAsync(algorithm, data) {
+		const buf = await globalThis.crypto.subtle.digest(normalizeAlgorithmForWebCrypto(algorithm), data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+		return new Uint8Array(buf);
+	}
+	/**
+	* Normalize a hash algorithm name to the format Web Crypto API expects.
+	* Accepts: "sha256", "SHA-256", "sha-256", "SHA256" → "SHA-256"
+	*/
+	function normalizeAlgorithmForWebCrypto(algorithm) {
+		switch (algorithm.toLowerCase().replace(/-/g, "")) {
+			case "sha1": return "SHA-1";
+			case "sha256": return "SHA-256";
+			case "sha384": return "SHA-384";
+			case "sha512": return "SHA-512";
+			default: return algorithm;
+		}
+	}
+	var SBOX, RCON, SHA256_H, SHA256_K;
+	var init_crypto_browser = __esmMin((() => {
+		SBOX = new Uint8Array([
+			99,
+			124,
+			119,
+			123,
+			242,
+			107,
+			111,
+			197,
+			48,
+			1,
+			103,
+			43,
+			254,
+			215,
+			171,
+			118,
+			202,
+			130,
+			201,
+			125,
+			250,
+			89,
+			71,
+			240,
+			173,
+			212,
+			162,
+			175,
+			156,
+			164,
+			114,
+			192,
+			183,
+			253,
+			147,
+			38,
+			54,
+			63,
+			247,
+			204,
+			52,
+			165,
+			229,
+			241,
+			113,
+			216,
+			49,
+			21,
+			4,
+			199,
+			35,
+			195,
+			24,
+			150,
+			5,
+			154,
+			7,
+			18,
+			128,
+			226,
+			235,
+			39,
+			178,
+			117,
+			9,
+			131,
+			44,
+			26,
+			27,
+			110,
+			90,
+			160,
+			82,
+			59,
+			214,
+			179,
+			41,
+			227,
+			47,
+			132,
+			83,
+			209,
+			0,
+			237,
+			32,
+			252,
+			177,
+			91,
+			106,
+			203,
+			190,
+			57,
+			74,
+			76,
+			88,
+			207,
+			208,
+			239,
+			170,
+			251,
+			67,
+			77,
+			51,
+			133,
+			69,
+			249,
+			2,
+			127,
+			80,
+			60,
+			159,
+			168,
+			81,
+			163,
+			64,
+			143,
+			146,
+			157,
+			56,
+			245,
+			188,
+			182,
+			218,
+			33,
+			16,
+			255,
+			243,
+			210,
+			205,
+			12,
+			19,
+			236,
+			95,
+			151,
+			68,
+			23,
+			196,
+			167,
+			126,
+			61,
+			100,
+			93,
+			25,
+			115,
+			96,
+			129,
+			79,
+			220,
+			34,
+			42,
+			144,
+			136,
+			70,
+			238,
+			184,
+			20,
+			222,
+			94,
+			11,
+			219,
+			224,
+			50,
+			58,
+			10,
+			73,
+			6,
+			36,
+			92,
+			194,
+			211,
+			172,
+			98,
+			145,
+			149,
+			228,
+			121,
+			231,
+			200,
+			55,
+			109,
+			141,
+			213,
+			78,
+			169,
+			108,
+			86,
+			244,
+			234,
+			101,
+			122,
+			174,
+			8,
+			186,
+			120,
+			37,
+			46,
+			28,
+			166,
+			180,
+			198,
+			232,
+			221,
+			116,
+			31,
+			75,
+			189,
+			139,
+			138,
+			112,
+			62,
+			181,
+			102,
+			72,
+			3,
+			246,
+			14,
+			97,
+			53,
+			87,
+			185,
+			134,
+			193,
+			29,
+			158,
+			225,
+			248,
+			152,
+			17,
+			105,
+			217,
+			142,
+			148,
+			155,
+			30,
+			135,
+			233,
+			206,
+			85,
+			40,
+			223,
+			140,
+			161,
+			137,
+			13,
+			191,
+			230,
+			66,
+			104,
+			65,
+			153,
+			45,
+			15,
+			176,
+			84,
+			187,
+			22
+		]);
+		RCON = [
+			1,
+			2,
+			4,
+			8,
+			16,
+			32,
+			64,
+			128,
+			27,
+			54
+		];
+		SHA256_H = new Uint32Array([
+			1779033703,
+			3144134277,
+			1013904242,
+			2773480762,
+			1359893119,
+			2600822924,
+			528734635,
+			1541459225
+		]);
+		SHA256_K = new Uint32Array([
+			1116352408,
+			1899447441,
+			3049323471,
+			3921009573,
+			961987163,
+			1508970993,
+			2453635748,
+			2870763221,
+			3624381080,
+			310598401,
+			607225278,
+			1426881987,
+			1925078388,
+			2162078206,
+			2614888103,
+			3248222580,
+			3835390401,
+			4022224774,
+			264347078,
+			604807628,
+			770255983,
+			1249150122,
+			1555081692,
+			1996064986,
+			2554220882,
+			2821834349,
+			2952996808,
+			3210313671,
+			3336571891,
+			3584528711,
+			113926993,
+			338241895,
+			666307205,
+			773529912,
+			1294757372,
+			1396182291,
+			1695183700,
+			1986661051,
+			2177026350,
+			2456956037,
+			2730485921,
+			2820302411,
+			3259730800,
+			3345764771,
+			3516065817,
+			3600352804,
+			4094571909,
+			275423344,
+			430227734,
+			506948616,
+			659060556,
+			883997877,
+			958139571,
+			1322822218,
+			1537002063,
+			1747873779,
+			1955562222,
+			2024104815,
+			2227730452,
+			2361852424,
+			2428436474,
+			2756734187,
+			3204031479,
+			3329325298
+		]);
+		new Uint32Array([
+			3614090360,
+			3905402710,
+			606105819,
+			3250441966,
+			4118548399,
+			1200080426,
+			2821735955,
+			4249261313,
+			1770035416,
+			2336552879,
+			4294925233,
+			2304563134,
+			1804603682,
+			4254626195,
+			2792965006,
+			1236535329,
+			4129170786,
+			3225465664,
+			643717713,
+			3921069994,
+			3593408605,
+			38016083,
+			3634488961,
+			3889429448,
+			568446438,
+			3275163606,
+			4107603335,
+			1163531501,
+			2850285829,
+			4243563512,
+			1735328473,
+			2368359562,
+			4294588738,
+			2272392833,
+			1839030562,
+			4259657740,
+			2763975236,
+			1272893353,
+			4139469664,
+			3200236656,
+			681279174,
+			3936430074,
+			3572445317,
+			76029189,
+			3654602809,
+			3873151461,
+			530742520,
+			3299628645,
+			4096336452,
+			1126891415,
+			2878612391,
+			4237533241,
+			1700485571,
+			2399980690,
+			4293915773,
+			2240044497,
+			1873313359,
+			4264355552,
+			2734768916,
+			1309151649,
+			4149444226,
+			3174756917,
+			718787259,
+			3951481745
+		]);
+	}));
+	//#endregion
 	//#region src/utils/binary.ts
+	init_crypto_browser();
 	/**
 	* Binary Utilities
 	*
@@ -5056,8 +5712,7 @@ var ExcelTS = (function(exports) {
 	//#endregion
 	//#region src/modules/excel/utils/encryptor.browser.ts
 	/**
-	* Browser-only Encryptor
-	* Uses Web Crypto API (hardware accelerated)
+	* Browser-only Encryptor — uses shared crypto primitives from `@utils/crypto`.
 	*/
 	function uint32ToLe(num) {
 		const arr = new Uint8Array(4);
@@ -5069,9 +5724,7 @@ var ExcelTS = (function(exports) {
 	}
 	const Encryptor = {
 		async hash(algorithm, ...buffers) {
-			const data = concatUint8Arrays(buffers);
-			const hashBuffer = await crypto.subtle.digest(algorithm, new Uint8Array(data));
-			return new Uint8Array(hashBuffer);
+			return hashAsync(algorithm, concatUint8Arrays(buffers));
 		},
 		async convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
 			const passwordBuffer = stringToUtf16Le(password);
@@ -5081,9 +5734,7 @@ var ExcelTS = (function(exports) {
 			return uint8ArrayToBase64(key);
 		},
 		randomBytes(size) {
-			const bytes = new Uint8Array(size);
-			crypto.getRandomValues(bytes);
-			return bytes;
+			return randomBytes(size);
 		}
 	};
 	//#endregion
@@ -27863,6 +28514,7 @@ self.onmessage = async function(event) {
 	*
 	* Works in both Node.js and browsers using the Web Crypto API.
 	*/
+	init_crypto_browser();
 	/**
 	* AES vendor ID for WinZip format.
 	*/
@@ -27911,22 +28563,6 @@ self.onmessage = async function(event) {
 		throw new Error("Web Crypto API not available");
 	}
 	/**
-	* Get crypto.getRandomValues (works in both Node.js and browsers).
-	*/
-	function getRandomValues(array) {
-		if (typeof globalThis.crypto?.getRandomValues !== "undefined") {
-			globalThis.crypto.getRandomValues(array);
-			return array;
-		}
-		throw new Error("crypto.getRandomValues not available");
-	}
-	/**
-	* Generate random bytes.
-	*/
-	function randomBytes$1(length) {
-		return getRandomValues(new Uint8Array(length));
-	}
-	/**
 	* Derive AES keys from password using PBKDF2.
 	*
 	* The derived key material is split into:
@@ -28077,7 +28713,7 @@ self.onmessage = async function(event) {
 	*/
 	async function aesEncrypt(data, password, keyStrength) {
 		const saltLen = AES_SALT_LENGTH[keyStrength];
-		const salt = randomBytes$1(saltLen);
+		const salt = randomBytes(saltLen);
 		const keys = await aesDerive(password, salt, keyStrength);
 		const ciphertext = await aesCtr(keys.encryptionKey, data, true);
 		const hmac = await aesComputeHmac(keys.hmacKey, ciphertext);
@@ -29017,7 +29653,7 @@ self.onmessage = async function(event) {
 			if (this._zipCryptoState || this._encryptionMethod !== "zipcrypto") return;
 			this._zipCryptoState = zipCryptoInitKeys(this._password);
 			const dosTimeForCheck = this.dosTime << 16 | this.dosDate;
-			const header = zipCryptoCreateHeader(this._zipCryptoState, dosTimeForCheck, randomBytes$1);
+			const header = zipCryptoCreateHeader(this._zipCryptoState, dosTimeForCheck, randomBytes);
 			this._compressedSize += header.length;
 			this._enqueueData(header, false);
 		}
@@ -46284,15 +46920,31 @@ onmessage = async (ev) => {
 	* Builds a PDF dictionary object from key-value pairs.
 	* Values are already-serialized PDF strings.
 	*/
-	var PdfDict = class {
+	var PdfDict = class PdfDict {
 		constructor() {
 			this.entries = [];
+			this._raw = null;
+		}
+		/**
+		* Create a PdfDict that wraps a pre-serialized dictionary string.
+		* toString() returns the raw string (with any set() overrides applied).
+		*/
+		static fromRawString(raw) {
+			const d = new PdfDict();
+			d._raw = raw;
+			return d;
 		}
 		/**
 		* Set a dictionary entry. The key should NOT include the leading /.
 		* The value should be a pre-serialized PDF value string.
 		*/
 		set(key, value) {
+			if (this._raw !== null) {
+				const keyPattern = new RegExp(`(/${key})\\s+\\S+(?:\\s+\\d+\\s+R)?`);
+				if (keyPattern.test(this._raw)) this._raw = this._raw.replace(keyPattern, `/${key} ${value}`);
+				else this._raw = this._raw.replace(/>>$/, `\n${pdfName(key)} ${value}\n>>`);
+				return this;
+			}
 			const idx = this.entries.findIndex(([k]) => k === key);
 			if (idx >= 0) this.entries[idx] = [key, value];
 			else this.entries.push([key, value]);
@@ -46306,9 +46958,18 @@ onmessage = async (ev) => {
 			return this;
 		}
 		/**
+		* Remove a dictionary entry by key.
+		*/
+		delete(key) {
+			const idx = this.entries.findIndex(([k]) => k === key);
+			if (idx >= 0) this.entries.splice(idx, 1);
+			return this;
+		}
+		/**
 		* Serialize to a PDF dictionary string.
 		*/
 		toString() {
+			if (this._raw !== null) return this._raw;
 			const parts = ["<<"];
 			for (const [key, value] of this.entries) parts.push(`${pdfName(key)} ${value}`);
 			parts.push(">>");
@@ -46363,702 +47024,8 @@ onmessage = async (ev) => {
 		return err instanceof PdfError;
 	}
 	//#endregion
-	//#region src/modules/pdf/core/crypto.ts
-	/**
-	* Shared cryptographic primitives for PDF encryption/decryption.
-	*
-	* Zero-dependency, pure JavaScript implementations of:
-	* - AES (128/256-bit) CBC encrypt and decrypt
-	* - SHA-256
-	* - MD5
-	* - RC4 (for reading legacy PDFs only)
-	*
-	* @see FIPS 197 — AES
-	* @see FIPS 180-4 — SHA-256
-	* @see RFC 1321 — MD5
-	*/
-	/** AES S-Box */
-	const SBOX = new Uint8Array([
-		99,
-		124,
-		119,
-		123,
-		242,
-		107,
-		111,
-		197,
-		48,
-		1,
-		103,
-		43,
-		254,
-		215,
-		171,
-		118,
-		202,
-		130,
-		201,
-		125,
-		250,
-		89,
-		71,
-		240,
-		173,
-		212,
-		162,
-		175,
-		156,
-		164,
-		114,
-		192,
-		183,
-		253,
-		147,
-		38,
-		54,
-		63,
-		247,
-		204,
-		52,
-		165,
-		229,
-		241,
-		113,
-		216,
-		49,
-		21,
-		4,
-		199,
-		35,
-		195,
-		24,
-		150,
-		5,
-		154,
-		7,
-		18,
-		128,
-		226,
-		235,
-		39,
-		178,
-		117,
-		9,
-		131,
-		44,
-		26,
-		27,
-		110,
-		90,
-		160,
-		82,
-		59,
-		214,
-		179,
-		41,
-		227,
-		47,
-		132,
-		83,
-		209,
-		0,
-		237,
-		32,
-		252,
-		177,
-		91,
-		106,
-		203,
-		190,
-		57,
-		74,
-		76,
-		88,
-		207,
-		208,
-		239,
-		170,
-		251,
-		67,
-		77,
-		51,
-		133,
-		69,
-		249,
-		2,
-		127,
-		80,
-		60,
-		159,
-		168,
-		81,
-		163,
-		64,
-		143,
-		146,
-		157,
-		56,
-		245,
-		188,
-		182,
-		218,
-		33,
-		16,
-		255,
-		243,
-		210,
-		205,
-		12,
-		19,
-		236,
-		95,
-		151,
-		68,
-		23,
-		196,
-		167,
-		126,
-		61,
-		100,
-		93,
-		25,
-		115,
-		96,
-		129,
-		79,
-		220,
-		34,
-		42,
-		144,
-		136,
-		70,
-		238,
-		184,
-		20,
-		222,
-		94,
-		11,
-		219,
-		224,
-		50,
-		58,
-		10,
-		73,
-		6,
-		36,
-		92,
-		194,
-		211,
-		172,
-		98,
-		145,
-		149,
-		228,
-		121,
-		231,
-		200,
-		55,
-		109,
-		141,
-		213,
-		78,
-		169,
-		108,
-		86,
-		244,
-		234,
-		101,
-		122,
-		174,
-		8,
-		186,
-		120,
-		37,
-		46,
-		28,
-		166,
-		180,
-		198,
-		232,
-		221,
-		116,
-		31,
-		75,
-		189,
-		139,
-		138,
-		112,
-		62,
-		181,
-		102,
-		72,
-		3,
-		246,
-		14,
-		97,
-		53,
-		87,
-		185,
-		134,
-		193,
-		29,
-		158,
-		225,
-		248,
-		152,
-		17,
-		105,
-		217,
-		142,
-		148,
-		155,
-		30,
-		135,
-		233,
-		206,
-		85,
-		40,
-		223,
-		140,
-		161,
-		137,
-		13,
-		191,
-		230,
-		66,
-		104,
-		65,
-		153,
-		45,
-		15,
-		176,
-		84,
-		187,
-		22
-	]);
-	/** AES round constants */
-	const RCON = [
-		1,
-		2,
-		4,
-		8,
-		16,
-		32,
-		64,
-		128,
-		27,
-		54
-	];
-	/** GF(2^8) multiplication by 2 */
-	function gf2(a) {
-		return a < 128 ? a << 1 : a << 1 ^ 283;
-	}
-	/**
-	* AES key expansion. Supports AES-128 (16-byte key) and AES-256 (32-byte key).
-	*/
-	function aesKeyExpansion(key) {
-		const nk = key.length / 4;
-		const nr = nk + 6;
-		const w = [];
-		for (let i = 0; i < nk; i++) w.push(new Uint8Array([
-			key[4 * i],
-			key[4 * i + 1],
-			key[4 * i + 2],
-			key[4 * i + 3]
-		]));
-		for (let i = nk; i < 4 * (nr + 1); i++) {
-			const temp = new Uint8Array(w[i - 1]);
-			if (i % nk === 0) {
-				const t0 = temp[0];
-				temp[0] = SBOX[temp[1]] ^ RCON[i / nk - 1];
-				temp[1] = SBOX[temp[2]];
-				temp[2] = SBOX[temp[3]];
-				temp[3] = SBOX[t0];
-			} else if (nk > 6 && i % nk === 4) {
-				temp[0] = SBOX[temp[0]];
-				temp[1] = SBOX[temp[1]];
-				temp[2] = SBOX[temp[2]];
-				temp[3] = SBOX[temp[3]];
-			}
-			const word = new Uint8Array(4);
-			for (let j = 0; j < 4; j++) word[j] = w[i - nk][j] ^ temp[j];
-			w.push(word);
-		}
-		return w;
-	}
-	/**
-	* Encrypt a single AES block (16 bytes).
-	* State layout: column-major per FIPS 197 §3.4.
-	*/
-	function aesEncryptBlock(block, roundKeys) {
-		const nr = roundKeys.length / 4 - 1;
-		const state = new Uint8Array(16);
-		state.set(block);
-		for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) state[4 * c + r] ^= roundKeys[c][r];
-		for (let round = 1; round < nr; round++) {
-			for (let i = 0; i < 16; i++) state[i] = SBOX[state[i]];
-			let tmp;
-			tmp = state[1];
-			state[1] = state[5];
-			state[5] = state[9];
-			state[9] = state[13];
-			state[13] = tmp;
-			tmp = state[2];
-			state[2] = state[10];
-			state[10] = tmp;
-			tmp = state[6];
-			state[6] = state[14];
-			state[14] = tmp;
-			tmp = state[15];
-			state[15] = state[11];
-			state[11] = state[7];
-			state[7] = state[3];
-			state[3] = tmp;
-			for (let c = 0; c < 4; c++) {
-				const s0 = state[4 * c];
-				const s1 = state[4 * c + 1];
-				const s2 = state[4 * c + 2];
-				const s3 = state[4 * c + 3];
-				state[4 * c] = gf2(s0) ^ gf2(s1) ^ s1 ^ s2 ^ s3;
-				state[4 * c + 1] = s0 ^ gf2(s1) ^ gf2(s2) ^ s2 ^ s3;
-				state[4 * c + 2] = s0 ^ s1 ^ gf2(s2) ^ gf2(s3) ^ s3;
-				state[4 * c + 3] = gf2(s0) ^ s0 ^ s1 ^ s2 ^ gf2(s3);
-			}
-			const keyOffset = round * 4;
-			for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) state[4 * c + r] ^= roundKeys[keyOffset + c][r];
-		}
-		for (let i = 0; i < 16; i++) state[i] = SBOX[state[i]];
-		let tmp;
-		tmp = state[1];
-		state[1] = state[5];
-		state[5] = state[9];
-		state[9] = state[13];
-		state[13] = tmp;
-		tmp = state[2];
-		state[2] = state[10];
-		state[10] = tmp;
-		tmp = state[6];
-		state[6] = state[14];
-		state[14] = tmp;
-		tmp = state[15];
-		state[15] = state[11];
-		state[11] = state[7];
-		state[7] = state[3];
-		state[3] = tmp;
-		for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) state[4 * c + r] ^= roundKeys[nr * 4 + c][r];
-		return state;
-	}
-	/**
-	* AES-CBC encryption with PKCS#7 padding.
-	* Supports AES-128 (16-byte key) and AES-256 (32-byte key).
-	*/
-	function aesCbcEncrypt(plaintext, key, iv) {
-		const padLen = 16 - plaintext.length % 16;
-		const padded = new Uint8Array(plaintext.length + padLen);
-		padded.set(plaintext);
-		for (let i = plaintext.length; i < padded.length; i++) padded[i] = padLen;
-		const roundKeys = aesKeyExpansion(key);
-		const numBlocks = padded.length / 16;
-		const output = new Uint8Array(padded.length);
-		let prevBlock = iv;
-		for (let b = 0; b < numBlocks; b++) {
-			const block = new Uint8Array(16);
-			for (let i = 0; i < 16; i++) block[i] = padded[b * 16 + i] ^ prevBlock[i];
-			const encrypted = aesEncryptBlock(block, roundKeys);
-			output.set(encrypted, b * 16);
-			prevBlock = encrypted;
-		}
-		return output;
-	}
-	/**
-	* AES-CBC encryption WITHOUT PKCS#7 padding.
-	* Used when the plaintext is already block-aligned (e.g., encrypting
-	* the 32-byte file encryption key in V=5).
-	*
-	* @throws if plaintext length is not a multiple of 16.
-	*/
-	function aesCbcEncryptRaw(plaintext, key, iv) {
-		if (plaintext.length % 16 !== 0) throw new Error("aesCbcEncryptRaw: plaintext length must be a multiple of 16");
-		const roundKeys = aesKeyExpansion(key);
-		const numBlocks = plaintext.length / 16;
-		const output = new Uint8Array(plaintext.length);
-		let prevBlock = iv;
-		for (let b = 0; b < numBlocks; b++) {
-			const block = new Uint8Array(16);
-			for (let i = 0; i < 16; i++) block[i] = plaintext[b * 16 + i] ^ prevBlock[i];
-			const encrypted = aesEncryptBlock(block, roundKeys);
-			output.set(encrypted, b * 16);
-			prevBlock = encrypted;
-		}
-		return output;
-	}
-	/**
-	* AES-ECB encryption of a single 16-byte block (no padding, no IV).
-	* Used for the /Perms value in V=5 encryption.
-	*/
-	function aesEcbEncrypt(block, key) {
-		return aesEncryptBlock(block, aesKeyExpansion(key));
-	}
-	/** SHA-256 initial hash values */
-	const SHA256_H = new Uint32Array([
-		1779033703,
-		3144134277,
-		1013904242,
-		2773480762,
-		1359893119,
-		2600822924,
-		528734635,
-		1541459225
-	]);
-	/** SHA-256 round constants */
-	const SHA256_K = new Uint32Array([
-		1116352408,
-		1899447441,
-		3049323471,
-		3921009573,
-		961987163,
-		1508970993,
-		2453635748,
-		2870763221,
-		3624381080,
-		310598401,
-		607225278,
-		1426881987,
-		1925078388,
-		2162078206,
-		2614888103,
-		3248222580,
-		3835390401,
-		4022224774,
-		264347078,
-		604807628,
-		770255983,
-		1249150122,
-		1555081692,
-		1996064986,
-		2554220882,
-		2821834349,
-		2952996808,
-		3210313671,
-		3336571891,
-		3584528711,
-		113926993,
-		338241895,
-		666307205,
-		773529912,
-		1294757372,
-		1396182291,
-		1695183700,
-		1986661051,
-		2177026350,
-		2456956037,
-		2730485921,
-		2820302411,
-		3259730800,
-		3345764771,
-		3516065817,
-		3600352804,
-		4094571909,
-		275423344,
-		430227734,
-		506948616,
-		659060556,
-		883997877,
-		958139571,
-		1322822218,
-		1537002063,
-		1747873779,
-		1955562222,
-		2024104815,
-		2227730452,
-		2361852424,
-		2428436474,
-		2756734187,
-		3204031479,
-		3329325298
-	]);
-	function rotr32(x, n) {
-		return (x >>> n | x << 32 - n) >>> 0;
-	}
-	/**
-	* SHA-256 hash function.
-	* @returns 32-byte digest
-	*/
-	function sha256(input) {
-		const msgLen = input.length;
-		const paddedLen = Math.ceil((msgLen + 9) / 64) * 64;
-		const padded = new Uint8Array(paddedLen);
-		padded.set(input);
-		padded[msgLen] = 128;
-		const bitLen = msgLen * 8;
-		const view = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
-		view.setUint32(paddedLen - 8, 0, false);
-		view.setUint32(paddedLen - 4, bitLen, false);
-		let h0 = SHA256_H[0];
-		let h1 = SHA256_H[1];
-		let h2 = SHA256_H[2];
-		let h3 = SHA256_H[3];
-		let h4 = SHA256_H[4];
-		let h5 = SHA256_H[5];
-		let h6 = SHA256_H[6];
-		let h7 = SHA256_H[7];
-		const w = new Uint32Array(64);
-		for (let offset = 0; offset < paddedLen; offset += 64) {
-			for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4, false);
-			for (let i = 16; i < 64; i++) {
-				const s0 = rotr32(w[i - 15], 7) ^ rotr32(w[i - 15], 18) ^ w[i - 15] >>> 3;
-				const s1 = rotr32(w[i - 2], 17) ^ rotr32(w[i - 2], 19) ^ w[i - 2] >>> 10;
-				w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
-			}
-			let a = h0;
-			let b = h1;
-			let c = h2;
-			let d = h3;
-			let e = h4;
-			let f = h5;
-			let g = h6;
-			let h = h7;
-			for (let i = 0; i < 64; i++) {
-				const S1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
-				const ch = e & f ^ ~e & g;
-				const temp1 = h + S1 + ch + SHA256_K[i] + w[i] >>> 0;
-				const temp2 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
-				h = g;
-				g = f;
-				f = e;
-				e = d + temp1 >>> 0;
-				d = c;
-				c = b;
-				b = a;
-				a = temp1 + temp2 >>> 0;
-			}
-			h0 = h0 + a >>> 0;
-			h1 = h1 + b >>> 0;
-			h2 = h2 + c >>> 0;
-			h3 = h3 + d >>> 0;
-			h4 = h4 + e >>> 0;
-			h5 = h5 + f >>> 0;
-			h6 = h6 + g >>> 0;
-			h7 = h7 + h >>> 0;
-		}
-		const result = new Uint8Array(32);
-		const resultView = new DataView(result.buffer);
-		resultView.setUint32(0, h0, false);
-		resultView.setUint32(4, h1, false);
-		resultView.setUint32(8, h2, false);
-		resultView.setUint32(12, h3, false);
-		resultView.setUint32(16, h4, false);
-		resultView.setUint32(20, h5, false);
-		resultView.setUint32(24, h6, false);
-		resultView.setUint32(28, h7, false);
-		return result;
-	}
-	new Uint32Array([
-		3614090360,
-		3905402710,
-		606105819,
-		3250441966,
-		4118548399,
-		1200080426,
-		2821735955,
-		4249261313,
-		1770035416,
-		2336552879,
-		4294925233,
-		2304563134,
-		1804603682,
-		4254626195,
-		2792965006,
-		1236535329,
-		4129170786,
-		3225465664,
-		643717713,
-		3921069994,
-		3593408605,
-		38016083,
-		3634488961,
-		3889429448,
-		568446438,
-		3275163606,
-		4107603335,
-		1163531501,
-		2850285829,
-		4243563512,
-		1735328473,
-		2368359562,
-		4294588738,
-		2272392833,
-		1839030562,
-		4259657740,
-		2763975236,
-		1272893353,
-		4139469664,
-		3200236656,
-		681279174,
-		3936430074,
-		3572445317,
-		76029189,
-		3654602809,
-		3873151461,
-		530742520,
-		3299628645,
-		4096336452,
-		1126891415,
-		2878612391,
-		4237533241,
-		1700485571,
-		2399980690,
-		4293915773,
-		2240044497,
-		1873313359,
-		4264355552,
-		2734768916,
-		1309151649,
-		4149444226,
-		3174756917,
-		718787259,
-		3951481745
-	]);
-	/**
-	* Generate pseudo-random bytes.
-	* Uses Math.random — adequate for PDF IVs but not cryptographically secure.
-	*/
-	function randomBytes(length) {
-		const bytes = new Uint8Array(length);
-		for (let i = 0; i < length; i++) bytes[i] = Math.random() * 256 | 0;
-		return bytes;
-	}
-	/**
-	* Concatenate multiple Uint8Arrays.
-	*/
-	function concatArrays(...arrays) {
-		let totalLen = 0;
-		for (const arr of arrays) totalLen += arr.length;
-		const result = new Uint8Array(totalLen);
-		let offset = 0;
-		for (const arr of arrays) {
-			result.set(arr, offset);
-			offset += arr.length;
-		}
-		return result;
-	}
-	//#endregion
 	//#region src/modules/pdf/core/encryption.ts
-	/**
-	* PDF encryption support (Standard Security Handler, V=5, R=5).
-	*
-	* Implements AES-256 encryption compatible with PDF 2.0 (ISO 32000-2:2020).
-	* Supports:
-	* - User password (required to open the document)
-	* - Owner password (grants full access)
-	* - Permission flags (print, copy, modify, etc.)
-	*
-	* The file encryption key (FEK) is a random 256-bit key.
-	* All streams and strings are encrypted using AES-256-CBC with a random
-	* 16-byte IV prepended to each encrypted value.
-	*
-	* @see ISO 32000-2:2020, §7.6 — Encryption
-	*/
+	init_crypto_browser();
 	/**
 	* Initialize encryption state for AES-256 (V=5, R=5).
 	*/
@@ -47071,12 +47038,28 @@ onmessage = async (ev) => {
 		const uKeySalt = randomBytes(8);
 		const oValidationSalt = randomBytes(8);
 		const oKeySalt = randomBytes(8);
-		const uValue = concatArrays(sha256(concatArrays(userPwd, uValidationSalt)), uValidationSalt, uKeySalt);
-		const ueKey = sha256(concatArrays(userPwd, uKeySalt));
+		const uValue = concatUint8Arrays([
+			sha256(concatUint8Arrays([userPwd, uValidationSalt])),
+			uValidationSalt,
+			uKeySalt
+		]);
+		const ueKey = sha256(concatUint8Arrays([userPwd, uKeySalt]));
 		const zeroIv = new Uint8Array(16);
 		const ueValue = aesCbcEncryptRaw(encryptionKey, ueKey, zeroIv);
-		const oValue = concatArrays(sha256(concatArrays(ownerPwd, oValidationSalt, uValue)), oValidationSalt, oKeySalt);
-		const oeValue = aesCbcEncryptRaw(encryptionKey, sha256(concatArrays(ownerPwd, oKeySalt, uValue)), zeroIv);
+		const oValue = concatUint8Arrays([
+			sha256(concatUint8Arrays([
+				ownerPwd,
+				oValidationSalt,
+				uValue
+			])),
+			oValidationSalt,
+			oKeySalt
+		]);
+		const oeValue = aesCbcEncryptRaw(encryptionKey, sha256(concatUint8Arrays([
+			ownerPwd,
+			oKeySalt,
+			uValue
+		])), zeroIv);
 		const permsBlock = new Uint8Array(16);
 		new DataView(permsBlock.buffer).setInt32(0, perms, true);
 		permsBlock[4] = 255;
@@ -47146,6 +47129,9 @@ onmessage = async (ev) => {
 	* 3. Cross-reference table
 	* 4. Trailer (with document catalog reference)
 	*
+	* Also provides {@link buildIncremental} for appending incremental updates
+	* to an existing PDF without rewriting the original bytes.
+	*
 	* Encryption uses AES-256 (V=5, R=5) per ISO 32000-2:2020.
 	*
 	* @see ISO 32000-2:2020, Chapter 7.5 — File Structure
@@ -47165,6 +47151,14 @@ onmessage = async (ev) => {
 			this.catalogRef = 0;
 			this.infoRef = 0;
 			this.encryption = null;
+			this.pdfVersion = "2.0";
+		}
+		/**
+		* Set the PDF version string (e.g. "1.4", "1.7", "2.0").
+		* Default is "2.0".
+		*/
+		setVersion(version) {
+			this.pdfVersion = version;
 		}
 		/**
 		* Enable encryption for this document.
@@ -47191,9 +47185,9 @@ onmessage = async (ev) => {
 				content: typeof dict === "string" ? dict : dict.toString()
 			});
 		}
-		addStreamObject(objectNumber, dict, data) {
+		addStreamObject(objectNumber, dict, data, options) {
 			let streamData = data instanceof Uint8Array ? data : data.toUint8Array();
-			if (streamData.length > 256 && !dict.toString().includes("/Filter")) {
+			if ((options?.compress ?? true) && streamData.length > 256 && !dict.toString().includes("/Filter")) {
 				const compressed = zlibSync(streamData, { level: 6 });
 				if (compressed.length < streamData.length) {
 					dict.set("Filter", "/FlateDecode");
@@ -47209,6 +47203,20 @@ onmessage = async (ev) => {
 			});
 		}
 		/**
+		* Return all stored objects for inspection (e.g., incremental update remapping).
+		* Stream objects include their binary data.
+		*/
+		getObjects() {
+			return this.objects.map((o) => {
+				const result = {
+					objectNumber: o.objectNumber,
+					content: o.content
+				};
+				if ("streamData" in o) result.streamData = o.streamData;
+				return result;
+			});
+		}
+		/**
 		* Set the document catalog object number.
 		* This is required and references the root of the document structure.
 		*/
@@ -47245,14 +47253,19 @@ onmessage = async (ev) => {
 		}
 		/**
 		* Create and add the Catalog dictionary.
+		*
+		* @param pagesRef - Object number of the Pages tree root
+		* @param optionsOrOutlinesRef - Either an outlinesRef number (legacy) or an options object
 		*/
-		addCatalog(pagesRef, outlinesRef) {
+		addCatalog(pagesRef, optionsOrOutlinesRef) {
+			const resolvedOptions = typeof optionsOrOutlinesRef === "number" ? { outlinesRef: optionsOrOutlinesRef } : optionsOrOutlinesRef ?? {};
 			const objNum = this.allocObject();
 			const dict = new PdfDict().set("Type", "/Catalog").set("Pages", pdfRef(pagesRef));
-			if (outlinesRef) {
-				dict.set("Outlines", pdfRef(outlinesRef));
+			if (resolvedOptions.outlinesRef) {
+				dict.set("Outlines", pdfRef(resolvedOptions.outlinesRef));
 				dict.set("PageMode", "/UseOutlines");
 			}
+			if (resolvedOptions.extraEntries) for (const [key, value] of resolvedOptions.extraEntries) dict.set(key, value);
 			this.addObject(objNum, dict);
 			this.setCatalog(objNum);
 			return objNum;
@@ -47265,7 +47278,8 @@ onmessage = async (ev) => {
 			const encoder = new TextEncoder();
 			const chunks = [];
 			let byteOffset = 0;
-			const headerStrBytes = encoder.encode("%PDF-2.0\n");
+			const headerStr = `%PDF-${this.pdfVersion}\n`;
+			const headerStrBytes = encoder.encode(headerStr);
 			chunks.push(headerStrBytes);
 			byteOffset += headerStrBytes.length;
 			const binaryComment = new Uint8Array([
@@ -47604,6 +47618,30 @@ onmessage = async (ev) => {
 			return this;
 		}
 		/**
+		* Append a cubic Bezier curve to the current path.
+		* From current point to (x3, y3), with control points (x1, y1) and (x2, y2).
+		*/
+		curveTo(x1, y1, x2, y2, x3, y3) {
+			this.parts.push(`${pdfNumber(x1)} ${pdfNumber(y1)} ${pdfNumber(x2)} ${pdfNumber(y2)} ${pdfNumber(x3)} ${pdfNumber(y3)} c`);
+			return this;
+		}
+		/**
+		* Append a cubic Bezier curve where the first control point is the current point.
+		* From current point to (x3, y3), with control points (current, y1) and (x2, y2).
+		*/
+		curveToV(x2, y2, x3, y3) {
+			this.parts.push(`${pdfNumber(x2)} ${pdfNumber(y2)} ${pdfNumber(x3)} ${pdfNumber(y3)} v`);
+			return this;
+		}
+		/**
+		* Append a cubic Bezier curve where the second control point equals (x3, y3).
+		* From current point to (x3, y3), with control point (x1, y1).
+		*/
+		curveToY(x1, y1, x3, y3) {
+			this.parts.push(`${pdfNumber(x1)} ${pdfNumber(y1)} ${pdfNumber(x3)} ${pdfNumber(y3)} y`);
+			return this;
+		}
+		/**
 		* Stroke the current path.
 		*/
 		stroke() {
@@ -47805,6 +47843,47 @@ onmessage = async (ev) => {
 			return this.moveTo(x1, y1).lineTo(x2, y2).stroke().restore();
 		}
 		/**
+		* Append an ellipse to the current path using 4 cubic Bezier curves.
+		* (cx, cy) is the center; rx, ry are the radii.
+		*
+		* Uses the standard kappa = 4 * (sqrt(2) - 1) / 3 ≈ 0.5522847 approximation.
+		*/
+		ellipse(cx, cy, rx, ry) {
+			const k = .5522847;
+			const kx = k * rx;
+			const ky = k * ry;
+			this.moveTo(cx + rx, cy);
+			this.curveTo(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry);
+			this.curveTo(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy);
+			this.curveTo(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry);
+			this.curveTo(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy);
+			return this;
+		}
+		/**
+		* Append a circle to the current path.
+		* (cx, cy) is the center; r is the radius.
+		*/
+		circle(cx, cy, r) {
+			return this.ellipse(cx, cy, r, r);
+		}
+		/**
+		* Append a rounded rectangle to the current path.
+		* (x, y) is the lower-left corner; r is the corner radius.
+		*/
+		roundedRect(x, y, width, height, r) {
+			const kr = .5522847 * r;
+			this.moveTo(x + r, y);
+			this.lineTo(x + width - r, y);
+			this.curveTo(x + width - r + kr, y, x + width, y + r - kr, x + width, y + r);
+			this.lineTo(x + width, y + height - r);
+			this.curveTo(x + width, y + height - r + kr, x + width - r + kr, y + height, x + width - r, y + height);
+			this.lineTo(x + r, y + height);
+			this.curveTo(x + r - kr, y + height, x, y + height - r + kr, x, y + height - r);
+			this.lineTo(x, y + r);
+			this.curveTo(x, y + r - kr, x + r - kr, y, x + r, y);
+			return this;
+		}
+		/**
 		* Get the content stream as a string.
 		*/
 		toString() {
@@ -49806,6 +49885,299 @@ onmessage = async (ev) => {
 	const LINE_HEIGHT_FACTOR = 1.2;
 	const PX_TO_PT = 72 / 96;
 	//#endregion
+	//#region src/modules/pdf/render/png-decoder.ts
+	/**
+	* Minimal PNG decoder for PDF image embedding.
+	*
+	* Extracts raw RGB pixel data from a PNG file. Handles:
+	* - Color types: RGB (2), RGBA (6), Grayscale (0), Grayscale+Alpha (4), Palette (3)
+	* - Bit depth: 8 (most common)
+	* - Interlacing: non-interlaced only (Adam7 interlacing is not supported)
+	* - All 5 PNG filter types (None, Sub, Up, Average, Paeth)
+	*
+	* For RGBA images, produces separate RGB pixels and an alpha mask (for PDF SMask).
+	*/
+	/**
+	* Maximum allowed pixel count for PNG decoding (default: 100 million pixels).
+	* A 10000x10000 RGBA image at 100M pixels would need ~400MB for raw data alone.
+	* This limit prevents memory exhaustion from malicious PNG files with
+	* excessively large declared dimensions.
+	*/
+	const MAX_PNG_PIXELS = 1e8;
+	/**
+	* Decode a PNG file to raw RGB pixels for PDF embedding.
+	* @throws on invalid or unsupported PNG data
+	*/
+	function decodePng(data) {
+		if (data.length < 8 || data[0] !== 137 || data[1] !== 80 || data[2] !== 78 || data[3] !== 71) throw new Error("Invalid PNG signature");
+		let offset = 8;
+		let width = 0;
+		let height = 0;
+		let bitDepth = 0;
+		let colorType = 0;
+		const idatChunks = [];
+		let palette = null;
+		let trns = null;
+		while (offset + 8 <= data.length) {
+			const chunkLen = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(offset, false);
+			const chunkType = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
+			const chunkData = data.subarray(offset + 8, offset + 8 + chunkLen);
+			offset += 8 + chunkLen + 4;
+			switch (chunkType) {
+				case "IHDR": {
+					const hdr = new DataView(chunkData.buffer, chunkData.byteOffset, chunkData.byteLength);
+					width = hdr.getUint32(0, false);
+					height = hdr.getUint32(4, false);
+					bitDepth = chunkData[8];
+					colorType = chunkData[9];
+					if (chunkData[12] !== 0) throw new Error("Interlaced PNG is not supported");
+					if (bitDepth !== 8) throw new Error(`Unsupported PNG bit depth: ${bitDepth}. Only 8-bit PNGs are supported.`);
+					if (width === 0 || height === 0) throw new Error(`Invalid PNG dimensions: ${width}x${height}`);
+					const totalPixels = width * height;
+					if (totalPixels > MAX_PNG_PIXELS) throw new Error(`PNG dimensions too large: ${width}x${height} (${totalPixels} pixels). Maximum allowed: ${MAX_PNG_PIXELS} pixels.`);
+					break;
+				}
+				case "PLTE":
+					palette = new Uint8Array(chunkData);
+					break;
+				case "tRNS":
+					trns = new Uint8Array(chunkData);
+					break;
+				case "IDAT":
+					idatChunks.push(chunkData);
+					break;
+				case "IEND": break;
+			}
+		}
+		if (width === 0 || height === 0) throw new Error("PNG missing IHDR chunk");
+		const compressedData = concatUint8Arrays(idatChunks);
+		let rawCompressed;
+		if (compressedData.length > 6 && (compressedData[0] & 15) === 8) rawCompressed = compressedData.subarray(2, compressedData.length - 4);
+		else rawCompressed = compressedData;
+		const rawData = decompressSync(rawCompressed);
+		const channels = getChannelCount(colorType);
+		const bytesPerPixel = Math.max(1, channels * bitDepth / 8);
+		const scanlineLen = Math.ceil(width * channels * bitDepth / 8);
+		return toRgb(applyFilters(rawData, width, height, scanlineLen, bytesPerPixel), width, height, colorType, bitDepth, palette, trns);
+	}
+	function applyFilters(data, _width, height, scanlineLen, bytesPerPixel) {
+		const result = new Uint8Array(height * scanlineLen);
+		const bpp = Math.max(1, Math.floor(bytesPerPixel));
+		let srcOffset = 0;
+		for (let y = 0; y < height; y++) {
+			const filterType = data[srcOffset++];
+			const dstOffset = y * scanlineLen;
+			const prevRow = y > 0 ? (y - 1) * scanlineLen : -1;
+			for (let x = 0; x < scanlineLen; x++) {
+				const raw = data[srcOffset++] ?? 0;
+				const a = x >= bpp ? result[dstOffset + x - bpp] : 0;
+				const b = prevRow >= 0 ? result[prevRow + x] : 0;
+				const c = prevRow >= 0 && x >= bpp ? result[prevRow + x - bpp] : 0;
+				switch (filterType) {
+					case 0:
+						result[dstOffset + x] = raw;
+						break;
+					case 1:
+						result[dstOffset + x] = raw + a & 255;
+						break;
+					case 2:
+						result[dstOffset + x] = raw + b & 255;
+						break;
+					case 3:
+						result[dstOffset + x] = raw + Math.floor((a + b) / 2) & 255;
+						break;
+					case 4:
+						result[dstOffset + x] = raw + paethPredictor(a, b, c) & 255;
+						break;
+					default: result[dstOffset + x] = raw;
+				}
+			}
+		}
+		return result;
+	}
+	function paethPredictor(a, b, c) {
+		const p = a + b - c;
+		const pa = Math.abs(p - a);
+		const pb = Math.abs(p - b);
+		const pc = Math.abs(p - c);
+		if (pa <= pb && pa <= pc) return a;
+		if (pb <= pc) return b;
+		return c;
+	}
+	function getChannelCount(colorType) {
+		switch (colorType) {
+			case 0: return 1;
+			case 2: return 3;
+			case 3: return 1;
+			case 4: return 2;
+			case 6: return 4;
+			default: return 3;
+		}
+	}
+	function toRgb(data, width, height, colorType, _bitDepth, palette, trns) {
+		const totalPixels = width * height;
+		const pixels = new Uint8Array(totalPixels * 3);
+		let alpha = null;
+		switch (colorType) {
+			case 2:
+				pixels.set(data.subarray(0, totalPixels * 3));
+				if (trns && trns.length >= 6) {
+					const trR = trns[1];
+					const trG = trns[3];
+					const trB = trns[5];
+					alpha = new Uint8Array(totalPixels);
+					alpha.fill(255);
+					for (let i = 0; i < totalPixels; i++) if (data[i * 3] === trR && data[i * 3 + 1] === trG && data[i * 3 + 2] === trB) alpha[i] = 0;
+				}
+				break;
+			case 6:
+				alpha = new Uint8Array(totalPixels);
+				for (let i = 0; i < totalPixels; i++) {
+					pixels[i * 3] = data[i * 4];
+					pixels[i * 3 + 1] = data[i * 4 + 1];
+					pixels[i * 3 + 2] = data[i * 4 + 2];
+					alpha[i] = data[i * 4 + 3];
+				}
+				break;
+			case 0: {
+				let trGray = -1;
+				if (trns && trns.length >= 2) trGray = trns[1];
+				if (trGray >= 0) {
+					alpha = new Uint8Array(totalPixels);
+					alpha.fill(255);
+				}
+				for (let i = 0; i < totalPixels; i++) {
+					const g = data[i];
+					pixels[i * 3] = g;
+					pixels[i * 3 + 1] = g;
+					pixels[i * 3 + 2] = g;
+					if (alpha && g === trGray) alpha[i] = 0;
+				}
+				break;
+			}
+			case 4:
+				alpha = new Uint8Array(totalPixels);
+				for (let i = 0; i < totalPixels; i++) {
+					const g = data[i * 2];
+					pixels[i * 3] = g;
+					pixels[i * 3 + 1] = g;
+					pixels[i * 3 + 2] = g;
+					alpha[i] = data[i * 2 + 1];
+				}
+				break;
+			case 3:
+				if (!palette) throw new Error("PNG palette color type (3) but missing PLTE chunk");
+				if (trns && trns.length > 0) alpha = new Uint8Array(totalPixels);
+				for (let i = 0; i < totalPixels; i++) {
+					const idx = data[i];
+					pixels[i * 3] = palette[idx * 3] ?? 0;
+					pixels[i * 3 + 1] = palette[idx * 3 + 1] ?? 0;
+					pixels[i * 3 + 2] = palette[idx * 3 + 2] ?? 0;
+					if (alpha) alpha[i] = idx < trns.length ? trns[idx] : 255;
+				}
+				break;
+			default: throw new Error(`Unsupported PNG color type: ${colorType}`);
+		}
+		if (alpha) {
+			let fullyOpaque = true;
+			for (let i = 0; i < alpha.length; i++) if (alpha[i] !== 255) {
+				fullyOpaque = false;
+				break;
+			}
+			if (fullyOpaque) alpha = null;
+		}
+		return {
+			width,
+			height,
+			pixels,
+			alpha,
+			bitsPerComponent: 8
+		};
+	}
+	//#endregion
+	//#region src/modules/pdf/builder/image-utils.ts
+	/**
+	* Parse image dimensions from raw bytes.
+	*/
+	function parseImageDimensions(data, format) {
+		if (format === "png") return parsePngDimensions(data);
+		return parseJpegDimensions(data);
+	}
+	/**
+	* Read width/height from a PNG IHDR chunk (bytes 16-23).
+	*/
+	function parsePngDimensions(data) {
+		if (data.length >= 24 && data[12] === 73 && data[13] === 72 && data[14] === 68 && data[15] === 82) return {
+			width: data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19],
+			height: data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23]
+		};
+		return {
+			width: 1,
+			height: 1
+		};
+	}
+	/**
+	* Read width/height from JPEG SOF marker.
+	*
+	* Correctly excludes non-SOF markers in the 0xC0-0xCF range:
+	* - 0xC4 = DHT (Define Huffman Table)
+	* - 0xC8 = JPG (reserved)
+	* - 0xCC = DAC (Define Arithmetic Coding)
+	*/
+	function parseJpegDimensions(data) {
+		let offset = 2;
+		while (offset < data.length - 1) {
+			while (offset < data.length && data[offset] === 255 && data[offset + 1] === 255) offset++;
+			if (offset >= data.length - 1 || data[offset] !== 255) break;
+			const marker = data[offset + 1];
+			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204 && offset + 8 < data.length) return {
+				width: data[offset + 7] << 8 | data[offset + 8],
+				height: data[offset + 5] << 8 | data[offset + 6]
+			};
+			if (offset + 3 >= data.length) break;
+			const segLen = data[offset + 2] << 8 | data[offset + 3];
+			offset += 2 + segLen;
+		}
+		return {
+			width: 1,
+			height: 1
+		};
+	}
+	/**
+	* Write an image XObject (JPEG or PNG) to the writer.
+	* Returns the allocated object number.
+	*/
+	function writeImageXObject(writer, data, format) {
+		if (format === "png") return writePngImageXObject(writer, data);
+		return writeJpegImageXObject(writer, data);
+	}
+	/**
+	* Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+	*/
+	function writeJpegImageXObject(writer, data) {
+		const objNum = writer.allocObject();
+		const dims = parseJpegDimensions(data);
+		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(dims.width)).set("Height", pdfNumber(dims.height)).set("ColorSpace", "/DeviceRGB").set("BitsPerComponent", "8").set("Filter", "/DCTDecode");
+		writer.addStreamObject(objNum, dict, data);
+		return objNum;
+	}
+	/**
+	* Write a PNG image: decode to raw RGB, create SMask for alpha if needed.
+	*/
+	function writePngImageXObject(writer, data) {
+		const png = decodePng(data);
+		const objNum = writer.allocObject();
+		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", "/DeviceRGB").set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
+		if (png.alpha) {
+			const smaskObjNum = writer.allocObject();
+			const smaskDict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", "/DeviceGray").set("BitsPerComponent", "8");
+			writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
+			dict.set("SMask", pdfRef(smaskObjNum));
+		}
+		writer.addStreamObject(objNum, dict, png.pixels);
+		return objNum;
+	}
+	//#endregion
 	//#region src/modules/pdf/render/page-renderer.ts
 	/**
 	* Page renderer for PDF generation.
@@ -49818,6 +50190,14 @@ onmessage = async (ev) => {
 	* - Grid lines
 	* - Page headers (sheet names) and footers (page numbers)
 	*/
+	function computeCellPadding(cell, scaleFactor = 1) {
+		return {
+			left: (3 + cell.borderInsets.left) * scaleFactor,
+			right: (3 + cell.borderInsets.right) * scaleFactor,
+			top: (2 + cell.borderInsets.top) * scaleFactor,
+			bottom: (2 + cell.borderInsets.bottom) * scaleFactor
+		};
+	}
 	/**
 	* Render a single page to a PDF content stream.
 	*/
@@ -49923,10 +50303,9 @@ onmessage = async (ev) => {
 	function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
 		const { rect, text, fontSize, horizontalAlign, verticalAlign, wrapText } = cell;
 		if (!text && !cell.richText) return;
-		const padH = 3 * scaleFactor;
-		const padV = 2 * scaleFactor;
-		const availWidth = rect.width - padH * 2;
-		const availHeight = rect.height - padV * 2;
+		const pad = computeCellPadding(cell, scaleFactor);
+		const availWidth = rect.width - pad.left - pad.right;
+		const availHeight = rect.height - pad.top - pad.bottom;
 		if (availWidth <= 0 || availHeight <= 0) return;
 		const indentPts = cell.indent * 10 * scaleFactor;
 		const clipWidth = rect.width + (cell.textOverflowWidth || 0);
@@ -49967,28 +50346,27 @@ onmessage = async (ev) => {
 		const lines = wrapText ? wrapTextLines(text, measure, effectiveWidth) : text.split(/\r?\n/);
 		const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
 		const ascent = fontManager.getFontAscent(resourceName, fontSize);
-		const textStartY = computeTextStartY(verticalAlign, rect, lines.length * lineHeight, ascent, padV);
+		const textStartY = computeTextStartY(verticalAlign, rect, lines.length * lineHeight, ascent, pad.top, pad.bottom);
 		stream.setFillColor(cell.textColor);
 		stream.beginText();
 		stream.setFont(resourceName, fontSize);
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
 			const lineY = textStartY - i * lineHeight;
-			const textX = computeTextX(horizontalAlign, rect, measure(line), indentPts, padH);
+			const textX = computeTextX(horizontalAlign, rect, measure(line), indentPts, pad.left, pad.right);
 			stream.setTextMatrix(1, 0, 0, 1, textX, lineY);
 			const hexEncoded = fontManager.encodeText(line, resourceName);
 			if (hexEncoded) stream.showTextHex(hexEncoded);
 			else stream.showText(line);
 		}
 		stream.endText();
-		drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts);
+		drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts, pad);
 		stream.restore();
 	}
 	function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
 		const { rect, horizontalAlign, verticalAlign, wrapText } = cell;
 		const runs = cell.richText;
-		const padH = 3 * scaleFactor;
-		const padV = 2 * scaleFactor;
+		const pad = computeCellPadding(cell, scaleFactor);
 		let maxFontSize = cell.fontSize;
 		for (const run of runs) if (run.fontSize > maxFontSize) maxFontSize = run.fontSize;
 		const primaryFontSize = maxFontSize;
@@ -49996,7 +50374,7 @@ onmessage = async (ev) => {
 		const isEmbedded = fontManager.hasEmbeddedFont();
 		const runResource = (run) => isEmbedded ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(run.fontFamily, run.bold, run.italic));
 		if (wrapText) {
-			const availWidth = rect.width - padH * 2 - indentPts;
+			const availWidth = rect.width - pad.left - pad.right - indentPts;
 			if (availWidth <= 0) return;
 			const fullText = runs.map((r) => r.text).join("");
 			const primaryResource = runResource(runs[0]);
@@ -50006,7 +50384,7 @@ onmessage = async (ev) => {
 			for (let ri = 0; ri < runs.length; ri++) for (let ci = 0; ci < runs[ri].text.length; ci++) runForChar.push(ri);
 			const primaryResourceName = runResource(runs[0]);
 			const ascent = fontManager.getFontAscent(primaryResourceName, primaryFontSize);
-			const textStartY = computeTextStartY(verticalAlign, rect, lines.length * lineHeight, ascent, padV);
+			const textStartY = computeTextStartY(verticalAlign, rect, lines.length * lineHeight, ascent, pad.top, pad.bottom);
 			let charPos = 0;
 			for (let li = 0; li < lines.length; li++) {
 				const lineY = textStartY - li * lineHeight;
@@ -50034,7 +50412,7 @@ onmessage = async (ev) => {
 				}
 				let lineWidth = 0;
 				for (const seg of segments) lineWidth += fontManager.measureText(seg.text, seg.resourceName, seg.run.fontSize);
-				let textX = computeTextX(horizontalAlign, rect, lineWidth, indentPts, padH);
+				let textX = computeTextX(horizontalAlign, rect, lineWidth, indentPts, pad.left, pad.right);
 				for (const seg of segments) {
 					const { run, text, resourceName } = seg;
 					const segWidth = fontManager.measureText(text, resourceName, run.fontSize);
@@ -50071,8 +50449,8 @@ onmessage = async (ev) => {
 			totalWidth += w;
 		}
 		const primaryResourceName = runMetrics[0]?.resourceName ?? "F1";
-		const textStartY = computeTextStartY(verticalAlign, rect, lineHeight, fontManager.getFontAscent(primaryResourceName, primaryFontSize), padV);
-		let textX = computeTextX(horizontalAlign, rect, totalWidth, indentPts, padH);
+		const textStartY = computeTextStartY(verticalAlign, rect, lineHeight, fontManager.getFontAscent(primaryResourceName, primaryFontSize), pad.top, pad.bottom);
+		let textX = computeTextX(horizontalAlign, rect, totalWidth, indentPts, pad.left, pad.right);
 		for (let i = 0; i < runs.length; i++) {
 			const run = runs[i];
 			const { resourceName } = runMetrics[i];
@@ -50099,8 +50477,7 @@ onmessage = async (ev) => {
 	function drawRotatedText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
 		const { rect, wrapText } = cell;
 		let { fontSize } = cell;
-		const padH = 3 * scaleFactor;
-		const padV = 2 * scaleFactor;
+		const pad = computeCellPadding(cell, scaleFactor);
 		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
 		const degrees = excelRotationToDegrees(cell.textRotation);
 		const radians = degrees * Math.PI / 180;
@@ -50108,8 +50485,8 @@ onmessage = async (ev) => {
 		const sin = Math.sin(radians);
 		const absSin = Math.abs(sin);
 		const absCos = Math.abs(cos);
-		const maxWidth = rect.width - padH * 2;
-		const maxHeight = rect.height - padV * 2;
+		const maxWidth = rect.width - pad.left - pad.right;
+		const maxHeight = rect.height - pad.top - pad.bottom;
 		let availTextLength;
 		if (absSin > .01 && absCos > .01) availTextLength = Math.min(maxHeight / absSin, maxWidth / absCos);
 		else if (absSin > .01) availTextLength = maxHeight / absSin;
@@ -50138,27 +50515,27 @@ onmessage = async (ev) => {
 		const is90 = Math.abs(degrees - 90) < .01;
 		const isMinus90 = Math.abs(degrees + 90) < .01;
 		stream.setFillColor(cell.textColor);
-		if (is90) drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, padH, padV);
-		else if (isMinus90) drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, padH, padV);
+		if (is90) drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, pad);
+		else if (isMinus90) drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, pad);
 		else drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, cos, sin, indentPts);
 	}
 	/** 90° CCW: text reads bottom-to-top, lines stack left-to-right. */
-	function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, padH, padV) {
+	function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, pad) {
 		const { rect, horizontalAlign, verticalAlign } = cell;
 		const totalColumnsWidth = lines.length * lineHeight;
 		let startX;
 		if (horizontalAlign === "center") startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + ascent;
-		else if (horizontalAlign === "right") startX = rect.x + rect.width - padH - totalColumnsWidth + ascent;
-		else startX = rect.x + padH + ascent;
+		else if (horizontalAlign === "right") startX = rect.x + rect.width - pad.right - totalColumnsWidth + ascent;
+		else startX = rect.x + pad.left + ascent;
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
 			const lineWidth = fontManager.measureText(line, resourceName, fontSize);
 			const colX = startX + i * lineHeight;
 			let ty;
-			if (verticalAlign === "top") ty = rect.y + rect.height - padV - lineWidth;
+			if (verticalAlign === "top") ty = rect.y + rect.height - pad.top - lineWidth;
 			else if (verticalAlign === "middle") ty = rect.y + (rect.height - lineWidth) / 2;
-			else ty = rect.y + padV;
-			ty = Math.max(ty, rect.y + padV);
+			else ty = rect.y + pad.bottom;
+			ty = Math.max(ty, rect.y + pad.bottom);
 			stream.beginText();
 			stream.setFont(resourceName, fontSize);
 			stream.setTextMatrix(0, 1, -1, 0, colX, ty);
@@ -50167,22 +50544,22 @@ onmessage = async (ev) => {
 		}
 	}
 	/** -90° (270° CW): text reads top-to-bottom, lines stack right-to-left. */
-	function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, padH, padV) {
+	function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, pad) {
 		const { rect, horizontalAlign, verticalAlign } = cell;
 		const totalColumnsWidth = lines.length * lineHeight;
 		let startX;
 		if (horizontalAlign === "center") startX = rect.x + rect.width / 2 + totalColumnsWidth / 2 - lineHeight + ascent;
-		else if (horizontalAlign === "right") startX = rect.x + rect.width - padH - lineHeight + ascent;
-		else startX = rect.x + padH + totalColumnsWidth - lineHeight + ascent;
+		else if (horizontalAlign === "right") startX = rect.x + rect.width - pad.right - lineHeight + ascent;
+		else startX = rect.x + pad.left + totalColumnsWidth - lineHeight + ascent;
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
 			const lineWidth = fontManager.measureText(line, resourceName, fontSize);
 			const colX = startX - i * lineHeight;
 			let ty;
-			if (verticalAlign === "top") ty = rect.y + rect.height - padV;
+			if (verticalAlign === "top") ty = rect.y + rect.height - pad.top;
 			else if (verticalAlign === "middle") ty = rect.y + (rect.height + lineWidth) / 2;
-			else ty = rect.y + padV + lineWidth;
-			ty = Math.min(ty, rect.y + rect.height - padV);
+			else ty = rect.y + pad.bottom + lineWidth;
+			ty = Math.min(ty, rect.y + rect.height - pad.top);
 			stream.beginText();
 			stream.setFont(resourceName, fontSize);
 			stream.setTextMatrix(0, -1, 1, 0, colX, ty);
@@ -50193,8 +50570,7 @@ onmessage = async (ev) => {
 	/** General rotation — center a multi-line text block in the cell. */
 	function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, cos, sin, indentPts) {
 		const { rect, horizontalAlign, verticalAlign } = cell;
-		const padH = 3;
-		const padV = 2;
+		const pad = computeCellPadding(cell);
 		let maxLineWidth = 0;
 		for (const line of lines) {
 			const w = fontManager.measureText(line, resourceName, fontSize);
@@ -50208,14 +50584,14 @@ onmessage = async (ev) => {
 		const slantShift = computeSlantOffset(cell.textRotation, rect.height) / 2;
 		const indentOffset = horizontalAlign === "left" ? indentPts / 2 : horizontalAlign === "right" ? -indentPts / 2 : 0;
 		let cy;
-		if (verticalAlign === "top") cy = rect.y + rect.height - padV - rotatedHeight / 2;
-		else if (verticalAlign === "bottom") cy = rect.y + padV + rotatedHeight / 2;
+		if (verticalAlign === "top") cy = rect.y + rect.height - pad.top - rotatedHeight / 2;
+		else if (verticalAlign === "bottom") cy = rect.y + pad.bottom + rotatedHeight / 2;
 		else cy = rect.y + rect.height / 2;
 		const verticalRatio = rect.height > 0 ? (cy - rect.y) / rect.height : .5;
 		const slantAtCy = slantShift * 2 * verticalRatio;
 		let cx;
-		if (horizontalAlign === "right") cx = rect.x + rect.width - padH - rotatedWidth / 2 + indentOffset + slantAtCy;
-		else if (horizontalAlign === "left") cx = rect.x + padH + rotatedWidth / 2 + indentOffset + slantAtCy;
+		if (horizontalAlign === "right") cx = rect.x + rect.width - pad.right - rotatedWidth / 2 + indentOffset + slantAtCy;
+		else if (horizontalAlign === "left") cx = rect.x + pad.left + rotatedWidth / 2 + indentOffset + slantAtCy;
 		else cx = rect.x + rect.width / 2 + indentOffset + slantAtCy;
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
@@ -50244,8 +50620,7 @@ onmessage = async (ev) => {
 	*/
 	function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFactor = 1) {
 		const { rect, text, fontSize, horizontalAlign, verticalAlign } = cell;
-		const padH = 3 * scaleFactor;
-		const padV = 2 * scaleFactor;
+		const pad = computeCellPadding(cell, scaleFactor);
 		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
 		const charHeight = fontSize * 1.3;
 		const ascent = fontManager.getFontAscent(resourceName, fontSize);
@@ -50254,8 +50629,8 @@ onmessage = async (ev) => {
 		const totalColumnsWidth = columns.length * columnWidth;
 		let startX;
 		if (horizontalAlign === "center") startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + columnWidth / 2;
-		else if (horizontalAlign === "right") startX = rect.x + rect.width - padH - totalColumnsWidth + columnWidth / 2;
-		else startX = rect.x + padH + columnWidth / 2;
+		else if (horizontalAlign === "right") startX = rect.x + rect.width - pad.right - totalColumnsWidth + columnWidth / 2;
+		else startX = rect.x + pad.left + columnWidth / 2;
 		stream.setFillColor(cell.textColor);
 		for (let colIdx = 0; colIdx < columns.length; colIdx++) {
 			const colText = columns[colIdx];
@@ -50263,10 +50638,10 @@ onmessage = async (ev) => {
 			const totalTextHeight = colText.length * charHeight;
 			let currentY;
 			if (verticalAlign === "middle") currentY = rect.y + rect.height / 2 + totalTextHeight / 2 - ascent;
-			else if (verticalAlign === "bottom") currentY = rect.y + padV + totalTextHeight - ascent;
-			else currentY = rect.y + rect.height - padV - ascent;
+			else if (verticalAlign === "bottom") currentY = rect.y + pad.bottom + totalTextHeight - ascent;
+			else currentY = rect.y + rect.height - pad.top - ascent;
 			for (const ch of colText) {
-				if (currentY < rect.y + padV) break;
+				if (currentY < rect.y + pad.bottom) break;
 				const charWidth = fontManager.measureText(ch, resourceName, fontSize);
 				stream.beginText();
 				stream.setFont(resourceName, fontSize);
@@ -50285,49 +50660,49 @@ onmessage = async (ev) => {
 	function alphaGsName(alpha) {
 		return `GS${Math.round(alpha * 1e4)}`;
 	}
-	function computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padV = 2) {
+	function computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padVTop = 2, padVBottom = padVTop) {
 		let y;
 		switch (verticalAlign) {
 			case "top":
-				y = rect.y + rect.height - padV - ascent;
+				y = rect.y + rect.height - padVTop - ascent;
 				break;
 			case "middle":
 				y = rect.y + rect.height / 2 + totalTextHeight / 2 - ascent;
 				break;
 			default:
-				y = rect.y + padV + (totalTextHeight - ascent);
+				y = rect.y + padVBottom + (totalTextHeight - ascent);
 				break;
 		}
-		const maxY = rect.y + rect.height - padV - ascent;
+		const maxY = rect.y + rect.height - padVTop - ascent;
 		if (y > maxY) y = maxY;
-		const minY = rect.y + padV;
+		const minY = rect.y + padVBottom;
 		if (y < minY) y = minY;
 		return y;
 	}
-	function computeTextX(align, rect, textWidth, indentPts = 0, padH = 3) {
+	function computeTextX(align, rect, textWidth, indentPts = 0, padHLeft = 3, padHRight = padHLeft) {
 		let x;
 		switch (align) {
 			case "center":
 				x = rect.x + (rect.width - textWidth) / 2;
 				break;
 			case "right":
-				x = rect.x + rect.width - padH - textWidth;
+				x = rect.x + rect.width - padHRight - textWidth;
 				break;
 			default:
-				x = rect.x + padH + indentPts;
+				x = rect.x + padHLeft + indentPts;
 				break;
 		}
-		const minX = rect.x + padH;
+		const minX = rect.x + padHLeft;
 		if (x < minX) x = minX;
 		return x;
 	}
-	function drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts) {
+	function drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts, pad) {
 		if (cell.strike) {
 			const strikeY = textStartY + fontManager.getFontDescent(resourceName, cell.fontSize) + cell.fontSize * .3;
 			for (let i = 0; i < lines.length; i++) {
 				const lineY = strikeY - i * lineHeight;
 				const lw = measure(lines[i]);
-				const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts);
+				const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts, pad?.left, pad?.right);
 				stream.drawLine(startX, lineY, startX + lw, lineY, cell.textColor, .5);
 			}
 		}
@@ -50336,7 +50711,7 @@ onmessage = async (ev) => {
 			for (let i = 0; i < lines.length; i++) {
 				const lineY = textStartY - i * lineHeight + underlineOffset;
 				const lw = measure(lines[i]);
-				const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts);
+				const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts, pad?.left, pad?.right);
 				stream.drawLine(startX, lineY, startX + lw, lineY, cell.textColor, .5);
 			}
 		}
@@ -50581,41 +50956,6 @@ onmessage = async (ev) => {
 	/**
 	* Parse image dimensions from raw JPEG or PNG data without a full decode.
 	*/
-	function parseImageDimensions(data, format) {
-		if (format === "png") return parsePngDimensions(data);
-		return parseJpegDimensions(data);
-	}
-	/** Read width/height from a PNG IHDR chunk (bytes 16-23). */
-	function parsePngDimensions(data) {
-		if (data.length >= 24 && data[12] === 73 && data[13] === 72 && data[14] === 68 && data[15] === 82) return {
-			width: data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19],
-			height: data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23]
-		};
-		return {
-			width: 1,
-			height: 1
-		};
-	}
-	/** Read width/height from JPEG SOF marker. */
-	function parseJpegDimensions(data) {
-		let offset = 2;
-		while (offset < data.length - 1) {
-			while (offset < data.length && data[offset] === 255 && data[offset + 1] === 255) offset++;
-			if (offset >= data.length - 1 || data[offset] !== 255) break;
-			const marker = data[offset + 1];
-			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204 && offset + 8 < data.length) return {
-				width: data[offset + 7] << 8 | data[offset + 8],
-				height: data[offset + 5] << 8 | data[offset + 6]
-			};
-			if (offset + 3 >= data.length) break;
-			const segLen = data[offset + 2] << 8 | data[offset + 3];
-			offset += 2 + segLen;
-		}
-		return {
-			width: 1,
-			height: 1
-		};
-	}
 	/**
 	* Resolve the center position for a watermark on a given page.
 	*/
@@ -50791,6 +51131,7 @@ onmessage = async (ev) => {
 				cellGrid.set(`${ri}:${gci}`, layoutCell);
 			}
 		}
+		resolveSharedBorders(cellGrid, rowPage.length, colGroup.length);
 		computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleCols, groupColWidths, mergeMap, fontManager);
 		return {
 			pageNumber: currentPageCount + 1,
@@ -50930,7 +51271,9 @@ onmessage = async (ev) => {
 					const fontSize = getCellFontSize(cell);
 					const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
 					const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
-					const neededHeight = fontSize + (wrapLineCount - 1) * lineHeight + 4;
+					const borderTop = cell.style?.border?.top?.style ? borderStyleToLineWidth(cell.style.border.top.style) / 2 : 0;
+					const borderBottom = cell.style?.border?.bottom?.style ? borderStyleToLineWidth(cell.style.border.bottom.style) / 2 : 0;
+					const neededHeight = fontSize + (wrapLineCount - 1) * lineHeight + (2 + borderTop + borderBottom) * 2;
 					if (neededHeight > height) height = neededHeight;
 				}
 			}
@@ -50968,7 +51311,10 @@ onmessage = async (ev) => {
 		const lineCount = Math.max(1, (text.match(/\n/g) ?? []).length + 1);
 		if (!cell.style?.alignment?.wrapText || text.length === 0) return lineCount;
 		const scaledColPts = ((sheet.columns.get(cell.col)?.width ?? DEFAULT_COLUMN_WIDTH) * 7 + 5) * PX_TO_PT * scaleFactor;
-		const padding = 6 + (cell.style.alignment.indent ?? 0) * 10;
+		const indent = cell.style.alignment.indent ?? 0;
+		const borderLeft = cell.style?.border?.left?.style ? borderStyleToLineWidth(cell.style.border.left.style) / 2 : 0;
+		const borderRight = cell.style?.border?.right?.style ? borderStyleToLineWidth(cell.style.border.right.style) / 2 : 0;
+		const padding = 3 + borderLeft + (3 + borderRight) + indent * 10;
 		const effectiveWidth = Math.max(scaledColPts - padding, 1);
 		const scaledFontSize = fontSize * scaleFactor;
 		const fontProps = extractFontProperties(cell.style.font, options.defaultFontFamily, options.defaultFontSize);
@@ -51109,6 +51455,7 @@ onmessage = async (ev) => {
 			fontManager.ensureFont(pdfFontName);
 		}
 		const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor);
+		const borders = excelBordersToPdf(style.border);
 		return {
 			text,
 			rect: {
@@ -51128,7 +51475,13 @@ onmessage = async (ev) => {
 			horizontalAlign: resolveHorizontalAlign(style.alignment, cell?.type, cell?.result),
 			verticalAlign: excelVAlignToPdf(style.alignment),
 			wrapText: style.alignment?.wrapText ?? false,
-			borders: excelBordersToPdf(style.border),
+			borders,
+			borderInsets: {
+				top: (borders.top?.width ?? 0) / 2,
+				right: (borders.right?.width ?? 0) / 2,
+				bottom: (borders.bottom?.width ?? 0) / 2,
+				left: (borders.left?.width ?? 0) / 2
+			},
 			colSpan,
 			rowSpan,
 			hyperlink: cell?.hyperlink ?? null,
@@ -51139,6 +51492,64 @@ onmessage = async (ev) => {
 		};
 	}
 	/**
+	* Border precedence weight.
+	*
+	* When two adjacent cells both declare a border on a shared edge the winning
+	* border is chosen by:  1. thicker wins,  2. solid beats dashed,
+	* 3. double beats single,  4. darker colour wins (tie-break).
+	*
+	* Returns a numeric score – higher score wins.
+	*/
+	function borderPrecedence(b) {
+		let score = b.width * 1e3;
+		if (b.dashPattern.length === 0) score += 100;
+		if (b.isDouble) score += 50;
+		const brightness = b.color.r + b.color.g + b.color.b;
+		score += (3 - brightness) * 10;
+		return score;
+	}
+	/**
+	* Resolve shared borders between adjacent cells.
+	*
+	* For each shared edge, determine the winning border (by precedence), then:
+	* - The cell that "owns" the winning border keeps it in `borders` for drawing.
+	* - The losing cell has that border side set to `null` (it won't draw).
+	* - Both cells' `borderInsets` are updated to reflect the winning border's
+	*   half-width, so text padding accounts for the line that is actually there.
+	*/
+	function resolveSharedBorders(cellGrid, rowCount, colCount) {
+		for (let ri = 0; ri < rowCount; ri++) for (let gci = 0; gci < colCount; gci++) {
+			const cell = cellGrid.get(`${ri}:${gci}`);
+			if (!cell) continue;
+			if (cell.borders.right) {
+				const rightNeighbor = cellGrid.get(`${ri}:${gci + 1}`);
+				if (rightNeighbor?.borders.left) {
+					const myScore = borderPrecedence(cell.borders.right);
+					if (borderPrecedence(rightNeighbor.borders.left) > myScore) {
+						cell.borderInsets.right = rightNeighbor.borders.left.width / 2;
+						cell.borders.right = null;
+					} else {
+						rightNeighbor.borderInsets.left = cell.borders.right.width / 2;
+						rightNeighbor.borders.left = null;
+					}
+				}
+			}
+			if (cell.borders.bottom) {
+				const belowNeighbor = cellGrid.get(`${ri + 1}:${gci}`);
+				if (belowNeighbor?.borders.top) {
+					const myScore = borderPrecedence(cell.borders.bottom);
+					if (borderPrecedence(belowNeighbor.borders.top) > myScore) {
+						cell.borderInsets.bottom = belowNeighbor.borders.top.width / 2;
+						cell.borders.bottom = null;
+					} else {
+						belowNeighbor.borderInsets.top = cell.borders.bottom.width / 2;
+						belowNeighbor.borders.top = null;
+					}
+				}
+			}
+		}
+	}
+	/**
 	* Assign pre-collected images to the pages that contain their top-left anchor.
 	*/
 	function assignImagesToPages(images, layoutPages, scaleFactor) {
@@ -51199,7 +51610,10 @@ onmessage = async (ev) => {
 			const rightCellData = sheet.rows.get(wsRowNumber)?.cells.get(rightCol);
 			if (rightCellData?.style?.border?.right) {
 				const converted = excelBordersToPdf({ right: rightCellData.style.border.right });
-				if (converted.right) layoutCell.borders.right = converted.right;
+				if (converted.right) {
+					layoutCell.borders.right = converted.right;
+					layoutCell.borderInsets.right = converted.right.width / 2;
+				}
 			}
 		}
 		if (mergeInfo.rowSpan > 1) {
@@ -51207,7 +51621,10 @@ onmessage = async (ev) => {
 			const bottomCellData = sheet.rows.get(bottomRowNum)?.cells.get(wsColNumber);
 			if (bottomCellData?.style?.border?.bottom) {
 				const converted = excelBordersToPdf({ bottom: bottomCellData.style.border.bottom });
-				if (converted.bottom) layoutCell.borders.bottom = converted.bottom;
+				if (converted.bottom) {
+					layoutCell.borders.bottom = converted.bottom;
+					layoutCell.borderInsets.bottom = converted.bottom.width / 2;
+				}
 			}
 		}
 	}
@@ -51222,7 +51639,7 @@ onmessage = async (ev) => {
 			if (!cell || cell.wrapText || cell.colSpan > 1 || !cell.text || cell.richText || typeof cell.textRotation === "number" && cell.textRotation !== 0 || cell.textRotation === "vertical") continue;
 			const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
 			const textWidth = fontManager.measureText(cell.text, resourceName, cell.fontSize);
-			const cellContentWidth = cell.rect.width - 6;
+			const cellContentWidth = cell.rect.width - (3 + cell.borderInsets.left) - (3 + cell.borderInsets.right);
 			if (textWidth <= cellContentWidth) continue;
 			const overflowNeeded = textWidth - cellContentWidth;
 			let overflowAvailable = 0;
@@ -51267,216 +51684,6 @@ onmessage = async (ev) => {
 		});
 	}
 	//#endregion
-	//#region src/modules/pdf/render/png-decoder.ts
-	/**
-	* Minimal PNG decoder for PDF image embedding.
-	*
-	* Extracts raw RGB pixel data from a PNG file. Handles:
-	* - Color types: RGB (2), RGBA (6), Grayscale (0), Grayscale+Alpha (4), Palette (3)
-	* - Bit depth: 8 (most common)
-	* - Interlacing: non-interlaced only (Adam7 interlacing is not supported)
-	* - All 5 PNG filter types (None, Sub, Up, Average, Paeth)
-	*
-	* For RGBA images, produces separate RGB pixels and an alpha mask (for PDF SMask).
-	*/
-	/**
-	* Maximum allowed pixel count for PNG decoding (default: 100 million pixels).
-	* A 10000x10000 RGBA image at 100M pixels would need ~400MB for raw data alone.
-	* This limit prevents memory exhaustion from malicious PNG files with
-	* excessively large declared dimensions.
-	*/
-	const MAX_PNG_PIXELS = 1e8;
-	/**
-	* Decode a PNG file to raw RGB pixels for PDF embedding.
-	* @throws on invalid or unsupported PNG data
-	*/
-	function decodePng(data) {
-		if (data.length < 8 || data[0] !== 137 || data[1] !== 80 || data[2] !== 78 || data[3] !== 71) throw new Error("Invalid PNG signature");
-		let offset = 8;
-		let width = 0;
-		let height = 0;
-		let bitDepth = 0;
-		let colorType = 0;
-		const idatChunks = [];
-		let palette = null;
-		let trns = null;
-		while (offset + 8 <= data.length) {
-			const chunkLen = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(offset, false);
-			const chunkType = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
-			const chunkData = data.subarray(offset + 8, offset + 8 + chunkLen);
-			offset += 8 + chunkLen + 4;
-			switch (chunkType) {
-				case "IHDR": {
-					const hdr = new DataView(chunkData.buffer, chunkData.byteOffset, chunkData.byteLength);
-					width = hdr.getUint32(0, false);
-					height = hdr.getUint32(4, false);
-					bitDepth = chunkData[8];
-					colorType = chunkData[9];
-					if (chunkData[12] !== 0) throw new Error("Interlaced PNG is not supported");
-					if (bitDepth !== 8) throw new Error(`Unsupported PNG bit depth: ${bitDepth}. Only 8-bit PNGs are supported.`);
-					if (width === 0 || height === 0) throw new Error(`Invalid PNG dimensions: ${width}x${height}`);
-					const totalPixels = width * height;
-					if (totalPixels > MAX_PNG_PIXELS) throw new Error(`PNG dimensions too large: ${width}x${height} (${totalPixels} pixels). Maximum allowed: ${MAX_PNG_PIXELS} pixels.`);
-					break;
-				}
-				case "PLTE":
-					palette = new Uint8Array(chunkData);
-					break;
-				case "tRNS":
-					trns = new Uint8Array(chunkData);
-					break;
-				case "IDAT":
-					idatChunks.push(chunkData);
-					break;
-				case "IEND": break;
-			}
-		}
-		if (width === 0 || height === 0) throw new Error("PNG missing IHDR chunk");
-		const compressedData = concatUint8Arrays(idatChunks);
-		let rawCompressed;
-		if (compressedData.length > 6 && (compressedData[0] & 15) === 8) rawCompressed = compressedData.subarray(2, compressedData.length - 4);
-		else rawCompressed = compressedData;
-		const rawData = decompressSync(rawCompressed);
-		const channels = getChannelCount(colorType);
-		const bytesPerPixel = Math.max(1, channels * bitDepth / 8);
-		const scanlineLen = Math.ceil(width * channels * bitDepth / 8);
-		return toRgb(applyFilters(rawData, width, height, scanlineLen, bytesPerPixel), width, height, colorType, bitDepth, palette, trns);
-	}
-	function applyFilters(data, _width, height, scanlineLen, bytesPerPixel) {
-		const result = new Uint8Array(height * scanlineLen);
-		const bpp = Math.max(1, Math.floor(bytesPerPixel));
-		let srcOffset = 0;
-		for (let y = 0; y < height; y++) {
-			const filterType = data[srcOffset++];
-			const dstOffset = y * scanlineLen;
-			const prevRow = y > 0 ? (y - 1) * scanlineLen : -1;
-			for (let x = 0; x < scanlineLen; x++) {
-				const raw = data[srcOffset++] ?? 0;
-				const a = x >= bpp ? result[dstOffset + x - bpp] : 0;
-				const b = prevRow >= 0 ? result[prevRow + x] : 0;
-				const c = prevRow >= 0 && x >= bpp ? result[prevRow + x - bpp] : 0;
-				switch (filterType) {
-					case 0:
-						result[dstOffset + x] = raw;
-						break;
-					case 1:
-						result[dstOffset + x] = raw + a & 255;
-						break;
-					case 2:
-						result[dstOffset + x] = raw + b & 255;
-						break;
-					case 3:
-						result[dstOffset + x] = raw + Math.floor((a + b) / 2) & 255;
-						break;
-					case 4:
-						result[dstOffset + x] = raw + paethPredictor(a, b, c) & 255;
-						break;
-					default: result[dstOffset + x] = raw;
-				}
-			}
-		}
-		return result;
-	}
-	function paethPredictor(a, b, c) {
-		const p = a + b - c;
-		const pa = Math.abs(p - a);
-		const pb = Math.abs(p - b);
-		const pc = Math.abs(p - c);
-		if (pa <= pb && pa <= pc) return a;
-		if (pb <= pc) return b;
-		return c;
-	}
-	function getChannelCount(colorType) {
-		switch (colorType) {
-			case 0: return 1;
-			case 2: return 3;
-			case 3: return 1;
-			case 4: return 2;
-			case 6: return 4;
-			default: return 3;
-		}
-	}
-	function toRgb(data, width, height, colorType, _bitDepth, palette, trns) {
-		const totalPixels = width * height;
-		const pixels = new Uint8Array(totalPixels * 3);
-		let alpha = null;
-		switch (colorType) {
-			case 2:
-				pixels.set(data.subarray(0, totalPixels * 3));
-				if (trns && trns.length >= 6) {
-					const trR = trns[1];
-					const trG = trns[3];
-					const trB = trns[5];
-					alpha = new Uint8Array(totalPixels);
-					alpha.fill(255);
-					for (let i = 0; i < totalPixels; i++) if (data[i * 3] === trR && data[i * 3 + 1] === trG && data[i * 3 + 2] === trB) alpha[i] = 0;
-				}
-				break;
-			case 6:
-				alpha = new Uint8Array(totalPixels);
-				for (let i = 0; i < totalPixels; i++) {
-					pixels[i * 3] = data[i * 4];
-					pixels[i * 3 + 1] = data[i * 4 + 1];
-					pixels[i * 3 + 2] = data[i * 4 + 2];
-					alpha[i] = data[i * 4 + 3];
-				}
-				break;
-			case 0: {
-				let trGray = -1;
-				if (trns && trns.length >= 2) trGray = trns[1];
-				if (trGray >= 0) {
-					alpha = new Uint8Array(totalPixels);
-					alpha.fill(255);
-				}
-				for (let i = 0; i < totalPixels; i++) {
-					const g = data[i];
-					pixels[i * 3] = g;
-					pixels[i * 3 + 1] = g;
-					pixels[i * 3 + 2] = g;
-					if (alpha && g === trGray) alpha[i] = 0;
-				}
-				break;
-			}
-			case 4:
-				alpha = new Uint8Array(totalPixels);
-				for (let i = 0; i < totalPixels; i++) {
-					const g = data[i * 2];
-					pixels[i * 3] = g;
-					pixels[i * 3 + 1] = g;
-					pixels[i * 3 + 2] = g;
-					alpha[i] = data[i * 2 + 1];
-				}
-				break;
-			case 3:
-				if (!palette) throw new Error("PNG palette color type (3) but missing PLTE chunk");
-				if (trns && trns.length > 0) alpha = new Uint8Array(totalPixels);
-				for (let i = 0; i < totalPixels; i++) {
-					const idx = data[i];
-					pixels[i * 3] = palette[idx * 3] ?? 0;
-					pixels[i * 3 + 1] = palette[idx * 3 + 1] ?? 0;
-					pixels[i * 3 + 2] = palette[idx * 3 + 2] ?? 0;
-					if (alpha) alpha[i] = idx < trns.length ? trns[idx] : 255;
-				}
-				break;
-			default: throw new Error(`Unsupported PNG color type: ${colorType}`);
-		}
-		if (alpha) {
-			let fullyOpaque = true;
-			for (let i = 0; i < alpha.length; i++) if (alpha[i] !== 255) {
-				fullyOpaque = false;
-				break;
-			}
-			if (fullyOpaque) alpha = null;
-		}
-		return {
-			width,
-			height,
-			pixels,
-			alpha,
-			bitsPerComponent: 8
-		};
-	}
-	//#endregion
 	//#region src/modules/pdf/render/pdf-exporter.ts
 	/**
 	* PDF Exporter - Main orchestrator for PDF document generation.
@@ -51822,39 +52029,6 @@ onmessage = async (ev) => {
 		}
 		return true;
 	}
-	/**
-	* Write a JPEG or PNG image as a PDF XObject Image.
-	*/
-	function writeImageXObject(writer, data, format) {
-		if (format === "png") return writePngImageXObject(writer, data);
-		return writeJpegImageXObject(writer, data);
-	}
-	/**
-	* Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
-	*/
-	function writeJpegImageXObject(writer, data) {
-		const objNum = writer.allocObject();
-		const dims = parseImageDimensions(data, "jpeg");
-		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(dims.width)).set("Height", pdfNumber(dims.height)).set("ColorSpace", "/DeviceRGB").set("BitsPerComponent", "8").set("Filter", "/DCTDecode");
-		writer.addStreamObject(objNum, dict, data);
-		return objNum;
-	}
-	/**
-	* Write a PNG image: decode to raw RGB, create SMask for alpha if needed.
-	*/
-	function writePngImageXObject(writer, data) {
-		const png = decodePng(data);
-		const objNum = writer.allocObject();
-		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", "/DeviceRGB").set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
-		if (png.alpha) {
-			const smaskObjNum = writer.allocObject();
-			const smaskDict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", "/DeviceGray").set("BitsPerComponent", "8");
-			writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
-			dict.set("SMask", pdfRef(smaskObjNum));
-		}
-		writer.addStreamObject(objNum, dict, png.pixels);
-		return objNum;
-	}
 	//#endregion
 	//#region src/modules/pdf/pdf.ts
 	/**