pdf-codec 1.4.2 → 1.6.0

package/dist/crypto/md5.js

@@ -0,0 +1,214 @@
+//#region src/crypto/md5.ts
+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 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
+];
+const INITIAL_STATE = [
+	1732584193,
+	4023233417,
+	2562383102,
+	271733878
+];
+function rotl32(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function padMessage(bytes) {
+	const paddedLength = (Math.floor((bytes.length + 8) / 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;
+		low = Math.floor(low / 256);
+		padded[paddedLength - 4 + i] = high & 255;
+		high = Math.floor(high / 256);
+	}
+	return padded;
+}
+function md5(bytes) {
+	const padded = padMessage(bytes);
+	const state = Int32Array.from(INITIAL_STATE);
+	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;
+		}
+		let a = state[0];
+		let b = state[1];
+		let c = state[2];
+		let d = state[3];
+		for (let i = 0; i < ROUNDS; i++) {
+			let f;
+			let g;
+			if (i < 16) {
+				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) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % WORDS_PER_BLOCK;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % WORDS_PER_BLOCK;
+			}
+			const rotated = rotl32(a + (f >>> 0) + T[i] + block[g] >>> 0, SHIFT[i]);
+			a = d;
+			d = c;
+			c = b;
+			b = b + rotated >>> 0;
+		}
+		state[0] = state[0] + a | 0;
+		state[1] = state[1] + b | 0;
+		state[2] = state[2] + c | 0;
+		state[3] = state[3] + d | 0;
+	}
+	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;
+	}
+	return digest;
+}
+//#endregion
+export { md5 };

package/dist/crypto/rc4.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/rc4.ts
+const STATE_SIZE = 256;
+function rc4(key, data) {
+	const state = new Uint8Array(STATE_SIZE);
+	for (let i = 0; i < STATE_SIZE; i++) state[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;
+		const swap = state[i];
+		state[i] = state[j];
+		state[j] = swap;
+	}
+	const out = new Uint8Array(data.length);
+	let x = 0;
+	let y = 0;
+	for (let n = 0; n < data.length; n++) {
+		x = x + 1 & 255;
+		y = y + state[x] & 255;
+		const swap = state[x];
+		state[x] = state[y];
+		state[y] = swap;
+		out[n] = data[n] ^ state[state[x] + state[y] & 255];
+	}
+	return out;
+}
+//#endregion
+exports.rc4 = rc4;

package/dist/crypto/rc4.d.cts

