@zip.js/zip.js 2.5.20 → 2.5.23

package/dist/zip-full.js

@@ -7223,8 +7223,12 @@
 			const endOfDirectoryView = getDataView$1(endOfDirectoryInfo);
 			let directoryDataLength = getUint32(endOfDirectoryView, 12);
 			let directoryDataOffset = getUint32(endOfDirectoryView, 16);
+			const commentOffset = endOfDirectoryInfo.offset;
+			const commentLength = getUint16(endOfDirectoryView, 20);
+			const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
 			let filesLength = getUint16(endOfDirectoryView, 8);
 			let prependedDataLength = 0;
+			let startOffset = 0;
 			if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS) {
 				const endOfDirectoryLocatorArray = await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH);
 				const endOfDirectoryLocatorView = getDataView$1(endOfDirectoryLocatorArray);
@@ -7295,6 +7299,7 @@
 					commentUTF8: languageEncodingFlag,
 					rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset)
 				});
+				startOffset = Math.max(fileEntry.offset, startOffset);
 				const endOffset = commentOffset + fileEntry.commentLength;
 				fileEntry.rawComment = directoryArray.subarray(commentOffset, endOffset);
 				const filenameEncoding = getOptionValue$1(zipReader, options, "filenameEncoding");
@@ -7321,16 +7326,22 @@
 				}
 				yield entry;
 			}
+			const extractPrependedData = getOptionValue$1(zipReader, options, "extractPrependedData");
+			const extractAppendedData = getOptionValue$1(zipReader, options, "extractAppendedData");
+			if (extractPrependedData) {
+				zipReader.prependedData = await readUint8Array(reader, 0, startOffset);
+			}
+			zipReader.comment = await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength);
+			if (extractAppendedData) {
+				zipReader.appendedData = appendedDataOffset < reader.size ? await readUint8Array(reader, appendedDataOffset, reader.size - appendedDataOffset) : new Uint8Array();
+			}
 			return true;
 		}
 
 		async getEntries(options = {}) {
 			const entries = [];
-			const iterator = this.getEntriesGenerator(options);
-			let result = iterator.next();
-			while (!(await result).done) {
-				entries.push((await result).value);
-				result = iterator.next();
+			for await (const entry of this.getEntriesGenerator(options)) {
+				entries.push(entry);
 			}
 			return entries;
 		}
@@ -7778,7 +7789,7 @@
 				await Promise.all(Array.from(pendingAddFileCalls));
 			}
 			await closeFile(this, comment, options);
