pdf-parser.js 5.2.26 → 5.2.28

package/dist/crypto/aes.cjs

@@ -4,9 +4,30 @@ const AES_BLOCK_BYTES = 16;
 const WORDS_PER_BLOCK = 4;
 const GF_MODULUS = 283;
 const AFFINE_CONSTANT = 99;
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
+const BYTE_RANGE = 256;
+const WORD_BYTES = 4;
+const BYTE_OVERFLOW_BIT = 256;
+const ROUND_COUNT_OFFSET = 6;
+const EXTRA_SUBWORD_NK_THRESHOLD = 6;
+const EXTRA_SUBWORD_INTERVAL = 4;
+const AES_128_KEY_BYTES = 16;
+const AES_192_KEY_BYTES = 24;
+const AES_256_KEY_BYTES = 32;
+const AFFINE_ROTATE_1 = 1;
+const AFFINE_ROTATE_2 = 2;
+const AFFINE_ROTATE_3 = 3;
+const AFFINE_ROTATE_4 = 4;
+const MIX_COLUMNS_02 = 2;
+const MIX_COLUMNS_03 = 3;
+const INV_MIX_COLUMNS_0E = 14;
+const INV_MIX_COLUMNS_09 = 9;
+const INV_MIX_COLUMNS_0D = 13;
+const INV_MIX_COLUMNS_0B = 11;
 function xtime(a) {
 	const doubled = a << 1;
-	return (doubled & 256) !== 0 ? (doubled ^ GF_MODULUS) & 255 : doubled;
+	return (doubled & BYTE_OVERFLOW_BIT) !== 0 ? (doubled ^ GF_MODULUS) & BYTE_MASK : doubled;
 }
 function gmul(a, b) {
 	let product = 0;
@@ -17,22 +38,22 @@ function gmul(a, b) {
 		left = xtime(left);
 		right >>= 1;
 	}
-	return product & 255;
+	return product & BYTE_MASK;
 }
 function rotl8(value, bits) {
-	return (value << bits | value >>> 8 - bits) & 255;
+	return (value << bits | value >>> BITS_PER_BYTE - bits) & BYTE_MASK;
 }
 const { SBOX, INV_SBOX } = (() => {
-	const inverse = /* @__PURE__ */ new Uint8Array(256);
-	for (let a = 1; a < 256; a++) for (let b = 1; b < 256; b++) if (gmul(a, b) === 1) {
+	const inverse = new Uint8Array(BYTE_RANGE);
+	for (let a = 1; a < BYTE_RANGE; a++) for (let b = 1; b < BYTE_RANGE; b++) if (gmul(a, b) === 1) {
 		inverse[a] = b;
 		break;
 	}
-	const sbox = /* @__PURE__ */ new Uint8Array(256);
-	const invSbox = /* @__PURE__ */ new Uint8Array(256);
-	for (let i = 0; i < 256; i++) {
+	const sbox = new Uint8Array(BYTE_RANGE);
+	const invSbox = new Uint8Array(BYTE_RANGE);
+	for (let i = 0; i < BYTE_RANGE; i++) {
 		const b = inverse[i];
-		const s = (b ^ rotl8(b, 1) ^ rotl8(b, 2) ^ rotl8(b, 3) ^ rotl8(b, 4) ^ AFFINE_CONSTANT) & 255;
+		const s = (b ^ rotl8(b, AFFINE_ROTATE_1) ^ rotl8(b, AFFINE_ROTATE_2) ^ rotl8(b, AFFINE_ROTATE_3) ^ rotl8(b, AFFINE_ROTATE_4) ^ AFFINE_CONSTANT) & BYTE_MASK;
 		sbox[i] = s;
 		invSbox[s] = i;
 	}
@@ -42,17 +63,17 @@ const { SBOX, INV_SBOX } = (() => {
 	};
 })();
 function subWord(word) {
-	return (SBOX[word >>> 24 & 255] << 24 | SBOX[word >>> 16 & 255] << 16 | SBOX[word >>> 8 & 255] << 8 | SBOX[word & 255]) >>> 0;
+	return (SBOX[word >>> 24 & BYTE_MASK] << 24 | SBOX[word >>> 16 & BYTE_MASK] << 16 | SBOX[word >>> BITS_PER_BYTE & BYTE_MASK] << BITS_PER_BYTE | SBOX[word & BYTE_MASK]) >>> 0;
 }
 function rotWord(word) {
-	return (word << 8 | word >>> 24) >>> 0;
+	return (word << BITS_PER_BYTE | word >>> 24) >>> 0;
 }
 function expandKey(key) {
-	if (key.length !== 16 && key.length !== 24 && key.length !== 32) throw new Error(`AES key must be 16, 24, or 32 bytes; got ${String(key.length)}`);
-	const nk = key.length / 4;
-	const rounds = nk + 6;
+	if (key.length !== AES_128_KEY_BYTES && key.length !== AES_192_KEY_BYTES && key.length !== AES_256_KEY_BYTES) throw new Error(`AES key must be 16, 24, or 32 bytes; got ${String(key.length)}`);
+	const nk = key.length / WORD_BYTES;
+	const rounds = nk + ROUND_COUNT_OFFSET;
 	const words = new Uint32Array(WORDS_PER_BLOCK * (rounds + 1));
-	words.set(Array.from({ length: nk }, (_unused, i) => readWord(key, 4 * i)));
+	words.set(Array.from({ length: nk }, (_unused, i) => readWord(key, WORD_BYTES * i)));
 	let rcon = 1;
 	words.forEach((_word, i) => {
 		if (i < nk) return;
@@ -60,7 +81,7 @@ function expandKey(key) {
 		if (i % nk === 0) {
 			temp = (subWord(rotWord(temp)) ^ rcon << 24) >>> 0;
 			rcon = xtime(rcon);
-		} else if (nk > 6 && i % nk === 4) temp = subWord(temp);
+		} else if (nk > EXTRA_SUBWORD_NK_THRESHOLD && i % nk === EXTRA_SUBWORD_INTERVAL) temp = subWord(temp);
 		words[i] = (words[i - nk] ^ temp) >>> 0;
 	});
 	return {
@@ -69,28 +90,28 @@ function expandKey(key) {
 	};
 }
 function packWord(row0, row1, row2, row3) {
-	return (row0 << 24 | row1 << 16 | row2 << 8 | row3) >>> 0;
+	return (row0 << 24 | row1 << 16 | row2 << BITS_PER_BYTE | row3) >>> 0;
 }
 function rotateRight8(word) {
-	return (word >>> 8 | word << 24) >>> 0;
+	return (word >>> BITS_PER_BYTE | word << 24) >>> 0;
 }
 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 te0 = new Uint32Array(BYTE_RANGE);
+	const te1 = new Uint32Array(BYTE_RANGE);
+	const te2 = new Uint32Array(BYTE_RANGE);
+	const te3 = new Uint32Array(BYTE_RANGE);
+	const td0 = new Uint32Array(BYTE_RANGE);
+	const td1 = new Uint32Array(BYTE_RANGE);
+	const td2 = new Uint32Array(BYTE_RANGE);
+	const td3 = new Uint32Array(BYTE_RANGE);
+	for (let x = 0; x < BYTE_RANGE; x++) {
 		const s = SBOX[x];
-		te0[x] = packWord(gmul(s, 2), s, s, gmul(s, 3));
+		te0[x] = packWord(gmul(s, MIX_COLUMNS_02), s, s, gmul(s, MIX_COLUMNS_03));
 		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));
+		td0[x] = packWord(gmul(i, INV_MIX_COLUMNS_0E), gmul(i, INV_MIX_COLUMNS_09), gmul(i, INV_MIX_COLUMNS_0D), gmul(i, INV_MIX_COLUMNS_0B));
 		td1[x] = rotateRight8(td0[x]);
 		td2[x] = rotateRight8(td1[x]);
 		td3[x] = rotateRight8(td2[x]);
@@ -112,7 +133,7 @@ function inverseKeyWords(expanded) {
 		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]];
+		return round === 0 || round === rounds ? word : TD0[SBOX[word >>> 24]] ^ TD1[SBOX[word >>> 16 & BYTE_MASK]] ^ TD2[SBOX[word >>> BITS_PER_BYTE & BYTE_MASK]] ^ TD3[SBOX[word & BYTE_MASK]];
 	});
 }
 function readWord(bytes, offset) {
@@ -120,9 +141,9 @@ function readWord(bytes, offset) {
 }
 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;
+	bytes[offset + 1] = word >>> 16 & BYTE_MASK;
+	bytes[offset + 2] = word >>> BITS_PER_BYTE & BYTE_MASK;
+	bytes[offset + 3] = word & BYTE_MASK;
 }
 function encryptWords(key, a0, a1, a2, a3, out) {
 	const rk = key.words;
@@ -132,20 +153,20 @@ function encryptWords(key, a0, a1, a2, a3, out) {
 	let s3 = a3 ^ rk[3];
 	for (let round = 1; round < key.rounds; 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];
+		const t0 = TE0[s0 >>> 24] ^ TE1[s1 >>> 16 & BYTE_MASK] ^ TE2[s2 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s3 & BYTE_MASK] ^ rk[at];
+		const t1 = TE0[s1 >>> 24] ^ TE1[s2 >>> 16 & BYTE_MASK] ^ TE2[s3 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s0 & BYTE_MASK] ^ rk[at + 1];
+		const t2 = TE0[s2 >>> 24] ^ TE1[s3 >>> 16 & BYTE_MASK] ^ TE2[s0 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s1 & BYTE_MASK] ^ rk[at + 2];
+		const t3 = TE0[s3 >>> 24] ^ TE1[s0 >>> 16 & BYTE_MASK] ^ TE2[s1 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s2 & BYTE_MASK] ^ rk[at + 3];
 		s0 = t0;
 		s1 = t1;
 		s2 = t2;
 		s3 = t3;
 	}
 	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];
