pdf-parser.js 4.8.5 → 4.8.7

package/dist/crypto/aes.cjs

@@ -52,112 +52,175 @@ function expandKey(key) {
 	const nk = key.length / 4;
 	const rounds = nk + 6;
 	const words = new Uint32Array(WORDS_PER_BLOCK * (rounds + 1));
-	for (let i = 0; i < nk; i++) words[i] = (key[4 * i] << 24 | key[4 * i + 1] << 16 | key[4 * i + 2] << 8 | key[4 * i + 3]) >>> 0;
+	words.set(Array.from({ length: nk }, (_unused, i) => readWord(key, 4 * i)));
 	let rcon = 1;
-	for (let i = nk; i < words.length; i++) {
+	words.forEach((_word, i) => {
+		if (i < nk) return;
 		let temp = words[i - 1];
 		if (i % nk === 0) {
 			temp = (subWord(rotWord(temp)) ^ rcon << 24) >>> 0;
 			rcon = xtime(rcon);
 		} else if (nk > 6 && i % nk === 4) temp = subWord(temp);
 		words[i] = (words[i - nk] ^ temp) >>> 0;
-	}
+	});
 	return {
 		words,
 		rounds
 	};
 }
-function addRoundKey(state, words, round) {
-	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
-		const word = words[round * WORDS_PER_BLOCK + c];
-		for (let r = 0; r < WORDS_PER_BLOCK; r++) state[4 * c + r] = state[4 * c + r] ^ word >>> 24 - r * 8 & 255;
-	}
+function packWord(row0, row1, row2, row3) {
+	return (row0 << 24 | row1 << 16 | row2 << 8 | row3) >>> 0;
+}
+function rotateRight8(word) {
+	return (word >>> 8 | word << 24) >>> 0;
 }
