@zip.js/zip.js 2.8.30 → 2.8.32

package/lib/core/zip-fs.js

@@ -78,8 +78,6 @@ class ZipEntry {
 			uncompressedSize: params.uncompressedSize || 0,
 			passThrough: params.passThrough
 		});
-		// detached entries (e.g. clones) are not registered until they are attached,
-		// otherwise they could never be garbage collected
 		if (parent || !fs.root) {
 			fs.entries[zipEntry.id] = zipEntry;
 		}
@@ -148,7 +146,7 @@ class ZipFileEntry extends ZipEntry {
 		if (!writer || (writer.constructor == zipEntry.Writer && zipEntry.data)) {
 			return zipEntry.data;
 		} else {
-			const reader = zipEntry.reader = new zipEntry.Reader(zipEntry.data, options);
+			const reader = zipEntry.reader = createReader(zipEntry.Reader, zipEntry.data, options);
 			const uncompressedSize = zipEntry.data ? zipEntry.data.uncompressedSize : reader.size;
 			await Promise.all([initStream(reader), initStream(writer, uncompressedSize)]);
 			const { readable } = reader;
@@ -204,11 +202,7 @@ class ZipFileEntry extends ZipEntry {
 	}
 
 	async getArrayBuffer(options) {
-		// this.data may be a string, a Uint8Array, a data URI or a Blob depending on how the entry
-		// was created, so retrieve the bytes through getUint8Array rather than assuming a Blob; this
-		// also applies the options (password, signal, onprogress...) like the other getData() getters
 		const array = await this.getUint8Array(options);
-		// return the backing buffer directly when the array spans it, slicing the exact bytes otherwise
 		return array.byteOffset || array.byteLength != array.buffer.byteLength
 			? array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength)
 			: array.buffer;
@@ -578,7 +572,6 @@ class FS {
 			node = node.getChildByName(path[index]);
 		}
 		if (!node) {
-			// exclude detached entries, e.g. clones registered in `entries` but not attached
 			node = this.entries.find(entry => entry && (entry == this.root || entry.isDescendantOf(this.root)) &&
 				entry.getRelativeName() == fullname);
 		}
@@ -751,10 +744,13 @@ function getZipBlobReader(options) {
 	};
 }
 
+function createReader(Reader, data, options) {
+	return Reader.prototype ? new Reader(data, options) : Reader(data, options);
+}
+
 async function initReaders(entry, options) {
 	const fileEntries = [];
 	const pendingEntries = [entry];
-	// per-export map so concurrent exports do not share (and lock) the same readers
 	const readers = new Map();
 	while (pendingEntries.length) {
 		const pendingEntry = pendingEntries.pop();
@@ -767,7 +763,7 @@ async function initReaders(entry, options) {
 		}
 	}
 	await Promise.all(fileEntries.map(async child => {
-		const reader = child.reader = new child.Reader(child.data, options);
+		const reader = child.reader = createReader(child.Reader, child.data, options);
 		readers.set(child, reader);
 		try {
 			await initStream(reader);
@@ -932,7 +928,6 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 	return directoryHandle;
 
 	async function exportChildren(entry, parentHandle) {
-		// Separate files have no ordering constraint, so they can be written concurrently on demand.
 		if (options.concurrent) {
 			const results = await Promise.allSettled(entry.children.map(child => exportChild(child, parentHandle)));
 			const failedResult = results.find(result => result.status == "rejected");
@@ -954,8 +949,6 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 			} else {
 				const fileHandle = await parentHandle.getFileHandle(child.name, { create: true });
 				const writable = await fileHandle.createWritable();
-				// getData() streams the entry's data into `writable` and closes it (a FileSystemWritableFileStream
-				// only commits the file on close), applying options such as password, signal and onprogress.
 				await child.getData({ writable }, Object.assign({}, options, {
 					onprogress: async progress => {
 						if (options.onprogress) {

package/lib/core/zip-reader.js

@@ -82,7 +82,8 @@ import {
 	COMPRESSION_METHOD_DEFLATE_64,
 	FILE_ATTR_UNIX_SETUID_MASK,
 	FILE_ATTR_UNIX_SETGID_MASK,
-	FILE_ATTR_UNIX_STICKY_MASK
+	FILE_ATTR_UNIX_STICKY_MASK,
+	EMPTY_UINT8_ARRAY
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -164,8 +165,6 @@ const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 const CHARSET_CP437 = "cp437";
-// bits of the general purpose flag that change how an entry is interpreted; the level bits (1-2) are excluded
-// because they are informative only
 const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_LANG_ENCODING_FLAG;
 const ZIP64_PROPERTIES = [
 	[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
@@ -207,7 +206,6 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
-		reader.chunkSize = getChunkSize(config);
 		const strictness = getStrictness(getOptionValue(zipReader, options, OPTION_STRICTNESS), getOptionValue(zipReader, options, OPTION_CHECK_AMBIGUITY));
 		const checkAmbiguity = strictness == STRICTNESS_STRICT;
 		const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
@@ -222,8 +220,6 @@ class ZipReader {
 				throw new Error(ERR_EOCDR_NOT_FOUND);
 			}
 		}
-		// two or more end-anchored records that each dereference to a valid central directory cannot be told
-		// apart (see comment_length ⟺ EOF): the archive is genuinely ambiguous, so refuse rather than guess
 		if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
 			throwAmbiguousArchive("multiple end of central directory records");
 		}
@@ -246,7 +242,7 @@ class ZipReader {
 		if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS) {
 			const endOfDirectoryLocatorArray = endOfDirectoryInfo.offset >= ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH ?
 				await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH) :
-				new Uint8Array();
+				EMPTY_UINT8_ARRAY;
 			const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
 			if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
 				getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
@@ -313,12 +309,6 @@ class ZipReader {
 			}
 			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength - (reader.lastDiskOffset || 0);
 			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
-				// the reconciled offset (the directory ends exactly where the canonical record begins) is anchored
-				// to the unforgeable end of the archive; the stored offset is not. Prefer the reconciled offset
-				// unless the stored one points at a directory and the reconciled one does not — that exception
-				// keeps a corrupt declared directory length from sending the read astray, while still moving off a
-				// stored offset that only looks valid because an append remnant left the previous (identically
-				// laid out) directory sitting there.
 				const storedPointsAtDirectory = getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
 				let reconcile = !storedPointsAtDirectory;
 				if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
@@ -475,11 +465,11 @@ class ZipReader {
 		const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 		if (extractPrependedData) {
-			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : new Uint8Array();
+			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : EMPTY_UINT8_ARRAY;
 		}
-		zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : new Uint8Array();
+		zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : EMPTY_UINT8_ARRAY;
 		if (extractAppendedData) {
-			zipReader.appendedData = appendedDataOffset < reader.size ? await readUint8Array(reader, appendedDataOffset, reader.size - appendedDataOffset) : new Uint8Array();
+			zipReader.appendedData = appendedDataOffset < reader.size ? await readUint8Array(reader, appendedDataOffset, reader.size - appendedDataOffset) : EMPTY_UINT8_ARRAY;
 		}
 		return true;
 	}
@@ -612,7 +602,7 @@ class ZipEntry {
 			filenameLength
 		} = localDirectory;
 		const checkAmbiguity = getStrictness(getOptionValue(zipEntry, options, OPTION_STRICTNESS), getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
-		let rawLocalFilename = new Uint8Array();
+		let rawLocalFilename = EMPTY_UINT8_ARRAY;
 		if (checkAmbiguity && (filenameLength || extraFieldLength)) {
 			const trailingDataArray = await readUint8Array(reader, offset + HEADER_SIZE, filenameLength + extraFieldLength, diskNumberStart);
 			rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
@@ -620,7 +610,7 @@ class ZipEntry {
 		} else {
 			localDirectory.rawExtraField = extraFieldLength ?
 				await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
-				new Uint8Array();
+				EMPTY_UINT8_ARRAY;
 		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
 		if (checkAmbiguity) {
@@ -647,12 +637,7 @@ class ZipEntry {
 		}
 		const dataOffset = offset + HEADER_SIZE + filenameLength + extraFieldLength;
 		const size = compressedSize;
-		const readable = reader.readable;
-		Object.assign(readable, {
-			diskNumberStart,
-			offset: dataOffset,
-			size
-		});
+		const readable = reader.createReadable({ offset: dataOffset, size, diskNumberStart, chunkSize: getChunkSize(config) });
 		const signal = getOptionValue(zipEntry, options, OPTION_SIGNAL);
 		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
@@ -923,7 +908,6 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		const view = getDataView(new Uint8Array(extraField.data));
 		let uid, gid;
 		if (isInfoZip) {
-			// Info-ZIP New Unix "ux" field (0x7875): version + variable-length uid/gid
 			let offset = 0;
 			const version = getUint8(view, offset++);
 			const uidSize = getUint8(view, offset++);
@@ -933,8 +917,6 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 			gid = unpackUnixId(extraField.data.subarray(offset, offset + gidSize));
 			Object.assign(extraField, { version, uid, gid });
 		} else if (extraField.data.length >= 4) {
-			// Info-ZIP Unix "Ux" field (0x7855): fixed 2-byte uid + gid (the file mode, if any, is
-			// carried in the external file attributes, not here)
 			uid = getUint16(view, 0);
 			gid = getUint16(view, 2);
 			Object.assign(extraField, { uid, gid });
@@ -986,7 +968,6 @@ function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory,
 	timeProperties.forEach((propertyName, indexProperty) => {
 		if (extraFieldExtendedTimestamp.data.length >= offset + 4) {
 			const time = getUint32(extraFieldView, offset);
-			// the extended timestamp is a signed 32-bit time_t value
 			directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date((time | 0) * 1000);
 			const rawPropertyName = timeRawProperties[indexProperty];
 			extraFieldExtendedTimestamp[rawPropertyName] = time;
@@ -1063,7 +1044,6 @@ async function detectOverlappingEntry({
 
 function getStrictness(strictness, checkAmbiguity) {
 	if (strictness === UNDEFINED_VALUE) {
-		// `checkAmbiguity: true` is kept as a backward-compatible alias for the strictest mode
 		return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
 	}
 	return strictness;
@@ -1074,81 +1054,45 @@ function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
 		return maxAppendedDataSize;
 	}
 	if (strictness == STRICTNESS_STRICT) {
-		// the comment must reach the end of the file: no trailing data tolerated
 		return 0;
 	}
 	if (strictness == STRICTNESS_TOLERANT) {
 		return Infinity;
 	}
-	// balanced: tolerate up to a legal comment's worth of trailing data (a 16-bit length); beyond that the
-	// trailing bytes cannot hide inside a comment, so they are treated as a second thing bolted onto the file
 	return MAX_16_BITS;
 }
 
-// cap on how many out-of-window central directory probes the scan below may issue. A legitimate archive needs
-// at most a couple (the canonical record, plus one more to detect genuine ambiguity); every other reachability
-// check is served from the tail window already in memory. The cap keeps an archive whose comment is stuffed
-// with unreachable end-anchored records from forcing an unbounded number of (potentially remote) reads.
 const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
 
-// reachability rankings for an end-anchored candidate record (see getCentralDirectoryReachability)
 const CENTRAL_DIRECTORY_UNREACHABLE = 0;
 const CENTRAL_DIRECTORY_PLAUSIBLE = 1;
 const CENTRAL_DIRECTORY_REACHABLE = 2;
 
-// Locates the authoritative end of central directory record. The canonical record is the last one whose
-// declared comment reaches exactly the end of the file ("end-anchored") and that points to a central directory
-// ("reachable"); earlier signatures (stale append remnants, bytes embedded in a comment) are ignored. When two
-// or more end-anchored records point to a central directory the archive is ambiguous, and the count is returned
-// so the caller can refuse it. A record that reaches the end of the file but points to no central directory (an
-// empty archive) is only "plausible": it cannot be corroborated, so it never counts towards ambiguity and is
-// chosen only when no reachable record exists — otherwise an empty record forged in a comment could outrank the
-// genuine directory. When no record is end-anchored (appended data or an oversized comment), falls back to the
-// last record within the tolerated window that points to a directory (see seekEndOfCentralDirectory).
 async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDataSize) {
 	const { size } = reader;
-	// an end-anchored record can only live within the last END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS bytes,
-	// since the comment length that ties it to the end of the file is a 16-bit field
 	const anchoredLength = Math.min(size, END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS);
-	const anchoredOffset = size - anchoredLength;
-	const anchoredArray = await readUint8Array(reader, anchoredOffset, anchoredLength);
-	const anchoredView = getDataView(anchoredArray);
 	const remoteProbeBudget = { count: MAX_END_OF_CENTRAL_DIR_PROBES };
 	let endOfDirectoryInfo;
 	let plausibleEndOfDirectoryInfo;
 	let endOfDirectoryReachingEndCount = 0;
-	for (let indexByte = anchoredArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
-		if (getUint32(anchoredView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
-			const offset = anchoredOffset + indexByte;
-			const commentLength = getUint16(anchoredView, indexByte + 20);
-			// end-anchored: the declared comment extends exactly to the end of the file. The comment length is
-			// attacker-controlled, but the reconciliation against the (unforgeable) end of file is not.
-			if (offset + END_OF_CENTRAL_DIR_LENGTH + commentLength == size) {
-				const reachability = await getCentralDirectoryReachability(reader, anchoredView, anchoredOffset, indexByte, offset, size, remoteProbeBudget);
-				if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
-					if (!endOfDirectoryInfo) {
-						endOfDirectoryInfo = {
-							offset,
-							buffer: anchoredArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer
-						};
-					}
-					endOfDirectoryReachingEndCount++;
-					// the canonical record (highest offset) is found first; a second one is enough to flag ambiguity
-					if (!rejectAmbiguous || endOfDirectoryReachingEndCount > 1) {
-						break;
-					}
-				} else if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleEndOfDirectoryInfo) {
-					plausibleEndOfDirectoryInfo = {
-						offset,
-						buffer: anchoredArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer
-					};
+	for await (const [anchoredView, anchoredOffset, anchoredArray, indexByte, offset] of scanEndOfCentralDirectory(reader, anchoredLength)) {
+		const commentLength = getUint16(anchoredView, indexByte + 20);
+		if (offset + END_OF_CENTRAL_DIR_LENGTH + commentLength == size) {
+			const reachability = await getCentralDirectoryReachability(reader, anchoredView, anchoredOffset, indexByte, offset, size, remoteProbeBudget);
+			if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
+				if (!endOfDirectoryInfo) {
+					endOfDirectoryInfo = getEndOfCentralDirectoryInfo(anchoredArray, indexByte, offset);
 				}
+				endOfDirectoryReachingEndCount++;
+				if (!rejectAmbiguous || endOfDirectoryReachingEndCount > 1) {
+					break;
+				}
+			} else if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleEndOfDirectoryInfo) {
+				plausibleEndOfDirectoryInfo = getEndOfCentralDirectoryInfo(anchoredArray, indexByte, offset);
 			}
 		}
 	}
 	if (!endOfDirectoryInfo) {
-		// no record points to a directory: prefer a plausible (empty) end-anchored record before scanning the
-		// tolerated window for a bare signature
 		endOfDirectoryInfo = plausibleEndOfDirectoryInfo;
 	}
 	if (!endOfDirectoryInfo) {
@@ -1157,69 +1101,53 @@ async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDat
 	return { endOfDirectoryInfo, endOfDirectoryReachingEndCount };
 }
 
-// Fallback for findEndOfCentralDirectory when no record is end-anchored: appended data or an oversized comment
-// pushed the record's declared comment past the end of the file, so its position can no longer be reconciled
-// against the end of the file. Scans the tolerated window from the end and returns the first record that points
-// to a central directory, so a stray signature embedded in appended data cannot hijack discovery (which the
-// anchored scan already prevents for anchored records). Falls back to the first plausible (empty) record, then
-// to the last bare signature, so a degenerate archive still opens as before. The window ends at the file, so the
-// same in-window / metered reads as the anchored scan apply.
 async function seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget) {
 	const { size } = reader;
 	const searchLength = Math.min(size, maxAppendedDataSize == Infinity ? size :
 		END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS + maxAppendedDataSize);
-	const searchOffset = size - searchLength;
-	const searchArray = await readUint8Array(reader, searchOffset, searchLength);
-	const searchView = getDataView(searchArray);
 	let firstSignatureInfo, plausibleInfo;
-	for (let indexByte = searchArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
-		if (getUint32(searchView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
-			const offset = searchOffset + indexByte;
-			const record = { offset, buffer: searchArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer };
-			if (!firstSignatureInfo) {
-				firstSignatureInfo = record;
-			}
-			const reachability = await getCentralDirectoryReachability(reader, searchView, searchOffset, indexByte, offset, size, remoteProbeBudget);
-			if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
-				return record;
-			}
-			if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleInfo) {
-				plausibleInfo = record;
-			}
+	for await (const [searchView, searchOffset, searchArray, indexByte, offset] of scanEndOfCentralDirectory(reader, searchLength)) {
+		const record = getEndOfCentralDirectoryInfo(searchArray, indexByte, offset);
+		if (!firstSignatureInfo) {
+			firstSignatureInfo = record;
+		}
+		const reachability = await getCentralDirectoryReachability(reader, searchView, searchOffset, indexByte, offset, size, remoteProbeBudget);
+		if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
+			return record;
+		}
+		if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleInfo) {
+			plausibleInfo = record;
 		}
 	}
 	return plausibleInfo || firstSignatureInfo;
 }
 
-// Ranks how strongly an end-anchored candidate record is backed by an actual central directory, used to decide
-// which record is canonical and which count towards ambiguity. It is intentionally conservative and does not
-// fully parse the directory (the caller does that for the canonical record):
-//   - REACHABLE: the record dereferences a central directory (a central file header signature at the
-//     reconciled offset), or, for a zip64 record, the zip64 locator that a genuine zip64 archive places
-//     immediately before it. Only these count towards ambiguity.
-//   - PLAUSIBLE: the record describes an empty archive, which has no central directory to dereference. Its
-//     fields are indistinguishable from an empty end of central directory record forged inside a comment, so it
-//     is accepted only as a last resort and never inflates the ambiguity count.
-//   - UNREACHABLE: neither — stale append remnant or signature bytes embedded in a comment.
-// Signatures are read from the tail window (`view`, spanning `[anchoredOffset, size)`) when they fall inside it;
-// only a target below the window costs a (possibly remote) read, metered by `remoteProbeBudget` so a stuffed
-// comment cannot amplify into an unbounded number of requests.
+async function* scanEndOfCentralDirectory(reader, scanLength) {
+	const scanOffset = reader.size - scanLength;
+	const scanArray = await readUint8Array(reader, scanOffset, scanLength);
+	const scanView = getDataView(scanArray);
+	for (let indexByte = scanArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
+		if (getUint32(scanView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
+			yield [scanView, scanOffset, scanArray, indexByte, scanOffset + indexByte];
+		}
+	}
+}
+
+function getEndOfCentralDirectoryInfo(scanArray, indexByte, offset) {
+	return { offset, buffer: scanArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer };
+}
+
 async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
 	const filesLength = getUint16(view, indexByte + 10);
 	const directoryDataLength = getUint32(view, indexByte + 12);
 	const directoryDataOffset = getUint32(view, indexByte + 16);
 	if (filesLength == MAX_16_BITS || directoryDataLength == MAX_32_BITS || directoryDataOffset == MAX_32_BITS) {
-		// saturated fields imply a zip64 record; corroborate it with the zip64 end of central directory locator
-		// that sits immediately before it, so saturated bytes inside a comment cannot masquerade as one
 		const locatorSignature = await readSignature(reader, view, anchoredOffset, offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, size, remoteProbeBudget);
 		return locatorSignature == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE ? CENTRAL_DIRECTORY_REACHABLE : CENTRAL_DIRECTORY_UNREACHABLE;
 	}
 	if (!filesLength && !directoryDataLength) {
-		// a valid empty archive has no central directory to dereference
 		return CENTRAL_DIRECTORY_PLAUSIBLE;
 	}
-	// the central directory ends where this record starts; reconcile the stored offset against that actual
-	// position (see stored_cd_offset ⟺ eocd_pos − cd_size) so prepended data does not hide the directory
 	for (const centralDirectoryOffset of [offset - directoryDataLength, directoryDataOffset]) {
 		if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
 			return CENTRAL_DIRECTORY_REACHABLE;
@@ -1228,15 +1156,11 @@ async function getCentralDirectoryReachability(reader, view, anchoredOffset, ind
 	return CENTRAL_DIRECTORY_UNREACHABLE;
 }
 
-// Reads a 4-byte little-endian signature at `signatureOffset`, served from the tail window (`view`, spanning
-// `[anchoredOffset, size)`) when it falls inside it and otherwise from a metered (possibly remote) read. Returns
-// UNDEFINED_VALUE when the position is out of range or the out-of-window read budget is exhausted.
 async function readSignature(reader, view, anchoredOffset, signatureOffset, size, remoteProbeBudget) {
 	if (signatureOffset < 0 || signatureOffset + 4 > size) {
 		return UNDEFINED_VALUE;
 	}
 	if (signatureOffset >= anchoredOffset) {
-		// the target sits inside the tail window already in memory: no extra read needed
 		return getUint32(view, signatureOffset - anchoredOffset);
 	}
 	if (remoteProbeBudget.count > 0) {
@@ -1244,7 +1168,6 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 		const signatureArray = await readUint8Array(reader, signatureOffset, 4);
 		return getUint32(getDataView(signatureArray), 0);
 	}
-	// out of budget: leave this candidate unverified rather than issue another read
 	return UNDEFINED_VALUE;
 }
 
@@ -1260,8 +1183,6 @@ function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
 	if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
 		throwAmbiguousArchive("mismatched local file header (compression method)");
 	}
-	// when the data descriptor flag is set, the local signature and sizes are zeroed out; all-zero values are
-	// also tolerated when the flag is clear because some tools produce them (streaming writers predating bit 3)
 	if (!localDirectory.bitFlag.dataDescriptor &&
 		(localDirectory.signature || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
 		(localDirectory.signature != zipEntry.signature ||