+	out[0] = packWord(SBOX[s0 >>> 24], SBOX[s1 >>> 16 & BYTE_MASK], SBOX[s2 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s3 & BYTE_MASK]) ^ rk[at];
+	out[1] = packWord(SBOX[s1 >>> 24], SBOX[s2 >>> 16 & BYTE_MASK], SBOX[s3 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s0 & BYTE_MASK]) ^ rk[at + 1];
+	out[2] = packWord(SBOX[s2 >>> 24], SBOX[s3 >>> 16 & BYTE_MASK], SBOX[s0 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s1 & BYTE_MASK]) ^ rk[at + 2];
+	out[3] = packWord(SBOX[s3 >>> 24], SBOX[s0 >>> 16 & BYTE_MASK], SBOX[s1 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s2 & BYTE_MASK]) ^ rk[at + 3];
 }
 function decryptWords(rk, rounds, a0, a1, a2, a3, out) {
 	let s0 = a0 ^ rk[0];
@@ -154,20 +175,20 @@ function decryptWords(rk, rounds, a0, a1, a2, a3, out) {
 	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];
+		const t0 = TD0[s0 >>> 24] ^ TD1[s3 >>> 16 & BYTE_MASK] ^ TD2[s2 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s1 & BYTE_MASK] ^ rk[at];
+		const t1 = TD0[s1 >>> 24] ^ TD1[s0 >>> 16 & BYTE_MASK] ^ TD2[s3 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s2 & BYTE_MASK] ^ rk[at + 1];
+		const t2 = TD0[s2 >>> 24] ^ TD1[s1 >>> 16 & BYTE_MASK] ^ TD2[s0 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s3 & BYTE_MASK] ^ rk[at + 2];
+		const t3 = TD0[s3 >>> 24] ^ TD1[s2 >>> 16 & BYTE_MASK] ^ TD2[s1 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s0 & BYTE_MASK] ^ rk[at + 3];
 		s0 = t0;
 		s1 = t1;
 		s2 = t2;
 		s3 = t3;
 	}
 	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];