-			if (!writer.preventClose) {
+			if (!writer.preventClose && !options.preventClose) {
 				await writable.getWriter().close();
 			}
 			return writer.getData ? writer.getData() : writable;
@@ -7931,36 +7942,36 @@
 		const previousFileEntry = Array.from(files.values()).pop();
 		let fileEntry = {};
 		let bufferedWrite;
-		let resolveLockUnbufferedWrite;
+		let releaseLockWriter;
 		let resolveLockCurrentFileEntry;
+		let writingBufferedData;
+		let fileWriter;
 		files.set(name, fileEntry);
 		try {
 			let lockPreviousFileEntry;
-			let fileWriter;
 			if (options.keepOrder) {
 				lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
 			}
 			fileEntry.lock = new Promise(resolve => resolveLockCurrentFileEntry = resolve);
-			if (options.bufferedWrite || zipWriter.lockWrite || !options.dataDescriptor) {
+			if (options.bufferedWrite || zipWriter.lockWriter || !options.dataDescriptor) {
 				fileWriter = new BlobWriter();
 				fileWriter.init();
 				bufferedWrite = true;
 			} else {
-				zipWriter.lockWrite = Promise.resolve();
+				zipWriter.lockWriter = Promise.resolve();
 				if (writer.init && !writer.initialized) {
 					await writer.init();
 				}
 				fileWriter = writer;
 			}
-			fileEntry = await createFileEntry(reader, fileWriter.writable, zipWriter.config, options);
+			fileEntry = await createFileEntry(reader, fileEntry, fileWriter.writable, zipWriter.config, options);
 			files.set(name, fileEntry);
 			fileEntry.filename = name;
 			if (bufferedWrite) {
-				let indexWrittenData = 0;
-				const blob = fileWriter.getData();
+				let blob = fileWriter.getData();
 				await lockPreviousFileEntry;
-				await lockWriterAccess();
-				fileEntry.writingBufferedData = true;
+				await lockWriter();
+				writingBufferedData = true;
 				const { writable } = writer;
 				if (!options.dataDescriptor) {
 					const headerLength = 26;
@@ -7977,10 +7988,10 @@
 						setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
 					}
 					await writeUint8Array(writable, new Uint8Array(arrayBuffer));
-					indexWrittenData = headerLength;
+					blob = blob.slice(headerLength);
 				}
-				await writeBlob(writable, blob, indexWrittenData);
-				delete fileEntry.writingBufferedData;
+				await blob.stream().pipeTo(writable, { preventClose: true });
+				writingBufferedData = false;
 			}
 			fileEntry.offset = zipWriter.offset;
 			if (fileEntry.zip64) {
@@ -7992,32 +8003,30 @@
 			zipWriter.offset += fileEntry.length;
 			return fileEntry;
 		} catch (error) {
-			if ((bufferedWrite && fileEntry.writingBufferedData) || (!bufferedWrite && fileEntry.dataWritten)) {
+			if ((bufferedWrite && writingBufferedData) || (!bufferedWrite && fileEntry.dataWritten)) {
 				error.corruptedEntry = zipWriter.hasCorruptedEntries = true;
-				if (fileEntry.uncompressedSize) {
-					zipWriter.offset += fileEntry.uncompressedSize;
-				}
+				zipWriter.offset += fileWriter.size;
 			}
 			files.delete(name);
 			throw error;
 		} finally {
 			resolveLockCurrentFileEntry();
-			if (resolveLockUnbufferedWrite) {
-				resolveLockUnbufferedWrite();
+			if (releaseLockWriter) {
+				releaseLockWriter();
 			}
 		}
 
-		async function lockWriterAccess() {
-			if (zipWriter.lockWrite) {
-				await zipWriter.lockWrite.then(() => delete zipWriter.lockWrite);
-				await lockWriterAccess();
+		async function lockWriter() {
+			if (zipWriter.lockWriter) {
+				await zipWriter.lockWriter.then(() => delete zipWriter.lockWriter);
+				await lockWriter();
 			} else {
-				zipWriter.lockWrite = new Promise(resolve => resolveLockUnbufferedWrite = resolve);
+				zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = resolve);
 			}
 		}
 	}
 
-	async function createFileEntry(reader, writable, config, options) {
+	async function createFileEntry(reader, pendingFileEntry, writable, config, options) {
 		const {
 			rawFilename,
 			lastAccessDate,
@@ -8167,7 +8176,7 @@
 		let compressedSize = 0;
 		if (reader) {
 			await writeUint8Array(writable, localHeaderArray);
-			fileEntry.dataWritten = true;
+			fileEntry.dataWritten = pendingFileEntry.dataWritten = true;
 			const size = () => reader.size;
 			const readable = reader.readable;
 			readable.size = size;
@@ -8195,7 +8204,7 @@
 			compressedSize = result.length;
 		} else {
 			await writeUint8Array(writable, localHeaderArray);
-			fileEntry.dataWritten = true;
+			fileEntry.dataWritten = pendingFileEntry.dataWritten = true;
 		}
 		let dataDescriptorArray = new Uint8Array();
 		let dataDescriptorView, dataDescriptorOffset = 0;
@@ -8271,13 +8280,6 @@
 		}
 		const directoryArray = new Uint8Array(directoryDataLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH));
 		const directoryView = getDataView(directoryArray);
-		if (comment && comment.length) {
-			if (comment.length <= MAX_16_BITS) {
-				setUint16(directoryView, offset + 20, comment.length);
-			} else {
-				throw new Error(ERR_INVALID_COMMENT);
-			}
-		}
 		for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
 			const {
 				rawFilename,
@@ -8361,6 +8363,13 @@
 		setUint16(directoryView, offset + 10, filesLength);
 		setUint32(directoryView, offset + 12, directoryDataLength);
 		setUint32(directoryView, offset + 16, directoryOffset);
+		if (comment && comment.length) {
+			if (comment.length <= MAX_16_BITS) {
+				setUint16(directoryView, offset + 20, comment.length);
+			} else {
+				throw new Error(ERR_INVALID_COMMENT);
+			}
+		}
 		const { writable } = zipWriter.writer;
 		await writeUint8Array(writable, directoryArray);
 		if (comment && comment.length) {
@@ -8376,20 +8385,6 @@
 		}
 	}
 
-	async function writeBlob(writable, blob, start = 0) {
-		const blockSize = 512 * 1024 * 1024;
-		await writeSlice();
-
-		async function writeSlice() {
-			if (start < blob.size) {
-				const arrayBuffer = await sliceAsArrayBuffer(blob, start, start + blockSize);
-				await writeUint8Array(writable, new Uint8Array(arrayBuffer));
-				start += blockSize;
-				await writeSlice();
-			}
-		}
-	}
-
 	async function writeUint8Array(writable, array) {
 		const streamWriter = writable.getWriter();
 		await streamWriter.ready;