pdf-parser.js 5.2.27 → 5.2.28

package/dist/crypto/sha2.cjs

@@ -107,42 +107,66 @@ const H384 = [
 	15784041429090275239n,
 	5167115440072839076n
 ];
-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 WORD_BITS = 32;
+const WORD_BITS_BIGINT = 32n;
+const K256 = Uint32Array.from(K512.slice(0, SHA256_ROUNDS), (k) => Number(k >> WORD_BITS_BIGINT));
+const H256 = Uint32Array.from(H512, (h) => Number(h >> WORD_BITS_BIGINT));
+const K512_HIGH = Uint32Array.from(K512, (k) => Number(k >> WORD_BITS_BIGINT));
+const K512_LOW = Uint32Array.from(K512, (k) => Number(BigInt.asUintN(WORD_BITS, k)));
 const TWO_POW_32 = 4294967296;
+const BITS_PER_BYTE = 8;
+const BYTE_MODULUS = 256;
 function padBigEndian(bytes, blockBytes, lengthBytes) {
 	const paddedLength = (Math.floor((bytes.length + lengthBytes) / blockBytes) + 1) * blockBytes;
 	const padded = new Uint8Array(paddedLength);
 	padded.set(bytes);
 	padded[bytes.length] = 128;
-	let bitLength = bytes.length * 8;
+	let bitLength = bytes.length * BITS_PER_BYTE;
 	for (let i = 0; i < lengthBytes; i++) {
-		padded[paddedLength - 1 - i] = bitLength % 256;
-		bitLength = Math.floor(bitLength / 256);
+		padded[paddedLength - 1 - i] = bitLength % BYTE_MODULUS;
+		bitLength = Math.floor(bitLength / BYTE_MODULUS);
 	}
 	return padded;
 }
 function rotr32(value, bits) {
-	return (value >>> bits | value << 32 - bits) >>> 0;
+	return (value >>> bits | value << WORD_BITS - bits) >>> 0;
 }
+const SHA256_SIGMA0_ROTR_A = 7;
+const SHA256_SIGMA0_ROTR_B = 18;
+const SHA256_SIGMA0_SHR = 3;
+const SHA256_SIGMA1_ROTR_A = 17;
+const SHA256_SIGMA1_ROTR_B = 19;
+const SHA256_SIGMA1_SHR = 10;
+const SHA256_BIG_SIGMA0_ROTR_B = 13;
+const SHA256_BIG_SIGMA0_ROTR_C = 22;
+const SHA256_BIG_SIGMA1_ROTR_A = 6;
+const SHA256_BIG_SIGMA1_ROTR_B = 11;
+const SHA256_BIG_SIGMA1_ROTR_C = 25;
+const BYTES_PER_WORD = 4;
+const WORD_LAST_BYTE_OFFSET = 3;
+const SCHEDULE_OFFSET_7 = 7;
+const SCHEDULE_OFFSET_15 = 15;
+const SCHEDULE_OFFSET_16 = 16;
+const BYTE_SHIFT_1 = 8;
+const BYTE_SHIFT_2 = 16;
+const BYTE_SHIFT_3 = 24;
+const BYTE_MASK = 255;
 function sha256(bytes) {
 	const padded = padBigEndian(bytes, SHA256_BLOCK_BYTES, 8);
 	const state = Uint32Array.from(H256);
 	const w = new Uint32Array(SHA256_ROUNDS);
 	for (let offset = 0; offset < padded.length; offset += SHA256_BLOCK_BYTES) {
 		w.set(Array.from({ length: WORDS_PER_BLOCK }, (_, t) => {
-			const at = offset + t * 4;
-			return (padded[at] << 24 | padded[at + 1] << 16 | padded[at + 2] << 8 | padded[at + 3]) >>> 0;
+			const at = offset + t * BYTES_PER_WORD;
+			return (padded[at] << BYTE_SHIFT_3 | padded[at + 1] << BYTE_SHIFT_2 | padded[at + 2] << BYTE_SHIFT_1 | padded[at + WORD_LAST_BYTE_OFFSET]) >>> 0;
 		}));
 		Array.from({ length: SHA256_ROUNDS }, (_, t) => {
 			if (t < WORDS_PER_BLOCK) return;
-			const x = w[t - 15];
+			const x = w[t - SCHEDULE_OFFSET_15];
 			const y = w[t - 2];
-			const s0 = rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
-			const s1 = rotr32(y, 17) ^ rotr32(y, 19) ^ y >>> 10;
-			w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+			const s0 = rotr32(x, SHA256_SIGMA0_ROTR_A) ^ rotr32(x, SHA256_SIGMA0_ROTR_B) ^ x >>> SHA256_SIGMA0_SHR;
+			const s1 = rotr32(y, SHA256_SIGMA1_ROTR_A) ^ rotr32(y, SHA256_SIGMA1_ROTR_B) ^ y >>> SHA256_SIGMA1_SHR;
+			w[t] = w[t - SCHEDULE_OFFSET_16] + s0 + w[t - SCHEDULE_OFFSET_7] + s1 >>> 0;
 		});
 		let a = state[0];
 		let b = state[1];
@@ -153,10 +177,10 @@ function sha256(bytes) {
 		let g = state[6];
 		let h = state[7];
 		for (let t = 0; t < SHA256_ROUNDS; t++) {
-			const bigS1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+			const bigS1 = rotr32(e, SHA256_BIG_SIGMA1_ROTR_A) ^ rotr32(e, SHA256_BIG_SIGMA1_ROTR_B) ^ rotr32(e, SHA256_BIG_SIGMA1_ROTR_C);
 			const ch = e & f ^ ~e & g;
 			const t1 = h + bigS1 + (ch >>> 0) + K256[t] + w[t] >>> 0;
-			const t2 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) + ((a & b ^ a & c ^ b & c) >>> 0) >>> 0;
+			const t2 = (rotr32(a, 2) ^ rotr32(a, SHA256_BIG_SIGMA0_ROTR_B) ^ rotr32(a, SHA256_BIG_SIGMA0_ROTR_C)) + ((a & b ^ a & c ^ b & c) >>> 0) >>> 0;
 			h = g;
 			g = f;
 			f = e;
@@ -178,44 +202,67 @@ function sha256(bytes) {
 		];
 		state.set(state.map((value, i) => value + next[i] >>> 0));
 	}
-	const digest = new Uint8Array(state.length * 4);
+	const digest = new Uint8Array(state.length * BYTES_PER_WORD);
 	state.forEach((word, i) => {
-		digest[i * 4] = word >>> 24 & 255;
-		digest[i * 4 + 1] = word >>> 16 & 255;
-		digest[i * 4 + 2] = word >>> 8 & 255;
-		digest[i * 4 + 3] = word & 255;
+		digest[i * BYTES_PER_WORD] = word >>> BYTE_SHIFT_3 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 1] = word >>> BYTE_SHIFT_2 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 2] = word >>> BYTE_SHIFT_1 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + WORD_LAST_BYTE_OFFSET] = word & BYTE_MASK;
 	});
 	return digest;
 }
 function readWord32(bytes, offset) {
-	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+	return (bytes[offset] << BYTE_SHIFT_3 | bytes[offset + 1] << BYTE_SHIFT_2 | bytes[offset + 2] << BYTE_SHIFT_1 | bytes[offset + WORD_LAST_BYTE_OFFSET]) >>> 0;
 }