@@ -0,0 +1,4 @@
+//#region src/crypto/rc4.d.ts
+declare function rc4(key: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { rc4 };

package/dist/crypto/rc4.d.ts

@@ -0,0 +1,4 @@
+//#region src/crypto/rc4.d.ts
+declare function rc4(key: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { rc4 };

package/dist/crypto/rc4.js

@@ -0,0 +1,28 @@
+//#region src/crypto/rc4.ts
+const STATE_SIZE = 256;
+function rc4(key, data) {
+	const state = new Uint8Array(STATE_SIZE);
+	for (let i = 0; i < STATE_SIZE; i++) state[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;
+		const swap = state[i];
+		state[i] = state[j];
+		state[j] = swap;
+	}
+	const out = new Uint8Array(data.length);
+	let x = 0;
+	let y = 0;
+	for (let n = 0; n < data.length; n++) {
+		x = x + 1 & 255;
+		y = y + state[x] & 255;
+		const swap = state[x];
+		state[x] = state[y];
+		state[y] = swap;
+		out[n] = data[n] ^ state[state[x] + state[y] & 255];
+	}
+	return out;
+}
+//#endregion
+export { rc4 };

package/dist/crypto/sha2.cjs

@@ -0,0 +1,261 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/sha2.ts
+const SHA256_BLOCK_BYTES = 64;
+const SHA256_ROUNDS = 64;
+const SHA512_BLOCK_BYTES = 128;
+const SHA512_ROUNDS = 80;
+const WORDS_PER_BLOCK = 16;
+const MASK64 = 18446744073709551615n;
+const K512 = [
+	4794697086780616226n,
+	8158064640168781261n,
+	13096744586834688815n,
+	16840607885511220156n,
+	4131703408338449720n,
+	6480981068601479193n,
+	10538285296894168987n,
+	12329834152419229976n,
+	15566598209576043074n,
+	1334009975649890238n,
+	2608012711638119052n,
+	6128411473006802146n,
+	8268148722764581231n,
+	9286055187155687089n,
+	11230858885718282805n,
+	13951009754708518548n,
+	16472876342353939154n,
+	17275323862435702243n,
+	1135362057144423861n,
+	2597628984639134821n,
+	3308224258029322869n,
+	5365058923640841347n,
+	6679025012923562964n,
+	8573033837759648693n,
+	10970295158949994411n,
+	12119686244451234320n,
+	12683024718118986047n,
+	13788192230050041572n,
+	14330467153632333762n,
+	15395433587784984357n,
+	489312712824947311n,
+	1452737877330783856n,
+	2861767655752347644n,
+	3322285676063803686n,
+	5560940570517711597n,
+	5996557281743188959n,
+	7280758554555802590n,
+	8532644243296465576n,
+	9350256976987008742n,
+	10552545826968843579n,
+	11727347734174303076n,
+	12113106623233404929n,
+	14000437183269869457n,
+	14369950271660146224n,
+	15101387698204529176n,
+	15463397548674623760n,
+	17586052441742319658n,
+	1182934255886127544n,
+	1847814050463011016n,
+	2177327727835720531n,
+	2830643537854262169n,
+	3796741975233480872n,
+	4115178125766777443n,
+	5681478168544905931n,
+	6601373596472566643n,
+	7507060721942968483n,
+	8399075790359081724n,
+	8693463985226723168n,
+	9568029438360202098n,
+	10144078919501101548n,
+	10430055236837252648n,
+	11840083180663258601n,
+	13761210420658862357n,
+	14299343276471374635n,
+	14566680578165727644n,
+	15097957966210449927n,
+	16922976911328602910n,
+	17689382322260857208n,
+	500013540394364858n,
+	748580250866718886n,
+	1242879168328830382n,
+	1977374033974150939n,
+	2944078676154940804n,
+	3659926193048069267n,
+	4368137639120453308n,
+	4836135668995329356n,
+	5532061633213252278n,
+	6448918945643986474n,
+	6902733635092675308n,
+	7801388544844847127n
+];
+const H512 = [
+	7640891576956012808n,
+	13503953896175478587n,
+	4354685564936845355n,
+	11912009170470909681n,
+	5840696475078001361n,
+	11170449401992604703n,
+	2270897969802886507n,
+	6620516959819538809n
+];
+const H384 = [
+	14680500436340154072n,
+	7105036623409894663n,
+	10473403895298186519n,
+	1526699215303891257n,
+	7436329637833083697n,
+	10282925794625328401n,
+	15784041429090275239n,
+	5167115440072839076n
+];
+const K256 = Uint32Array.from(K512.slice(0, SHA256_ROUNDS), (k) => Number(k >> 32n));
+const H256 = Uint32Array.from(H512, (h) => Number(h >> 32n));
+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;
+	for (let i = 0; i < lengthBytes && bitLength > 0; i++) {
+		padded[paddedLength - 1 - i] = bitLength % 256;
+		bitLength = Math.floor(bitLength / 256);
+	}
+	return padded;
+}
+function rotr32(value, bits) {
+	return (value >>> bits | value << 32 - bits) >>> 0;
+}
+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) {
+		for (let t = 0; t < WORDS_PER_BLOCK; t++) {
+			const at = offset + t * 4;
+			w[t] = (padded[at] << 24 | padded[at + 1] << 16 | padded[at + 2] << 8 | padded[at + 3]) >>> 0;
+		}
+		for (let t = WORDS_PER_BLOCK; t < SHA256_ROUNDS; t++) {
+			const x = w[t - 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;
+		}
+		let a = state[0];
+		let b = state[1];
+		let c = state[2];
+		let d = state[3];
+		let e = state[4];
+		let f = state[5];
+		let g = state[6];
+		let h = state[7];
+		for (let t = 0; t < SHA256_ROUNDS; t++) {
+			const bigS1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+			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;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		const next = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f,
+			g,
+			h
+		];
+		for (let i = 0; i < state.length; i++) state[i] = state[i] + next[i] >>> 0;
+	}
+	const digest = new Uint8Array(state.length * 4);
+	for (let i = 0; i < state.length; i++) {
+		const word = state[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;
+	}
+	return digest;
+}
+function rotr64(value, bits) {
+	return (value >> bits | value << 64n - bits) & MASK64;
+}
+function sha512Core(bytes, initialState, outputWords) {
+	const padded = padBigEndian(bytes, SHA512_BLOCK_BYTES, 16);
+	const state = Array.from(initialState);
+	const w = new Array(SHA512_ROUNDS).fill(0n);
+	for (let offset = 0; offset < padded.length; offset += SHA512_BLOCK_BYTES) {
+		for (let t = 0; t < WORDS_PER_BLOCK; t++) {
+			let word = 0n;
+			for (let i = 0; i < 8; i++) word = word << 8n | BigInt(padded[offset + t * 8 + i]);
+			w[t] = word;
+		}
+		for (let t = WORDS_PER_BLOCK; t < SHA512_ROUNDS; t++) {
+			const x = w[t - 15];
+			const y = w[t - 2];
+			const s0 = rotr64(x, 1n) ^ rotr64(x, 8n) ^ x >> 7n;
+			const s1 = rotr64(y, 19n) ^ rotr64(y, 61n) ^ y >> 6n;
+			w[t] = w[t - 16] + s0 + w[t - 7] + s1 & MASK64;
+		}
+		let a = state[0];
+		let b = state[1];
+		let c = state[2];
+		let d = state[3];
+		let e = state[4];
+		let f = state[5];
+		let g = state[6];
+		let h = state[7];
+		for (let t = 0; t < SHA512_ROUNDS; t++) {
+			const bigS1 = rotr64(e, 14n) ^ rotr64(e, 18n) ^ rotr64(e, 41n);
+			const ch = e & f ^ ~e & MASK64 & g;
+			const t1 = h + bigS1 + ch + K512[t] + w[t] & MASK64;
+			const t2 = (rotr64(a, 28n) ^ rotr64(a, 34n) ^ rotr64(a, 39n)) + (a & b ^ a & c ^ b & c) & MASK64;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 & MASK64;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 & MASK64;
+		}
+		const next = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f,
+			g,
+			h
+		];
+		for (let i = 0; i < state.length; i++) state[i] = state[i] + next[i] & MASK64;
+	}
+	const digest = new Uint8Array(outputWords * 8);
+	for (let i = 0; i < outputWords; i++) {
+		let word = state[i];
+		for (let j = 7; j >= 0; j--) {
+			digest[i * 8 + j] = Number(word & 255n);
+			word >>= 8n;
+		}
+	}
+	return digest;
+}
+function sha512(bytes) {
+	return sha512Core(bytes, H512, 8);
+}
+function sha384(bytes) {
+	return sha512Core(bytes, H384, 6);
+}
+//#endregion
+exports.sha256 = sha256;
+exports.sha384 = sha384;
+exports.sha512 = sha512;

package/dist/crypto/sha2.d.cts

@@ -0,0 +1,6 @@
+//#region src/crypto/sha2.d.ts
+declare function sha256(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function sha512(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function sha384(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { sha256, sha384, sha512 };

package/dist/crypto/sha2.d.ts

@@ -0,0 +1,6 @@
+//#region src/crypto/sha2.d.ts
+declare function sha256(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function sha512(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function sha384(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { sha256, sha384, sha512 };