@zip.js/zip.js 2.14.0 → 2.14.1

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;
 }
@@ -2368,7 +2506,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,14 +2520,14 @@ 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();
+						terminateResolvers.forEach(resolve => resolve());
 					}
 					workerData.busy = false;
 					onTaskFinished(workerData);
@@ -4574,7 +4713,7 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			readRanges: new Map()
+			readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
 		});
 	}
 
@@ -5219,7 +5358,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 +5431,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 });
@@ -5728,14 +5867,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) {
@@ -8666,7 +8852,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.14.0";
+const VERSION = "2.14.1";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9189,7 +9375,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 +9423,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 +9447,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 +9465,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 +9474,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;