@zip.js/zip.js 2.6.26 → 2.6.28

package/lib/core/codec-interface.js

@@ -35,6 +35,7 @@ import {
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_SIGNATURE
 } from "./streams/zip-entry-stream.js";
+import { CodecStream } from "./streams/codec-stream.js";
 
 const CODEC_DEFLATE = "deflate";
 const CODEC_INFLATE = "inflate";
@@ -47,6 +48,7 @@ const MESSAGE_CLOSE = "close";
 
 export {
 	Codec,
+	getCodecStreamClass,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
@@ -61,17 +63,16 @@ export {
 
 class Codec {
 
-	constructor(CodecConstructor, readable, writable, options, config) {
+	constructor(readable, writable, options, config) {
 		const { codecType } = options;
-		let StreamConstructor;
+		let CodecStream;
 		if (codecType.startsWith(CODEC_DEFLATE)) {
-			StreamConstructor = DeflateStream;
+			CodecStream = DeflateStream;
 		} else if (codecType.startsWith(CODEC_INFLATE)) {
-			StreamConstructor = InflateStream;
+			CodecStream = InflateStream;
 		}
 		Object.assign(this, {
-			StreamConstructor,
-			CodecConstructor,
+			CodecStream,
 			readable,
 			writable,
 			options,
@@ -81,14 +82,13 @@ class Codec {
 
 	async run() {
 		const {
-			StreamConstructor,
-			CodecConstructor,
+			CodecStream,
 			readable,
 			writable,
 			options,
 			config
 		} = this;
-		const stream = new StreamConstructor(CodecConstructor, options, config);
+		const stream = new CodecStream(options, config);
 		let size = 0;
 		await readable
 			.pipeThrough(stream)
@@ -104,4 +104,12 @@ class Codec {
 		const { signature } = stream;
 		return { size, signature };
 	}
+}
+
+function getCodecStreamClass(Codec) {
+	return class extends CodecStream {
+		constructor(algorithm, options) {
+			super(Codec, options);
+		}
+	};
 }

package/lib/core/codec-pool-worker.js

@@ -50,10 +50,9 @@ class CodecWorker {
 
 	constructor(workerData, stream, workerOptions, onTaskFinished) {
 		const { readable, writable } = stream;
-		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts, codecConstructor } = workerOptions;
+		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts } = workerOptions;
 		Object.assign(workerData, {
 			busy: true,
-			codecConstructor,
 			readable,
 			writable,
 			options: Object.assign({}, options),
@@ -106,7 +105,7 @@ async function callHandler(handler, ...parameters) {
 }
 
 function createWorkerInterface(workerData, config) {
-	const interfaceCodec = new Codec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
+	const interfaceCodec = new Codec(workerData.readable, workerData.writable, workerData.options, config);
 	const { onTaskFinished } = workerData;
 	const codec = {
 		async run() {

package/lib/core/codec-pool.js

@@ -58,7 +58,7 @@ async function runWorker(stream, workerOptions) {
 	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
 	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
 	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
-	options.useCompressionStream = useCompressionStream === undefined ? config.useCompressionStream : useCompressionStream;
+	options.useCompressionStream = useCompressionStream || (useCompressionStream === undefined && config.useCompressionStream);
 	let worker;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };

package/lib/core/configuration.js

@@ -26,16 +26,29 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global navigator */
+/* global navigator, CompressionStream, DecompressionStream */
+
+import { getCodecStreamClass } from "./codec-interface.js";
 
 const MINIMUM_CHUNK_SIZE = 64;
-const UNDEFINED_TYPE = undefined;
+const UNDEFINED_VALUE = undefined;
+let maxWorkers = 2;
+try {
+	if (typeof navigator != "undefined" && navigator.hardwareConcurrency) {
+		maxWorkers = navigator.hardwareConcurrency;
+	}
+} catch (_error) {
+	// ignored
+}
 const DEFAULT_CONFIGURATION = {
 	chunkSize: 512 * 1024,
-	maxWorkers: (typeof navigator != "undefined" && navigator.hardwareConcurrency) || 2,
+	maxWorkers,
 	terminateWorkerTimeout: 5000,
 	useWebWorkers: true,
-	workerScripts: undefined
+	useCompressionStream: true,
+	workerScripts: undefined,
+	CompressionStreamNative: typeof CompressionStream != "undefined" && CompressionStream,
+	DecompressionStreamNative: typeof DecompressionStream != "undefined" && DecompressionStream
 };
 
 const config = Object.assign({}, DEFAULT_CONFIGURATION);
@@ -64,6 +77,8 @@ function configure(configuration) {
 		useWebWorkers,
 		Deflate,
 		Inflate,
+		CompressionStream,
+		DecompressionStream,
 		workerScripts
 	} = configuration;
 	setIfDefined("baseURL", baseURL);
@@ -72,9 +87,15 @@ function configure(configuration) {
 	setIfDefined("terminateWorkerTimeout", terminateWorkerTimeout);
 	setIfDefined("useCompressionStream", useCompressionStream);
 	setIfDefined("useWebWorkers", useWebWorkers);
-	setIfDefined("Deflate", Deflate);
-	setIfDefined("Inflate", Inflate);
-	if (workerScripts !== UNDEFINED_TYPE) {
+	if (Deflate) {
+		config.CompressionStream = getCodecStreamClass(Deflate);
+	}
+	if (Inflate) {
+		config.DecompressionStream = getCodecStreamClass(Inflate);
+	}
+	setIfDefined("CompressionStream", CompressionStream);
+	setIfDefined("DecompressionStream", DecompressionStream);
+	if (workerScripts !== UNDEFINED_VALUE) {
 		const { deflate, inflate } = workerScripts;
 		if (deflate || inflate) {
 			if (!config.workerScripts) {
@@ -97,7 +118,7 @@ function configure(configuration) {
 }
 
 function setIfDefined(propertyName, propertyValue) {
-	if (propertyValue !== UNDEFINED_TYPE) {
+	if (propertyValue !== UNDEFINED_VALUE) {
 		config[propertyName] = propertyValue;
 	}
 }

package/lib/core/io.js

@@ -100,52 +100,6 @@ class Writer extends Stream {
 	}
 }
 
-class TextReader extends Reader {
-
-	constructor(text) {
-		super();
-		this.blobReader = new BlobReader(new Blob([text], { type: CONTENT_TYPE_TEXT_PLAIN }));
-	}
-
-	init() {
-		const reader = this;
-		super.init();
-		reader.blobReader.init();
-		reader.size = reader.blobReader.size;
-	}
-
-	readUint8Array(offset, length) {
-		return this.blobReader.readUint8Array(offset, length);
-	}
-}
-
-class TextWriter extends Writer {
-
-	constructor(encoding) {
-		super();
-		this.encoding = encoding;
-		this.blob = new Blob([], { type: CONTENT_TYPE_TEXT_PLAIN });
-	}
-
-	writeUint8Array(array) {
-		this.blob = new Blob([this.blob, array.buffer], { type: CONTENT_TYPE_TEXT_PLAIN });
-	}
-
-	getData() {
-		const writer = this;
-		if (writer.blob.text && (writer.encoding === undefined || (writer.encoding && writer.encoding.toLowerCase() == "utf-8"))) {
-			return writer.blob.text();
-		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				reader.onload = event => resolve(event.target.result);
-				reader.onerror = () => reject(reader.error);
-				reader.readAsText(writer.blob, writer.encoding);
-			});
-		}
-	}
-}
-
 class Data64URIReader extends Reader {
 
 	constructor(dataURI) {
@@ -242,6 +196,42 @@ class BlobWriter extends Stream {
 	}
 }
 
+class TextReader extends BlobReader {
+
+	constructor(text) {
+		super(new Blob([text], { type: CONTENT_TYPE_TEXT_PLAIN }));
+	}
+}
+
+class TextWriter extends BlobWriter {
+
+	constructor(encoding) {
+		super(encoding);
+		Object.assign(this, {
+			encoding,
+			utf8: !encoding || encoding.toLowerCase() == "utf-8"
+		});
+	}
+
+	async getData() {
+		const {
+			encoding,
+			utf8
+		} = this;
+		const blob = await super.getData();
+		if (blob.text && utf8) {
+			return blob.text();
+		} else {
+			const reader = new FileReader();
+			return new Promise((resolve, reject) => {
+				reader.onload = ({ target }) => resolve(target.result);
+				reader.onerror = () => reject(reader.error);
+				reader.readAsText(blob, encoding);
+			});
+		}
+	}
+}
+
 class FetchReader extends Reader {
 
 	constructor(url, options) {

package/lib/core/streams/aes-crypto-stream.js

@@ -38,6 +38,7 @@ import {
 } from "./codecs/sjcl.js";
 import {
 	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
 	getRandomValues
 } from "./common-crypto.js";
 
@@ -56,9 +57,10 @@ const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
 const UNDEFINED_TYPE = "undefined";
 const FUNCTION_TYPE = "function";
 const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
-const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.subtle != UNDEFINED_TYPE;
-const IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.importKey == FUNCTION_TYPE;
-const DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.deriveBits == FUNCTION_TYPE;
+const subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
+const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE;
+const IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.importKey == FUNCTION_TYPE;
+const DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.deriveBits == FUNCTION_TYPE;
 const codecBytes = codec.bytes;
 const Aes = cipher.aes;
 const CtrGladman = mode.ctrGladman;
@@ -67,7 +69,6 @@ const HmacSha1 = misc.hmacSha1;
 class AESDecryptionStream extends TransformStream {
 
 	constructor(password, signed, strength) {
-		let stream;
 		super({
 			start() {
 				Object.assign(this, {
@@ -80,47 +81,51 @@ class AESDecryptionStream extends TransformStream {
 			},
 			async transform(chunk, controller) {
 				const aesCrypto = this;
-				if (aesCrypto.password) {
-					const password = aesCrypto.password;
-					aesCrypto.password = null;
-					const preamble = subarray(chunk, 0, SALT_LENGTH[aesCrypto.strength] + 2);
-					await createDecryptionKeys(aesCrypto, preamble, password);
-					aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
-					aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
-					chunk = subarray(chunk, SALT_LENGTH[aesCrypto.strength] + 2);
-					aesCrypto.resolveReady();
+				const {
+					password,
+					strength,
+					resolveReady,
+					ready
+				} = aesCrypto;
+				if (password) {
+					await createDecryptionKeys(aesCrypto, strength, password, subarray(chunk, 0, SALT_LENGTH[strength] + 2));
+					chunk = subarray(chunk, SALT_LENGTH[strength] + 2);
+					resolveReady();
 				} else {
-					await aesCrypto.ready;
+					await ready;
 				}
 				const output = new Uint8Array(chunk.length - SIGNATURE_LENGTH - ((chunk.length - SIGNATURE_LENGTH) % BLOCK_LENGTH));
 				controller.enqueue(append(aesCrypto, chunk, output, 0, SIGNATURE_LENGTH, true));
 			},
 			async flush(controller) {
-				const aesCrypto = this;
-				await aesCrypto.ready;
-				const pending = aesCrypto.pending;
+				const {
+					signed,
+					ctr,
+					hmac,
+					pending,
+					ready
+				} = this;
+				await ready;
 				const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH);
 				const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
 				let decryptedChunkArray = new Uint8Array();
 				if (chunkToDecrypt.length) {
 					const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
-					aesCrypto.hmac.update(encryptedChunk);
-					const decryptedChunk = aesCrypto.ctr.update(encryptedChunk);
+					hmac.update(encryptedChunk);
+					const decryptedChunk = ctr.update(encryptedChunk);
 					decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 				}
-				stream.valid = true;
-				if (aesCrypto.signed) {
-					const signature = subarray(fromBits(codecBytes, aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
+				if (signed) {
+					const signature = subarray(fromBits(codecBytes, hmac.digest()), 0, SIGNATURE_LENGTH);
 					for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
 						if (signature[indexSignature] != originalSignature[indexSignature]) {
-							stream.valid = false;
+							throw new Error(ERR_INVALID_SIGNATURE);
 						}
 					}
 				}
 				controller.enqueue(decryptedChunkArray);
 			}
 		});
-		stream = this;
 	}
 }
 
@@ -139,31 +144,38 @@ class AESEncryptionStream extends TransformStream {
 			},
 			async transform(chunk, controller) {
 				const aesCrypto = this;
+				const {
+					password,
+					strength,
+					resolveReady,
+					ready
+				} = aesCrypto;
 				let preamble = new Uint8Array();
-				if (aesCrypto.password) {
-					const password = aesCrypto.password;
-					aesCrypto.password = null;
-					preamble = await createEncryptionKeys(aesCrypto, password);
-					aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
-					aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
-					aesCrypto.resolveReady();
+				if (password) {
+					preamble = await createEncryptionKeys(aesCrypto, strength, password);
+					resolveReady();
 				} else {
-					await aesCrypto.ready;
+					await ready;
 				}
 				const output = new Uint8Array(preamble.length + chunk.length - (chunk.length % BLOCK_LENGTH));
 				output.set(preamble, 0);
 				controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0));
 			},
 			async flush(controller) {
-				const aesCrypto = this;
-				await aesCrypto.ready;
+				const {
+					ctr,
+					hmac,
+					pending,
+					ready
+				} = this;
+				await ready;
 				let encryptedChunkArray = new Uint8Array();
-				if (aesCrypto.pending.length) {
-					const encryptedChunk = aesCrypto.ctr.update(toBits(codecBytes, aesCrypto.pending));
-					aesCrypto.hmac.update(encryptedChunk);
+				if (pending.length) {
+					const encryptedChunk = ctr.update(toBits(codecBytes, pending));
+					hmac.update(encryptedChunk);
 					encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
 				}
-				stream.signature = fromBits(codecBytes, aesCrypto.hmac.digest()).slice(0, SIGNATURE_LENGTH);
+				stream.signature = fromBits(codecBytes, hmac.digest()).slice(0, SIGNATURE_LENGTH);
 				controller.enqueue(concat(encryptedChunkArray, stream.signature));
 			}
 		});
@@ -178,20 +190,25 @@ export {
 };
 
 function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignature) {
+	const {
+		ctr,
+		hmac,
+		pending
+	} = aesCrypto;
 	const inputLength = input.length - paddingEnd;
-	if (aesCrypto.pending.length) {
-		input = concat(aesCrypto.pending, input);
+	if (pending.length) {
+		input = concat(pending, input);
 		output = expand(output, inputLength - (inputLength % BLOCK_LENGTH));
 	}
 	let offset;
 	for (offset = 0; offset <= inputLength - BLOCK_LENGTH; offset += BLOCK_LENGTH) {
 		const inputChunk = toBits(codecBytes, subarray(input, offset, offset + BLOCK_LENGTH));
 		if (verifySignature) {
-			aesCrypto.hmac.update(inputChunk);
+			hmac.update(inputChunk);
 		}
-		const outputChunk = aesCrypto.ctr.update(inputChunk);
+		const outputChunk = ctr.update(inputChunk);
 		if (!verifySignature) {
-			aesCrypto.hmac.update(outputChunk);
+			hmac.update(outputChunk);
 		}
 		output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
 	}
@@ -199,36 +216,44 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignat
 	return output;
 }
 
-async function createDecryptionKeys(decrypt, preambleArray, password) {
-	await createKeys(decrypt, password, subarray(preambleArray, 0, SALT_LENGTH[decrypt.strength]));
-	const passwordVerification = subarray(preambleArray, SALT_LENGTH[decrypt.strength]);
-	const passwordVerificationKey = decrypt.keys.passwordVerification;
+async function createDecryptionKeys(decrypt, strength, password, preamble) {
+	const passwordVerificationKey = await createKeys(decrypt, strength, password, subarray(preamble, 0, SALT_LENGTH[strength]));
+	const passwordVerification = subarray(preamble, SALT_LENGTH[strength]);
 	if (passwordVerificationKey[0] != passwordVerification[0] || passwordVerificationKey[1] != passwordVerification[1]) {
 		throw new Error(ERR_INVALID_PASSWORD);
 	}
 }
 
-async function createEncryptionKeys(encrypt, password) {
-	const salt = getRandomValues(new Uint8Array(SALT_LENGTH[encrypt.strength]));
-	await createKeys(encrypt, password, salt);
-	return concat(salt, encrypt.keys.passwordVerification);
+async function createEncryptionKeys(encrypt, strength, password) {
+	const salt = getRandomValues(new Uint8Array(SALT_LENGTH[strength]));
+	const passwordVerification = await createKeys(encrypt, strength, password, salt);
+	return concat(salt, passwordVerification);
 }
 
-async function createKeys(target, password, salt) {
+async function createKeys(aesCrypto, strength, password, salt) {
+	aesCrypto.password = null;
 	const encodedPassword = encodeText(password);
-	const basekey = await importKey(RAW_FORMAT, encodedPassword, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
-	const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), basekey, 8 * ((KEY_LENGTH[target.strength] * 2) + 2));
+	const baseKey = await importKey(RAW_FORMAT, encodedPassword, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
+	const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), baseKey, 8 * ((KEY_LENGTH[strength] * 2) + 2));
 	const compositeKey = new Uint8Array(derivedBits);
-	target.keys = {
-		key: toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[target.strength])),
-		authentication: toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[target.strength], KEY_LENGTH[target.strength] * 2)),
-		passwordVerification: subarray(compositeKey, KEY_LENGTH[target.strength] * 2)
-	};
+	const key = toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[strength]));
+	const authentication = toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[strength], KEY_LENGTH[strength] * 2));
+	const passwordVerification = subarray(compositeKey, KEY_LENGTH[strength] * 2);
+	Object.assign(aesCrypto, {
+		keys: {
+			key,
+			authentication,
+			passwordVerification
+		},
+		ctr: new CtrGladman(new Aes(key), Array.from(COUNTER_DEFAULT_VALUE)),
+		hmac: new HmacSha1(authentication)
+	});
+	return passwordVerification;
 }
 
 function importKey(format, password, algorithm, extractable, keyUsages) {
 	if (IMPORT_KEY_SUPPORTED) {
-		return crypto.subtle.importKey(format, password, algorithm, extractable, keyUsages);
+		return subtle.importKey(format, password, algorithm, extractable, keyUsages);
 	} else {
 		return misc.importKey(password);
 	}
@@ -236,7 +261,7 @@ function importKey(format, password, algorithm, extractable, keyUsages) {
 
 async function deriveBits(algorithm, baseKey, length) {
 	if (DERIVE_BITS_SUPPORTED) {
-		return await crypto.subtle.deriveBits(algorithm, baseKey, length);
+		return await subtle.deriveBits(algorithm, baseKey, length);
 	} else {
 		return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
 	}

package/lib/core/streams/codec-stream.js

@@ -44,8 +44,7 @@ class CodecStream extends TransformStream {
 				codec = new Codec(options);
 			},
 			transform(chunk, controller) {
-				chunk = codec.append(chunk);
-				controller.enqueue(chunk);
+				controller.enqueue(codec.append(chunk));
 			},
 			flush(controller) {
 				const chunk = codec.flush();

package/lib/core/streams/common-crypto.js

@@ -35,10 +35,12 @@ import {
 } from "./codecs/sjcl.js";
 
 const ERR_INVALID_PASSWORD = "Invalid password";
+const ERR_INVALID_SIGNATURE = "Invalid signature";
 
 export {
 	getRandomValues,
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
 };
 
 function getRandomValues(array) {

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

@@ -39,7 +39,6 @@ const HEADER_LENGTH = 12;
 class ZipCryptoDecryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
-		let stream;
 		super({
 			start() {
 				Object.assign(this, {
@@ -59,12 +58,8 @@ class ZipCryptoDecryptionStream extends TransformStream {
 					chunk = chunk.subarray(HEADER_LENGTH);
 				}
 				controller.enqueue(decrypt(zipCrypto, chunk));
-			},
-			flush() {
-				stream.valid = true;
 			}
 		});
-		stream = this;
 	}
 }
 
@@ -128,21 +123,25 @@ function encrypt(target, input) {
 }
 
 function createKeys(target, password) {
-	target.keys = [0x12345678, 0x23456789, 0x34567890];
-	target.crcKey0 = new Crc32(target.keys[0]);
-	target.crcKey2 = new Crc32(target.keys[2]);
+	const keys = [0x12345678, 0x23456789, 0x34567890];
+	Object.assign(target, {
+		keys,
+		crcKey0: new Crc32(keys[0]),
+		crcKey2: new Crc32(keys[2]),
+	});
 	for (let index = 0; index < password.length; index++) {
 		updateKeys(target, password.charCodeAt(index));
 	}
 }
 
 function updateKeys(target, byte) {
+	let [key0, key1, key2] = target.keys;
 	target.crcKey0.append([byte]);
-	target.keys[0] = ~target.crcKey0.get();
-	target.keys[1] = getInt32(target.keys[1] + getInt8(target.keys[0]));
-	target.keys[1] = getInt32(Math.imul(target.keys[1], 134775813) + 1);
-	target.crcKey2.append([target.keys[1] >>> 24]);
-	target.keys[2] = ~target.crcKey2.get();
+	key0 = ~target.crcKey0.get();
+	key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1);
+	target.crcKey2.append([key1 >>> 24]);
+	key2 = ~target.crcKey2.get();
+	target.keys = [key0, key1, key2];
 }
 
 function getByte(target) {