-function substituteBytes(state, table) {
-	for (let i = 0; i < 16; i++) state[i] = table[state[i]];
-}
-function shiftRows(state, direction) {
-	const source = Uint8Array.from(state);
-	for (let r = 1; r < WORDS_PER_BLOCK; r++) for (let c = 0; c < WORDS_PER_BLOCK; c++) state[r + 4 * c] = source[r + 4 * (((c + direction * r) % WORDS_PER_BLOCK + WORDS_PER_BLOCK) % WORDS_PER_BLOCK)];
-}
-function mixColumns(state, coefficients) {
-	const [k0, k1, k2, k3] = coefficients;
-	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
-		const a0 = state[4 * c];
-		const a1 = state[4 * c + 1];
-		const a2 = state[4 * c + 2];
-		const a3 = state[4 * c + 3];
-		state[4 * c] = gmul(a0, k0) ^ gmul(a1, k1) ^ gmul(a2, k2) ^ gmul(a3, k3);
-		state[4 * c + 1] = gmul(a0, k3) ^ gmul(a1, k0) ^ gmul(a2, k1) ^ gmul(a3, k2);
-		state[4 * c + 2] = gmul(a0, k2) ^ gmul(a1, k3) ^ gmul(a2, k0) ^ gmul(a3, k1);
-		state[4 * c + 3] = gmul(a0, k1) ^ gmul(a1, k2) ^ gmul(a2, k3) ^ gmul(a3, k0);
+const { TE0, TE1, TE2, TE3, TD0, TD1, TD2, TD3 } = (() => {
+	const te0 = /* @__PURE__ */ new Uint32Array(256);
+	const te1 = /* @__PURE__ */ new Uint32Array(256);
+	const te2 = /* @__PURE__ */ new Uint32Array(256);
+	const te3 = /* @__PURE__ */ new Uint32Array(256);
+	const td0 = /* @__PURE__ */ new Uint32Array(256);
+	const td1 = /* @__PURE__ */ new Uint32Array(256);
+	const td2 = /* @__PURE__ */ new Uint32Array(256);
+	const td3 = /* @__PURE__ */ new Uint32Array(256);
+	for (let x = 0; x < 256; x++) {
+		const s = SBOX[x];
+		te0[x] = packWord(gmul(s, 2), s, s, gmul(s, 3));
+		te1[x] = rotateRight8(te0[x]);
+		te2[x] = rotateRight8(te1[x]);
+		te3[x] = rotateRight8(te2[x]);
+		const i = INV_SBOX[x];
+		td0[x] = packWord(gmul(i, 14), gmul(i, 9), gmul(i, 13), gmul(i, 11));
+		td1[x] = rotateRight8(td0[x]);
+		td2[x] = rotateRight8(td1[x]);
+		td3[x] = rotateRight8(td2[x]);
 	}
+	return {
+		TE0: te0,
+		TE1: te1,
+		TE2: te2,
+		TE3: te3,
+		TD0: td0,
+		TD1: td1,
+		TD2: td2,
+		TD3: td3
+	};
+})();
+function inverseKeyWords(expanded) {
+	const { words, rounds } = expanded;
+	return Uint32Array.from(words, (_word, index) => {
+		const round = Math.floor(index / WORDS_PER_BLOCK);
+		const column = index % WORDS_PER_BLOCK;
+		const word = words[(rounds - round) * WORDS_PER_BLOCK + column];
+		return round === 0 || round === rounds ? word : TD0[SBOX[word >>> 24]] ^ TD1[SBOX[word >>> 16 & 255]] ^ TD2[SBOX[word >>> 8 & 255]] ^ TD3[SBOX[word & 255]];
+	});
 }
-const FORWARD_MIX = [
-	2,
-	3,
-	1,
-	1
-];
-const INVERSE_MIX = [
-	14,
-	11,
-	13,
-	9
-];
-function encryptBlock(state, key) {
-	addRoundKey(state, key.words, 0);
+function readWord(bytes, offset) {
+	return packWord(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function writeWord(bytes, offset, word) {
+	bytes[offset] = word >>> 24;
+	bytes[offset + 1] = word >>> 16 & 255;
+	bytes[offset + 2] = word >>> 8 & 255;
+	bytes[offset + 3] = word & 255;
+}
+function encryptWords(key, a0, a1, a2, a3, out) {
+	const rk = key.words;
+	let s0 = a0 ^ rk[0];
+	let s1 = a1 ^ rk[1];
+	let s2 = a2 ^ rk[2];
+	let s3 = a3 ^ rk[3];
 	for (let round = 1; round < key.rounds; round++) {
-		substituteBytes(state, SBOX);
-		shiftRows(state, 1);
-		mixColumns(state, FORWARD_MIX);
-		addRoundKey(state, key.words, round);
+		const at = round * WORDS_PER_BLOCK;
+		const t0 = TE0[s0 >>> 24] ^ TE1[s1 >>> 16 & 255] ^ TE2[s2 >>> 8 & 255] ^ TE3[s3 & 255] ^ rk[at];
+		const t1 = TE0[s1 >>> 24] ^ TE1[s2 >>> 16 & 255] ^ TE2[s3 >>> 8 & 255] ^ TE3[s0 & 255] ^ rk[at + 1];
+		const t2 = TE0[s2 >>> 24] ^ TE1[s3 >>> 16 & 255] ^ TE2[s0 >>> 8 & 255] ^ TE3[s1 & 255] ^ rk[at + 2];
+		const t3 = TE0[s3 >>> 24] ^ TE1[s0 >>> 16 & 255] ^ TE2[s1 >>> 8 & 255] ^ TE3[s2 & 255] ^ rk[at + 3];
+		s0 = t0;
+		s1 = t1;
+		s2 = t2;
+		s3 = t3;
 	}
-	substituteBytes(state, SBOX);
-	shiftRows(state, 1);
-	addRoundKey(state, key.words, key.rounds);
-}
-function decryptBlock(state, key) {
-	addRoundKey(state, key.words, key.rounds);
-	for (let round = key.rounds - 1; round >= 1; round--) {
-		shiftRows(state, -1);
-		substituteBytes(state, INV_SBOX);
-		addRoundKey(state, key.words, round);
-		mixColumns(state, INVERSE_MIX);
+	const at = key.rounds * WORDS_PER_BLOCK;
+	out[0] = packWord(SBOX[s0 >>> 24], SBOX[s1 >>> 16 & 255], SBOX[s2 >>> 8 & 255], SBOX[s3 & 255]) ^ rk[at];
+	out[1] = packWord(SBOX[s1 >>> 24], SBOX[s2 >>> 16 & 255], SBOX[s3 >>> 8 & 255], SBOX[s0 & 255]) ^ rk[at + 1];
+	out[2] = packWord(SBOX[s2 >>> 24], SBOX[s3 >>> 16 & 255], SBOX[s0 >>> 8 & 255], SBOX[s1 & 255]) ^ rk[at + 2];
+	out[3] = packWord(SBOX[s3 >>> 24], SBOX[s0 >>> 16 & 255], SBOX[s1 >>> 8 & 255], SBOX[s2 & 255]) ^ rk[at + 3];
+}
+function decryptWords(rk, rounds, a0, a1, a2, a3, out) {
+	let s0 = a0 ^ rk[0];
+	let s1 = a1 ^ rk[1];
+	let s2 = a2 ^ rk[2];
+	let s3 = a3 ^ rk[3];
+	for (let round = 1; round < rounds; round++) {
+		const at = round * WORDS_PER_BLOCK;
+		const t0 = TD0[s0 >>> 24] ^ TD1[s3 >>> 16 & 255] ^ TD2[s2 >>> 8 & 255] ^ TD3[s1 & 255] ^ rk[at];
+		const t1 = TD0[s1 >>> 24] ^ TD1[s0 >>> 16 & 255] ^ TD2[s3 >>> 8 & 255] ^ TD3[s2 & 255] ^ rk[at + 1];
+		const t2 = TD0[s2 >>> 24] ^ TD1[s1 >>> 16 & 255] ^ TD2[s0 >>> 8 & 255] ^ TD3[s3 & 255] ^ rk[at + 2];
+		const t3 = TD0[s3 >>> 24] ^ TD1[s2 >>> 16 & 255] ^ TD2[s1 >>> 8 & 255] ^ TD3[s0 & 255] ^ rk[at + 3];
+		s0 = t0;
+		s1 = t1;
+		s2 = t2;
+		s3 = t3;
 	}
-	shiftRows(state, -1);
-	substituteBytes(state, INV_SBOX);
-	addRoundKey(state, key.words, 0);
+	const at = rounds * WORDS_PER_BLOCK;
+	out[0] = packWord(INV_SBOX[s0 >>> 24], INV_SBOX[s3 >>> 16 & 255], INV_SBOX[s2 >>> 8 & 255], INV_SBOX[s1 & 255]) ^ rk[at];
+	out[1] = packWord(INV_SBOX[s1 >>> 24], INV_SBOX[s0 >>> 16 & 255], INV_SBOX[s3 >>> 8 & 255], INV_SBOX[s2 & 255]) ^ rk[at + 1];
+	out[2] = packWord(INV_SBOX[s2 >>> 24], INV_SBOX[s1 >>> 16 & 255], INV_SBOX[s0 >>> 8 & 255], INV_SBOX[s3 & 255]) ^ rk[at + 2];
+	out[3] = packWord(INV_SBOX[s3 >>> 24], INV_SBOX[s2 >>> 16 & 255], INV_SBOX[s1 >>> 8 & 255], INV_SBOX[s0 & 255]) ^ rk[at + 3];
 }
 function wholeBlockCount(byteLength) {
 	return Math.floor(byteLength / 16);
 }
 function aesCbcDecrypt(key, iv, data) {
 	const expanded = expandKey(key);
+	const inverseKey = inverseKeyWords(expanded);
 	const blocks = wholeBlockCount(data.length);
 	const out = new Uint8Array(blocks * 16);
-	const chain = Uint8Array.from(iv.subarray(0, 16));
-	for (let b = 0; b < blocks; b++) {
-		const cipherBlock = data.subarray(b * 16, (b + 1) * 16);
-		const state = Uint8Array.from(cipherBlock);
-		decryptBlock(state, expanded);
-		for (let i = 0; i < 16; i++) out[b * 16 + i] = state[i] ^ chain[i];
-		chain.set(cipherBlock);
-	}
+	const plain = new Uint32Array(WORDS_PER_BLOCK);
+	let c0 = readWord(iv, 0);
+	let c1 = readWord(iv, 4);
+	let c2 = readWord(iv, 8);
+	let c3 = readWord(iv, 12);
+	Array.from({ length: blocks }).forEach((_unused, b) => {
+		const at = b * 16;
+		const x0 = readWord(data, at);
+		const x1 = readWord(data, at + 4);
+		const x2 = readWord(data, at + 8);
+		const x3 = readWord(data, at + 12);
+		decryptWords(inverseKey, expanded.rounds, x0, x1, x2, x3, plain);
+		writeWord(out, at, plain[0] ^ c0);
+		writeWord(out, at + 4, plain[1] ^ c1);
+		writeWord(out, at + 8, plain[2] ^ c2);
+		writeWord(out, at + 12, plain[3] ^ c3);
+		c0 = x0;
+		c1 = x1;
+		c2 = x2;
+		c3 = x3;
+	});
 	return out;
 }
 function aesCbcEncrypt(key, iv, data) {
 	const expanded = expandKey(key);
 	const blocks = wholeBlockCount(data.length);
 	const out = new Uint8Array(blocks * 16);
-	const chain = Uint8Array.from(iv.subarray(0, 16));
-	for (let b = 0; b < blocks; b++) {
-		const state = /* @__PURE__ */ new Uint8Array(16);
-		for (let i = 0; i < 16; i++) state[i] = data[b * 16 + i] ^ chain[i];
-		encryptBlock(state, expanded);
-		out.set(state, b * 16);
-		chain.set(state);
-	}
+	const cipher = new Uint32Array(WORDS_PER_BLOCK);
+	let c0 = readWord(iv, 0);
+	let c1 = readWord(iv, 4);
+	let c2 = readWord(iv, 8);
+	let c3 = readWord(iv, 12);
+	Array.from({ length: blocks }).forEach((_unused, b) => {
+		const at = b * 16;
+		encryptWords(expanded, readWord(data, at) ^ c0, readWord(data, at + 4) ^ c1, readWord(data, at + 8) ^ c2, readWord(data, at + 12) ^ c3, cipher);
+		c0 = cipher[0];
+		c1 = cipher[1];
+		c2 = cipher[2];
+		c3 = cipher[3];
+		writeWord(out, at, c0);
+		writeWord(out, at + 4, c1);
+		writeWord(out, at + 8, c2);
+		writeWord(out, at + 12, c3);
+	});
 	return out;
 }
 //#endregion

package/dist/crypto/aes.js

@@ -51,112 +51,175 @@ function expandKey(key) {
 	const nk = key.length / 4;
 	const rounds = nk + 6;
 	const words = new Uint32Array(WORDS_PER_BLOCK * (rounds + 1));
-	for (let i = 0; i < nk; i++) words[i] = (key[4 * i] << 24 | key[4 * i + 1] << 16 | key[4 * i + 2] << 8 | key[4 * i + 3]) >>> 0;
+	words.set(Array.from({ length: nk }, (_unused, i) => readWord(key, 4 * i)));
 	let rcon = 1;
-	for (let i = nk; i < words.length; i++) {
+	words.forEach((_word, i) => {
+		if (i < nk) return;
 		let temp = words[i - 1];
 		if (i % nk === 0) {
 			temp = (subWord(rotWord(temp)) ^ rcon << 24) >>> 0;
 			rcon = xtime(rcon);
 		} else if (nk > 6 && i % nk === 4) temp = subWord(temp);
 		words[i] = (words[i - nk] ^ temp) >>> 0;
-	}
+	});
 	return {
 		words,
 		rounds
 	};
 }
-function addRoundKey(state, words, round) {
-	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
-		const word = words[round * WORDS_PER_BLOCK + c];
-		for (let r = 0; r < WORDS_PER_BLOCK; r++) state[4 * c + r] = state[4 * c + r] ^ word >>> 24 - r * 8 & 255;
-	}
+function packWord(row0, row1, row2, row3) {
+	return (row0 << 24 | row1 << 16 | row2 << 8 | row3) >>> 0;
+}
+function rotateRight8(word) {
+	return (word >>> 8 | word << 24) >>> 0;
 }
-function substituteBytes(state, table) {
-	for (let i = 0; i < 16; i++) state[i] = table[state[i]];
-}
-function shiftRows(state, direction) {
-	const source = Uint8Array.from(state);
-	for (let r = 1; r < WORDS_PER_BLOCK; r++) for (let c = 0; c < WORDS_PER_BLOCK; c++) state[r + 4 * c] = source[r + 4 * (((c + direction * r) % WORDS_PER_BLOCK + WORDS_PER_BLOCK) % WORDS_PER_BLOCK)];
-}
-function mixColumns(state, coefficients) {
-	const [k0, k1, k2, k3] = coefficients;
-	for (let c = 0; c < WORDS_PER_BLOCK; c++) {
-		const a0 = state[4 * c];
-		const a1 = state[4 * c + 1];
-		const a2 = state[4 * c + 2];
-		const a3 = state[4 * c + 3];
-		state[4 * c] = gmul(a0, k0) ^ gmul(a1, k1) ^ gmul(a2, k2) ^ gmul(a3, k3);
-		state[4 * c + 1] = gmul(a0, k3) ^ gmul(a1, k0) ^ gmul(a2, k1) ^ gmul(a3, k2);
-		state[4 * c + 2] = gmul(a0, k2) ^ gmul(a1, k3) ^ gmul(a2, k0) ^ gmul(a3, k1);
-		state[4 * c + 3] = gmul(a0, k1) ^ gmul(a1, k2) ^ gmul(a2, k3) ^ gmul(a3, k0);
+const { TE0, TE1, TE2, TE3, TD0, TD1, TD2, TD3 } = (() => {
+	const te0 = /* @__PURE__ */ new Uint32Array(256);
+	const te1 = /* @__PURE__ */ new Uint32Array(256);
+	const te2 = /* @__PURE__ */ new Uint32Array(256);
+	const te3 = /* @__PURE__ */ new Uint32Array(256);
+	const td0 = /* @__PURE__ */ new Uint32Array(256);
+	const td1 = /* @__PURE__ */ new Uint32Array(256);
+	const td2 = /* @__PURE__ */ new Uint32Array(256);
+	const td3 = /* @__PURE__ */ new Uint32Array(256);
+	for (let x = 0; x < 256; x++) {
+		const s = SBOX[x];
+		te0[x] = packWord(gmul(s, 2), s, s, gmul(s, 3));
+		te1[x] = rotateRight8(te0[x]);
+		te2[x] = rotateRight8(te1[x]);
+		te3[x] = rotateRight8(te2[x]);
+		const i = INV_SBOX[x];
+		td0[x] = packWord(gmul(i, 14), gmul(i, 9), gmul(i, 13), gmul(i, 11));
+		td1[x] = rotateRight8(td0[x]);
+		td2[x] = rotateRight8(td1[x]);
+		td3[x] = rotateRight8(td2[x]);
 	}
+	return {
+		TE0: te0,
+		TE1: te1,
+		TE2: te2,
+		TE3: te3,
+		TD0: td0,
+		TD1: td1,
+		TD2: td2,
+		TD3: td3
+	};
+})();
+function inverseKeyWords(expanded) {
+	const { words, rounds } = expanded;
+	return Uint32Array.from(words, (_word, index) => {
+		const round = Math.floor(index / WORDS_PER_BLOCK);
+		const column = index % WORDS_PER_BLOCK;
+		const word = words[(rounds - round) * WORDS_PER_BLOCK + column];
+		return round === 0 || round === rounds ? word : TD0[SBOX[word >>> 24]] ^ TD1[SBOX[word >>> 16 & 255]] ^ TD2[SBOX[word >>> 8 & 255]] ^ TD3[SBOX[word & 255]];
+	});
 }
-const FORWARD_MIX = [
-	2,
-	3,
-	1,
-	1
-];
-const INVERSE_MIX = [
-	14,
-	11,
-	13,
-	9
-];
-function encryptBlock(state, key) {
-	addRoundKey(state, key.words, 0);
+function readWord(bytes, offset) {
+	return packWord(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function writeWord(bytes, offset, word) {
+	bytes[offset] = word >>> 24;
+	bytes[offset + 1] = word >>> 16 & 255;
+	bytes[offset + 2] = word >>> 8 & 255;
+	bytes[offset + 3] = word & 255;
+}
+function encryptWords(key, a0, a1, a2, a3, out) {
+	const rk = key.words;
+	let s0 = a0 ^ rk[0];
+	let s1 = a1 ^ rk[1];
+	let s2 = a2 ^ rk[2];
+	let s3 = a3 ^ rk[3];
 	for (let round = 1; round < key.rounds; round++) {
-		substituteBytes(state, SBOX);
-		shiftRows(state, 1);
-		mixColumns(state, FORWARD_MIX);
-		addRoundKey(state, key.words, round);
+		const at = round * WORDS_PER_BLOCK;
+		const t0 = TE0[s0 >>> 24] ^ TE1[s1 >>> 16 & 255] ^ TE2[s2 >>> 8 & 255] ^ TE3[s3 & 255] ^ rk[at];
+		const t1 = TE0[s1 >>> 24] ^ TE1[s2 >>> 16 & 255] ^ TE2[s3 >>> 8 & 255] ^ TE3[s0 & 255] ^ rk[at + 1];
+		const t2 = TE0[s2 >>> 24] ^ TE1[s3 >>> 16 & 255] ^ TE2[s0 >>> 8 & 255] ^ TE3[s1 & 255] ^ rk[at + 2];
+		const t3 = TE0[s3 >>> 24] ^ TE1[s0 >>> 16 & 255] ^ TE2[s1 >>> 8 & 255] ^ TE3[s2 & 255] ^ rk[at + 3];
+		s0 = t0;
+		s1 = t1;
+		s2 = t2;
+		s3 = t3;
 	}
-	substituteBytes(state, SBOX);
-	shiftRows(state, 1);
-	addRoundKey(state, key.words, key.rounds);
-}
-function decryptBlock(state, key) {
-	addRoundKey(state, key.words, key.rounds);
-	for (let round = key.rounds - 1; round >= 1; round--) {
-		shiftRows(state, -1);
-		substituteBytes(state, INV_SBOX);
-		addRoundKey(state, key.words, round);
-		mixColumns(state, INVERSE_MIX);
+	const at = key.rounds * WORDS_PER_BLOCK;
+	out[0] = packWord(SBOX[s0 >>> 24], SBOX[s1 >>> 16 & 255], SBOX[s2 >>> 8 & 255], SBOX[s3 & 255]) ^ rk[at];
+	out[1] = packWord(SBOX[s1 >>> 24], SBOX[s2 >>> 16 & 255], SBOX[s3 >>> 8 & 255], SBOX[s0 & 255]) ^ rk[at + 1];
+	out[2] = packWord(SBOX[s2 >>> 24], SBOX[s3 >>> 16 & 255], SBOX[s0 >>> 8 & 255], SBOX[s1 & 255]) ^ rk[at + 2];
+	out[3] = packWord(SBOX[s3 >>> 24], SBOX[s0 >>> 16 & 255], SBOX[s1 >>> 8 & 255], SBOX[s2 & 255]) ^ rk[at + 3];
+}
+function decryptWords(rk, rounds, a0, a1, a2, a3, out) {
+	let s0 = a0 ^ rk[0];
+	let s1 = a1 ^ rk[1];
+	let s2 = a2 ^ rk[2];
+	let s3 = a3 ^ rk[3];
+	for (let round = 1; round < rounds; round++) {
+		const at = round * WORDS_PER_BLOCK;
+		const t0 = TD0[s0 >>> 24] ^ TD1[s3 >>> 16 & 255] ^ TD2[s2 >>> 8 & 255] ^ TD3[s1 & 255] ^ rk[at];
+		const t1 = TD0[s1 >>> 24] ^ TD1[s0 >>> 16 & 255] ^ TD2[s3 >>> 8 & 255] ^ TD3[s2 & 255] ^ rk[at + 1];
+		const t2 = TD0[s2 >>> 24] ^ TD1[s1 >>> 16 & 255] ^ TD2[s0 >>> 8 & 255] ^ TD3[s3 & 255] ^ rk[at + 2];
+		const t3 = TD0[s3 >>> 24] ^ TD1[s2 >>> 16 & 255] ^ TD2[s1 >>> 8 & 255] ^ TD3[s0 & 255] ^ rk[at + 3];
+		s0 = t0;
+		s1 = t1;
+		s2 = t2;
+		s3 = t3;
 	}
-	shiftRows(state, -1);
-	substituteBytes(state, INV_SBOX);
-	addRoundKey(state, key.words, 0);
+	const at = rounds * WORDS_PER_BLOCK;
+	out[0] = packWord(INV_SBOX[s0 >>> 24], INV_SBOX[s3 >>> 16 & 255], INV_SBOX[s2 >>> 8 & 255], INV_SBOX[s1 & 255]) ^ rk[at];
+	out[1] = packWord(INV_SBOX[s1 >>> 24], INV_SBOX[s0 >>> 16 & 255], INV_SBOX[s3 >>> 8 & 255], INV_SBOX[s2 & 255]) ^ rk[at + 1];
+	out[2] = packWord(INV_SBOX[s2 >>> 24], INV_SBOX[s1 >>> 16 & 255], INV_SBOX[s0 >>> 8 & 255], INV_SBOX[s3 & 255]) ^ rk[at + 2];
+	out[3] = packWord(INV_SBOX[s3 >>> 24], INV_SBOX[s2 >>> 16 & 255], INV_SBOX[s1 >>> 8 & 255], INV_SBOX[s0 & 255]) ^ rk[at + 3];
 }
 function wholeBlockCount(byteLength) {
 	return Math.floor(byteLength / 16);
 }
 function aesCbcDecrypt(key, iv, data) {
 	const expanded = expandKey(key);
+	const inverseKey = inverseKeyWords(expanded);
 	const blocks = wholeBlockCount(data.length);
 	const out = new Uint8Array(blocks * 16);
-	const chain = Uint8Array.from(iv.subarray(0, 16));
-	for (let b = 0; b < blocks; b++) {
-		const cipherBlock = data.subarray(b * 16, (b + 1) * 16);
-		const state = Uint8Array.from(cipherBlock);
-		decryptBlock(state, expanded);
-		for (let i = 0; i < 16; i++) out[b * 16 + i] = state[i] ^ chain[i];
-		chain.set(cipherBlock);
-	}
+	const plain = new Uint32Array(WORDS_PER_BLOCK);
+	let c0 = readWord(iv, 0);
+	let c1 = readWord(iv, 4);
+	let c2 = readWord(iv, 8);
+	let c3 = readWord(iv, 12);
+	Array.from({ length: blocks }).forEach((_unused, b) => {
+		const at = b * 16;
+		const x0 = readWord(data, at);
+		const x1 = readWord(data, at + 4);
+		const x2 = readWord(data, at + 8);
+		const x3 = readWord(data, at + 12);
+		decryptWords(inverseKey, expanded.rounds, x0, x1, x2, x3, plain);
+		writeWord(out, at, plain[0] ^ c0);
+		writeWord(out, at + 4, plain[1] ^ c1);
+		writeWord(out, at + 8, plain[2] ^ c2);
+		writeWord(out, at + 12, plain[3] ^ c3);
+		c0 = x0;
+		c1 = x1;
+		c2 = x2;
+		c3 = x3;
+	});
 	return out;
 }
 function aesCbcEncrypt(key, iv, data) {
 	const expanded = expandKey(key);
 	const blocks = wholeBlockCount(data.length);
 	const out = new Uint8Array(blocks * 16);
-	const chain = Uint8Array.from(iv.subarray(0, 16));
-	for (let b = 0; b < blocks; b++) {
-		const state = /* @__PURE__ */ new Uint8Array(16);
-		for (let i = 0; i < 16; i++) state[i] = data[b * 16 + i] ^ chain[i];
-		encryptBlock(state, expanded);
-		out.set(state, b * 16);
-		chain.set(state);
-	}
+	const cipher = new Uint32Array(WORDS_PER_BLOCK);
+	let c0 = readWord(iv, 0);
+	let c1 = readWord(iv, 4);
+	let c2 = readWord(iv, 8);
+	let c3 = readWord(iv, 12);
+	Array.from({ length: blocks }).forEach((_unused, b) => {
+		const at = b * 16;
+		encryptWords(expanded, readWord(data, at) ^ c0, readWord(data, at + 4) ^ c1, readWord(data, at + 8) ^ c2, readWord(data, at + 12) ^ c3, cipher);
+		c0 = cipher[0];
+		c1 = cipher[1];
+		c2 = cipher[2];
+		c3 = cipher[3];
+		writeWord(out, at, c0);
+		writeWord(out, at + 4, c1);
+		writeWord(out, at + 8, c2);
+		writeWord(out, at + 12, c3);
+	});
 	return out;
 }
 //#endregion

package/dist/crypto/sha2.cjs

@@ -5,7 +5,6 @@ const SHA256_ROUNDS = 64;
 const SHA512_BLOCK_BYTES = 128;
 const SHA512_ROUNDS = 80;
 const WORDS_PER_BLOCK = 16;
-const MASK64 = 18446744073709551615n;
 const K512 = [
 	4794697086780616226n,
 	8158064640168781261n,
@@ -110,6 +109,9 @@ const H384 = [
 ];
 const K256 = Uint32Array.from(K512.slice(0, SHA256_ROUNDS), (k) => Number(k >> 32n));
 const H256 = Uint32Array.from(H512, (h) => Number(h >> 32n));
+const K512_HIGH = Uint32Array.from(K512, (k) => Number(k >> 32n));
+const K512_LOW = Uint32Array.from(K512, (k) => Number(BigInt.asUintN(32, k)));
+const TWO_POW_32 = 4294967296;
 function padBigEndian(bytes, blockBytes, lengthBytes) {
 	const paddedLength = (Math.floor((bytes.length + lengthBytes) / blockBytes) + 1) * blockBytes;
 	const padded = new Uint8Array(paddedLength);
@@ -185,69 +187,115 @@ function sha256(bytes) {
 	}
 	return digest;
 }
-function rotr64(value, bits) {
-	return (value >> bits | value << 64n - bits) & MASK64;
+function readWord32(bytes, offset) {
+	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
 }
 function sha512Core(bytes, initialState, outputWords) {
 	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, 16);
-	const state = Array.from(initialState);
-	const w = new Array(SHA512_ROUNDS).fill(0n);
+	const stateHigh = Uint32Array.from(initialState, (word) => Number(word >> 32n));
+	const stateLow = Uint32Array.from(initialState, (word) => Number(BigInt.asUintN(32, word)));
+	const wHigh = new Uint32Array(SHA512_ROUNDS);
+	const wLow = new Uint32Array(SHA512_ROUNDS);
 	for (let offset = 0; offset < padded.length; offset += SHA512_BLOCK_BYTES) {
-		for (let t = 0; t < WORDS_PER_BLOCK; t++) {
-			let word = 0n;
-			for (let i = 0; i < 8; i++) word = word << 8n | BigInt(padded[offset + t * 8 + i]);
-			w[t] = word;
-		}
-		for (let t = WORDS_PER_BLOCK; t < SHA512_ROUNDS; t++) {
-			const x = w[t - 15];
-			const y = w[t - 2];
-			const s0 = rotr64(x, 1n) ^ rotr64(x, 8n) ^ x >> 7n;
-			const s1 = rotr64(y, 19n) ^ rotr64(y, 61n) ^ y >> 6n;
-			w[t] = w[t - 16] + s0 + w[t - 7] + s1 & MASK64;
-		}
-		let a = state[0];
-		let b = state[1];
-		let c = state[2];
-		let d = state[3];
-		let e = state[4];
-		let f = state[5];
-		let g = state[6];
-		let h = state[7];
+		wHigh.forEach((_word, t) => {
+			if (t < WORDS_PER_BLOCK) {
+				const at = offset + t * 8;
+				wHigh[t] = readWord32(padded, at);
+				wLow[t] = readWord32(padded, at + 4);
+				return;
+			}
+			const xh = wHigh[t - 15];
+			const xl = wLow[t - 15];
+			const yh = wHigh[t - 2];
+			const yl = wLow[t - 2];
+			const s0h = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ xh >>> 7;
+			const s0l = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25);
+			const s1h = (yh >>> 19 | yl << 13) ^ (yl >>> 29 | yh << 3) ^ yh >>> 6;
+			const s1l = (yl >>> 19 | yh << 13) ^ (yh >>> 29 | yl << 3) ^ (yl >>> 6 | yh << 26);
+			const low = wLow[t - 16] + (s0l >>> 0) + wLow[t - 7] + (s1l >>> 0);
+			const carry = Math.floor(low / TWO_POW_32);
+			wLow[t] = low;
+			wHigh[t] = wHigh[t - 16] + (s0h >>> 0) + wHigh[t - 7] + (s1h >>> 0) + carry;
+		});
+		let ah = stateHigh[0];
+		let al = stateLow[0];
+		let bh = stateHigh[1];
+		let bl = stateLow[1];
+		let ch = stateHigh[2];
+		let cl = stateLow[2];
+		let dh = stateHigh[3];
+		let dl = stateLow[3];
+		let eh = stateHigh[4];
+		let el = stateLow[4];
+		let fh = stateHigh[5];
+		let fl = stateLow[5];
+		let gh = stateHigh[6];
+		let gl = stateLow[6];
+		let hh = stateHigh[7];
+		let hl = stateLow[7];
 		for (let t = 0; t < SHA512_ROUNDS; t++) {
-			const bigS1 = rotr64(e, 14n) ^ rotr64(e, 18n) ^ rotr64(e, 41n);
-			const ch = e & f ^ ~e & MASK64 & g;
-			const t1 = h + bigS1 + ch + K512[t] + w[t] & MASK64;
-			const t2 = (rotr64(a, 28n) ^ rotr64(a, 34n) ^ rotr64(a, 39n)) + (a & b ^ a & c ^ b & c) & MASK64;
-			h = g;
-			g = f;
-			f = e;
-			e = d + t1 & MASK64;
-			d = c;
-			c = b;
-			b = a;
-			a = t1 + t2 & MASK64;
+			const bigS1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
+			const bigS1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+			const chh = eh & fh ^ ~eh & gh;
+			const chl = el & fl ^ ~el & gl;
+			const t1Sum = hl + (bigS1l >>> 0) + (chl >>> 0) + K512_LOW[t] + wLow[t];
+			const t1l = t1Sum >>> 0;
+			const t1h = hh + (bigS1h >>> 0) + (chh >>> 0) + K512_HIGH[t] + wHigh[t] + Math.floor(t1Sum / TWO_POW_32) >>> 0;
+			const bigS0h = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25);
+			const bigS0l = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25);
+			const majh = ah & bh ^ ah & ch ^ bh & ch;
+			const majl = al & bl ^ al & cl ^ bl & cl;
+			const t2Sum = (bigS0l >>> 0) + (majl >>> 0);
+			const t2l = t2Sum >>> 0;
+			const t2h = (bigS0h >>> 0) + (majh >>> 0) + Math.floor(t2Sum / TWO_POW_32) >>> 0;
+			hh = gh;
+			hl = gl;
+			gh = fh;
+			gl = fl;
+			fh = eh;
+			fl = el;
+			const eSum = dl + t1l;
+			eh = dh + t1h + Math.floor(eSum / TWO_POW_32) >>> 0;
+			el = eSum >>> 0;
+			dh = ch;
+			dl = cl;
+			ch = bh;
+			cl = bl;
+			bh = ah;
+			bl = al;
+			const aSum = t1l + t2l;
+			ah = t1h + t2h + Math.floor(aSum / TWO_POW_32) >>> 0;
+			al = aSum >>> 0;
 		}
-		const next = [
-			a,
-			b,
-			c,
-			d,
-			e,
-			f,
-			g,
-			h
+		const nextHigh = [
+			ah,
+			bh,
+			ch,
+			dh,
+			eh,
+			fh,
+			gh,
+			hh
 		];
-		for (let i = 0; i < state.length; i++) state[i] = state[i] + next[i] & MASK64;
-	}
-	const digest = new Uint8Array(outputWords * 8);
-	for (let i = 0; i < outputWords; i++) {
-		let word = state[i];
-		for (let j = 7; j >= 0; j--) {
-			digest[i * 8 + j] = Number(word & 255n);
-			word >>= 8n;
-		}
+		const nextLow = [
+			al,
+			bl,
+			cl,
+			dl,
+			el,
+			fl,
+			gl,
+			hl
+		];
+		stateHigh.forEach((word, i) => {
+			const sum = stateLow[i] + nextLow[i];
+			stateHigh[i] = word + nextHigh[i] + Math.floor(sum / TWO_POW_32);
+			stateLow[i] = sum;
+		});
 	}
-	return digest;
+	return Uint8Array.from({ length: outputWords * 8 }, (_unused, index) => {
+		return (index % 8 < 4 ? stateHigh : stateLow)[Math.floor(index / 8)] >>> 24 - 8 * (index % 4) & 255;
+	});
 }
 function sha512(bytes) {
 	return sha512Core(bytes, H512, 8);

package/dist/crypto/sha2.js

@@ -4,7 +4,6 @@ const SHA256_ROUNDS = 64;
 const SHA512_BLOCK_BYTES = 128;
 const SHA512_ROUNDS = 80;
 const WORDS_PER_BLOCK = 16;
-const MASK64 = 18446744073709551615n;
 const K512 = [
 	4794697086780616226n,
 	8158064640168781261n,
@@ -109,6 +108,9 @@ const H384 = [
 ];
 const K256 = Uint32Array.from(K512.slice(0, SHA256_ROUNDS), (k) => Number(k >> 32n));
 const H256 = Uint32Array.from(H512, (h) => Number(h >> 32n));
+const K512_HIGH = Uint32Array.from(K512, (k) => Number(k >> 32n));
+const K512_LOW = Uint32Array.from(K512, (k) => Number(BigInt.asUintN(32, k)));
+const TWO_POW_32 = 4294967296;
 function padBigEndian(bytes, blockBytes, lengthBytes) {
 	const paddedLength = (Math.floor((bytes.length + lengthBytes) / blockBytes) + 1) * blockBytes;
 	const padded = new Uint8Array(paddedLength);
@@ -184,69 +186,115 @@ function sha256(bytes) {
 	}
 	return digest;
 }
-function rotr64(value, bits) {
-	return (value >> bits | value << 64n - bits) & MASK64;
+function readWord32(bytes, offset) {
+	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
 }
 function sha512Core(bytes, initialState, outputWords) {
 	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, 16);
-	const state = Array.from(initialState);
-	const w = new Array(SHA512_ROUNDS).fill(0n);
+	const stateHigh = Uint32Array.from(initialState, (word) => Number(word >> 32n));
+	const stateLow = Uint32Array.from(initialState, (word) => Number(BigInt.asUintN(32, word)));
+	const wHigh = new Uint32Array(SHA512_ROUNDS);
+	const wLow = new Uint32Array(SHA512_ROUNDS);
 	for (let offset = 0; offset < padded.length; offset += SHA512_BLOCK_BYTES) {
-		for (let t = 0; t < WORDS_PER_BLOCK; t++) {
-			let word = 0n;
-			for (let i = 0; i < 8; i++) word = word << 8n | BigInt(padded[offset + t * 8 + i]);
-			w[t] = word;
-		}
-		for (let t = WORDS_PER_BLOCK; t < SHA512_ROUNDS; t++) {
-			const x = w[t - 15];
-			const y = w[t - 2];
-			const s0 = rotr64(x, 1n) ^ rotr64(x, 8n) ^ x >> 7n;
-			const s1 = rotr64(y, 19n) ^ rotr64(y, 61n) ^ y >> 6n;
-			w[t] = w[t - 16] + s0 + w[t - 7] + s1 & MASK64;
-		}
-		let a = state[0];
-		let b = state[1];
-		let c = state[2];
-		let d = state[3];
-		let e = state[4];
-		let f = state[5];
-		let g = state[6];
-		let h = state[7];
+		wHigh.forEach((_word, t) => {
+			if (t < WORDS_PER_BLOCK) {
+				const at = offset + t * 8;
+				wHigh[t] = readWord32(padded, at);
+				wLow[t] = readWord32(padded, at + 4);
+				return;
+			}
+			const xh = wHigh[t - 15];
+			const xl = wLow[t - 15];
+			const yh = wHigh[t - 2];
+			const yl = wLow[t - 2];
+			const s0h = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ xh >>> 7;
+			const s0l = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25);
+			const s1h = (yh >>> 19 | yl << 13) ^ (yl >>> 29 | yh << 3) ^ yh >>> 6;
+			const s1l = (yl >>> 19 | yh << 13) ^ (yh >>> 29 | yl << 3) ^ (yl >>> 6 | yh << 26);
+			const low = wLow[t - 16] + (s0l >>> 0) + wLow[t - 7] + (s1l >>> 0);
+			const carry = Math.floor(low / TWO_POW_32);
+			wLow[t] = low;
+			wHigh[t] = wHigh[t - 16] + (s0h >>> 0) + wHigh[t - 7] + (s1h >>> 0) + carry;
+		});
+		let ah = stateHigh[0];
+		let al = stateLow[0];
+		let bh = stateHigh[1];
+		let bl = stateLow[1];
+		let ch = stateHigh[2];
+		let cl = stateLow[2];
+		let dh = stateHigh[3];
+		let dl = stateLow[3];
+		let eh = stateHigh[4];
+		let el = stateLow[4];
+		let fh = stateHigh[5];
+		let fl = stateLow[5];
+		let gh = stateHigh[6];
+		let gl = stateLow[6];
+		let hh = stateHigh[7];
+		let hl = stateLow[7];
 		for (let t = 0; t < SHA512_ROUNDS; t++) {
-			const bigS1 = rotr64(e, 14n) ^ rotr64(e, 18n) ^ rotr64(e, 41n);
-			const ch = e & f ^ ~e & MASK64 & g;
-			const t1 = h + bigS1 + ch + K512[t] + w[t] & MASK64;
-			const t2 = (rotr64(a, 28n) ^ rotr64(a, 34n) ^ rotr64(a, 39n)) + (a & b ^ a & c ^ b & c) & MASK64;
-			h = g;
-			g = f;
-			f = e;
-			e = d + t1 & MASK64;
-			d = c;
-			c = b;
-			b = a;
-			a = t1 + t2 & MASK64;
+			const bigS1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
+			const bigS1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+			const chh = eh & fh ^ ~eh & gh;
+			const chl = el & fl ^ ~el & gl;
+			const t1Sum = hl + (bigS1l >>> 0) + (chl >>> 0) + K512_LOW[t] + wLow[t];
+			const t1l = t1Sum >>> 0;
+			const t1h = hh + (bigS1h >>> 0) + (chh >>> 0) + K512_HIGH[t] + wHigh[t] + Math.floor(t1Sum / TWO_POW_32) >>> 0;
+			const bigS0h = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25);
+			const bigS0l = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25);
+			const majh = ah & bh ^ ah & ch ^ bh & ch;
+			const majl = al & bl ^ al & cl ^ bl & cl;
+			const t2Sum = (bigS0l >>> 0) + (majl >>> 0);
+			const t2l = t2Sum >>> 0;
+			const t2h = (bigS0h >>> 0) + (majh >>> 0) + Math.floor(t2Sum / TWO_POW_32) >>> 0;
+			hh = gh;
+			hl = gl;
+			gh = fh;
+			gl = fl;
+			fh = eh;
+			fl = el;
+			const eSum = dl + t1l;
+			eh = dh + t1h + Math.floor(eSum / TWO_POW_32) >>> 0;
+			el = eSum >>> 0;
+			dh = ch;
+			dl = cl;
+			ch = bh;
+			cl = bl;
+			bh = ah;
+			bl = al;
+			const aSum = t1l + t2l;
+			ah = t1h + t2h + Math.floor(aSum / TWO_POW_32) >>> 0;
+			al = aSum >>> 0;
 		}
-		const next = [
-			a,
-			b,
-			c,
-			d,
-			e,
-			f,
-			g,
-			h
+		const nextHigh = [
+			ah,
+			bh,
+			ch,
+			dh,
+			eh,
+			fh,
+			gh,
+			hh
 		];
-		for (let i = 0; i < state.length; i++) state[i] = state[i] + next[i] & MASK64;
-	}
-	const digest = new Uint8Array(outputWords * 8);
-	for (let i = 0; i < outputWords; i++) {
-		let word = state[i];
-		for (let j = 7; j >= 0; j--) {
-			digest[i * 8 + j] = Number(word & 255n);
-			word >>= 8n;
-		}
+		const nextLow = [
+			al,
+			bl,
+			cl,
+			dl,
+			el,
+			fl,
+			gl,
+			hl
+		];
+		stateHigh.forEach((word, i) => {
+			const sum = stateLow[i] + nextLow[i];
+			stateHigh[i] = word + nextHigh[i] + Math.floor(sum / TWO_POW_32);
+			stateLow[i] = sum;
+		});
 	}
-	return digest;
+	return Uint8Array.from({ length: outputWords * 8 }, (_unused, index) => {
+		return (index % 8 < 4 ? stateHigh : stateLow)[Math.floor(index / 8)] >>> 24 - 8 * (index % 4) & 255;
+	});
 }
 function sha512(bytes) {
 	return sha512Core(bytes, H512, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-parser.js",
-  "version": "4.8.5",
+  "version": "4.8.7",
   "description": "Hand-written, dependency-minimal PDF codec: parses arbitrary real-world PDFs and generates new ones, built on its own codec-owned LayoutDocument item model and Zod 4 codecs.",
   "type": "module",
   "repository": {