+const SHA512_LENGTH_FIELD_BYTES = 16;
+const BYTES_PER_WORD64 = 8;
+const SHA512_SIGMA0_ROTR_1 = 1;
+const SHA512_SIGMA0_ROTR_1_COMPLEMENT = 31;
+const SHA512_SIGMA0_ROTR_8 = 8;
+const SHA512_SIGMA0_ROTR_8_COMPLEMENT = 24;
+const SHA512_SIGMA0_SHR_7 = 7;
+const SHA512_SIGMA0_SHR_7_CARRY = 25;
+const SHA512_SIGMA1_ROTR_19 = 19;
+const SHA512_SIGMA1_ROTR_19_COMPLEMENT = 13;
+const SHA512_SIGMA1_ROTR_61_SHIFT = 29;
+const SHA512_SIGMA1_ROTR_61_COMPLEMENT = 3;
+const SHA512_SIGMA1_SHR_6 = 6;
+const SHA512_SIGMA1_SHR_6_CARRY = 26;
+const SHA512_BIG_SIGMA1_ROTR_A = 14;
+const SHA512_BIG_SIGMA1_ROTR_B = 18;
+const SHA512_BIG_SIGMA1_ROTR_41_SHIFT = 9;
+const SHA512_BIG_SIGMA1_ROTR_41_COMPLEMENT = 23;
+const SHA512_BIG_SIGMA0_ROTR_28 = 28;
+const SHA512_BIG_SIGMA0_ROTR_28_COMPLEMENT = 4;
+const SHA512_BIG_SIGMA0_ROTR_34_COMPLEMENT = 30;
+const SHA512_BIG_SIGMA0_ROTR_39_SHIFT = 7;
+const SHA512_BIG_SIGMA0_ROTR_39_COMPLEMENT = 25;
 function sha512Core(bytes, initialState, outputWords) {
-	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, 16);
-	const stateHigh = Uint32Array.from(initialState, (word) => Number(word >> 32n));
-	const stateLow = Uint32Array.from(initialState, (word) => Number(BigInt.asUintN(32, word)));
+	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, SHA512_LENGTH_FIELD_BYTES);
+	const stateHigh = Uint32Array.from(initialState, (word) => Number(word >> WORD_BITS_BIGINT));
+	const stateLow = Uint32Array.from(initialState, (word) => Number(BigInt.asUintN(WORD_BITS, word)));
 	const wHigh = new Uint32Array(SHA512_ROUNDS);
 	const wLow = new Uint32Array(SHA512_ROUNDS);
 	for (let offset = 0; offset < padded.length; offset += SHA512_BLOCK_BYTES) {
 		wHigh.forEach((_word, t) => {
 			if (t < WORDS_PER_BLOCK) {
-				const at = offset + t * 8;
+				const at = offset + t * BYTES_PER_WORD64;
 				wHigh[t] = readWord32(padded, at);
-				wLow[t] = readWord32(padded, at + 4);
+				wLow[t] = readWord32(padded, at + BYTES_PER_WORD);
 				return;
 			}
-			const xh = wHigh[t - 15];
-			const xl = wLow[t - 15];
+			const xh = wHigh[t - SCHEDULE_OFFSET_15];
+			const xl = wLow[t - SCHEDULE_OFFSET_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 s0h = (xh >>> SHA512_SIGMA0_ROTR_1 | xl << SHA512_SIGMA0_ROTR_1_COMPLEMENT) ^ (xh >>> SHA512_SIGMA0_ROTR_8 | xl << SHA512_SIGMA0_ROTR_8_COMPLEMENT) ^ xh >>> SHA512_SIGMA0_SHR_7;
+			const s0l = (xl >>> SHA512_SIGMA0_ROTR_1 | xh << SHA512_SIGMA0_ROTR_1_COMPLEMENT) ^ (xl >>> SHA512_SIGMA0_ROTR_8 | xh << SHA512_SIGMA0_ROTR_8_COMPLEMENT) ^ (xl >>> SHA512_SIGMA0_SHR_7 | xh << SHA512_SIGMA0_SHR_7_CARRY);
+			const s1h = (yh >>> SHA512_SIGMA1_ROTR_19 | yl << SHA512_SIGMA1_ROTR_19_COMPLEMENT) ^ (yl >>> SHA512_SIGMA1_ROTR_61_SHIFT | yh << SHA512_SIGMA1_ROTR_61_COMPLEMENT) ^ yh >>> SHA512_SIGMA1_SHR_6;
+			const s1l = (yl >>> SHA512_SIGMA1_ROTR_19 | yh << SHA512_SIGMA1_ROTR_19_COMPLEMENT) ^ (yh >>> SHA512_SIGMA1_ROTR_61_SHIFT | yl << SHA512_SIGMA1_ROTR_61_COMPLEMENT) ^ (yl >>> SHA512_SIGMA1_SHR_6 | yh << SHA512_SIGMA1_SHR_6_CARRY);
+			const low = wLow[t - SCHEDULE_OFFSET_16] + (s0l >>> 0) + wLow[t - SCHEDULE_OFFSET_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;
+			wHigh[t] = wHigh[t - SCHEDULE_OFFSET_16] + (s0h >>> 0) + wHigh[t - SCHEDULE_OFFSET_7] + (s1h >>> 0) + carry;
 		});
 		let ah = stateHigh[0];
 		let al = stateLow[0];
@@ -234,15 +281,15 @@ function sha512Core(bytes, initialState, outputWords) {
 		let hh = stateHigh[7];
 		let hl = stateLow[7];
 		for (let t = 0; t < SHA512_ROUNDS; t++) {
-			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 bigS1h = (eh >>> SHA512_BIG_SIGMA1_ROTR_A | el << SHA512_BIG_SIGMA1_ROTR_B) ^ (eh >>> SHA512_BIG_SIGMA1_ROTR_B | el << SHA512_BIG_SIGMA1_ROTR_A) ^ (el >>> SHA512_BIG_SIGMA1_ROTR_41_SHIFT | eh << SHA512_BIG_SIGMA1_ROTR_41_COMPLEMENT);
+			const bigS1l = (el >>> SHA512_BIG_SIGMA1_ROTR_A | eh << SHA512_BIG_SIGMA1_ROTR_B) ^ (el >>> SHA512_BIG_SIGMA1_ROTR_B | eh << SHA512_BIG_SIGMA1_ROTR_A) ^ (eh >>> SHA512_BIG_SIGMA1_ROTR_41_SHIFT | el << SHA512_BIG_SIGMA1_ROTR_41_COMPLEMENT);
 			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 bigS0h = (ah >>> SHA512_BIG_SIGMA0_ROTR_28 | al << SHA512_BIG_SIGMA0_ROTR_28_COMPLEMENT) ^ (al >>> 2 | ah << SHA512_BIG_SIGMA0_ROTR_34_COMPLEMENT) ^ (al >>> SHA512_BIG_SIGMA0_ROTR_39_SHIFT | ah << SHA512_BIG_SIGMA0_ROTR_39_COMPLEMENT);
+			const bigS0l = (al >>> SHA512_BIG_SIGMA0_ROTR_28 | ah << SHA512_BIG_SIGMA0_ROTR_28_COMPLEMENT) ^ (ah >>> 2 | al << SHA512_BIG_SIGMA0_ROTR_34_COMPLEMENT) ^ (ah >>> SHA512_BIG_SIGMA0_ROTR_39_SHIFT | al << SHA512_BIG_SIGMA0_ROTR_39_COMPLEMENT);
 			const majh = ah & bh ^ ah & ch ^ bh & ch;
 			const majl = al & bl ^ al & cl ^ bl & cl;
 			const t2Sum = (bigS0l >>> 0) + (majl >>> 0);
@@ -293,15 +340,17 @@ function sha512Core(bytes, initialState, outputWords) {
 			stateLow[i] = sum;
 		});
 	}
-	return Uint8Array.from({ length: outputWords * 8 }, (_unused, index) => {
-		return (index % 8 < 4 ? stateHigh : stateLow)[Math.floor(index / 8)] >>> 24 - 8 * (index % 4) & 255;
+	return Uint8Array.from({ length: outputWords * BYTES_PER_WORD64 }, (_unused, index) => {
+		return (index % BYTES_PER_WORD64 < BYTES_PER_WORD ? stateHigh : stateLow)[Math.floor(index / BYTES_PER_WORD64)] >>> BYTE_SHIFT_3 - BYTE_SHIFT_1 * (index % BYTES_PER_WORD) & BYTE_MASK;
 	});
 }
+const SHA512_OUTPUT_WORDS = 8;
+const SHA384_OUTPUT_WORDS = 6;
 function sha512(bytes) {
-	return sha512Core(bytes, H512, 8);
+	return sha512Core(bytes, H512, SHA512_OUTPUT_WORDS);
 }
 function sha384(bytes) {
-	return sha512Core(bytes, H384, 6);
+	return sha512Core(bytes, H384, SHA384_OUTPUT_WORDS);
 }
 //#endregion
 exports.sha256 = sha256;

package/dist/crypto/sha2.js

@@ -106,42 +106,66 @@ const H384 = [
 	15784041429090275239n,
 	5167115440072839076n
 ];
-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 WORD_BITS = 32;
+const WORD_BITS_BIGINT = 32n;
+const K256 = Uint32Array.from(K512.slice(0, SHA256_ROUNDS), (k) => Number(k >> WORD_BITS_BIGINT));
+const H256 = Uint32Array.from(H512, (h) => Number(h >> WORD_BITS_BIGINT));
+const K512_HIGH = Uint32Array.from(K512, (k) => Number(k >> WORD_BITS_BIGINT));
+const K512_LOW = Uint32Array.from(K512, (k) => Number(BigInt.asUintN(WORD_BITS, k)));
 const TWO_POW_32 = 4294967296;
+const BITS_PER_BYTE = 8;
+const BYTE_MODULUS = 256;
 function padBigEndian(bytes, blockBytes, lengthBytes) {
 	const paddedLength = (Math.floor((bytes.length + lengthBytes) / blockBytes) + 1) * blockBytes;
 	const padded = new Uint8Array(paddedLength);
 	padded.set(bytes);
 	padded[bytes.length] = 128;
-	let bitLength = bytes.length * 8;
+	let bitLength = bytes.length * BITS_PER_BYTE;
 	for (let i = 0; i < lengthBytes; i++) {
-		padded[paddedLength - 1 - i] = bitLength % 256;
-		bitLength = Math.floor(bitLength / 256);
+		padded[paddedLength - 1 - i] = bitLength % BYTE_MODULUS;
+		bitLength = Math.floor(bitLength / BYTE_MODULUS);
 	}
 	return padded;
 }
 function rotr32(value, bits) {
-	return (value >>> bits | value << 32 - bits) >>> 0;
+	return (value >>> bits | value << WORD_BITS - bits) >>> 0;
 }
+const SHA256_SIGMA0_ROTR_A = 7;
+const SHA256_SIGMA0_ROTR_B = 18;
+const SHA256_SIGMA0_SHR = 3;
+const SHA256_SIGMA1_ROTR_A = 17;
+const SHA256_SIGMA1_ROTR_B = 19;
+const SHA256_SIGMA1_SHR = 10;
+const SHA256_BIG_SIGMA0_ROTR_B = 13;
+const SHA256_BIG_SIGMA0_ROTR_C = 22;
+const SHA256_BIG_SIGMA1_ROTR_A = 6;
+const SHA256_BIG_SIGMA1_ROTR_B = 11;
+const SHA256_BIG_SIGMA1_ROTR_C = 25;
+const BYTES_PER_WORD = 4;
+const WORD_LAST_BYTE_OFFSET = 3;
+const SCHEDULE_OFFSET_7 = 7;
+const SCHEDULE_OFFSET_15 = 15;
+const SCHEDULE_OFFSET_16 = 16;
+const BYTE_SHIFT_1 = 8;
+const BYTE_SHIFT_2 = 16;
+const BYTE_SHIFT_3 = 24;
+const BYTE_MASK = 255;
 function sha256(bytes) {
 	const padded = padBigEndian(bytes, SHA256_BLOCK_BYTES, 8);
 	const state = Uint32Array.from(H256);
 	const w = new Uint32Array(SHA256_ROUNDS);
 	for (let offset = 0; offset < padded.length; offset += SHA256_BLOCK_BYTES) {
 		w.set(Array.from({ length: WORDS_PER_BLOCK }, (_, t) => {
-			const at = offset + t * 4;
-			return (padded[at] << 24 | padded[at + 1] << 16 | padded[at + 2] << 8 | padded[at + 3]) >>> 0;
+			const at = offset + t * BYTES_PER_WORD;
+			return (padded[at] << BYTE_SHIFT_3 | padded[at + 1] << BYTE_SHIFT_2 | padded[at + 2] << BYTE_SHIFT_1 | padded[at + WORD_LAST_BYTE_OFFSET]) >>> 0;
 		}));
 		Array.from({ length: SHA256_ROUNDS }, (_, t) => {
 			if (t < WORDS_PER_BLOCK) return;
-			const x = w[t - 15];
+			const x = w[t - SCHEDULE_OFFSET_15];
 			const y = w[t - 2];
-			const s0 = rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
-			const s1 = rotr32(y, 17) ^ rotr32(y, 19) ^ y >>> 10;
-			w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+			const s0 = rotr32(x, SHA256_SIGMA0_ROTR_A) ^ rotr32(x, SHA256_SIGMA0_ROTR_B) ^ x >>> SHA256_SIGMA0_SHR;
+			const s1 = rotr32(y, SHA256_SIGMA1_ROTR_A) ^ rotr32(y, SHA256_SIGMA1_ROTR_B) ^ y >>> SHA256_SIGMA1_SHR;
+			w[t] = w[t - SCHEDULE_OFFSET_16] + s0 + w[t - SCHEDULE_OFFSET_7] + s1 >>> 0;
 		});
 		let a = state[0];
 		let b = state[1];
@@ -152,10 +176,10 @@ function sha256(bytes) {
 		let g = state[6];
 		let h = state[7];
 		for (let t = 0; t < SHA256_ROUNDS; t++) {
-			const bigS1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+			const bigS1 = rotr32(e, SHA256_BIG_SIGMA1_ROTR_A) ^ rotr32(e, SHA256_BIG_SIGMA1_ROTR_B) ^ rotr32(e, SHA256_BIG_SIGMA1_ROTR_C);
 			const ch = e & f ^ ~e & g;
 			const t1 = h + bigS1 + (ch >>> 0) + K256[t] + w[t] >>> 0;
-			const t2 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) + ((a & b ^ a & c ^ b & c) >>> 0) >>> 0;
+			const t2 = (rotr32(a, 2) ^ rotr32(a, SHA256_BIG_SIGMA0_ROTR_B) ^ rotr32(a, SHA256_BIG_SIGMA0_ROTR_C)) + ((a & b ^ a & c ^ b & c) >>> 0) >>> 0;
 			h = g;
 			g = f;
 			f = e;
@@ -177,44 +201,67 @@ function sha256(bytes) {
 		];
 		state.set(state.map((value, i) => value + next[i] >>> 0));
 	}
-	const digest = new Uint8Array(state.length * 4);
+	const digest = new Uint8Array(state.length * BYTES_PER_WORD);
 	state.forEach((word, i) => {
-		digest[i * 4] = word >>> 24 & 255;
-		digest[i * 4 + 1] = word >>> 16 & 255;
-		digest[i * 4 + 2] = word >>> 8 & 255;
-		digest[i * 4 + 3] = word & 255;
+		digest[i * BYTES_PER_WORD] = word >>> BYTE_SHIFT_3 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 1] = word >>> BYTE_SHIFT_2 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 2] = word >>> BYTE_SHIFT_1 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + WORD_LAST_BYTE_OFFSET] = word & BYTE_MASK;
 	});
 	return digest;
 }
 function readWord32(bytes, offset) {
-	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+	return (bytes[offset] << BYTE_SHIFT_3 | bytes[offset + 1] << BYTE_SHIFT_2 | bytes[offset + 2] << BYTE_SHIFT_1 | bytes[offset + WORD_LAST_BYTE_OFFSET]) >>> 0;
 }
+const SHA512_LENGTH_FIELD_BYTES = 16;
+const BYTES_PER_WORD64 = 8;
+const SHA512_SIGMA0_ROTR_1 = 1;
+const SHA512_SIGMA0_ROTR_1_COMPLEMENT = 31;
+const SHA512_SIGMA0_ROTR_8 = 8;
+const SHA512_SIGMA0_ROTR_8_COMPLEMENT = 24;
+const SHA512_SIGMA0_SHR_7 = 7;
+const SHA512_SIGMA0_SHR_7_CARRY = 25;
+const SHA512_SIGMA1_ROTR_19 = 19;
+const SHA512_SIGMA1_ROTR_19_COMPLEMENT = 13;
+const SHA512_SIGMA1_ROTR_61_SHIFT = 29;
+const SHA512_SIGMA1_ROTR_61_COMPLEMENT = 3;
+const SHA512_SIGMA1_SHR_6 = 6;
+const SHA512_SIGMA1_SHR_6_CARRY = 26;
+const SHA512_BIG_SIGMA1_ROTR_A = 14;
+const SHA512_BIG_SIGMA1_ROTR_B = 18;
+const SHA512_BIG_SIGMA1_ROTR_41_SHIFT = 9;
+const SHA512_BIG_SIGMA1_ROTR_41_COMPLEMENT = 23;
+const SHA512_BIG_SIGMA0_ROTR_28 = 28;
+const SHA512_BIG_SIGMA0_ROTR_28_COMPLEMENT = 4;
+const SHA512_BIG_SIGMA0_ROTR_34_COMPLEMENT = 30;
+const SHA512_BIG_SIGMA0_ROTR_39_SHIFT = 7;
+const SHA512_BIG_SIGMA0_ROTR_39_COMPLEMENT = 25;
 function sha512Core(bytes, initialState, outputWords) {
-	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, 16);
-	const stateHigh = Uint32Array.from(initialState, (word) => Number(word >> 32n));
-	const stateLow = Uint32Array.from(initialState, (word) => Number(BigInt.asUintN(32, word)));
+	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, SHA512_LENGTH_FIELD_BYTES);
+	const stateHigh = Uint32Array.from(initialState, (word) => Number(word >> WORD_BITS_BIGINT));
+	const stateLow = Uint32Array.from(initialState, (word) => Number(BigInt.asUintN(WORD_BITS, word)));
 	const wHigh = new Uint32Array(SHA512_ROUNDS);
 	const wLow = new Uint32Array(SHA512_ROUNDS);
 	for (let offset = 0; offset < padded.length; offset += SHA512_BLOCK_BYTES) {
 		wHigh.forEach((_word, t) => {
 			if (t < WORDS_PER_BLOCK) {
-				const at = offset + t * 8;
+				const at = offset + t * BYTES_PER_WORD64;
 				wHigh[t] = readWord32(padded, at);
-				wLow[t] = readWord32(padded, at + 4);
+				wLow[t] = readWord32(padded, at + BYTES_PER_WORD);
 				return;
 			}
-			const xh = wHigh[t - 15];
-			const xl = wLow[t - 15];
+			const xh = wHigh[t - SCHEDULE_OFFSET_15];
+			const xl = wLow[t - SCHEDULE_OFFSET_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 s0h = (xh >>> SHA512_SIGMA0_ROTR_1 | xl << SHA512_SIGMA0_ROTR_1_COMPLEMENT) ^ (xh >>> SHA512_SIGMA0_ROTR_8 | xl << SHA512_SIGMA0_ROTR_8_COMPLEMENT) ^ xh >>> SHA512_SIGMA0_SHR_7;
+			const s0l = (xl >>> SHA512_SIGMA0_ROTR_1 | xh << SHA512_SIGMA0_ROTR_1_COMPLEMENT) ^ (xl >>> SHA512_SIGMA0_ROTR_8 | xh << SHA512_SIGMA0_ROTR_8_COMPLEMENT) ^ (xl >>> SHA512_SIGMA0_SHR_7 | xh << SHA512_SIGMA0_SHR_7_CARRY);
+			const s1h = (yh >>> SHA512_SIGMA1_ROTR_19 | yl << SHA512_SIGMA1_ROTR_19_COMPLEMENT) ^ (yl >>> SHA512_SIGMA1_ROTR_61_SHIFT | yh << SHA512_SIGMA1_ROTR_61_COMPLEMENT) ^ yh >>> SHA512_SIGMA1_SHR_6;
+			const s1l = (yl >>> SHA512_SIGMA1_ROTR_19 | yh << SHA512_SIGMA1_ROTR_19_COMPLEMENT) ^ (yh >>> SHA512_SIGMA1_ROTR_61_SHIFT | yl << SHA512_SIGMA1_ROTR_61_COMPLEMENT) ^ (yl >>> SHA512_SIGMA1_SHR_6 | yh << SHA512_SIGMA1_SHR_6_CARRY);
+			const low = wLow[t - SCHEDULE_OFFSET_16] + (s0l >>> 0) + wLow[t - SCHEDULE_OFFSET_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;
+			wHigh[t] = wHigh[t - SCHEDULE_OFFSET_16] + (s0h >>> 0) + wHigh[t - SCHEDULE_OFFSET_7] + (s1h >>> 0) + carry;
 		});
 		let ah = stateHigh[0];
 		let al = stateLow[0];
@@ -233,15 +280,15 @@ function sha512Core(bytes, initialState, outputWords) {
 		let hh = stateHigh[7];
 		let hl = stateLow[7];
 		for (let t = 0; t < SHA512_ROUNDS; t++) {
-			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 bigS1h = (eh >>> SHA512_BIG_SIGMA1_ROTR_A | el << SHA512_BIG_SIGMA1_ROTR_B) ^ (eh >>> SHA512_BIG_SIGMA1_ROTR_B | el << SHA512_BIG_SIGMA1_ROTR_A) ^ (el >>> SHA512_BIG_SIGMA1_ROTR_41_SHIFT | eh << SHA512_BIG_SIGMA1_ROTR_41_COMPLEMENT);
+			const bigS1l = (el >>> SHA512_BIG_SIGMA1_ROTR_A | eh << SHA512_BIG_SIGMA1_ROTR_B) ^ (el >>> SHA512_BIG_SIGMA1_ROTR_B | eh << SHA512_BIG_SIGMA1_ROTR_A) ^ (eh >>> SHA512_BIG_SIGMA1_ROTR_41_SHIFT | el << SHA512_BIG_SIGMA1_ROTR_41_COMPLEMENT);
 			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 bigS0h = (ah >>> SHA512_BIG_SIGMA0_ROTR_28 | al << SHA512_BIG_SIGMA0_ROTR_28_COMPLEMENT) ^ (al >>> 2 | ah << SHA512_BIG_SIGMA0_ROTR_34_COMPLEMENT) ^ (al >>> SHA512_BIG_SIGMA0_ROTR_39_SHIFT | ah << SHA512_BIG_SIGMA0_ROTR_39_COMPLEMENT);
+			const bigS0l = (al >>> SHA512_BIG_SIGMA0_ROTR_28 | ah << SHA512_BIG_SIGMA0_ROTR_28_COMPLEMENT) ^ (ah >>> 2 | al << SHA512_BIG_SIGMA0_ROTR_34_COMPLEMENT) ^ (ah >>> SHA512_BIG_SIGMA0_ROTR_39_SHIFT | al << SHA512_BIG_SIGMA0_ROTR_39_COMPLEMENT);
 			const majh = ah & bh ^ ah & ch ^ bh & ch;
 			const majl = al & bl ^ al & cl ^ bl & cl;
 			const t2Sum = (bigS0l >>> 0) + (majl >>> 0);
@@ -292,15 +339,17 @@ function sha512Core(bytes, initialState, outputWords) {
 			stateLow[i] = sum;
 		});
 	}
-	return Uint8Array.from({ length: outputWords * 8 }, (_unused, index) => {
-		return (index % 8 < 4 ? stateHigh : stateLow)[Math.floor(index / 8)] >>> 24 - 8 * (index % 4) & 255;
+	return Uint8Array.from({ length: outputWords * BYTES_PER_WORD64 }, (_unused, index) => {
+		return (index % BYTES_PER_WORD64 < BYTES_PER_WORD ? stateHigh : stateLow)[Math.floor(index / BYTES_PER_WORD64)] >>> BYTE_SHIFT_3 - BYTE_SHIFT_1 * (index % BYTES_PER_WORD) & BYTE_MASK;
 	});
 }
+const SHA512_OUTPUT_WORDS = 8;
+const SHA384_OUTPUT_WORDS = 6;
 function sha512(bytes) {
-	return sha512Core(bytes, H512, 8);
+	return sha512Core(bytes, H512, SHA512_OUTPUT_WORDS);
 }
 function sha384(bytes) {
-	return sha512Core(bytes, H384, 6);
+	return sha512Core(bytes, H384, SHA384_OUTPUT_WORDS);
 }
 //#endregion
 export { sha256, sha384, sha512 };

package/dist/embedded-font.cjs

@@ -111,6 +111,8 @@ function parseHhea(font) {
 	};
 }
 const CID_BYTE_LENGTH = 2;
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
 function encodeForShowEmbedded(text, face) {
 	const resolvedGlyphIds = [];
 	const substitutions = [];
@@ -137,8 +139,8 @@ function encodeForShowEmbedded(text, face) {
 	}
 	const codes = new Uint8Array(shownGlyphIds.length * CID_BYTE_LENGTH);
 	shownGlyphIds.forEach((glyphId, index) => {
-		codes[index * CID_BYTE_LENGTH] = glyphId >> 8 & 255;
-		codes[index * CID_BYTE_LENGTH + 1] = glyphId & 255;
+		codes[index * CID_BYTE_LENGTH] = glyphId >> BITS_PER_BYTE & BYTE_MASK;
+		codes[index * CID_BYTE_LENGTH + 1] = glyphId & BYTE_MASK;
 	});
 	return {
 		codes,

package/dist/embedded-font.js

@@ -110,6 +110,8 @@ function parseHhea(font) {
 	};
 }
 const CID_BYTE_LENGTH = 2;
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
 function encodeForShowEmbedded(text, face) {
 	const resolvedGlyphIds = [];
 	const substitutions = [];
@@ -136,8 +138,8 @@ function encodeForShowEmbedded(text, face) {
 	}
 	const codes = new Uint8Array(shownGlyphIds.length * CID_BYTE_LENGTH);
 	shownGlyphIds.forEach((glyphId, index) => {
-		codes[index * CID_BYTE_LENGTH] = glyphId >> 8 & 255;
-		codes[index * CID_BYTE_LENGTH + 1] = glyphId & 255;
+		codes[index * CID_BYTE_LENGTH] = glyphId >> BITS_PER_BYTE & BYTE_MASK;
+		codes[index * CID_BYTE_LENGTH + 1] = glyphId & BYTE_MASK;
 	});
 	return {
 		codes,

package/dist/encoding.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_afm_widths = require("./afm-widths-BYiX2L9D.cjs");
+const require_afm_widths = require("./afm-widths-BHD2HZIL.cjs");
 exports.MACROMAN_GLYPH_NAMES = require_afm_widths.MACROMAN_GLYPH_NAMES;
 exports.STANDARD_GLYPH_NAMES = require_afm_widths.STANDARD_GLYPH_NAMES;
 exports.SYMBOL_GLYPH_NAMES = require_afm_widths.SYMBOL_GLYPH_NAMES;

package/dist/encoding.js

@@ -1,2 +1,2 @@
-import { a as SYMBOL_GLYPH_NAMES, c as glyphNameToUnicode, d as standardGlyphName, f as symbolGlyphName, i as STANDARD_GLYPH_NAMES, l as macRomanGlyphName, m as zapfDingbatsGlyphName, o as WINANSI_GLYPH_NAMES, p as winAnsiGlyphName, r as MACROMAN_GLYPH_NAMES, s as ZAPFDINGBATS_GLYPH_NAMES, u as namedEncodingGlyphName } from "./afm-widths-blUDDjlI.js";
+import { a as SYMBOL_GLYPH_NAMES, c as glyphNameToUnicode, d as standardGlyphName, f as symbolGlyphName, i as STANDARD_GLYPH_NAMES, l as macRomanGlyphName, m as zapfDingbatsGlyphName, o as WINANSI_GLYPH_NAMES, p as winAnsiGlyphName, r as MACROMAN_GLYPH_NAMES, s as ZAPFDINGBATS_GLYPH_NAMES, u as namedEncodingGlyphName } from "./afm-widths-B_IGbGky.js";
 export { MACROMAN_GLYPH_NAMES, STANDARD_GLYPH_NAMES, SYMBOL_GLYPH_NAMES, WINANSI_GLYPH_NAMES, ZAPFDINGBATS_GLYPH_NAMES, glyphNameToUnicode, macRomanGlyphName, namedEncodingGlyphName, standardGlyphName, symbolGlyphName, winAnsiGlyphName, zapfDingbatsGlyphName };

package/dist/encrypt-write.cjs

@@ -15,6 +15,8 @@ var PdfEncryptionError = class extends Error {
 };
 const RC4_128_KEY_BYTES = 16;
 const R6_PASSWORD_MAX_BYTES = 127;
+const BITS_PER_BYTE = 8;
+const MAX_PERMISSION_BITS = 32;
 const RESERVED_BIT_7_AND_8 = 192;
 const DEPRECATED_ALWAYS_ONE_BIT_10 = 512;
 const SCHEME_SPECS = {
@@ -43,11 +45,12 @@ const SCHEME_SPECS = {
 		method: "aes"
 	}
 };
+const MAX_PRINTABLE_ASCII = 127;
 function legacyPasswordBytes(password) {
 	const bytes = new Uint8Array(password.length);
 	for (let i = 0; i < password.length; i++) {
 		const code = password.charCodeAt(i);
-		if (code > 127) throw new PdfEncryptionError(`password contains character code ${String(code)}, outside the printable-ASCII range this writer supports for the rc4-40/rc4-128/aes-128 schemes; use a plain-ASCII password, or the aes-256 scheme, whose revision-6 passwords are Unicode`);
+		if (code > MAX_PRINTABLE_ASCII) throw new PdfEncryptionError(`password contains character code ${String(code)}, outside the printable-ASCII range this writer supports for the rc4-40/rc4-128/aes-128 schemes; use a plain-ASCII password, or the aes-256 scheme, whose revision-6 passwords are Unicode`);
 		bytes[i] = code;
 	}
 	return bytes;
@@ -66,15 +69,16 @@ function permissionsToP(permissions) {
 	p |= DEPRECATED_ALWAYS_ONE_BIT_10;
 	if (permissions?.assemble ?? true) p |= 1024;
 	if (permissions?.printHighRes ?? true) p |= 2048;
-	for (let bit = 13; bit <= 32; bit++) p |= 1 << bit - 1;
+	for (let bit = 13; bit <= MAX_PERMISSION_BITS; bit++) p |= 1 << bit - 1;
 	return p;
 }
+const ITERATED_REVISION_MIN = 3;
 function computeLegacyOwnerValue(ownerPassword, userPassword, revision, keyBytes) {
 	let digest = require_crypto_md5.md5(require_encrypt.padOrTruncatePassword(ownerPassword));
-	if (revision >= 3) for (let i = 0; i < 50; i++) digest = require_crypto_md5.md5(digest);
+	if (revision >= ITERATED_REVISION_MIN) for (let i = 0; i < 50; i++) digest = require_crypto_md5.md5(digest);
 	const ownerKey = digest.subarray(0, keyBytes);
 	let value = require_crypto_rc4.rc4(ownerKey, require_encrypt.padOrTruncatePassword(userPassword));
-	if (revision >= 3) for (let i = 1; i <= 19; i++) {
+	if (revision >= ITERATED_REVISION_MIN) for (let i = 1; i <= 19; i++) {
 		const roundKey = Uint8Array.from(ownerKey, (byte) => byte ^ i);
 		value = require_crypto_rc4.rc4(roundKey, value);
 	}
@@ -125,9 +129,9 @@ function buildLegacyEncryptor(spec, options, fileId) {
 		["O", require_objects.pdfHexString(owner)],
 		["U", require_objects.pdfHexString(user)],
 		["P", require_objects.pdfNum(p)],
-		["Length", require_objects.pdfNum(spec.keyBytes * 8)]
+		["Length", require_objects.pdfNum(spec.keyBytes * BITS_PER_BYTE)]
 	]);
-	if (spec.v === 4) {
+	if (spec.v === SCHEME_SPECS["aes-128"].v) {
 		entries.set("CF", require_objects.pdfDict({ StdCF: require_objects.pdfDict({
 			AuthEvent: require_objects.pdfName("DocOpen"),
 			CFM: require_objects.pdfName("AESV2"),
@@ -166,21 +170,21 @@ function buildAes256Encryptor(spec, options) {
 	]);
 	const ownerIntermediateKey = require_encrypt.hardenedHash(ownerPassword, ownerKeySalt, u, spec.r);
 	const oe = require_crypto_aes.aesCbcEncrypt(ownerIntermediateKey, require_encrypt.ZERO_IV, fileKey);
+	const PERMS_P_BYTES = 4;
+	const PERMS_SIGN_EXTENSION_BYTES = new Uint8Array(PERMS_P_BYTES).fill(255);
+	const PERMS_METADATA_FLAG_OFFSET = 8;
+	const ENCRYPT_METADATA_TRUE_ASCII = 84;
+	const ENCRYPT_METADATA_FALSE_ASCII = 70;
+	const ADB_MARKER_OFFSET = 9;
+	const ADB_MARKER_BYTES = Uint8Array.from("adb", (c) => c.charCodeAt(0));
+	const PERMS_RANDOM_BYTES = 4;
+	const PERMS_RANDOM_OFFSET = ADB_MARKER_OFFSET + ADB_MARKER_BYTES.length;
 	const permsBlock = /* @__PURE__ */ new Uint8Array(16);
 	permsBlock.set(require_encrypt.permissionsBytes(p), 0);
-	permsBlock.set([
-		255,
-		255,
-		255,
-		255
-	], 4);
-	permsBlock[8] = encryptMetadata ? 84 : 70;
-	permsBlock.set([
-		97,
-		100,
-		98
-	], 9);
-	permsBlock.set(require_crypto_random.randomBytes(4), 12);
+	permsBlock.set(PERMS_SIGN_EXTENSION_BYTES, PERMS_P_BYTES);
+	permsBlock[PERMS_METADATA_FLAG_OFFSET] = encryptMetadata ? ENCRYPT_METADATA_TRUE_ASCII : ENCRYPT_METADATA_FALSE_ASCII;
+	permsBlock.set(ADB_MARKER_BYTES, ADB_MARKER_OFFSET);
+	permsBlock.set(require_crypto_random.randomBytes(PERMS_RANDOM_BYTES), PERMS_RANDOM_OFFSET);
 	const perms = require_crypto_aes.aesCbcEncrypt(fileKey, require_encrypt.ZERO_IV, permsBlock);
 	const entries = /* @__PURE__ */ new Map([
 		["Filter", require_objects.pdfName("Standard")],
@@ -192,7 +196,7 @@ function buildAes256Encryptor(spec, options) {
 		["UE", require_objects.pdfHexString(ue)],
 		["P", require_objects.pdfNum(p)],
 		["Perms", require_objects.pdfHexString(perms)],
-		["Length", require_objects.pdfNum(spec.keyBytes * 8)],
+		["Length", require_objects.pdfNum(spec.keyBytes * BITS_PER_BYTE)],
 		["CF", require_objects.pdfDict({ StdCF: require_objects.pdfDict({
 			AuthEvent: require_objects.pdfName("DocOpen"),
 			CFM: require_objects.pdfName("AESV3"),
@@ -207,7 +211,7 @@ function buildAes256Encryptor(spec, options) {
 function createStandardEncryptor(options, fileId) {
 	const scheme = options.scheme ?? "aes-256";
 	const spec = SCHEME_SPECS[scheme];
-	return spec.v === 5 ? buildAes256Encryptor(spec, options) : buildLegacyEncryptor(spec, options, fileId);
+	return spec.v === SCHEME_SPECS["aes-256"].v ? buildAes256Encryptor(spec, options) : buildLegacyEncryptor(spec, options, fileId);
 }
 function encryptIndirectObject(value, num, gen, encryptor) {
 	if (value.kind === "string") return {