+	out[0] = packWord(INV_SBOX[s0 >>> 24], INV_SBOX[s3 >>> 16 & BYTE_MASK], INV_SBOX[s2 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s1 & BYTE_MASK]) ^ rk[at];
+	out[1] = packWord(INV_SBOX[s1 >>> 24], INV_SBOX[s0 >>> 16 & BYTE_MASK], INV_SBOX[s3 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s2 & BYTE_MASK]) ^ rk[at + 1];
+	out[2] = packWord(INV_SBOX[s2 >>> 24], INV_SBOX[s1 >>> 16 & BYTE_MASK], INV_SBOX[s0 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s3 & BYTE_MASK]) ^ rk[at + 2];
+	out[3] = packWord(INV_SBOX[s3 >>> 24], INV_SBOX[s2 >>> 16 & BYTE_MASK], INV_SBOX[s1 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s0 & BYTE_MASK]) ^ rk[at + 3];
 }
 function wholeBlockCount(byteLength) {
 	return Math.floor(byteLength / 16);
@@ -179,18 +200,18 @@ function aesCbcDecrypt(key, iv, data) {
 	const out = new Uint8Array(blocks * 16);
 	const plain = new Uint32Array(WORDS_PER_BLOCK);
 	let c0 = readWord(iv, 0);
-	let c1 = readWord(iv, 4);
+	let c1 = readWord(iv, WORD_BYTES);
 	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 x1 = readWord(data, at + WORD_BYTES);
 		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 + WORD_BYTES, plain[1] ^ c1);
 		writeWord(out, at + 8, plain[2] ^ c2);
 		writeWord(out, at + 12, plain[3] ^ c3);
 		c0 = x0;
@@ -206,18 +227,18 @@ function aesCbcEncrypt(key, iv, data) {
 	const out = new Uint8Array(blocks * 16);
 	const cipher = new Uint32Array(WORDS_PER_BLOCK);
 	let c0 = readWord(iv, 0);
-	let c1 = readWord(iv, 4);
+	let c1 = readWord(iv, WORD_BYTES);
 	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);
+		encryptWords(expanded, readWord(data, at) ^ c0, readWord(data, at + WORD_BYTES) ^ 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 + WORD_BYTES, c1);
 		writeWord(out, at + 8, c2);
 		writeWord(out, at + 12, c3);
 	});

