@cj-tech-master/excelts 8.0.0 → 8.1.0

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v8.0.0
+* @cj-tech-master/excelts v8.1.0
 * Zero-dependency TypeScript toolkit — Excel (XLSX), PDF, CSV, Markdown, XML, ZIP/TAR, and streaming.
 * (c) 2026 cjnoname
 * Released under the MIT License
@@ -27555,7 +27555,7 @@ self.onmessage = async function(event) {
 	/**
 	* Generate random bytes.
 	*/
-	function randomBytes(length) {
+	function randomBytes$1(length) {
 		return getRandomValues(new Uint8Array(length));
 	}
 	/**
@@ -27709,7 +27709,7 @@ self.onmessage = async function(event) {
 	*/
 	async function aesEncrypt(data, password, keyStrength) {
 		const saltLen = AES_SALT_LENGTH[keyStrength];
-		const salt = randomBytes(saltLen);
+		const salt = randomBytes$1(saltLen);
 		const keys = await aesDerive(password, salt, keyStrength);
 		const ciphertext = await aesCtr(keys.encryptionKey, data, true);
 		const hmac = await aesComputeHmac(keys.hmacKey, ciphertext);
@@ -28531,6 +28531,12 @@ self.onmessage = async function(event) {
 	* - In browser builds the bundler aliases those imports to their browser variants.
 	*/
 	const SMART_STORE_DECIDE_BYTES = 16 * 1024;
+	/** Input batching threshold for push().  Small chunks are accumulated in an
+	*  internal buffer and flushed to the compression pipeline once this size is
+	*  reached.  64 KB matches the standard deflate window and keeps the number
+	*  of async push() calls — each of which creates a full Promise chain in the
+	*  browser CompressionStream path — down to a manageable level. */
+	const INPUT_BATCH_BYTES = 65536;
 	/**
 	* True Streaming ZIP File - compresses chunk by chunk
 	*/
@@ -28566,6 +28572,8 @@ self.onmessage = async function(event) {
 			this._dataQueue = [];
 			this._finalQueued = false;
 			this._pushChain = Promise.resolve();
+			this._inputBuf = null;
+			this._inputPos = 0;
 			this._syncDeflater = null;
 			this._syncZlibReady = false;
 			const resolvedName = options?.path ? normalizeZipPath(name, options.path) : name;
@@ -28641,7 +28649,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);
+			const header = zipCryptoCreateHeader(this._zipCryptoState, dosTimeForCheck, randomBytes$1);
 			this._compressedSize += header.length;
 			this._enqueueData(header, false);
 		}
@@ -28992,6 +29000,34 @@ self.onmessage = async function(event) {
 				}
 				return Promise.resolve();
 			}
+			if (!final && data.length > 0 && data.length < INPUT_BATCH_BYTES) {
+				if (!this._inputBuf) {
+					this._inputBuf = new Uint8Array(INPUT_BATCH_BYTES);
+					this._inputPos = 0;
+				}
+				if (this._inputPos + data.length <= INPUT_BATCH_BYTES) {
+					this._inputBuf.set(data, this._inputPos);
+					this._inputPos += data.length;
+					callback?.();
+					return Promise.resolve();
+				}
+				const combined = new Uint8Array(this._inputPos + data.length);
+				combined.set(this._inputBuf.subarray(0, this._inputPos));
+				combined.set(data, this._inputPos);
+				this._inputPos = 0;
+				return this._pushAsync(combined, false, callback);
+			}
+			if (this._inputPos > 0) {
+				const flushData = this._inputBuf.slice(0, this._inputPos);
+				this._inputPos = 0;
+				const promise = this._pushChain = this._pushAsync(flushData, false).then(() => this._pushUnchained(data, final, callback), () => this._pushUnchained(data, final, callback));
+				promise.catch(() => {});
+				return promise;
+			}
+			return this._pushAsync(data, final, callback);
+		}
+		/** Enqueue an async push through the _pushChain serialization. */
+		_pushAsync(data, final, callback) {
 			const promise = this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback), () => this._pushUnchained(data, final, callback));
 			promise.catch(() => {});
 			return promise;
