pdf-parser.js 5.2.26 → 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/document.cjs

@@ -154,19 +154,22 @@ function openPdfDocument(bytes, sink) {
 	function pages() {
 		const pagesRoot = resolveDict(require_objects.dictGet(catalog, "Pages"));
 		if (pagesRoot === void 0) return [];
-		const result = [];
 		originalLeaves.clear();
-		walkPageTree(pagesRoot, {}, /* @__PURE__ */ new Set(), result);
+		const result = [];
+		for (const leaf of walkPageTree(pagesRoot, {}, /* @__PURE__ */ new Set())) {
+			originalLeaves.set(leaf.node, result.length);
+			result.push(leaf.page);
+		}
 		return result;
 	}
-	function walkPageTree(node, inherited, visited, result) {
+	function walkPageTree(node, inherited, visited) {
 		if (visited.has(node)) {
 			sink({
 				code: "pdf/page-tree-cycle",
 				severity: "warning",
 				message: "the page tree contains a cycle; stopping descent at the repeated node"
 			});
-			return;
+			return [];
 		}
 		visited.add(node);
 		const merged = { ...inherited };
@@ -178,17 +181,20 @@ function openPdfDocument(bytes, sink) {
 		if (kids === void 0) {
 			const entries = new Map(node.entries);
 			for (const key of INHERITABLE_PAGE_KEYS) if (!entries.has(key) && merged[key] !== void 0) entries.set(key, merged[key]);
-			originalLeaves.set(node, result.length);
-			result.push({
-				kind: "dict",
-				entries
-			});
-			return;
+			return [{
+				node,
+				page: {
+					kind: "dict",
+					entries
+				}
+			}];
 		}
+		const leaves = [];
 		for (const kid of kids) {
 			const kidDict = resolveDict(kid);
-			if (kidDict !== void 0) walkPageTree(kidDict, merged, visited, result);
+			if (kidDict !== void 0) for (const leaf of walkPageTree(kidDict, merged, visited)) leaves.push(leaf);
 		}
+		return leaves;
 	}
 	function pageIndex(obj) {
 		const dict = require_objects.asDict(resolve(obj));

package/dist/document.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.cjs";
 //#region src/document.d.ts
 interface PdfDocument {
   readonly trailer: PdfDict;

package/dist/document.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.js";
 //#region src/document.d.ts
 interface PdfDocument {
   readonly trailer: PdfDict;

package/dist/document.js

@@ -153,19 +153,22 @@ function openPdfDocument(bytes, sink) {
 	function pages() {
 		const pagesRoot = resolveDict(dictGet(catalog, "Pages"));
 		if (pagesRoot === void 0) return [];
-		const result = [];
 		originalLeaves.clear();
-		walkPageTree(pagesRoot, {}, /* @__PURE__ */ new Set(), result);
+		const result = [];
+		for (const leaf of walkPageTree(pagesRoot, {}, /* @__PURE__ */ new Set())) {
+			originalLeaves.set(leaf.node, result.length);
+			result.push(leaf.page);
+		}
 		return result;
 	}
-	function walkPageTree(node, inherited, visited, result) {
+	function walkPageTree(node, inherited, visited) {
 		if (visited.has(node)) {
 			sink({
 				code: "pdf/page-tree-cycle",
 				severity: "warning",
 				message: "the page tree contains a cycle; stopping descent at the repeated node"
 			});
-			return;
+			return [];
 		}
 		visited.add(node);
 		const merged = { ...inherited };
@@ -177,17 +180,20 @@ function openPdfDocument(bytes, sink) {
 		if (kids === void 0) {
 			const entries = new Map(node.entries);
 			for (const key of INHERITABLE_PAGE_KEYS) if (!entries.has(key) && merged[key] !== void 0) entries.set(key, merged[key]);
-			originalLeaves.set(node, result.length);
-			result.push({
-				kind: "dict",
-				entries
-			});
-			return;
+			return [{
+				node,
+				page: {
+					kind: "dict",
+					entries
+				}
+			}];
 		}
+		const leaves = [];
 		for (const kid of kids) {
 			const kidDict = resolveDict(kid);
-			if (kidDict !== void 0) walkPageTree(kidDict, merged, visited, result);
+			if (kidDict !== void 0) for (const leaf of walkPageTree(kidDict, merged, visited)) leaves.push(leaf);
 		}
+		return leaves;
 	}
 	function pageIndex(obj) {
 		const dict = asDict(resolve(obj));

package/dist/{embedded-font-Bnhh4juV.d.ts → embedded-font-ByD7ZiQS.d.ts}

@@ -45,6 +45,6 @@ interface EmbeddedShow {
   readonly kerns: readonly EmbeddedKern[];
 }
 declare function encodeForShowEmbedded(text: string, face: EmbeddedFace): EmbeddedShow;
-declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, readonly number[]>;
+declare function collectEmbeddedGlyphs(texts: Readonly<Iterable<string>>, face: EmbeddedFace): ReadonlyMap<number, readonly number[]>;
 //#endregion
 export { EmbeddedShow as a, encodeForShowEmbedded as c, EmbeddedKern as i, loadEmbeddedFace as l, EmbeddedFaceMetrics as n, NOTDEF_GLYPH_ID as o, EmbeddedFaceSubstitution as r, collectEmbeddedGlyphs as s, EmbeddedFace as t };

package/dist/{embedded-font-CEf-zBCA.d.cts → embedded-font-DgVBedw6.d.cts}

@@ -45,6 +45,6 @@ interface EmbeddedShow {
   readonly kerns: readonly EmbeddedKern[];
 }
 declare function encodeForShowEmbedded(text: string, face: EmbeddedFace): EmbeddedShow;
-declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, readonly number[]>;
+declare function collectEmbeddedGlyphs(texts: Readonly<Iterable<string>>, face: EmbeddedFace): ReadonlyMap<number, readonly number[]>;
 //#endregion
 export { EmbeddedShow as a, encodeForShowEmbedded as c, EmbeddedKern as i, loadEmbeddedFace as l, EmbeddedFaceMetrics as n, NOTDEF_GLYPH_ID as o, EmbeddedFaceSubstitution as r, collectEmbeddedGlyphs as s, EmbeddedFace as t };

package/dist/embedded-font-write.d.cts

@@ -1,5 +1,5 @@
-import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
-import { t as EmbeddedFace } from "./embedded-font-CEf-zBCA.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.cjs";
+import { t as EmbeddedFace } from "./embedded-font-DgVBedw6.cjs";
 import { SfntSubsetResult } from "./sfnt-subset.cjs";
 //#region src/embedded-font-write.d.ts
 declare function embeddedSubsetTag(postScriptName: string, glyphIds: readonly number[]): string;

package/dist/embedded-font-write.d.ts

@@ -1,5 +1,5 @@
-import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
-import { t as EmbeddedFace } from "./embedded-font-Bnhh4juV.js";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.js";
+import { t as EmbeddedFace } from "./embedded-font-ByD7ZiQS.js";
 import { SfntSubsetResult } from "./sfnt-subset.js";
 //#region src/embedded-font-write.d.ts
 declare function embeddedSubsetTag(postScriptName: string, glyphIds: readonly number[]): string;

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.d.cts

@@ -1,2 +1,2 @@
-import { a as EmbeddedShow, c as encodeForShowEmbedded, i as EmbeddedKern, l as loadEmbeddedFace, n as EmbeddedFaceMetrics, o as NOTDEF_GLYPH_ID, r as EmbeddedFaceSubstitution, s as collectEmbeddedGlyphs, t as EmbeddedFace } from "./embedded-font-CEf-zBCA.cjs";
+import { a as EmbeddedShow, c as encodeForShowEmbedded, i as EmbeddedKern, l as loadEmbeddedFace, n as EmbeddedFaceMetrics, o as NOTDEF_GLYPH_ID, r as EmbeddedFaceSubstitution, s as collectEmbeddedGlyphs, t as EmbeddedFace } from "./embedded-font-DgVBedw6.cjs";
 export { EmbeddedFace, EmbeddedFaceMetrics, EmbeddedFaceSubstitution, EmbeddedKern, EmbeddedShow, NOTDEF_GLYPH_ID, collectEmbeddedGlyphs, encodeForShowEmbedded, loadEmbeddedFace };