package/dist/crypto/aes.js

@@ -3,9 +3,30 @@ const AES_BLOCK_BYTES = 16;
 const WORDS_PER_BLOCK = 4;
 const GF_MODULUS = 283;
 const AFFINE_CONSTANT = 99;
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
+const BYTE_RANGE = 256;
+const WORD_BYTES = 4;
+const BYTE_OVERFLOW_BIT = 256;
+const ROUND_COUNT_OFFSET = 6;
+const EXTRA_SUBWORD_NK_THRESHOLD = 6;
+const EXTRA_SUBWORD_INTERVAL = 4;
+const AES_128_KEY_BYTES = 16;
+const AES_192_KEY_BYTES = 24;
+const AES_256_KEY_BYTES = 32;
+const AFFINE_ROTATE_1 = 1;
+const AFFINE_ROTATE_2 = 2;
+const AFFINE_ROTATE_3 = 3;
+const AFFINE_ROTATE_4 = 4;
+const MIX_COLUMNS_02 = 2;
+const MIX_COLUMNS_03 = 3;
+const INV_MIX_COLUMNS_0E = 14;
+const INV_MIX_COLUMNS_09 = 9;
+const INV_MIX_COLUMNS_0D = 13;
+const INV_MIX_COLUMNS_0B = 11;
 function xtime(a) {
 	const doubled = a << 1;
-	return (doubled & 256) !== 0 ? (doubled ^ GF_MODULUS) & 255 : doubled;
+	return (doubled & BYTE_OVERFLOW_BIT) !== 0 ? (doubled ^ GF_MODULUS) & BYTE_MASK : doubled;
 }
 function gmul(a, b) {
 	let product = 0;
@@ -16,22 +37,22 @@ function gmul(a, b) {
 		left = xtime(left);
 		right >>= 1;
 	}
-	return product & 255;
+	return product & BYTE_MASK;
 }
 function rotl8(value, bits) {
-	return (value << bits | value >>> 8 - bits) & 255;
+	return (value << bits | value >>> BITS_PER_BYTE - bits) & BYTE_MASK;
 }
 const { SBOX, INV_SBOX } = (() => {
-	const inverse = /* @__PURE__ */ new Uint8Array(256);
-	for (let a = 1; a < 256; a++) for (let b = 1; b < 256; b++) if (gmul(a, b) === 1) {
+	const inverse = new Uint8Array(BYTE_RANGE);
+	for (let a = 1; a < BYTE_RANGE; a++) for (let b = 1; b < BYTE_RANGE; b++) if (gmul(a, b) === 1) {
 		inverse[a] = b;
 		break;
 	}
-	const sbox = /* @__PURE__ */ new Uint8Array(256);
-	const invSbox = /* @__PURE__ */ new Uint8Array(256);
-	for (let i = 0; i < 256; i++) {
+	const sbox = new Uint8Array(BYTE_RANGE);
+	const invSbox = new Uint8Array(BYTE_RANGE);
+	for (let i = 0; i < BYTE_RANGE; i++) {
 		const b = inverse[i];
-		const s = (b ^ rotl8(b, 1) ^ rotl8(b, 2) ^ rotl8(b, 3) ^ rotl8(b, 4) ^ AFFINE_CONSTANT) & 255;
+		const s = (b ^ rotl8(b, AFFINE_ROTATE_1) ^ rotl8(b, AFFINE_ROTATE_2) ^ rotl8(b, AFFINE_ROTATE_3) ^ rotl8(b, AFFINE_ROTATE_4) ^ AFFINE_CONSTANT) & BYTE_MASK;
 		sbox[i] = s;
 		invSbox[s] = i;
 	}
@@ -41,17 +62,17 @@ const { SBOX, INV_SBOX } = (() => {
 	};
 })();
 function subWord(word) {
-	return (SBOX[word >>> 24 & 255] << 24 | SBOX[word >>> 16 & 255] << 16 | SBOX[word >>> 8 & 255] << 8 | SBOX[word & 255]) >>> 0;
+	return (SBOX[word >>> 24 & BYTE_MASK] << 24 | SBOX[word >>> 16 & BYTE_MASK] << 16 | SBOX[word >>> BITS_PER_BYTE & BYTE_MASK] << BITS_PER_BYTE | SBOX[word & BYTE_MASK]) >>> 0;
 }
 function rotWord(word) {
-	return (word << 8 | word >>> 24) >>> 0;
+	return (word << BITS_PER_BYTE | word >>> 24) >>> 0;
 }
 function expandKey(key) {
-	if (key.length !== 16 && key.length !== 24 && key.length !== 32) throw new Error(`AES key must be 16, 24, or 32 bytes; got ${String(key.length)}`);
-	const nk = key.length / 4;
-	const rounds = nk + 6;
+	if (key.length !== AES_128_KEY_BYTES && key.length !== AES_192_KEY_BYTES && key.length !== AES_256_KEY_BYTES) throw new Error(`AES key must be 16, 24, or 32 bytes; got ${String(key.length)}`);
+	const nk = key.length / WORD_BYTES;
+	const rounds = nk + ROUND_COUNT_OFFSET;
 	const words = new Uint32Array(WORDS_PER_BLOCK * (rounds + 1));
-	words.set(Array.from({ length: nk }, (_unused, i) => readWord(key, 4 * i)));
+	words.set(Array.from({ length: nk }, (_unused, i) => readWord(key, WORD_BYTES * i)));
 	let rcon = 1;
 	words.forEach((_word, i) => {
 		if (i < nk) return;
@@ -59,7 +80,7 @@ function expandKey(key) {
 		if (i % nk === 0) {
 			temp = (subWord(rotWord(temp)) ^ rcon << 24) >>> 0;
 			rcon = xtime(rcon);
-		} else if (nk > 6 && i % nk === 4) temp = subWord(temp);
+		} else if (nk > EXTRA_SUBWORD_NK_THRESHOLD && i % nk === EXTRA_SUBWORD_INTERVAL) temp = subWord(temp);
 		words[i] = (words[i - nk] ^ temp) >>> 0;
 	});
 	return {
@@ -68,28 +89,28 @@ function expandKey(key) {
 	};
 }
 function packWord(row0, row1, row2, row3) {
-	return (row0 << 24 | row1 << 16 | row2 << 8 | row3) >>> 0;
+	return (row0 << 24 | row1 << 16 | row2 << BITS_PER_BYTE | row3) >>> 0;
 }
 function rotateRight8(word) {
-	return (word >>> 8 | word << 24) >>> 0;
+	return (word >>> BITS_PER_BYTE | word << 24) >>> 0;
 }
 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 te0 = new Uint32Array(BYTE_RANGE);
+	const te1 = new Uint32Array(BYTE_RANGE);
+	const te2 = new Uint32Array(BYTE_RANGE);
+	const te3 = new Uint32Array(BYTE_RANGE);
+	const td0 = new Uint32Array(BYTE_RANGE);
+	const td1 = new Uint32Array(BYTE_RANGE);
+	const td2 = new Uint32Array(BYTE_RANGE);
+	const td3 = new Uint32Array(BYTE_RANGE);
+	for (let x = 0; x < BYTE_RANGE; x++) {
 		const s = SBOX[x];
-		te0[x] = packWord(gmul(s, 2), s, s, gmul(s, 3));
+		te0[x] = packWord(gmul(s, MIX_COLUMNS_02), s, s, gmul(s, MIX_COLUMNS_03));
 		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));
+		td0[x] = packWord(gmul(i, INV_MIX_COLUMNS_0E), gmul(i, INV_MIX_COLUMNS_09), gmul(i, INV_MIX_COLUMNS_0D), gmul(i, INV_MIX_COLUMNS_0B));
 		td1[x] = rotateRight8(td0[x]);
 		td2[x] = rotateRight8(td1[x]);
 		td3[x] = rotateRight8(td2[x]);
@@ -111,7 +132,7 @@ function inverseKeyWords(expanded) {
 		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]];
+		return round === 0 || round === rounds ? word : TD0[SBOX[word >>> 24]] ^ TD1[SBOX[word >>> 16 & BYTE_MASK]] ^ TD2[SBOX[word >>> BITS_PER_BYTE & BYTE_MASK]] ^ TD3[SBOX[word & BYTE_MASK]];
 	});
 }
 function readWord(bytes, offset) {
@@ -119,9 +140,9 @@ function readWord(bytes, offset) {
 }
 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;
+	bytes[offset + 1] = word >>> 16 & BYTE_MASK;
+	bytes[offset + 2] = word >>> BITS_PER_BYTE & BYTE_MASK;
+	bytes[offset + 3] = word & BYTE_MASK;
 }
 function encryptWords(key, a0, a1, a2, a3, out) {
 	const rk = key.words;
@@ -131,20 +152,20 @@ function encryptWords(key, a0, a1, a2, a3, out) {
 	let s3 = a3 ^ rk[3];
 	for (let round = 1; round < key.rounds; 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];
+		const t0 = TE0[s0 >>> 24] ^ TE1[s1 >>> 16 & BYTE_MASK] ^ TE2[s2 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s3 & BYTE_MASK] ^ rk[at];
+		const t1 = TE0[s1 >>> 24] ^ TE1[s2 >>> 16 & BYTE_MASK] ^ TE2[s3 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s0 & BYTE_MASK] ^ rk[at + 1];
+		const t2 = TE0[s2 >>> 24] ^ TE1[s3 >>> 16 & BYTE_MASK] ^ TE2[s0 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s1 & BYTE_MASK] ^ rk[at + 2];
+		const t3 = TE0[s3 >>> 24] ^ TE1[s0 >>> 16 & BYTE_MASK] ^ TE2[s1 >>> BITS_PER_BYTE & BYTE_MASK] ^ TE3[s2 & BYTE_MASK] ^ rk[at + 3];
 		s0 = t0;
 		s1 = t1;
 		s2 = t2;
 		s3 = t3;
 	}
 	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];
