@zip.js/zip.js 2.8.26 → 2.8.28

package/lib/core/codec-pool.js

@@ -35,12 +35,15 @@ import {
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
 	ERR_INVALID_PASSWORD,
+	ERR_INVALID_COMPRESSED_DATA,
 	ERR_ABORT_CHECK_PASSWORD
 } from "./streams/codec-stream.js";
 import { CodecWorker } from "./codec-worker.js";
 
 let pool = [];
 const pendingRequests = [];
+let starvationTimeout;
+let starvationDelay;
 
 export {
 	runWorker,
@@ -50,6 +53,7 @@ export {
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
 	ERR_INVALID_PASSWORD,
+	ERR_INVALID_COMPRESSED_DATA,
 	ERR_ABORT_CHECK_PASSWORD
 };
 
@@ -78,14 +82,20 @@ async function runWorker(stream, workerOptions) {
 			pool.push(workerData);
 			return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
 		} else {
-			return new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
+			return new Promise(resolve => {
+				pendingRequests.push({ resolve, stream, workerOptions });
+				starvationDelay = config.workerStarvationTimeout;
+				armStarvationTimeout();
+			});
 		}
 	}
 
 	function onTaskFinished(workerData) {
+		clearStarvationTimeout();
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
 			resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
+			armStarvationTimeout();
 		} else if (workerData.worker) {
 			clearTerminateTimeout(workerData);
 			terminateWorker(workerData, workerOptions);
@@ -95,6 +105,34 @@ async function runWorker(stream, workerOptions) {
 	}
 }
 
