@zip.js/zip.js 2.14.0 → 2.15.0

package/dist/zip-fs-core.js

@@ -736,7 +736,7 @@
 	const ROUND_KEYS_LENGTH = 60;
 	const SHA1_BLOCK_LENGTH = 64;
 	const SHA1_DIGEST_LENGTH = 20;
-	const SHA1_SCHEDULE_LENGTH = 80;
+	const SHA1_SCHEDULE_LENGTH = 16;
 	const SHA1_LENGTH_OFFSET = 56;
 	const SHA1_PADDING = new Uint8Array([0x80]);
 	const SHA1_ZERO = new Uint8Array(1);
@@ -755,9 +755,12 @@
 		initTables();
 		const roundKeys = new Int32Array(ROUND_KEYS_LENGTH);
 		const rounds = expandKey(key, roundKeys);
-		const counter = new Uint8Array(BLOCK_LENGTH$1);
 		const keystream = new Int32Array(BLOCK_LENGTH$1 / 4);
 		const hmac = createHmac(authenticationKey);
+		let counter0 = 0;
+		let counter1 = 0;
+		let counter2 = 0;
+		let counter3 = 0;
 		return {
 			process(data, decrypt) {
 				if (decrypt) {
@@ -793,31 +796,83 @@
 		}
 
 		function nextKeystream() {
-			for (let indexByte = 0; indexByte < BLOCK_LENGTH$1; indexByte++) {
-				counter[indexByte]++;
-				if (counter[indexByte] !== 0) {
-					break;
-				}
-			}
-			let s0 = ((counter[0] << 24) | (counter[1] << 16) | (counter[2] << 8) | counter[3]) ^ roundKeys[0];
-			let s1 = ((counter[4] << 24) | (counter[5] << 16) | (counter[6] << 8) | counter[7]) ^ roundKeys[1];
-			let s2 = ((counter[8] << 24) | (counter[9] << 16) | (counter[10] << 8) | counter[11]) ^ roundKeys[2];
-			let s3 = ((counter[12] << 24) | (counter[13] << 16) | (counter[14] << 8) | counter[15]) ^ roundKeys[3];
-			let indexKey = 4;
-			for (let round = 1; round < rounds; round++, indexKey += 4) {
-				const t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[indexKey];
-				const t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[indexKey + 1];
-				const t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[indexKey + 2];
-				const t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[indexKey + 3];
-				s0 = t0;
-				s1 = t1;
-				s2 = t2;
-				s3 = t3;
-			}
-			keystream[0] = ((S_BOX[s0 >>> 24] << 24) | (S_BOX[(s1 >>> 16) & 255] << 16) | (S_BOX[(s2 >>> 8) & 255] << 8) | S_BOX[s3 & 255]) ^ roundKeys[indexKey];
-			keystream[1] = ((S_BOX[s1 >>> 24] << 24) | (S_BOX[(s2 >>> 16) & 255] << 16) | (S_BOX[(s3 >>> 8) & 255] << 8) | S_BOX[s0 & 255]) ^ roundKeys[indexKey + 1];
-			keystream[2] = ((S_BOX[s2 >>> 24] << 24) | (S_BOX[(s3 >>> 16) & 255] << 16) | (S_BOX[(s0 >>> 8) & 255] << 8) | S_BOX[s1 & 255]) ^ roundKeys[indexKey + 2];
-			keystream[3] = ((S_BOX[s3 >>> 24] << 24) | (S_BOX[(s0 >>> 16) & 255] << 16) | (S_BOX[(s1 >>> 8) & 255] << 8) | S_BOX[s2 & 255]) ^ roundKeys[indexKey + 3];
+			counter0 = (counter0 + 1) | 0;
+			if (!counter0) {
+				counter1 = (counter1 + 1) | 0;
+				if (!counter1) {
+					counter2 = (counter2 + 1) | 0;
+					if (!counter2) {
+						counter3 = (counter3 + 1) | 0;
+					}
+				}
+			}
+			let s0 = swapBytes(counter0) ^ roundKeys[0];
+			let s1 = swapBytes(counter1) ^ roundKeys[1];
+			let s2 = swapBytes(counter2) ^ roundKeys[2];
+			let s3 = swapBytes(counter3) ^ roundKeys[3];
+			let t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[4];
+			let t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[5];
+			let t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[6];
+			let t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[7];
+			s0 = T0[t0 >>> 24] ^ T1[(t1 >>> 16) & 255] ^ T2[(t2 >>> 8) & 255] ^ T3[t3 & 255] ^ roundKeys[8];
+			s1 = T0[t1 >>> 24] ^ T1[(t2 >>> 16) & 255] ^ T2[(t3 >>> 8) & 255] ^ T3[t0 & 255] ^ roundKeys[9];
+			s2 = T0[t2 >>> 24] ^ T1[(t3 >>> 16) & 255] ^ T2[(t0 >>> 8) & 255] ^ T3[t1 & 255] ^ roundKeys[10];
+			s3 = T0[t3 >>> 24] ^ T1[(t0 >>> 16) & 255] ^ T2[(t1 >>> 8) & 255] ^ T3[t2 & 255] ^ roundKeys[11];
+			t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[12];
+			t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[13];
+			t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[14];
+			t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[15];
+			s0 = T0[t0 >>> 24] ^ T1[(t1 >>> 16) & 255] ^ T2[(t2 >>> 8) & 255] ^ T3[t3 & 255] ^ roundKeys[16];
+			s1 = T0[t1 >>> 24] ^ T1[(t2 >>> 16) & 255] ^ T2[(t3 >>> 8) & 255] ^ T3[t0 & 255] ^ roundKeys[17];
+			s2 = T0[t2 >>> 24] ^ T1[(t3 >>> 16) & 255] ^ T2[(t0 >>> 8) & 255] ^ T3[t1 & 255] ^ roundKeys[18];
+			s3 = T0[t3 >>> 24] ^ T1[(t0 >>> 16) & 255] ^ T2[(t1 >>> 8) & 255] ^ T3[t2 & 255] ^ roundKeys[19];
+			t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[20];
+			t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[21];
+			t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[22];
+			t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[23];
+			s0 = T0[t0 >>> 24] ^ T1[(t1 >>> 16) & 255] ^ T2[(t2 >>> 8) & 255] ^ T3[t3 & 255] ^ roundKeys[24];
+			s1 = T0[t1 >>> 24] ^ T1[(t2 >>> 16) & 255] ^ T2[(t3 >>> 8) & 255] ^ T3[t0 & 255] ^ roundKeys[25];
+			s2 = T0[t2 >>> 24] ^ T1[(t3 >>> 16) & 255] ^ T2[(t0 >>> 8) & 255] ^ T3[t1 & 255] ^ roundKeys[26];
+			s3 = T0[t3 >>> 24] ^ T1[(t0 >>> 16) & 255] ^ T2[(t1 >>> 8) & 255] ^ T3[t2 & 255] ^ roundKeys[27];
+			t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[28];
+			t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[29];
+			t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[30];
+			t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[31];
+			s0 = T0[t0 >>> 24] ^ T1[(t1 >>> 16) & 255] ^ T2[(t2 >>> 8) & 255] ^ T3[t3 & 255] ^ roundKeys[32];
+			s1 = T0[t1 >>> 24] ^ T1[(t2 >>> 16) & 255] ^ T2[(t3 >>> 8) & 255] ^ T3[t0 & 255] ^ roundKeys[33];
+			s2 = T0[t2 >>> 24] ^ T1[(t3 >>> 16) & 255] ^ T2[(t0 >>> 8) & 255] ^ T3[t1 & 255] ^ roundKeys[34];
+			s3 = T0[t3 >>> 24] ^ T1[(t0 >>> 16) & 255] ^ T2[(t1 >>> 8) & 255] ^ T3[t2 & 255] ^ roundKeys[35];
+			t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[36];
+			t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[37];
+			t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[38];
+			t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[39];
+			let indexKey = 40;
+			if (rounds > 10) {
+				s0 = T0[t0 >>> 24] ^ T1[(t1 >>> 16) & 255] ^ T2[(t2 >>> 8) & 255] ^ T3[t3 & 255] ^ roundKeys[40];
+				s1 = T0[t1 >>> 24] ^ T1[(t2 >>> 16) & 255] ^ T2[(t3 >>> 8) & 255] ^ T3[t0 & 255] ^ roundKeys[41];
+				s2 = T0[t2 >>> 24] ^ T1[(t3 >>> 16) & 255] ^ T2[(t0 >>> 8) & 255] ^ T3[t1 & 255] ^ roundKeys[42];
+				s3 = T0[t3 >>> 24] ^ T1[(t0 >>> 16) & 255] ^ T2[(t1 >>> 8) & 255] ^ T3[t2 & 255] ^ roundKeys[43];
+				t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[44];
+				t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[45];
+				t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[46];
+				t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[47];
+				indexKey = 48;
+			}
+			if (rounds > 12) {
+				s0 = T0[t0 >>> 24] ^ T1[(t1 >>> 16) & 255] ^ T2[(t2 >>> 8) & 255] ^ T3[t3 & 255] ^ roundKeys[48];
+				s1 = T0[t1 >>> 24] ^ T1[(t2 >>> 16) & 255] ^ T2[(t3 >>> 8) & 255] ^ T3[t0 & 255] ^ roundKeys[49];
+				s2 = T0[t2 >>> 24] ^ T1[(t3 >>> 16) & 255] ^ T2[(t0 >>> 8) & 255] ^ T3[t1 & 255] ^ roundKeys[50];
+				s3 = T0[t3 >>> 24] ^ T1[(t0 >>> 16) & 255] ^ T2[(t1 >>> 8) & 255] ^ T3[t2 & 255] ^ roundKeys[51];
+				t0 = T0[s0 >>> 24] ^ T1[(s1 >>> 16) & 255] ^ T2[(s2 >>> 8) & 255] ^ T3[s3 & 255] ^ roundKeys[52];
+				t1 = T0[s1 >>> 24] ^ T1[(s2 >>> 16) & 255] ^ T2[(s3 >>> 8) & 255] ^ T3[s0 & 255] ^ roundKeys[53];
+				t2 = T0[s2 >>> 24] ^ T1[(s3 >>> 16) & 255] ^ T2[(s0 >>> 8) & 255] ^ T3[s1 & 255] ^ roundKeys[54];
+				t3 = T0[s3 >>> 24] ^ T1[(s0 >>> 16) & 255] ^ T2[(s1 >>> 8) & 255] ^ T3[s2 & 255] ^ roundKeys[55];
+				indexKey = 56;
+			}
+			keystream[0] = ((S_BOX[t0 >>> 24] << 24) | (S_BOX[(t1 >>> 16) & 255] << 16) | (S_BOX[(t2 >>> 8) & 255] << 8) | S_BOX[t3 & 255]) ^ roundKeys[indexKey];
+			keystream[1] = ((S_BOX[t1 >>> 24] << 24) | (S_BOX[(t2 >>> 16) & 255] << 16) | (S_BOX[(t3 >>> 8) & 255] << 8) | S_BOX[t0 & 255]) ^ roundKeys[indexKey + 1];
+			keystream[2] = ((S_BOX[t2 >>> 24] << 24) | (S_BOX[(t3 >>> 16) & 255] << 16) | (S_BOX[(t0 >>> 8) & 255] << 8) | S_BOX[t1 & 255]) ^ roundKeys[indexKey + 2];
+			keystream[3] = ((S_BOX[t3 >>> 24] << 24) | (S_BOX[(t0 >>> 16) & 255] << 16) | (S_BOX[(t1 >>> 8) & 255] << 8) | S_BOX[t2 & 255]) ^ roundKeys[indexKey + 3];
 		}
 	}
 
@@ -941,47 +996,126 @@
 			for (let index = 0; index < 16; index++) {
 				schedule[index] = view.getInt32(offset + 4 * index);
 			}
-			for (let index = 16; index < SHA1_SCHEDULE_LENGTH; index++) {
-				const word = schedule[index - 3] ^ schedule[index - 8] ^ schedule[index - 14] ^ schedule[index - 16];
-				schedule[index] = (word << 1) | (word >>> 31);
-			}
 			let a = state[0];
 			let b = state[1];
 			let c = state[2];
 			let d = state[3];
 			let e = state[4];
 			let t;
-			for (let index = 0; index < 20; index++) {
-				t = (((a << 5) | (a >>> 27)) + ((b & c) | (~b & d)) + e + 0x5A827999 + schedule[index]) | 0;
-				e = d;
-				d = c;
-				c = (b << 30) | (b >>> 2);
-				b = a;
-				a = t;
-			}
-			for (let index = 20; index < 40; index++) {
-				t = (((a << 5) | (a >>> 27)) + (b ^ c ^ d) + e + 0x6ED9EBA1 + schedule[index]) | 0;
-				e = d;
-				d = c;
-				c = (b << 30) | (b >>> 2);
-				b = a;
-				a = t;
-			}
-			for (let index = 40; index < 60; index++) {
-				t = (((a << 5) | (a >>> 27)) + ((b & c) | (b & d) | (c & d)) + e + 0x8F1BBCDC + schedule[index]) | 0;
-				e = d;
-				d = c;
-				c = (b << 30) | (b >>> 2);
-				b = a;
-				a = t;
-			}
-			for (let index = 60; index < SHA1_SCHEDULE_LENGTH; index++) {
-				t = (((a << 5) | (a >>> 27)) + (b ^ c ^ d) + e + 0xCA62C1D6 + schedule[index]) | 0;
-				e = d;
-				d = c;
-				c = (b << 30) | (b >>> 2);
-				b = a;
-				a = t;
+			for (let index = 0; index < 15; index += 5) {
+				e = (((a << 5) | (a >>> 27)) + (((c ^ d) & b) ^ d) + e + 0x5A827999 + schedule[index]) | 0;
+				b = (b << 30) | (b >>> 2);
+				d = (((e << 5) | (e >>> 27)) + (((b ^ c) & a) ^ c) + d + 0x5A827999 + schedule[index + 1]) | 0;
+				a = (a << 30) | (a >>> 2);
+				c = (((d << 5) | (d >>> 27)) + (((a ^ b) & e) ^ b) + c + 0x5A827999 + schedule[index + 2]) | 0;
+				e = (e << 30) | (e >>> 2);
+				b = (((c << 5) | (c >>> 27)) + (((e ^ a) & d) ^ a) + b + 0x5A827999 + schedule[index + 3]) | 0;
+				d = (d << 30) | (d >>> 2);
+				a = (((b << 5) | (b >>> 27)) + (((d ^ e) & c) ^ e) + a + 0x5A827999 + schedule[index + 4]) | 0;
+				c = (c << 30) | (c >>> 2);
+			}
+			e = (((a << 5) | (a >>> 27)) + (((c ^ d) & b) ^ d) + e + 0x5A827999 + schedule[15]) | 0;
+			b = (b << 30) | (b >>> 2);
+			t = schedule[13] ^ schedule[8] ^ schedule[2] ^ schedule[0];
+			t = (t << 1) | (t >>> 31);
+			schedule[0] = t;
+			d = (((e << 5) | (e >>> 27)) + (((b ^ c) & a) ^ c) + d + 0x5A827999 + t) | 0;
+			a = (a << 30) | (a >>> 2);
+			t = schedule[14] ^ schedule[9] ^ schedule[3] ^ schedule[1];
+			t = (t << 1) | (t >>> 31);
+			schedule[1] = t;
+			c = (((d << 5) | (d >>> 27)) + (((a ^ b) & e) ^ b) + c + 0x5A827999 + t) | 0;
+			e = (e << 30) | (e >>> 2);
+			t = schedule[15] ^ schedule[10] ^ schedule[4] ^ schedule[2];
+			t = (t << 1) | (t >>> 31);
+			schedule[2] = t;
+			b = (((c << 5) | (c >>> 27)) + (((e ^ a) & d) ^ a) + b + 0x5A827999 + t) | 0;
+			d = (d << 30) | (d >>> 2);
+			t = schedule[0] ^ schedule[11] ^ schedule[5] ^ schedule[3];
+			t = (t << 1) | (t >>> 31);
+			schedule[3] = t;
+			a = (((b << 5) | (b >>> 27)) + (((d ^ e) & c) ^ e) + a + 0x5A827999 + t) | 0;
+			c = (c << 30) | (c >>> 2);
+			for (let index = 20; index < 40; index += 5) {
+				t = schedule[(index - 3) & 15] ^ schedule[(index - 8) & 15] ^ schedule[(index - 14) & 15] ^ schedule[(index) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index) & 15] = t;
+				e = (((a << 5) | (a >>> 27)) + (b ^ c ^ d) + e + 0x6ED9EBA1 + t) | 0;
+				b = (b << 30) | (b >>> 2);
+				t = schedule[(index - 2) & 15] ^ schedule[(index - 7) & 15] ^ schedule[(index - 13) & 15] ^ schedule[(index + 1) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 1) & 15] = t;
+				d = (((e << 5) | (e >>> 27)) + (a ^ b ^ c) + d + 0x6ED9EBA1 + t) | 0;
+				a = (a << 30) | (a >>> 2);
+				t = schedule[(index - 1) & 15] ^ schedule[(index - 6) & 15] ^ schedule[(index - 12) & 15] ^ schedule[(index + 2) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 2) & 15] = t;
+				c = (((d << 5) | (d >>> 27)) + (e ^ a ^ b) + c + 0x6ED9EBA1 + t) | 0;
+				e = (e << 30) | (e >>> 2);
+				t = schedule[(index) & 15] ^ schedule[(index - 5) & 15] ^ schedule[(index - 11) & 15] ^ schedule[(index + 3) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 3) & 15] = t;
+				b = (((c << 5) | (c >>> 27)) + (d ^ e ^ a) + b + 0x6ED9EBA1 + t) | 0;
+				d = (d << 30) | (d >>> 2);
+				t = schedule[(index + 1) & 15] ^ schedule[(index - 4) & 15] ^ schedule[(index - 10) & 15] ^ schedule[(index + 4) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 4) & 15] = t;
+				a = (((b << 5) | (b >>> 27)) + (c ^ d ^ e) + a + 0x6ED9EBA1 + t) | 0;
+				c = (c << 30) | (c >>> 2);
+			}
+			for (let index = 40; index < 60; index += 5) {
+				t = schedule[(index - 3) & 15] ^ schedule[(index - 8) & 15] ^ schedule[(index - 14) & 15] ^ schedule[(index) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index) & 15] = t;
+				e = (((a << 5) | (a >>> 27)) + ((b & c) | ((b | c) & d)) + e + 0x8F1BBCDC + t) | 0;
+				b = (b << 30) | (b >>> 2);
+				t = schedule[(index - 2) & 15] ^ schedule[(index - 7) & 15] ^ schedule[(index - 13) & 15] ^ schedule[(index + 1) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 1) & 15] = t;
+				d = (((e << 5) | (e >>> 27)) + ((a & b) | ((a | b) & c)) + d + 0x8F1BBCDC + t) | 0;
+				a = (a << 30) | (a >>> 2);
+				t = schedule[(index - 1) & 15] ^ schedule[(index - 6) & 15] ^ schedule[(index - 12) & 15] ^ schedule[(index + 2) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 2) & 15] = t;
+				c = (((d << 5) | (d >>> 27)) + ((e & a) | ((e | a) & b)) + c + 0x8F1BBCDC + t) | 0;
+				e = (e << 30) | (e >>> 2);
+				t = schedule[(index) & 15] ^ schedule[(index - 5) & 15] ^ schedule[(index - 11) & 15] ^ schedule[(index + 3) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 3) & 15] = t;
+				b = (((c << 5) | (c >>> 27)) + ((d & e) | ((d | e) & a)) + b + 0x8F1BBCDC + t) | 0;
+				d = (d << 30) | (d >>> 2);
+				t = schedule[(index + 1) & 15] ^ schedule[(index - 4) & 15] ^ schedule[(index - 10) & 15] ^ schedule[(index + 4) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 4) & 15] = t;
+				a = (((b << 5) | (b >>> 27)) + ((c & d) | ((c | d) & e)) + a + 0x8F1BBCDC + t) | 0;
+				c = (c << 30) | (c >>> 2);
+			}
+			for (let index = 60; index < 80; index += 5) {
+				t = schedule[(index - 3) & 15] ^ schedule[(index - 8) & 15] ^ schedule[(index - 14) & 15] ^ schedule[(index) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index) & 15] = t;
+				e = (((a << 5) | (a >>> 27)) + (b ^ c ^ d) + e + 0xCA62C1D6 + t) | 0;
+				b = (b << 30) | (b >>> 2);
+				t = schedule[(index - 2) & 15] ^ schedule[(index - 7) & 15] ^ schedule[(index - 13) & 15] ^ schedule[(index + 1) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 1) & 15] = t;
+				d = (((e << 5) | (e >>> 27)) + (a ^ b ^ c) + d + 0xCA62C1D6 + t) | 0;
+				a = (a << 30) | (a >>> 2);
+				t = schedule[(index - 1) & 15] ^ schedule[(index - 6) & 15] ^ schedule[(index - 12) & 15] ^ schedule[(index + 2) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 2) & 15] = t;
+				c = (((d << 5) | (d >>> 27)) + (e ^ a ^ b) + c + 0xCA62C1D6 + t) | 0;
+				e = (e << 30) | (e >>> 2);
+				t = schedule[(index) & 15] ^ schedule[(index - 5) & 15] ^ schedule[(index - 11) & 15] ^ schedule[(index + 3) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 3) & 15] = t;
+				b = (((c << 5) | (c >>> 27)) + (d ^ e ^ a) + b + 0xCA62C1D6 + t) | 0;
+				d = (d << 30) | (d >>> 2);
+				t = schedule[(index + 1) & 15] ^ schedule[(index - 4) & 15] ^ schedule[(index - 10) & 15] ^ schedule[(index + 4) & 15];
+				t = (t << 1) | (t >>> 31);
+				schedule[(index + 4) & 15] = t;
+				a = (((b << 5) | (b >>> 27)) + (c ^ d ^ e) + a + 0xCA62C1D6 + t) | 0;
+				c = (c << 30) | (c >>> 2);
 			}
 			state[0] = (state[0] + a) | 0;
 			state[1] = (state[1] + b) | 0;