+	out[0] = packWord(SBOX[s0 >>> 24], SBOX[s1 >>> 16 & BYTE_MASK], SBOX[s2 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s3 & BYTE_MASK]) ^ rk[at];
+	out[1] = packWord(SBOX[s1 >>> 24], SBOX[s2 >>> 16 & BYTE_MASK], SBOX[s3 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s0 & BYTE_MASK]) ^ rk[at + 1];
+	out[2] = packWord(SBOX[s2 >>> 24], SBOX[s3 >>> 16 & BYTE_MASK], SBOX[s0 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s1 & BYTE_MASK]) ^ rk[at + 2];
+	out[3] = packWord(SBOX[s3 >>> 24], SBOX[s0 >>> 16 & BYTE_MASK], SBOX[s1 >>> BITS_PER_BYTE & BYTE_MASK], SBOX[s2 & BYTE_MASK]) ^ rk[at + 3];
 }
 function decryptWords(rk, rounds, a0, a1, a2, a3, out) {
 	let s0 = a0 ^ rk[0];
@@ -153,20 +174,20 @@ function decryptWords(rk, rounds, a0, a1, a2, a3, out) {
 	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];
+		const t0 = TD0[s0 >>> 24] ^ TD1[s3 >>> 16 & BYTE_MASK] ^ TD2[s2 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s1 & BYTE_MASK] ^ rk[at];
+		const t1 = TD0[s1 >>> 24] ^ TD1[s0 >>> 16 & BYTE_MASK] ^ TD2[s3 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s2 & BYTE_MASK] ^ rk[at + 1];
+		const t2 = TD0[s2 >>> 24] ^ TD1[s1 >>> 16 & BYTE_MASK] ^ TD2[s0 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s3 & BYTE_MASK] ^ rk[at + 2];
+		const t3 = TD0[s3 >>> 24] ^ TD1[s2 >>> 16 & BYTE_MASK] ^ TD2[s1 >>> BITS_PER_BYTE & BYTE_MASK] ^ TD3[s0 & BYTE_MASK] ^ rk[at + 3];
 		s0 = t0;
 		s1 = t1;
 		s2 = t2;
 		s3 = t3;
 	}
 	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];
