pdf-parser.js 5.2.27 → 5.2.28

package/dist/crypto/md5.js

@@ -3,137 +3,333 @@ const BLOCK_BYTES = 64;
 const DIGEST_BYTES = 16;
 const ROUNDS = 64;
 const WORDS_PER_BLOCK = 16;
-const T = new Uint32Array([
-	3614090360,
-	3905402710,
-	606105819,
-	3250441966,
-	4118548399,
-	1200080426,
-	2821735955,
-	4249261313,
-	1770035416,
-	2336552879,
-	4294925233,
-	2304563134,
-	1804603682,
-	4254626195,
-	2792965006,
-	1236535329,
-	4129170786,
-	3225465664,
-	643717713,
-	3921069994,
-	3593408605,
-	38016083,
-	3634488961,
-	3889429448,
-	568446438,
-	3275163606,
-	4107603335,
-	1163531501,
-	2850285829,
-	4243563512,
-	1735328473,
-	2368359562,
-	4294588738,
-	2272392833,
-	1839030562,
-	4259657740,
-	2763975236,
-	1272893353,
-	4139469664,
-	3200236656,
-	681279174,
-	3936430074,
-	3572445317,
-	76029189,
-	3654602809,
-	3873151461,
-	530742520,
-	3299628645,
-	4096336452,
-	1126891415,
-	2878612391,
-	4237533241,
-	1700485571,
-	2399980690,
-	4293915773,
-	2240044497,
-	1873313359,
-	4264355552,
-	2734768916,
-	1309151649,
-	4149444226,
-	3174756917,
-	718787259,
-	3951481745
-]);
+const STEPS_PER_ROUND = 16;
+const BITS_PER_BYTE = 8;
+const BYTES_PER_WORD = 4;
+const BYTE_MASK = 255;
+const WORD_BITS = 32;
+const UINT32_MODULUS = 4294967296;
+const LENGTH_FIELD_BYTES = 8;
+const ROUND_2_G_MULTIPLIER = 5;
+const ROUND_3_G_MULTIPLIER = 3;
+const ROUND_3_G_OFFSET = 5;
+const ROUND_4_G_MULTIPLIER = 7;
+const ROUND_4_START = 48;
+const T = Uint32Array.from([
+	{
+		i: 1,
+		value: 3614090360
+	},
+	{
+		i: 2,
+		value: 3905402710
+	},
+	{
+		i: 3,
+		value: 606105819
+	},
+	{
+		i: 4,
+		value: 3250441966
+	},
+	{
+		i: 5,
+		value: 4118548399
+	},
+	{
+		i: 6,
+		value: 1200080426
+	},
+	{
+		i: 7,
+		value: 2821735955
+	},
+	{
+		i: 8,
+		value: 4249261313
+	},
+	{
+		i: 9,
+		value: 1770035416
+	},
+	{
+		i: 10,
+		value: 2336552879
+	},
+	{
+		i: 11,
+		value: 4294925233
+	},
+	{
+		i: 12,
+		value: 2304563134
+	},
+	{
+		i: 13,
+		value: 1804603682
+	},
+	{
+		i: 14,
+		value: 4254626195
+	},
+	{
+		i: 15,
+		value: 2792965006
+	},
+	{
+		i: 16,
+		value: 1236535329
+	},
+	{
+		i: 17,
+		value: 4129170786
+	},
+	{
+		i: 18,
+		value: 3225465664
+	},
+	{
+		i: 19,
+		value: 643717713
+	},
+	{
+		i: 20,
+		value: 3921069994
+	},
+	{
+		i: 21,
+		value: 3593408605
+	},
+	{
+		i: 22,
+		value: 38016083
+	},
+	{
+		i: 23,
+		value: 3634488961
+	},
+	{
+		i: 24,
+		value: 3889429448
+	},
+	{
+		i: 25,
+		value: 568446438
+	},
+	{
+		i: 26,
+		value: 3275163606
+	},
+	{
+		i: 27,
+		value: 4107603335
+	},
+	{
+		i: 28,
+		value: 1163531501
+	},
+	{
+		i: 29,
+		value: 2850285829
+	},
+	{
+		i: 30,
+		value: 4243563512
+	},
+	{
+		i: 31,
+		value: 1735328473
+	},
+	{
+		i: 32,
+		value: 2368359562
+	},
+	{
+		i: 33,
+		value: 4294588738
+	},
+	{
+		i: 34,
+		value: 2272392833
+	},
+	{
+		i: 35,
+		value: 1839030562
+	},
+	{
+		i: 36,
+		value: 4259657740
+	},
+	{
+		i: 37,
+		value: 2763975236
+	},
+	{
+		i: 38,
+		value: 1272893353
+	},
+	{
+		i: 39,
+		value: 4139469664
+	},
+	{
+		i: 40,
+		value: 3200236656
+	},
+	{
+		i: 41,
+		value: 681279174
+	},
+	{
+		i: 42,
+		value: 3936430074
+	},
+	{
+		i: 43,
+		value: 3572445317
+	},
+	{
+		i: 44,
+		value: 76029189
+	},
+	{
+		i: 45,
+		value: 3654602809
+	},
+	{
+		i: 46,
+		value: 3873151461
+	},
+	{
+		i: 47,
+		value: 530742520
+	},
+	{
+		i: 48,
+		value: 3299628645
+	},
+	{
+		i: 49,
+		value: 4096336452
+	},
+	{
+		i: 50,
+		value: 1126891415
+	},
+	{
+		i: 51,
+		value: 2878612391
+	},
+	{
+		i: 52,
+		value: 4237533241
+	},
+	{
+		i: 53,
+		value: 1700485571
+	},
+	{
+		i: 54,
+		value: 2399980690
+	},
+	{
+		i: 55,
+		value: 4293915773
+	},
+	{
+		i: 56,
+		value: 2240044497
+	},
+	{
+		i: 57,
+		value: 1873313359
+	},
+	{
+		i: 58,
+		value: 4264355552
+	},
+	{
+		i: 59,
+		value: 2734768916
+	},
+	{
+		i: 60,
+		value: 1309151649
+	},
+	{
+		i: 61,
+		value: 4149444226
+	},
+	{
+		i: 62,
+		value: 3174756917
+	},
+	{
+		i: 63,
+		value: 718787259
+	},
+	{
+		i: 64,
+		value: 3951481745
+	}
+], (entry) => entry.value);
+const S11 = 7;
+const S12 = 12;
+const S13 = 17;
+const S14 = 22;
+const S21 = 5;
+const S22 = 9;
+const S23 = 14;
+const S24 = 20;
+const S31 = 4;
+const S32 = 11;
+const S33 = 16;
+const S34 = 23;
+const S41 = 6;
+const S42 = 10;
+const S43 = 15;
+const S44 = 21;
+const ROUND_1_SHIFTS = [
+	S11,
+	S12,
+	S13,
+	S14
+];
+const ROUND_2_SHIFTS = [
+	S21,
+	S22,
+	S23,
+	S24
+];
+const ROUND_3_SHIFTS = [
+	S31,
+	S32,
+	S33,
+	S34
+];
+const ROUND_4_SHIFTS = [
+	S41,
+	S42,
+	S43,
+	S44
+];
 const SHIFT = [
-	7,
-	12,
-	17,
-	22,
-	7,
-	12,
-	17,
-	22,
-	7,
-	12,
-	17,
-	22,
-	7,
-	12,
-	17,
-	22,
-	5,
-	9,
-	14,
-	20,
-	5,
-	9,
-	14,
-	20,
-	5,
-	9,
-	14,
-	20,
-	5,
-	9,
-	14,
-	20,
-	4,
-	11,
-	16,
-	23,
-	4,
-	11,
-	16,
-	23,
-	4,
-	11,
-	16,
-	23,
-	4,
-	11,
-	16,
-	23,
-	6,
-	10,
-	15,
-	21,
-	6,
-	10,
-	15,
-	21,
-	6,
-	10,
-	15,
-	21,
-	6,
-	10,
-	15,
-	21
+	...ROUND_1_SHIFTS,
+	...ROUND_1_SHIFTS,
+	...ROUND_1_SHIFTS,
+	...ROUND_1_SHIFTS,
+	...ROUND_2_SHIFTS,
+	...ROUND_2_SHIFTS,
+	...ROUND_2_SHIFTS,
+	...ROUND_2_SHIFTS,
+	...ROUND_3_SHIFTS,
+	...ROUND_3_SHIFTS,
+	...ROUND_3_SHIFTS,
+	...ROUND_3_SHIFTS,
+	...ROUND_4_SHIFTS,
+	...ROUND_4_SHIFTS,
+	...ROUND_4_SHIFTS,
+	...ROUND_4_SHIFTS
 ];
 const INITIAL_STATE = [
 	1732584193,
@@ -142,20 +338,20 @@ const INITIAL_STATE = [
 	271733878
 ];
 function rotl32(value, bits) {
-	return (value << bits | value >>> 32 - bits) >>> 0;
+	return (value << bits | value >>> WORD_BITS - bits) >>> 0;
 }
 function padMessage(bytes) {
-	const paddedLength = (Math.floor((bytes.length + 8) / BLOCK_BYTES) + 1) * BLOCK_BYTES;
+	const paddedLength = (Math.floor((bytes.length + LENGTH_FIELD_BYTES) / BLOCK_BYTES) + 1) * BLOCK_BYTES;
 	const padded = new Uint8Array(paddedLength);
 	padded.set(bytes);
 	padded[bytes.length] = 128;
-	const bitLength = bytes.length * 8;
-	let low = bitLength % 4294967296;
-	let high = Math.floor(bitLength / 4294967296);
-	for (let i = 0; i < 4; i++) {
-		padded[paddedLength - 8 + i] = low & 255;
+	const bitLength = bytes.length * BITS_PER_BYTE;
+	let low = bitLength % UINT32_MODULUS;
+	let high = Math.floor(bitLength / UINT32_MODULUS);
+	for (let i = 0; i < BYTES_PER_WORD; i++) {
+		padded[paddedLength - LENGTH_FIELD_BYTES + i] = low & BYTE_MASK;
 		low = Math.floor(low / 256);
-		padded[paddedLength - 4 + i] = high & 255;
+		padded[paddedLength - BYTES_PER_WORD + i] = high & BYTE_MASK;
 		high = Math.floor(high / 256);
 	}
 	return padded;
@@ -166,8 +362,8 @@ function md5(bytes) {
 	const block = new Uint32Array(WORDS_PER_BLOCK);
 	for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) {
 		for (let i = 0; i < WORDS_PER_BLOCK; i++) {
-			const at = offset + i * 4;
-			block[i] = (padded[at] | padded[at + 1] << 8 | padded[at + 2] << 16 | padded[at + 3] << 24) >>> 0;
+			const at = offset + i * BYTES_PER_WORD;
+			block[i] = (padded[at] | padded[at + 1] << BITS_PER_BYTE | padded[at + 2] << 16 | padded[at + 3] << 24) >>> 0;
 		}
 		let a = state[0];
 		let b = state[1];
@@ -176,18 +372,18 @@ function md5(bytes) {
 		for (let i = 0; i < ROUNDS; i++) {
 			let f;
 			let g;
-			if (i < 16) {
+			if (i < STEPS_PER_ROUND) {
 				f = b & c | ~b & d;
 				g = i;
 			} else if (i < 32) {
 				f = d & b | ~d & c;
-				g = (5 * i + 1) % WORDS_PER_BLOCK;
-			} else if (i < 48) {
+				g = (ROUND_2_G_MULTIPLIER * i + 1) % WORDS_PER_BLOCK;
+			} else if (i < ROUND_4_START) {
 				f = b ^ c ^ d;
-				g = (3 * i + 5) % WORDS_PER_BLOCK;
+				g = (ROUND_3_G_MULTIPLIER * i + ROUND_3_G_OFFSET) % WORDS_PER_BLOCK;
 			} else {
 				f = c ^ (b | ~d);
-				g = 7 * i % WORDS_PER_BLOCK;
+				g = ROUND_4_G_MULTIPLIER * i % WORDS_PER_BLOCK;
 			}
 			const rotated = rotl32(a + (f >>> 0) + T[i] + block[g] >>> 0, SHIFT[i]);
 			a = d;
@@ -203,10 +399,10 @@ function md5(bytes) {
 	const digest = new Uint8Array(DIGEST_BYTES);
 	for (let i = 0; i < state.length; i++) {
 		const word = state[i];
-		digest[i * 4] = word & 255;
-		digest[i * 4 + 1] = word >>> 8 & 255;
-		digest[i * 4 + 2] = word >>> 16 & 255;
-		digest[i * 4 + 3] = word >>> 24 & 255;
+		digest[i * BYTES_PER_WORD] = word & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 1] = word >>> BITS_PER_BYTE & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 2] = word >>> 16 & BYTE_MASK;
+		digest[i * BYTES_PER_WORD + 3] = word >>> 24 & BYTE_MASK;
 	}
 	return digest;
 }

package/dist/crypto/rc4.cjs

@@ -1,12 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/crypto/rc4.ts
 const STATE_SIZE = 256;
+const STATE_INDEX_MASK = 255;
 function rc4(key, data) {
 	const state = Uint8Array.from({ length: STATE_SIZE }, (_, i) => i);
 	if (key.length === 0) return Uint8Array.from(data);
 	let j = 0;
 	for (let i = 0; i < STATE_SIZE; i++) {
-		j = j + state[i] + key[i % key.length] & 255;
+		j = j + state[i] + key[i % key.length] & STATE_INDEX_MASK;
 		const swap = state[i];
 		state[i] = state[j];
 		state[j] = swap;
@@ -15,12 +16,12 @@ function rc4(key, data) {
 	let x = 0;
 	let y = 0;
 	data.forEach((byte, n) => {
-		x = x + 1 & 255;
-		y = y + state[x] & 255;
+		x = x + 1 & STATE_INDEX_MASK;
+		y = y + state[x] & STATE_INDEX_MASK;
 		const swap = state[x];
 		state[x] = state[y];
 		state[y] = swap;
-		out[n] = byte ^ state[state[x] + state[y] & 255];
+		out[n] = byte ^ state[state[x] + state[y] & STATE_INDEX_MASK];
 	});
 	return out;
 }

package/dist/crypto/rc4.js

@@ -1,11 +1,12 @@
 //#region src/crypto/rc4.ts
 const STATE_SIZE = 256;
+const STATE_INDEX_MASK = 255;
 function rc4(key, data) {
 	const state = Uint8Array.from({ length: STATE_SIZE }, (_, i) => i);
 	if (key.length === 0) return Uint8Array.from(data);
 	let j = 0;
 	for (let i = 0; i < STATE_SIZE; i++) {
-		j = j + state[i] + key[i % key.length] & 255;
+		j = j + state[i] + key[i % key.length] & STATE_INDEX_MASK;
 		const swap = state[i];
 		state[i] = state[j];
 		state[j] = swap;
@@ -14,12 +15,12 @@ function rc4(key, data) {
 	let x = 0;
 	let y = 0;
 	data.forEach((byte, n) => {
-		x = x + 1 & 255;
-		y = y + state[x] & 255;
+		x = x + 1 & STATE_INDEX_MASK;
+		y = y + state[x] & STATE_INDEX_MASK;
 		const swap = state[x];
 		state[x] = state[y];
 		state[y] = swap;
-		out[n] = byte ^ state[state[x] + state[y] & 255];
+		out[n] = byte ^ state[state[x] + state[y] & STATE_INDEX_MASK];
 	});
 	return out;
 }