+function armStarvationTimeout() {
+	if (!starvationTimeout && pendingRequests.length && Number.isFinite(starvationDelay) && starvationDelay >= 0) {
+		starvationTimeout = setTimeout(onWorkerStarvation, starvationDelay);
+	}
+}
+
+function clearStarvationTimeout() {
+	if (starvationTimeout) {
+		clearTimeout(starvationTimeout);
+		starvationTimeout = null;
+	}
+}
+
+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 });
+		resolve(new CodecWorker({}, stream, inlineWorkerOptions, onInlineTaskFinished));
+		armStarvationTimeout();
+	}
+}
+
+function onInlineTaskFinished() {
+	clearStarvationTimeout();
+	armStarvationTimeout();
+}
+
 function terminateWorker(workerData, workerOptions) {
 	const { config } = workerOptions;
 	const { terminateWorkerTimeout } = config;

package/lib/core/codec-worker.js

@@ -26,13 +26,14 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Worker, URL, TransformStream, WritableStream */
+/* global Worker, URL, TransformStream, AbortController, structuredClone, DOMException */
 
 import {
 	UNDEFINED_VALUE,
 	UNDEFINED_TYPE,
 	FUNCTION_TYPE
 } from "./constants.js";
+import { getChunkSize } from "./configuration.js";
 import {
 	CodecStream,
 	ChunkStream,
@@ -45,8 +46,10 @@ import {
 } from "./streams/codec-stream.js";
 
 const MODULE_WORKER_OPTIONS = { type: "module" };
+const ERROR_EVENT_TYPE = "error";
+const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
 
-let webWorkerSupported, webWorkerURI, webWorkerOptions;
+let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions;
 let transferStreamsSupported = true;
 try {
 	transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
@@ -70,8 +73,9 @@ class CodecWorker {
 		const { signal } = streamOptions;
 		Object.assign(workerData, {
 			busy: true,
+			generation: (workerData.generation || 0) + 1,
 			readable: readable
-				.pipeThrough(new ChunkStream(config.chunkSize))
+				.pipeThrough(new ChunkStream(getChunkSize(config)))
 				.pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
@@ -94,15 +98,17 @@ class CodecWorker {
 				});
 			},
 			onTaskFinished() {
-				const { resolveTerminated } = workerData;
-				if (resolveTerminated) {
-					workerData.resolveTerminated = null;
-					workerData.terminated = true;
-					workerData.worker.terminate();
-					resolveTerminated();
+				if (workerData.busy) {
+					const { resolveTerminated } = workerData;
+					if (resolveTerminated) {
+						workerData.resolveTerminated = null;
+						workerData.terminated = true;
+						workerData.worker.terminate();
+						resolveTerminated();
+					}
+					workerData.busy = false;
+					onTaskFinished(workerData);
 				}
-				workerData.busy = false;
-				onTaskFinished(workerData);
 			}
 		});
 		if (webWorkerSupported === UNDEFINED_VALUE) {
@@ -171,6 +177,7 @@ function createWebWorkerInterface(workerData, config) {
 		}
 		Object.assign(workerData, {
 			worker,
+			terminated: false,
 			interface: {
 				run: () => runWebWorker(workerData, { chunkSize, wasmURI, baseURI })
 			}
@@ -225,37 +232,85 @@ async function runWebWorker(workerData, config) {
 		result
 	});
 	const { readable, options } = workerData;
-	const { writable, closed } = watchClosedStream(workerData.writable);
-	const streamsTransferred = sendMessage({
-		type: MESSAGE_START,
-		options,
-		config,
-		readable,
-		writable
-	}, workerData);
+	const { writable, closed, abortPipe } = watchClosedStream(workerData.writable);
+	let streamsTransferred;
+	try {
+		streamsTransferred = sendMessage({
+			type: MESSAGE_START,
+			options,
+			config,
+			readable,
+			writable
+		}, workerData);
+	} catch (error) {
+		abortPipe();
+		try {
+			await closed;
+		} catch {
+			// ignored
+		}
+		workerData.onTaskFinished();
+		throw error;
+	}
 	if (!streamsTransferred) {
 		Object.assign(workerData, {
 			reader: readable.getReader(),
 			writer: writable.getWriter()
 		});
 	}
-	const resultValue = await result;
-	if (!streamsTransferred) {
-		await writable.getWriter().close();
+	try {
+		const resultValue = await result;
+		await closeWritable();
+		await closed;
+		return resultValue;
+	} catch (error) {
+		await closeWritable();
+		// unblock the pipe watcher if the worker died before closing its end of the stream
+		abortPipe();
+		try {
+			await closed;
+		} catch {
+			// ignored
+		}
+		throw error;
+	}
+
+	async function closeWritable() {
+		if (!streamsTransferred && !writable.locked) {
+			try {
+				await writable.getWriter().close();
+			} catch {
+				// ignored
+			}
+		}
 	}
-	await closed;
-	return resultValue;
 }
 
 function watchClosedStream(writableSource) {
+	const abortController = new AbortController();
 	const { writable, readable } = new TransformStream();
-	const closed = readable.pipeTo(writableSource, { preventClose: true });
-	return { writable, closed };
+	const closed = readable.pipeTo(writableSource, { preventClose: true, preventAbort: true, signal: abortController.signal });
+	// the pipe can fail before `closed` is awaited (e.g. the destination write fails);
+	// mark the rejection as handled so it cannot kill the process in the meantime
+	closed.catch(() => { });
+	return { writable, closed, abortPipe: () => abortController.abort() };
+}
+
+function terminateWorker(workerData) {
+	const { worker } = workerData;
+	if (worker) {
+		try {
+			worker.terminate();
+		} catch {
+			// ignored
+		}
+	}
+	workerData.interface = null;
 }
 
 function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true) {
 	let worker, resolvedURI, resolvedOptions;
-	if (webWorkerURI === UNDEFINED_VALUE) {
+	if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
 		// deno-lint-ignore valid-typeof
 		const isFunctionURI = typeof url == FUNCTION_TYPE;
 		if (isFunctionURI) {
@@ -312,16 +367,36 @@ function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true)
 				}
 			}
 		}
+		webWorkerSource = url;
 		webWorkerURI = resolvedURI;
 		webWorkerOptions = resolvedOptions;
 	} else {
 		worker = new Worker(webWorkerURI, webWorkerOptions);
 	}
 	worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));
