@zip.js/zip.js 2.14.0 → 2.15.0

package/lib/core/codec-pool.js

@@ -106,7 +106,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();
@@ -144,12 +147,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();
@@ -159,18 +176,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);
 	}
 }
 
@@ -183,9 +196,12 @@ 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();
 }

package/lib/core/codec-worker.js

@@ -133,7 +133,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();
@@ -146,17 +147,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));
+					}
 				}
 			}
 		});

package/lib/core/streams/codecs/aes-hmac-sha1.js

@@ -30,7 +30,7 @@ const BLOCK_LENGTH = 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);
@@ -54,9 +54,12 @@ function createEngine(key, authenticationKey) {
 	initTables();
 	const roundKeys = new Int32Array(ROUND_KEYS_LENGTH);
 	const rounds = expandKey(key, roundKeys);
-	const counter = new Uint8Array(BLOCK_LENGTH);
 	const keystream = new Int32Array(BLOCK_LENGTH / 4);
 	const hmac = createHmac(authenticationKey);
+	let counter0 = 0;
+	let counter1 = 0;
+	let counter2 = 0;
+	let counter3 = 0;
 	return {
 		process(data, decrypt) {
 			if (decrypt) {
@@ -92,31 +95,83 @@ function createEngine(key, authenticationKey) {
 	}
 
 	function nextKeystream() {
-		for (let indexByte = 0; indexByte < BLOCK_LENGTH; indexByte++) {
-			counter[indexByte]++;
-			if (counter[indexByte] !== 0) {
-				break;
+		counter0 = (counter0 + 1) | 0;
+		if (!counter0) {
+			counter1 = (counter1 + 1) | 0;
+			if (!counter1) {
+				counter2 = (counter2 + 1) | 0;
+				if (!counter2) {
+					counter3 = (counter3 + 1) | 0;
+				}
 			}
 		}
-		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;
+		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;
 		}
-		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];
+		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];
 	}
 }
 
@@ -240,47 +295,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 = 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);
 		}
-		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;
+		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++) {
-			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 = 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 < 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 = 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;
@@ -343,6 +477,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;
 }

package/lib/core/streams/zip-entry-stream.js

@@ -70,8 +70,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);
@@ -81,7 +81,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));
+				readable = pipeThroughBackpressured(readable, new GzipCompressionStream(FORMAT_GZIP, { level, chunkSize }));
 				readable = pipeThrough(readable, gzipCrc32Stream);
 			} else {
 				try {
@@ -155,8 +155,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;
@@ -230,7 +229,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) {
@@ -257,19 +256,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);
 				}
 			}
@@ -343,6 +343,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 :

package/lib/core/streams/zlib-wasm/zlib-streams.js

@@ -72,7 +72,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.deflate_process;
 					this._last_consumed = wasm.deflate_last_consumed;
@@ -121,7 +120,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);
@@ -146,8 +144,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) {
@@ -165,7 +162,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;
@@ -175,8 +171,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;

package/lib/core/util/decode-text.js

@@ -32,13 +32,27 @@ import { decodeCP437 } from "./decode-cp437.js";
 
 export {
 	decodeText,
-	decodeTextRemovingBOM
+	decodeTextRemovingBOM,
+	isUTF8Text
 };
 
 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);
 }

package/lib/core/version.js

@@ -26,6 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.14.0";
+const VERSION = "2.15.0";
 
 export { VERSION };