@zip.js/zip.js 2.14.0 → 2.14.1

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;
 	}
@@ -2333,7 +2471,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,14 +2485,14 @@
 				},
 				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);
@@ -4539,7 +4678,7 @@
 			Object.assign(this, {
 				reader: new GenericReader(reader),
 				options,
-				readRanges: new Map()
+				readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
 			});
 		}
 
@@ -5184,7 +5323,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 +5396,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 });
@@ -5693,14 +5832,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) {
@@ -8631,7 +8817,7 @@
 	 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.