@@ -1044,6 +1178,10 @@
 		return (S_BOX[word >>> 24] << 24) | (S_BOX[(word >>> 16) & 255] << 16) | (S_BOX[(word >>> 8) & 255] << 8) | S_BOX[word & 255];
 	}
 
+	function swapBytes(value) {
+		return (value << 24) | ((value & 0xff00) << 8) | ((value >>> 8) & 0xff00) | (value >>> 24);
+	}
+
 	function multiplyByTwo(value) {
 		return ((value << 1) ^ ((value >> 7) * 0x1b)) & 255;
 	}
@@ -1731,8 +1869,8 @@
 			let crc32Stream, encryptionStream, gzipCrc32Stream;
 			let readable = super.readable;
 			const codecStreams = format && getCodecStreams(format);
-			const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) &&
-				Boolean(useCompressionStream && CompressionStream);
+			const GzipCompressionStream = getGzipCompressionStream(useCompressionStream, CompressionStream, CompressionStreamFallback);
+			const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) && Boolean(GzipCompressionStream);
 			if ((!encrypted || zipCrypto) && computeCrc32 && !useGzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
@@ -1742,7 +1880,7 @@
 					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.CompressionStream, format, { level, chunkSize, compressionMethod, uncompressedSize: inputSize }));
 				} else if (useGzipCrc32) {
 					gzipCrc32Stream = new GzipToRawDeflateStream();
-					readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
+					readable = pipeThroughBackpressured(readable, new GzipCompressionStream(FORMAT_GZIP, { level, chunkSize }));
 					readable = pipeThrough(readable, gzipCrc32Stream);
 				} else {
 					try {
@@ -1816,8 +1954,7 @@
 		}
 	}
 