+	worker.addEventListener(ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
+	worker.addEventListener(MESSAGE_ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
 	return worker;
 }
 
-function sendMessage(message, { worker, writer, onTaskFinished, transferStreams }) {
+function onWorkerError(event, workerData) {
+	if (event.preventDefault) {
+		event.preventDefault();
+	}
+	const { rejectResult, writer, onTaskFinished } = workerData;
+	// the worker is unusable (e.g. its script failed to load); terminate it and
+	// fail the current task instead of letting it hang forever
+	terminateWorker(workerData);
+	if (rejectResult) {
+		rejectResult(event.error || new Error(event.message || ERROR_EVENT_TYPE));
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+	}
+}
+
+function sendMessage(message, { worker, writer, transferStreams }) {
 	try {
 		const { value, readable, writable } = message;
 		const transferables = [];
@@ -355,14 +430,16 @@ function sendMessage(message, { worker, writer, onTaskFinished, transferStreams
 		if (writer) {
 			writer.releaseLock();
 		}
-		onTaskFinished();
 		throw error;
 	}
 }
 
 async function onMessage({ data }, workerData) {
 	const { type, value, messageId, result, error } = data;
-	const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
+	const { reader, writer, resolveResult, rejectResult, onTaskFinished, generation } = workerData;
+	// continuations below can settle after the worker slot has been reassigned to a new
+	// task (e.g. a pending pull read failing late); they must not touch the new task
+	const stale = () => workerData.generation != generation;
 	try {
 		if (error) {
 			const { message, stack, code, name, outputSize } = error;
@@ -372,23 +449,32 @@ async function onMessage({ data }, workerData) {
 		} else {
 			if (type == MESSAGE_PULL) {
 				const { value, done } = await reader.read();
-				sendMessage({ type: MESSAGE_DATA, value, done, messageId }, workerData);
+				if (!stale()) {
+					sendMessage({ type: MESSAGE_DATA, value, done, messageId }, workerData);
+				}
 			}
 			if (type == MESSAGE_DATA) {
 				await writer.ready;
 				await writer.write(new Uint8Array(value));
-				sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
+				if (!stale()) {
+					sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
+				}
 			}
 			if (type == MESSAGE_CLOSE) {
 				close(null, result);
 			}
 		}
 	} catch (error) {
-		sendMessage({ type: MESSAGE_CLOSE, messageId }, workerData);
-		close(error);
+		if (!stale()) {
+			terminateWorker(workerData);
+			close(error);
+		}
 	}
 
 	function close(error, result) {
+		if (stale()) {
+			return;
+		}
 		if (error) {
 			rejectResult(error);
 		} else {

package/lib/core/configuration.js

@@ -48,6 +48,7 @@ const DEFAULT_CONFIGURATION = {
 	chunkSize: 64 * 1024,
 	maxWorkers,
 	terminateWorkerTimeout: 5000,
+	workerStarvationTimeout: 5000,
 	useWebWorkers: true,
 	useCompressionStream: true,
 	CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
@@ -76,6 +77,7 @@ function configure(configuration) {
 		chunkSize,
 		maxWorkers,
 		terminateWorkerTimeout,
+		workerStarvationTimeout,
 		useCompressionStream,
 		useWebWorkers,
 		CompressionStream,
@@ -91,6 +93,7 @@ function configure(configuration) {
 	setIfDefined("chunkSize", chunkSize);
 	setIfDefined("maxWorkers", maxWorkers);
 	setIfDefined("terminateWorkerTimeout", terminateWorkerTimeout);
+	setIfDefined("workerStarvationTimeout", workerStarvationTimeout);
 	setIfDefined("useCompressionStream", useCompressionStream);
 	setIfDefined("useWebWorkers", useWebWorkers);
 	setIfDefined("CompressionStream", CompressionStream);

package/lib/core/constants.js

@@ -41,6 +41,7 @@ const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
 const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE = 0x07064b50;
+const CENTRAL_FILE_HEADER_LENGTH = 46;
 const END_OF_CENTRAL_DIR_LENGTH = 22;
 const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
 const ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
@@ -88,9 +89,11 @@ const VERSION_AES = 0x33;
 const DIRECTORY_SIGNATURE = "/";
 
 const HEADER_SIZE = 30;
+const HEADER_OFFSET_VERSION = 0;
 const HEADER_OFFSET_SIGNATURE = 10;
 const HEADER_OFFSET_COMPRESSED_SIZE = 14;
 const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
+const LOCAL_HEADER_COMMON_OFFSET = 4;
 
 const MAX_DATE = new Date(2107, 11, 31);
 const MIN_DATE = new Date(1980, 0, 1);
@@ -113,6 +116,7 @@ export {
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
+	CENTRAL_FILE_HEADER_LENGTH,
 	END_OF_CENTRAL_DIR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_SIGNATURE,
@@ -156,9 +160,11 @@ export {
 	VERSION_ZIP64,
 	VERSION_AES,
 	HEADER_SIZE,
+	HEADER_OFFSET_VERSION,
 	HEADER_OFFSET_SIGNATURE,
 	HEADER_OFFSET_COMPRESSED_SIZE,
 	HEADER_OFFSET_UNCOMPRESSED_SIZE,
+	LOCAL_HEADER_COMMON_OFFSET,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
 	MAX_DATE,

package/lib/core/io.js

@@ -44,6 +44,7 @@ const ERR_WRITER_NOT_INITIALIZED = "Writer not initialized";
 
 const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
 const HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
+const HTTP_HEADER_CONTENT_ENCODING = "Content-Encoding";
 const HTTP_HEADER_CONTENT_RANGE = "Content-Range";
 const HTTP_HEADER_ACCEPT_RANGES = "Accept-Ranges";
 const HTTP_HEADER_RANGE = "Range";
@@ -168,7 +169,7 @@ class Data64URIWriter extends Writer {
 
 	writeUint8Array(array) {
 		const writer = this;
-		let indexArray = 0;
+		let indexArray;
 		let dataString = writer.pending;
 		const delta = writer.pending.length;
 		writer.pending = "";
@@ -178,12 +179,10 @@ class Data64URIWriter extends Writer {
 		for (; indexArray < array.length; indexArray++) {
 			writer.pending += String.fromCharCode(array[indexArray]);
 		}
-		if (dataString.length) {
-			if (dataString.length > 2) {
-				writer.data += btoa(dataString);
-			} else {
-				writer.pending += dataString;
-			}
+		if (dataString.length > 2) {
+			writer.data += btoa(dataString);
+		} else {
+			writer.pending = dataString + writer.pending;
 		}
 	}
 
@@ -230,6 +229,9 @@ class BlobWriter extends Stream {
 			}
 		});
 		writer.blob = new Response(transformStream.readable, { headers }).blob();
+		// mark early rejections (e.g. aborted pipe) as handled; awaiting getData() still
+		// surfaces them
+		writer.blob.catch(() => { });
 	}
 
 	getData() {
@@ -314,7 +316,8 @@ function createHttpReader(httpReader, url, options) {
 		preventHeadRequest,
 		useRangeHeader,
 		forceRangeRequests,
-		combineSizeEocd
+		combineSizeEocd,
+		fetch
 	} = options;
 	options = Object.assign({}, options);
 	delete options.preventHeadRequest;
@@ -322,13 +325,15 @@ function createHttpReader(httpReader, url, options) {
 	delete options.forceRangeRequests;
 	delete options.combineSizeEocd;
 	delete options.useXHR;
+	delete options.fetch;
 	Object.assign(httpReader, {
 		url,
 		options,
 		preventHeadRequest,
 		useRangeHeader,
 		forceRangeRequests,
-		combineSizeEocd
+		combineSizeEocd,
+		fetch
 	});
 }
 
@@ -347,7 +352,10 @@ async function initHttpReader(httpReader, sendRequest, getRequestData) {
 			throw new Error(ERR_HTTP_RANGE);
 		} else {
 			if (combineSizeEocd) {
-				httpReader.eocdCache = new Uint8Array(await response.arrayBuffer());
+				const eocdCache = new Uint8Array(await response.arrayBuffer());
+				if (response.status == 206 && eocdCache.length == END_OF_CENTRAL_DIR_LENGTH) {
+					httpReader.eocdCache = eocdCache;
+				}
 			}
 			let contentSize;
 			const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
@@ -393,7 +401,18 @@ async function readUint8ArrayHttpReader(httpReader, index, length, sendRequest,
 			if (response.status != 206) {
 				throw new Error(ERR_HTTP_RANGE);
 			}
-			return new Uint8Array(await response.arrayBuffer());
+			const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
+			if (contentRangeHeader) {
+				const rangeStart = Number(contentRangeHeader.trim().split(/[\s-]+/)[1]);
+				if (!Number.isNaN(rangeStart) && rangeStart != index) {
+					throw new Error(ERR_HTTP_RANGE);
+				}
+			}
+			const data = new Uint8Array(await response.arrayBuffer());
+			if (data.length != length) {
+				throw new Error(ERR_HTTP_RANGE);
+			}
+			return data;
 		}
 	} else {
 		const { data } = httpReader;
@@ -430,9 +449,9 @@ async function getXMLHttpRequestData(httpReader) {
 async function getRequestData(httpReader, sendRequest) {
 	const response = await sendRequest(HTTP_METHOD_GET, httpReader, getHeaders(httpReader));
 	httpReader.data = new Uint8Array(await response.arrayBuffer());
-	if (!httpReader.size) {
-		httpReader.size = httpReader.data.length;
-	}
+	// the downloaded content is authoritative, e.g. the Content-Length response header
+	// of the HEAD request can be the encoded size when the content is compressed
+	httpReader.size = httpReader.data.length;
 }
 
 async function getContentLength(httpReader, sendRequest, getRequestData) {
@@ -441,7 +460,7 @@ async function getContentLength(httpReader, sendRequest, getRequestData) {
 	} else {
 		const response = await sendRequest(HTTP_METHOD_HEAD, httpReader, getHeaders(httpReader));
 		const contentLength = response.headers.get(HTTP_HEADER_CONTENT_LENGTH);
-		if (contentLength) {
+		if (contentLength && !response.headers.get(HTTP_HEADER_CONTENT_ENCODING)) {
 			httpReader.size = Number(contentLength);
 		} else {
 			await getRequestData(httpReader, httpReader.options);
@@ -449,8 +468,8 @@ async function getContentLength(httpReader, sendRequest, getRequestData) {
 	}
 }
 
-async function sendFetchRequest(method, { options, url }, headers) {
-	const response = await fetch(url, Object.assign({}, options, { method, headers }));
+async function sendFetchRequest(method, { fetch: fetchFunction = fetch, options, url }, headers) {
+	const response = await fetchFunction(url, Object.assign({}, options, { method, headers }));
 	if (response.status < 400) {
 		return response;
 	} else {
@@ -496,7 +515,8 @@ class HttpReader extends Reader {
 		super();
 		Object.assign(this, {
 			url,
-			reader: options.useXHR ? new XHRReader(url, options) : new FetchReader(url, options)
+			// an explicit fetch implementation takes precedence over useXHR
+			reader: options.useXHR && !options.fetch ? new XHRReader(url, options) : new FetchReader(url, options)
 		});
 	}
 
@@ -521,8 +541,7 @@ class HttpReader extends Reader {
 class HttpRangeReader extends HttpReader {
 
 	constructor(url, options = {}) {
-		options.useRangeHeader = true;
-		super(url, options);
+		super(url, Object.assign({}, options, { useRangeHeader: true }));
 	}
 }
 
@@ -596,7 +615,7 @@ class SplitDataReader extends Reader {
 		reader.lastDiskNumber = 0;
 		reader.lastDiskOffset = 0;
 		await Promise.all(readers.map(async (diskReader, indexDiskReader) => {
-			await diskReader.init();
+			await initStream(diskReader);
 			if (indexDiskReader != readers.length - 1) {
 				reader.lastDiskOffset += diskReader.size;
 			}
@@ -680,14 +699,26 @@ class SplitDataWriter extends Stream {
 					writer.diskOffset += diskSourceWriter.size;
 					writer.diskNumber++;
 					diskWriter = null;
-					await this.write(chunk.subarray(availableSize));
+					// the next disk is not opened yet but its space is available; leaving a
+					// stale value here would force a new disk for every subsequent write
+					writer.availableSize = writer.maxSize;
+					if (chunk.length > availableSize) {
+						await this.write(chunk.subarray(availableSize));
+					}
 				} else {
 					await writeChunk(chunk);
 				}
 			},
 			async close() {
-				await diskWriter.ready;
-				await closeDisk();
+				if (diskWriter) {
+					await diskWriter.ready;
+					await closeDisk();
+				}
+			},
+			async abort(reason) {
+				if (diskWriter) {
+					await diskWriter.abort(reason);
+				}
 			}
 		});
 		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
@@ -702,7 +733,6 @@ class SplitDataWriter extends Stream {
 				await diskWriter.ready;
 				await diskWriter.write(chunk);
 				diskSourceWriter.size += chunkLength;
-				writer.size += chunkLength;
 				writer.availableSize -= chunkLength;
 			}
 		}

package/lib/core/options.js

@@ -38,6 +38,7 @@ const OPTION_SIGNAL = "signal";
 const OPTION_CHECK_PASSWORD_ONLY = "checkPasswordOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
+const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
 const OPTION_CHECK_SIGNATURE = "checkSignature";
 const OPTION_USE_WEB_WORKERS = "useWebWorkers";
 const OPTION_USE_COMPRESSION_STREAM = "useCompressionStream";
@@ -71,6 +72,7 @@ export {
 	OPTION_CHECK_PASSWORD_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY,
+	OPTION_CHECK_AMBIGUITY,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_USE_WEB_WORKERS,
 	OPTION_USE_COMPRESSION_STREAM,

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

@@ -70,13 +70,12 @@ let DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && type
 
 class AESDecryptionStream extends TransformStream {
 
-	constructor({ password, rawPassword, signed, encryptionStrength, checkPasswordOnly }) {
+	constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly }) {
 		super({
 			start() {
 				Object.assign(this, {
 					ready: new Promise(resolve => this.resolveReady = resolve),
 					password: encodePassword(password, rawPassword),
-					signed,
 					strength: encryptionStrength - 1,
 					pending: new Uint8Array()
 				});
@@ -105,7 +104,6 @@ class AESDecryptionStream extends TransformStream {
 			},
 			async flush(controller) {
 				const {
-					signed,
 					ctr,
 					hmac,
 					pending,
@@ -122,13 +120,15 @@ class AESDecryptionStream extends TransformStream {
 						const decryptedChunk = ctr.update(encryptedChunk);
 						decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 					}
-					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]) {
-								throw new Error(ERR_INVALID_SIGNATURE);
-							}
-						}
+					const signature = subarray(fromBits(codecBytes, hmac.digest()), 0, SIGNATURE_LENGTH);
+					// branch-free comparison: accumulate the differences instead of
+					// short-circuiting on the first mismatching byte
+					let invalidSignature = pending.length < SIGNATURE_LENGTH ? 1 : 0;
+					for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
+						invalidSignature |= signature[indexSignature] ^ originalSignature[indexSignature];
+					}
+					if (invalidSignature) {
+						throw new Error(ERR_INVALID_SIGNATURE);
 					}
 					controller.enqueue(decryptedChunkArray);
 				}
@@ -206,11 +206,11 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignat
 		hmac,
 		pending
 	} = aesCrypto;
-	const inputLength = input.length - paddingEnd;
 	if (pending.length) {
 		input = concat(pending, input);
-		output = expand(output, inputLength - (inputLength % BLOCK_LENGTH));
 	}
+	const inputLength = input.length - paddingEnd;
+	output = expand(output, paddingStart + (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));