+	out[0] = packWord(INV_SBOX[s0 >>> 24], INV_SBOX[s3 >>> 16 & BYTE_MASK], INV_SBOX[s2 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s1 & BYTE_MASK]) ^ rk[at];
+	out[1] = packWord(INV_SBOX[s1 >>> 24], INV_SBOX[s0 >>> 16 & BYTE_MASK], INV_SBOX[s3 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s2 & BYTE_MASK]) ^ rk[at + 1];
+	out[2] = packWord(INV_SBOX[s2 >>> 24], INV_SBOX[s1 >>> 16 & BYTE_MASK], INV_SBOX[s0 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s3 & BYTE_MASK]) ^ rk[at + 2];
+	out[3] = packWord(INV_SBOX[s3 >>> 24], INV_SBOX[s2 >>> 16 & BYTE_MASK], INV_SBOX[s1 >>> BITS_PER_BYTE & BYTE_MASK], INV_SBOX[s0 & BYTE_MASK]) ^ rk[at + 3];
 }
 function wholeBlockCount(byteLength) {
 	return Math.floor(byteLength / 16);
@@ -178,18 +199,18 @@ function aesCbcDecrypt(key, iv, data) {
 	const out = new Uint8Array(blocks * 16);
 	const plain = new Uint32Array(WORDS_PER_BLOCK);
 	let c0 = readWord(iv, 0);
-	let c1 = readWord(iv, 4);
+	let c1 = readWord(iv, WORD_BYTES);
 	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 x1 = readWord(data, at + WORD_BYTES);
 		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 + WORD_BYTES, plain[1] ^ c1);
 		writeWord(out, at + 8, plain[2] ^ c2);
 		writeWord(out, at + 12, plain[3] ^ c3);
 		c0 = x0;
@@ -205,18 +226,18 @@ function aesCbcEncrypt(key, iv, data) {
 	const out = new Uint8Array(blocks * 16);
 	const cipher = new Uint32Array(WORDS_PER_BLOCK);
 	let c0 = readWord(iv, 0);
-	let c1 = readWord(iv, 4);
+	let c1 = readWord(iv, WORD_BYTES);
 	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);
+		encryptWords(expanded, readWord(data, at) ^ c0, readWord(data, at + WORD_BYTES) ^ 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 + WORD_BYTES, c1);
 		writeWord(out, at + 8, c2);
 		writeWord(out, at + 12, c3);
 	});