-	function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize) {
-		const crc32 = new Crc32();
+	function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
 		let outputLength = 0;
 		let inputDone = false;
 		let watchdogTimeout;
@@ -1891,7 +2028,7 @@
 		constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
 			super({});
 			const { zipCrypto, encrypted, checkCrc32, crc32, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
-			let crc32Stream, decryptionStream;
+			let crc32Stream, decryptionStream, gzipCrc32;
 			let readable = super.readable;
 			if (encrypted) {
 				if (zipCrypto) {
@@ -1918,19 +2055,20 @@
 						} catch {
 							throw error;
 						}
-						readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize);
+						gzipCrc32 = new Crc32();
+						readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, gzipCrc32);
 					}
 				}
 				readable = mapInflateStreamError(readable);
 			}
-			if (checkCrc32) {
+			if (checkCrc32 && !gzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
 			}
 			setReadable(this, readable, () => {
 				if (checkCrc32) {
-					const computedCrc32View = new DataView(crc32Stream.value.buffer);
-					if (crc32 != computedCrc32View.getUint32(0, false)) {
+					const computedCrc32 = gzipCrc32 ? gzipCrc32.get() >>> 0 : new DataView(crc32Stream.value.buffer).getUint32(0, false);
+					if (crc32 != computedCrc32) {
 						throw new Error(ERR_INVALID_CRC32);
 					}
 				}
@@ -1986,6 +2124,14 @@
 		return new CodecStreamClass(format, options);
 	}
 
+	function getGzipCompressionStream(useCompressionStream, CompressionStreamNative, CompressionStreamFallback) {
+		if (useCompressionStream && CompressionStreamNative) {
+			return CompressionStreamNative;
+		} else if (CompressionStreamFallback && CompressionStreamFallback.requiresModule) {
+			return CompressionStreamFallback;
+		}
+	}
+
 	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
 		const Stream = useCompressionStream && CompressionStreamNative ?
 			CompressionStreamNative :
@@ -2333,7 +2479,8 @@
 					return new Promise(resolve => {
 						const { worker, busy } = workerData;
 						if (busy) {
-							workerData.resolveTerminated = resolve;
+							workerData.terminateResolvers = workerData.terminateResolvers || [];
+							workerData.terminateResolvers.push(resolve);
 						} else {
 							if (worker) {
 								worker.terminate();
@@ -2346,17 +2493,19 @@
 				},
 				onTaskFinished() {
 					if (workerData.busy) {
-						const { resolveTerminated, worker } = workerData;
-						if (resolveTerminated) {
-							workerData.resolveTerminated = null;
+						const { terminateResolvers, worker } = workerData;
+						if (terminateResolvers) {
+							workerData.terminateResolvers = null;
 							if (worker) {
 								workerData.terminated = true;
 								worker.terminate();
 							}
-							resolveTerminated();
 						}
 						workerData.busy = false;
-						onTaskFinished(workerData);
+						const pendingTasks = onTaskFinished(workerData);
+						if (terminateResolvers) {
+							terminateResolvers.forEach(resolve => resolve(pendingTasks));
+						}
 					}
 				}
 			});
@@ -3041,7 +3190,10 @@
 
 		function onTaskFinished(workerData) {
 			clearStarvationTimeout();
-			if (pendingRequests.length) {
+			if (workerData.terminated) {
+				workerData.terminated = false;
+				return runPendingRequestsInline();
+			} else if (pendingRequests.length) {
 				const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
 				resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
 				armStarvationTimeout();
@@ -3079,12 +3231,26 @@
 		starvationTimeout = null;
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
-			resolve(new CodecWorker({}, stream, inlineWorkerOptions, onInlineTaskFinished));
+			resolve(new CodecWorker({}, stream, getInlineWorkerOptions(workerOptions), onInlineTaskFinished));
 			armStarvationTimeout();
 		}
 	}
 
+	function runPendingRequestsInline() {
+		const tasks = pendingRequests.splice(0).map(({ resolve, stream, workerOptions }) => new Promise(resolveTask => {
+			resolve(new CodecWorker({}, stream, getInlineWorkerOptions(workerOptions), () => {
+				onInlineTaskFinished();
+				resolveTask();
+			}));
+		}));
+		clearStarvationTimeout();
+		return Promise.all(tasks);
+	}
+
+	function getInlineWorkerOptions(workerOptions) {
+		return Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
+	}
+
 	function onInlineTaskFinished() {
 		clearStarvationTimeout();
 		armStarvationTimeout();
@@ -3094,18 +3260,14 @@
 		const { config } = workerOptions;
 		const { terminateWorkerTimeout } = config;
 		if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
-			if (workerData.terminated) {
-				workerData.terminated = false;
-			} else {
-				workerData.terminateTimeout = setTimeout(async () => {
-					pool = pool.filter(data => data != workerData);
-					try {
-						await workerData.terminate();
-					} catch {
-						// ignored
-					}
-				}, terminateWorkerTimeout);
-			}
+			workerData.terminateTimeout = setTimeout(async () => {
+				pool = pool.filter(data => data != workerData);
+				try {
+					await workerData.terminate();
+				} catch {
+					// ignored
+				}
+			}, terminateWorkerTimeout);
 		}
 	}
 
@@ -3118,10 +3280,13 @@
 	}
 
 	async function terminateWorkers() {
-		await Promise.allSettled(pool.map(workerData => {
-			clearTerminateTimeout(workerData);
-			return workerData.terminate();
-		}));
+		await Promise.allSettled([
+			runPendingRequestsInline(),
+			...pool.map(workerData => {
+				clearTerminateTimeout(workerData);
+				return workerData.terminate();
+			})
+		]);
 		resetWebWorkerSupport();
 	}
 
@@ -3196,6 +3361,19 @@
 		return decode(value, encoding, true);
 	}
 
+	function isUTF8Text(value) {
+		if (value.some(byte => byte > 0x7f)) {
+			try {
+				new TextDecoder("utf-8", { fatal: true }).decode(value);
+				return true;
+			} catch {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
 	function decodeTextRemovingBOM(value, encoding) {
 		return decode(value, encoding, false);
 	}
@@ -4505,6 +4683,7 @@
 	const WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES = "mismatched local file header (crc32 or sizes)";
 	const MAX_KNOWN_VERSION = 63;
 	const DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
+	const PARENT_DIRECTORY_REGEXP = /(^|[\\/])\.\.([\\/]|$)/;
 	const CHARSET_UTF8 = "utf-8";
 	const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 	const CHARSET_CP437 = "cp437";
@@ -4539,7 +4718,7 @@
 			Object.assign(this, {
 				reader: new GenericReader(reader),
 				options,
-				readRanges: new Map()
+				readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
 			});
 		}
 
@@ -4757,12 +4936,13 @@
 				const versionMadeBy = getUint16$1(directoryView, offset + 4);
 				const msDosCompatible = versionMadeBy >> 8 == 0;
 				const unixCompatible = versionMadeBy >> 8 == 3;
-				const rawFilename = directoryArray.subarray(filenameOffset, extraFieldOffset);
 				const commentLength = getUint16$1(directoryView, offset + 32);
 				const endOffset = commentOffset + commentLength;
-				const rawComment = directoryArray.subarray(commentOffset, endOffset);
-				const filenameUTF8 = languageEncodingFlag;
-				const commentUTF8 = languageEncodingFlag;
+				const rawEntryData = new Uint8Array(directoryArray.subarray(filenameOffset, endOffset));
+				const rawFilename = rawEntryData.subarray(0, fileEntry.filenameLength);
+				const rawComment = rawEntryData.subarray(fileEntry.filenameLength + fileEntry.extraFieldLength);
+				const filenameUTF8 = languageEncodingFlag || (!filenameEncoding && isUTF8Text(rawFilename));
+				const commentUTF8 = languageEncodingFlag || (!commentEncoding && isUTF8Text(rawComment));
 				const externalFileAttributes = getUint32$1(directoryView, offset + 38);
 				const msdosAttributesRaw = externalFileAttributes & MAX_8_BITS;
 				const msdosAttributes = {
@@ -4813,7 +4993,7 @@
 					rawFilename,
 					filenameUTF8,
 					commentUTF8,
-					rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset),
+					rawExtraField: rawEntryData.subarray(fileEntry.filenameLength, fileEntry.filenameLength + fileEntry.extraFieldLength),
 					rawComment,
 					filename,
 					comment
@@ -5184,7 +5364,6 @@
 				throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
 			}
 			const size = compressedSize;
-			const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 			const signal = checkSignalOption(getOptionValue$1(zipEntry, options, OPTION_SIGNAL));
 			throwIfAborted(signal);
 			let checkOverlappingEntry = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
@@ -5258,6 +5437,7 @@
 					writer = new GenericWriter(writer);
 					await initStream(writer, getDecodableOutputSize(outputSize, compressedSize, compressed));
 					({ writable } = writer);
+					const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 					const { outputSize: writtenSize } = await runWorker({ readable, writable }, workerOptions);
 					if (writtenSize != outputSize) {
 						throw Object.assign(new Error(ERR_INVALID_UNCOMPRESSED_SIZE), { outputSize: writtenSize });
@@ -5321,7 +5501,7 @@
 			if (getUint32$1(signatureRecordView, 0) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
 				const signatureDataLength = getUint16$1(signatureRecordView, 4);
 				if (6 + signatureDataLength <= signatureRecordArray.length) {
-					return signatureRecordArray.subarray(6, 6 + signatureDataLength);
+					return new Uint8Array(signatureRecordArray.subarray(6, 6 + signatureDataLength));
 				}
 			}
 		}
@@ -5693,14 +5873,61 @@
 			end: dataOffset + compressedSize + dataDescriptorLength,
 			fileEntry
 		};
-		for (const [otherIndex, otherRange] of readRanges) {
-			if (otherIndex != index && range.start < otherRange.end && otherRange.start < range.end) {
+		const { indexes, sortedRanges, pendingRanges } = readRanges;
+		if (!indexes.has(index)) {
+			const overlappingRange = findOverlappingRange(sortedRanges, range) || pendingRanges.find(otherRange => rangesOverlap(range, otherRange));
+			if (overlappingRange) {
 				const error = new Error(ERR_OVERLAPPING_ENTRY);
-				error.overlappingEntry = otherRange.fileEntry;
+				error.overlappingEntry = overlappingRange.fileEntry;
 				throw error;
 			}
+			indexes.add(index);
+			pendingRanges.push(range);
+			if (pendingRanges.length * pendingRanges.length > sortedRanges.length) {
+				pendingRanges.sort((range, otherRange) => range.start - otherRange.start);
+				readRanges.sortedRanges = mergeRanges(sortedRanges, pendingRanges);
+				pendingRanges.length = 0;
+			}
+		}
+	}
+
+	function findOverlappingRange(sortedRanges, range) {
+		let low = 0;
+		let high = sortedRanges.length;
+		while (low < high) {
+			const middle = (low + high) >>> 1;
+			if (sortedRanges[middle].start < range.start) {
+				low = middle + 1;
+			} else {
+				high = middle;
+			}
+		}
+		const previousRange = sortedRanges[low - 1];
+		const nextRange = sortedRanges[low];
+		if (previousRange && rangesOverlap(range, previousRange)) {
+			return previousRange;
+		}
+		if (nextRange && rangesOverlap(range, nextRange)) {
+			return nextRange;
+		}
+	}
+
+	function rangesOverlap(range, otherRange) {
+		return range.start < otherRange.end && otherRange.start < range.end;
+	}
+
+	function mergeRanges(sortedRanges, pendingRanges) {
+		const mergedRanges = [];
+		let indexSorted = 0;
+		let indexPending = 0;
+		while (indexSorted < sortedRanges.length || indexPending < pendingRanges.length) {
+			if (indexPending == pendingRanges.length || (indexSorted < sortedRanges.length && sortedRanges[indexSorted].start < pendingRanges[indexPending].start)) {
+				mergedRanges.push(sortedRanges[indexSorted++]);
+			} else {
+				mergedRanges.push(pendingRanges[indexPending++]);
+			}
 		}
-		readRanges.set(index, range);
+		return mergedRanges;
 	}
 
 	function readDataDescriptor(dataDescriptorView, offset, extraFieldZip64) {
@@ -5797,10 +6024,10 @@
 		if (pathParts.length > 1 && pathParts[pathParts.length - 1] === "") {
 			pathParts.pop();
 		}
-		if (pathParts.includes("..") || filename.startsWith("/") || filename.startsWith("\\\\") || DRIVE_LETTER_REGEXP.test(filename)) {
+		if (PARENT_DIRECTORY_REGEXP.test(filename) || filename.startsWith("/") || filename.startsWith("\\") || DRIVE_LETTER_REGEXP.test(filename)) {
 			return true;
 		}
-		return filenameValidation == STRICTNESS_STRICT && (pathParts.includes(".") || pathParts.includes(""));
+		return filenameValidation == STRICTNESS_STRICT && (pathParts.includes(".") || pathParts.includes("") || filename.includes("\0"));
 	}
 
 	function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
@@ -5886,7 +6113,7 @@
 	}
 
 	function getEndOfCentralDirectoryInfo(scanArray, indexByte, offset) {
-		return { offset, buffer: scanArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer };
+		return { offset, buffer: new Uint8Array(scanArray.subarray(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH)).buffer };
 	}
 
 	async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
@@ -8631,7 +8858,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.14.0";
+	const VERSION = "2.15.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.