@@ -44669,228 +44705,597 @@ onmessage = async (ev) => {
 		return err instanceof PdfError;
 	}
 	//#endregion
-	//#region src/modules/pdf/core/encryption.ts
-	/** PDF password padding string (32 bytes) per PDF spec §3.5.2 */
-	const PASSWORD_PADDING = new Uint8Array([
-		40,
-		191,
-		78,
-		94,
-		78,
+	//#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,
-		138,
-		65,
-		100,
+		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,
-		255,
-		250,
-		1,
+		244,
+		234,
+		101,
+		122,
+		174,
 		8,
+		186,
+		120,
+		37,
 		46,
-		46,
-		0,
-		182,
-		208,
-		104,
+		28,
+		166,
+		180,
+		198,
+		232,
+		221,
+		116,
+		31,
+		75,
+		189,
+		139,
+		138,
+		112,
 		62,
-		128,
-		47,
-		12,
-		169,
-		254,
-		100,
-		83,
+		181,
+		102,
+		72,
+		3,
+		246,
+		14,
+		97,
+		53,
+		87,
+		185,
+		134,
+		193,
+		29,
+		158,
+		225,
+		248,
+		152,
+		17,
 		105,
-		122
+		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;
+	}
 	/**
-	* Initialize encryption state from the given options.
-	*/
-	function initEncryption(options) {
-		const userPwd = options.userPassword ?? "";
-		const ownerPwd = options.ownerPassword;
-		const perms = computePermissions(options.permissions);
-		const fileId = generateFileId();
-		const oValue = computeOValue(ownerPwd, userPwd);
-		const encryptionKey = computeEncryptionKey(userPwd, oValue, perms, fileId);
-		return {
-			encryptionKey,
-			oValue,
-			uValue: computeUValue(encryptionKey, fileId),
-			permissions: perms,
-			fileId
-		};
+	* 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;
 	}
 	/**
-	* Encrypt a string or stream for a specific PDF object.
-	* Per-object encryption key = MD5(encryptionKey + objectNumber + generation).
+	* 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 encryptData(data, objectNumber, generation, encryptionKey) {
-		const keyInput = new Uint8Array(encryptionKey.length + 5);
-		keyInput.set(encryptionKey);
-		keyInput[encryptionKey.length] = objectNumber & 255;
-		keyInput[encryptionKey.length + 1] = objectNumber >> 8 & 255;
-		keyInput[encryptionKey.length + 2] = objectNumber >> 16 & 255;
-		keyInput[encryptionKey.length + 3] = generation & 255;
-		keyInput[encryptionKey.length + 4] = generation >> 8 & 255;
-		const objKey = md5(keyInput);
-		const keyLen = Math.min(encryptionKey.length + 5, 16);
-		return rc4(objKey.subarray(0, keyLen), data);
+	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;
 	}
 	/**
-	* RC4 stream cipher implementation.
+	* AES-ECB encryption of a single 16-byte block (no padding, no IV).
+	* Used for the /Perms value in V=5 encryption.
 	*/
-	function rc4(key, data) {
-		const s = new Uint8Array(256);
-		for (let i = 0; i < 256; i++) s[i] = i;
-		let j = 0;
-		for (let i = 0; i < 256; i++) {
-			j = j + s[i] + key[i % key.length] & 255;
-			[s[i], s[j]] = [s[j], s[i]];
-		}
-		const result = new Uint8Array(data.length);
-		let ii = 0;
-		let jj = 0;
-		for (let k = 0; k < data.length; k++) {
-			ii = ii + 1 & 255;
-			jj = jj + s[ii] & 255;
-			[s[ii], s[jj]] = [s[jj], s[ii]];
-			result[k] = data[k] ^ s[s[ii] + s[jj] & 255];
-		}
-		return result;
+	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;
 	}
 	/**
-	* MD5 hash implementation (RFC 1321).
-	* Returns 16-byte digest.
+	* SHA-256 hash function.
+	* @returns 32-byte digest
 	*/
-	function md5(input) {
+	function sha256(input) {
 		const msgLen = input.length;
-		const bitLen = msgLen * 8;
-		const padLen = (56 - (msgLen + 1) % 64 + 64) % 64 + 1;
-		const padded = new Uint8Array(msgLen + padLen + 8);
+		const paddedLen = Math.ceil((msgLen + 9) / 64) * 64;
+		const padded = new Uint8Array(paddedLen);
 		padded.set(input);
 		padded[msgLen] = 128;
-		const view = new DataView(padded.buffer);
-		view.setUint32(padded.length - 8, bitLen >>> 0, true);
-		view.setUint32(padded.length - 4, 0, true);
-		let a0 = 1732584193;
-		let b0 = 4023233417;
-		let c0 = 2562383102;
-		let d0 = 271733878;
-		for (let i = 0; i < padded.length; i += 64) {
-			const M = new Uint32Array(16);
-			for (let j = 0; j < 16; j++) M[j] = view.getUint32(i + j * 4, true);
-			let A = a0;
-			let B = b0;
-			let C = c0;
-			let D = d0;
-			for (let j = 0; j < 64; j++) {
-				let F;
-				let g;
-				if (j < 16) {
-					F = B & C | ~B & D;
-					g = j;
-				} else if (j < 32) {
-					F = D & B | ~D & C;
-					g = (5 * j + 1) % 16;
-				} else if (j < 48) {
-					F = B ^ C ^ D;
-					g = (3 * j + 5) % 16;
-				} else {
-					F = C ^ (B | ~D);
-					g = 7 * j % 16;
-				}
-				F = F + A + K[j] + M[g] >>> 0;
-				A = D;
-				D = C;
-				C = B;
-				B = B + rotl(F, S[j]) >>> 0;
-			}
-			a0 = a0 + A >>> 0;
-			b0 = b0 + B >>> 0;
-			c0 = c0 + C >>> 0;
-			d0 = d0 + D >>> 0;
-		}
-		const digest = new Uint8Array(16);
-		const dv = new DataView(digest.buffer);
-		dv.setUint32(0, a0, true);
-		dv.setUint32(4, b0, true);
-		dv.setUint32(8, c0, true);
-		dv.setUint32(12, d0, true);
-		return digest;
-	}
-	function rotl(x, n) {
-		return (x << n | x >>> 32 - n) >>> 0;
-	}
-	const S = [
-		7,
-		12,
-		17,
-		22,
-		7,
-		12,
-		17,
-		22,
-		7,
-		12,
-		17,
-		22,
-		7,
-		12,
-		17,
-		22,
-		5,
-		9,
-		14,
-		20,
-		5,
-		9,
-		14,
-		20,
-		5,
-		9,
-		14,
-		20,
-		5,
-		9,
-		14,
-		20,
-		4,
-		11,
-		16,
-		23,
-		4,
-		11,
-		16,
-		23,
-		4,
-		11,
-		16,
-		23,
-		4,
-		11,
-		16,
-		23,
-		6,
-		10,
-		15,
-		21,
-		6,
-		10,
-		15,
-		21,
-		6,
-		10,
-		15,
-		21,
-		6,
-		10,
-		15,
-		21
-	];
-	const K = new Uint32Array([
+		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,
@@ -44957,64 +45362,104 @@ onmessage = async (ev) => {
 		3951481745
 	]);
 	/**
-	* Pad or truncate a password to 32 bytes using the PDF password padding.
+	* Generate pseudo-random bytes.
+	* Uses Math.random — adequate for PDF IVs but not cryptographically secure.
 	*/
-	function padPassword(password) {
-		const result = new Uint8Array(32);
-		const bytes = new TextEncoder().encode(password);
-		const len = Math.min(bytes.length, 32);
-		result.set(bytes.subarray(0, len));
-		result.set(PASSWORD_PADDING.subarray(0, 32 - len), len);
-		return result;
+	function randomBytes(length) {
+		const bytes = new Uint8Array(length);
+		for (let i = 0; i < length; i++) bytes[i] = Math.random() * 256 | 0;
+		return bytes;
 	}
 	/**
-	* Compute the O (owner) value.
-	* Algorithm 3 from PDF spec §3.5.2.
+	* Concatenate multiple Uint8Arrays.
 	*/
-	function computeOValue(ownerPassword, userPassword) {
-		let hash = md5(padPassword(ownerPassword));
-		for (let i = 0; i < 50; i++) hash = md5(hash);
-		const rc4Key = hash.subarray(0, 16);
-		let result = rc4(rc4Key, padPassword(userPassword));
-		for (let i = 1; i <= 19; i++) {
-			const modKey = new Uint8Array(16);
-			for (let j = 0; j < 16; j++) modKey[j] = rc4Key[j] ^ i;
-			result = rc4(modKey, result);
+	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
+	*/
 	/**
-	* Compute the encryption key.
-	* Algorithm 2 from PDF spec §3.5.2.
+	* Initialize encryption state for AES-256 (V=5, R=5).
 	*/
-	function computeEncryptionKey(userPassword, oValue, permissions, fileId) {
-		const paddedPwd = padPassword(userPassword);
-		const input = new Uint8Array(68 + fileId.length);
-		input.set(paddedPwd);
-		input.set(oValue, 32);
-		new DataView(input.buffer, input.byteOffset).setInt32(64, permissions, true);
-		input.set(fileId, 68);
-		let hash = md5(input);
-		for (let i = 0; i < 50; i++) hash = md5(hash.subarray(0, 16));
-		return hash.subarray(0, 16);
+	function initEncryption(options) {
+		const userPwd = truncatePassword(options.userPassword ?? "");
+		const ownerPwd = truncatePassword(options.ownerPassword);
+		const perms = computePermissions(options.permissions);
+		const encryptionKey = randomBytes(32);
+		const uValidationSalt = randomBytes(8);
+		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 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 permsBlock = new Uint8Array(16);
+		new DataView(permsBlock.buffer).setInt32(0, perms, true);
+		permsBlock[4] = 255;
+		permsBlock[5] = 255;
+		permsBlock[6] = 255;
+		permsBlock[7] = 255;
+		permsBlock[8] = 84;
+		permsBlock[9] = 97;
+		permsBlock[10] = 100;
+		permsBlock[11] = 98;
+		return {
+			encryptionKey,
+			oValue,
+			uValue,
+			oeValue,
+			ueValue,
+			permsValue: aesEcbEncrypt(permsBlock, encryptionKey),
+			permissions: perms,
+			fileId: randomBytes(16)
+		};
 	}
 	/**
-	* Compute the U (user) value.
-	* Algorithm 5 from PDF spec §3.5.2 (revision 3).
+	* Encrypt data for a PDF object using AES-256-CBC.
+	*
+	* For V=5/R=5, the file encryption key is used directly (no per-object key derivation).
+	* A random 16-byte IV is prepended to the ciphertext.
 	*/
-	function computeUValue(encryptionKey, fileId) {
-		const hashInput = new Uint8Array(32 + fileId.length);
-		hashInput.set(PASSWORD_PADDING);
-		hashInput.set(fileId, 32);
-		let result = rc4(encryptionKey, md5(hashInput));
-		for (let i = 1; i <= 19; i++) {
-			const modKey = new Uint8Array(16);
-			for (let j = 0; j < 16; j++) modKey[j] = encryptionKey[j] ^ i;
-			result = rc4(modKey, result);
-		}
-		const uValue = new Uint8Array(32);
-		uValue.set(result);
-		return uValue;
+	function encryptData(data, _objectNumber, _generation, encryptionKey) {
+		const iv = randomBytes(16);
+		const ciphertext = aesCbcEncrypt(data, encryptionKey, iv);
+		const result = new Uint8Array(16 + ciphertext.length);
+		result.set(iv);
+		result.set(ciphertext, 16);
+		return result;
+	}
+	/**
+	* Truncate password to 127 bytes (UTF-8) per PDF 2.0 spec.
+	*/
+	function truncatePassword(password) {
+		const bytes = new TextEncoder().encode(password);
+		return bytes.length > 127 ? bytes.subarray(0, 127) : bytes;
 	}
 	/**
 	* Compute the permissions integer (P value) from permission flags.
@@ -45031,33 +45476,24 @@ onmessage = async (ev) => {
 		if (perms?.printHighQuality) p |= 2048;
 		return p | 0;
 	}
-	/**
-	* Generate a random file identifier (16 bytes).
-	*/
-	function generateFileId() {
-		const seed = new Uint8Array(16);
-		const now = Date.now();
-		const view = new DataView(seed.buffer);
-		view.setFloat64(0, now, true);
-		view.setFloat64(8, Math.random() * 0x38d7ea4c68000, true);
-		return md5(seed);
-	}
 	//#endregion
 	//#region src/modules/pdf/core/pdf-writer.ts
 	/**
 	* PDF file writer.
 	*
-	* Assembles a complete PDF document from indirect objects.
+	* Assembles a complete PDF 2.0 document from indirect objects.
 	* Handles the four sections of a PDF file:
-	* 1. Header (%PDF-1.4)
+	* 1. Header (%PDF-2.0)
 	* 2. Body (indirect objects)
 	* 3. Cross-reference table
 	* 4. Trailer (with document catalog reference)
 	*
-	* @see PDF Reference 1.7, Chapter 3.4 - File Structure
+	* Encryption uses AES-256 (V=5, R=5) per ISO 32000-2:2020.
+	*
+	* @see ISO 32000-2:2020, Chapter 7.5 — File Structure
 	*/
 	/**
-	* Constructs a valid PDF 1.4 file from a set of indirect objects.
+	* Constructs a valid PDF 2.0 file from a set of indirect objects.
 	*
 	* Usage:
 	* 1. Allocate object numbers with allocObject()
@@ -45170,7 +45606,7 @@ onmessage = async (ev) => {
 			const encoder = new TextEncoder();
 			const chunks = [];
 			let byteOffset = 0;
-			const headerStrBytes = encoder.encode("%PDF-1.4\n");
+			const headerStrBytes = encoder.encode("%PDF-2.0\n");
 			chunks.push(headerStrBytes);
 			byteOffset += headerStrBytes.length;
 			const binaryComment = new Uint8Array([
@@ -45219,7 +45655,7 @@ onmessage = async (ev) => {
 				byteOffset += objFooter.length;
 			}
 			if (this.encryption) {
-				const encContent = new PdfDict().set("Filter", "/Standard").set("V", "2").set("R", "3").set("Length", "128").set("P", String(this.encryption.permissions)).set("O", pdfHexString(this.encryption.oValue)).set("U", pdfHexString(this.encryption.uValue)).toString();
+				const encContent = new PdfDict().set("Filter", "/Standard").set("V", "5").set("R", "5").set("Length", "256").set("P", String(this.encryption.permissions)).set("O", pdfHexString(this.encryption.oValue)).set("U", pdfHexString(this.encryption.uValue)).set("OE", pdfHexString(this.encryption.oeValue)).set("UE", pdfHexString(this.encryption.ueValue)).set("Perms", pdfHexString(this.encryption.permsValue)).set("EncryptMetadata", "true").set("CF", "<< /StdCF << /Type /CryptFilter /CFM /AESV3 /AuthEvent /DocOpen /Length 32 >> >>").set("StmF", "/StdCF").set("StrF", "/StdCF").toString();
 				const encObj = {
 					objectNumber: encryptObjNum,
 					offset: byteOffset,