@zip.js/zip.js 2.14.0 → 2.15.0

package/dist/zip-fs-external.js

@@ -763,7 +763,7 @@ const BLOCK_LENGTH$1 = 16;
 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);
@@ -782,9 +782,12 @@ function createEngine$2(key, authenticationKey) {
 	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) {
@@ -820,31 +823,83 @@ function createEngine$2(key, authenticationKey) {
 	}
 
 	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];
 	}
 }
 
@@ -968,47 +1023,126 @@ function createSha1() {
 		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;
@@ -1071,6 +1205,10 @@ function substituteWord(word) {
 	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;
 }
@@ -1762,8 +1900,8 @@ class DeflateStream extends TransformStream {
 		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);
@@ -1773,7 +1911,7 @@ class DeflateStream extends TransformStream {
 				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$1));
+				readable = pipeThroughBackpressured(readable, new GzipCompressionStream(FORMAT_GZIP$1, { level, chunkSize }));
 				readable = pipeThrough(readable, gzipCrc32Stream);
 			} else {
 				try {
@@ -1847,8 +1985,7 @@ class GzipToRawDeflateStream extends TransformStream {
 	}
 }
 
-function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize) {
-	const crc32 = new Crc32();
+function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
 	let outputLength = 0;
 	let inputDone = false;
 	let watchdogTimeout;
@@ -1922,7 +2059,7 @@ class InflateStream extends TransformStream {
 	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) {
@@ -1949,19 +2086,20 @@ class InflateStream extends TransformStream {
 					} 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);
 				}
 			}
@@ -2017,6 +2155,14 @@ function createCodecStream(CodecStreamClass, format, options) {
 	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 :
@@ -2368,7 +2514,8 @@ class CodecWorker {
 				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();
@@ -2381,17 +2528,19 @@ class CodecWorker {
 			},
 			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));
+					}
 				}
 			}
 		});
@@ -3076,7 +3225,10 @@ async function runWorker(stream, workerOptions) {
 
 	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();
@@ -3114,12 +3266,26 @@ function onWorkerStarvation() {
 	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();
@@ -3129,18 +3295,14 @@ function terminateWorker(workerData, workerOptions) {
 	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);
 	}
 }
 
@@ -3153,10 +3315,13 @@ function clearTerminateTimeout(workerData) {
 }
 
 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();
 }
 
@@ -3231,6 +3396,19 @@ function decodeText(value, encoding) {
 	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);
 }
@@ -4540,6 +4718,7 @@ const WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD = "mismatched loca
 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";
@@ -4574,7 +4753,7 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			readRanges: new Map()
+			readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
 		});
 	}
 
@@ -4792,12 +4971,13 @@ class ZipReader {
 			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 = {
@@ -4848,7 +5028,7 @@ class ZipReader {
 				rawFilename,
 				filenameUTF8,
 				commentUTF8,
-				rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset),
+				rawExtraField: rawEntryData.subarray(fileEntry.filenameLength, fileEntry.filenameLength + fileEntry.extraFieldLength),
 				rawComment,
 				filename,
 				comment
@@ -5219,7 +5399,6 @@ let ZipEntry$1 = class ZipEntry {
 			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);
@@ -5293,6 +5472,7 @@ let ZipEntry$1 = class ZipEntry {
 				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 });
@@ -5356,7 +5536,7 @@ function readDigitalSignature(signatureRecordArray) {
 		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));
 			}
 		}
 	}
@@ -5728,14 +5908,61 @@ async function detectOverlappingEntry({
 		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) {
@@ -5832,10 +6059,10 @@ function isUnsafeFilename(filename, filenameValidation) {
 	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) {
@@ -5921,7 +6148,7 @@ async function* scanEndOfCentralDirectory(reader, scanLength) {
 }
 
 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) {
@@ -8666,7 +8893,7 @@ function formatSupported(StreamClass, format) {
  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.
@@ -9189,7 +9416,6 @@ function _make(isCompress, type, options = {}) {
 				if (!this.out || !this.in) {
 					throw new Error("allocation failed");
 				}
-				this._scratch = new Uint8Array(outBufferSize);
 				if (isCompress) {
 					this._process = wasm$1.deflate_process;
 					this._last_consumed = wasm$1.deflate_last_consumed;
@@ -9238,7 +9464,6 @@ function _make(isCompress, type, options = {}) {
 				const process = this._process;
 				const last_consumed = this._last_consumed;
 				const out = this.out;
-				const scratch = this._scratch;
 				let offset = 0;
 				while (offset < buffer.length) {
 					const toRead = Math.min(buffer.length - offset, 32 * 1024);
@@ -9263,8 +9488,7 @@ function _make(isCompress, type, options = {}) {
 					}
 					const prod = result & 0x00ffffff;
 					if (prod) {
-						scratch.set(heap.subarray(out, out + prod), 0);
-						controller.enqueue(scratch.slice(0, prod));
+						controller.enqueue(heap.slice(out, out + prod));
 					}
 					const consumed = last_consumed(this.streamHandle);
 					if (consumed === 0 && prod === 0) {
@@ -9282,7 +9506,6 @@ function _make(isCompress, type, options = {}) {
 				const heap = new Uint8Array(memory.buffer);
 				const process = this._process;
 				const out = this.out;
-				const scratch = this._scratch;
 				while (true) {
 					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
 					const code = (result >> 24) & 0xff;
@@ -9292,8 +9515,7 @@ function _make(isCompress, type, options = {}) {
 					}
 					const produced = result & 0x00ffffff;
 					if (produced) {
-						scratch.set(heap.subarray(out, out + produced), 0);
-						controller.enqueue(scratch.slice(0, produced));
+						controller.enqueue(heap.slice(out, out + produced));
 					}
 					if (code === 1 || produced === 0) {
 						break;