@zip.js/zip.js 2.6.37 → 2.6.40

package/index.d.ts

@@ -142,8 +142,7 @@ interface WorkerConfiguration {
  * @param registerDataHandler The function called to handle the `data` events triggered by a third-party codec implementation.
  * @returns An instance containing classes compatible with `ZipDeflate` and `ZipInflate`.
  */
-// deno-lint-ignore no-explicit-any
-export function initShimAsyncCodec(library: EventBasedZipLibrary, constructorOptions: any | null, registerDataHandler: registerDataHandler): ZipLibrary
+export function initShimAsyncCodec(library: EventBasedZipLibrary, constructorOptions: unknown | null, registerDataHandler: registerDataHandler): ZipLibrary
 
 /**
  * Represents the callback function used to register the `data` event handler.
@@ -267,7 +266,7 @@ declare class CodecStream extends TransformStream { }
 export function getMimeType(fileExtension: string): string
 
 /**
- * Represents an instance used to read or write any type of data.
+ * Represents an instance used to read or write unknown type of data.
  * 
  * zip.js can handle multiple types of data thanks to a generic API. This feature is based on 2 abstract constructors: `Reader` and `Writer`. 
  * The classes inheriting from `Reader` help to read data from a source of data. The classes inheriting from `Writer` help to write data into a destination.
@@ -290,7 +289,7 @@ interface ReadableReader {
 }
 
 /**
- * Represents a `Reader` instance used to read any type of data.
+ * Represents a `Reader` instance used to read unknown type of data.
  * 
  * @example
  * Here is an example of custom `Reader` class used to read binary strings:
@@ -369,8 +368,7 @@ export class Uint8ArrayReader extends Reader<Uint8Array> { }
 /**
  * Represents a `Reader` instance used to read data provided as an array of `Reader` instances (i.e. split zip files).
  */
-// deno-lint-ignore no-explicit-any
-export class SplitZipReader extends Reader<Reader<any>[] | ReadableReader[] | ReadableStream[]> { }
+export class SplitZipReader extends Reader<Reader<unknown>[] | ReadableReader[] | ReadableStream[]> { }
 
 /** 
  * Represents a URL stored into a `string`.
@@ -455,7 +453,7 @@ interface WritableWriter {
 }
 
 /**
- * Represents a `Writer` instance used to write any type of data.
+ * Represents a `Writer` instance used to write unknown type of data.
  * 
  * @example
  * Here is an example of custom `Writer` class used to write binary strings:
@@ -574,7 +572,7 @@ export class SplitZipWriter implements Initializable, WritableWriter {
      * @param writerGenerator The MIME type of the content.
      * @param maxSize The maximum size of the data written into `Writer` instances (default: 4GB).
      */
-    constructor(writerGenerator: AsyncGenerator<Writer<any> | WritableWriter | WritableStream, boolean>, maxSize?: number)
+    constructor(writerGenerator: AsyncGenerator<Writer<unknown> | WritableWriter | WritableStream, boolean>, maxSize?: number)
 }
 
 /**
@@ -621,8 +619,7 @@ export class ZipReader<Type> {
      * @param reader The `Reader` instance used to read data.
      * @param options The options.
      */
-    // deno-lint-ignore no-explicit-any
-    constructor(reader: Reader<Type> | ReadableReader | ReadableStream | Reader<any>[] | ReadableReader[] | ReadableStream[], options?: ZipReaderConstructorOptions)
+    constructor(reader: Reader<Type> | ReadableReader | ReadableStream | Reader<unknown>[] | ReadableReader[] | ReadableStream[], options?: ZipReaderConstructorOptions)
     /**
      * The global comment of the zip file.
      */
@@ -878,7 +875,7 @@ export class ZipWriter<Type> {
      * @param writer The `Writer` instance where the zip content will be written.
      * @param options The options.
      */
-    constructor(writer: Writer<Type> | WritableWriter | WritableStream | SplitZipWriter | AsyncGenerator<Writer<any> | WritableWriter | WritableStream, boolean>, options?: ZipWriterConstructorOptions)
+    constructor(writer: Writer<Type> | WritableWriter | WritableStream | SplitZipWriter | AsyncGenerator<Writer<unknown> | WritableWriter | WritableStream, boolean>, options?: ZipWriterConstructorOptions)
     /**
      * `true` if the zip contains at least one entry that has been partially written.
      */
@@ -891,7 +888,7 @@ export class ZipWriter<Type> {
      * @param options The options.
      * @returns A promise resolving to an `Entry` instance.
      */
-    add<ReaderType>(filename: string, reader?: Reader<ReaderType> | ReadableReader | ReadableStream | null, options?: ZipWriterAddDataOptions): Promise<Entry>
+    add<ReaderType>(filename: string, reader?: Reader<ReaderType> | ReadableReader | ReadableStream, options?: ZipWriterAddDataOptions): Promise<Entry>
     /**
      * Writes the entries directory, writes the global comment, and returns the content of the zip file
      * 
@@ -899,7 +896,7 @@ export class ZipWriter<Type> {
      * @param options The options.
      * @returns The content of the zip file.
      */
-    close(comment?: Uint8Array | null, options?: ZipWriterCloseOptions): Promise<Type>
+    close(comment?: Uint8Array, options?: ZipWriterCloseOptions): Promise<Type>
 }
 
 /**
@@ -1158,7 +1155,7 @@ export class ZipFileEntry<ReaderType, WriterType> extends ZipEntry {
      * @param options The options.
      * @returns A promise resolving to a `string`.
      */
-    getText(encoding?: string | null, options?: EntryGetDataOptions): Promise<string>
+    getText(encoding?: string, options?: EntryGetDataOptions): Promise<string>
     /**
      * Retrieves the content of the entry as a `Blob` instance
      * 
@@ -1166,7 +1163,7 @@ export class ZipFileEntry<ReaderType, WriterType> extends ZipEntry {
      * @param options The options.
      * @returns A promise resolving to a `Blob` instance.
      */
-    getBlob(mimeType?: string | null, options?: EntryGetDataOptions): Promise<Blob>
+    getBlob(mimeType?: string, options?: EntryGetDataOptions): Promise<Blob>
     /**
      * Retrieves the content of the entry as as a Data URI `string` encoded in Base64
      * 
@@ -1174,7 +1171,7 @@ export class ZipFileEntry<ReaderType, WriterType> extends ZipEntry {
      * @param options The options.
      * @returns A promise resolving to a Data URI `string` encoded in Base64.
      */
-    getData64URI(mimeType?: string | null, options?: EntryGetDataOptions): Promise<string>
+    getData64URI(mimeType?: string, options?: EntryGetDataOptions): Promise<string>
     /**
      * Retrieves the content of the entry as a `Uint8Array` instance
      * 
@@ -1189,7 +1186,7 @@ export class ZipFileEntry<ReaderType, WriterType> extends ZipEntry {
      * @param options The options.
      * @returns A promise resolving to the `WritableStream` instance.
      */
-    getWritable(writable?: WritableStream | null, options?: EntryGetDataOptions): Promise<WritableStream>
+    getWritable(writable?: WritableStream, options?: EntryGetDataOptions): Promise<WritableStream>
     /**
      * Retrieves the content of the entry via a `Writer` instance
      * 
@@ -1344,34 +1341,34 @@ export class ZipDirectoryEntry extends ZipEntry {
      */
     importReadable(readable: ReadableStream, options?: ZipReaderConstructorOptions): Promise<void>
     /**
-     * Returns a `Blob` instance containing a zip file of the entry and its descendants, if any
+     * Returns a `Blob` instance containing a zip file of the entry and its descendants, if unknown
      * 
      * @param options  The options.
      * @returns A promise resolving to the `Blob` instance.
      */
     exportBlob(options?: ZipDirectoryEntryExportOptions): Promise<Blob>
     /**
-     * Returns a Data URI `string` encoded in Base64 containing a zip file of the entry and its descendants, if any
+     * Returns a Data URI `string` encoded in Base64 containing a zip file of the entry and its descendants, if unknown
      * 
      * @param options  The options.
      * @returns A promise resolving to the Data URI `string` encoded in Base64.
      */
     exportData64URI(options?: ZipDirectoryEntryExportOptions): Promise<string>
     /**
-     * Returns a `Uint8Array` instance containing a zip file of the entry and its descendants, if any
+     * Returns a `Uint8Array` instance containing a zip file of the entry and its descendants, if unknown
      * 
      * @param options  The options.
      * @returns A promise resolving to the `Uint8Array` instance.
      */
     exportUint8Array(options?: ZipDirectoryEntryExportOptions): Promise<Uint8Array>
     /**
-     * Creates a zip file via a `WritableStream` instance containing the entry and its descendants, if any
+     * Creates a zip file via a `WritableStream` instance containing the entry and its descendants, if unknown
      * 
      * @param writable The `WritableStream` instance.
      * @param options  The options.
      * @returns A promise resolving to the `Uint8Array` instance.
      */
-    exportWritable(writable?: WritableStream | null, options?: ZipDirectoryEntryExportOptions): Promise<WritableStream>
+    exportWritable(writable?: WritableStream, options?: ZipDirectoryEntryExportOptions): Promise<WritableStream>
 }
 
 /**

package/lib/core/codec-pool.js

@@ -54,26 +54,24 @@ let indexWorker = 0;
 async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
 	const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options;
-	const { workerScripts } = config;
+	const { workerScripts, maxWorkers, terminateWorkerTimeout } = config;
 	workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE;
 	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
 	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
 	options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 	let worker;
-	if (pool.length < config.maxWorkers) {
+	const workerData = pool.find(workerData => !workerData.busy);
+	if (workerData) {
+		clearTerminateTimeout(workerData);
+		worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+	} else if (pool.length < maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
 		worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
 	} else {
-		const workerData = pool.find(workerData => !workerData.busy);
-		if (workerData) {
-			clearTerminateTimeout(workerData);
-			worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
-		} else {
-			worker = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
-		}
+		worker = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
 	}
 	return worker.run();
 
@@ -82,7 +80,6 @@ async function runWorker(stream, workerOptions) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
 			resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
 		} else if (workerData.worker) {
-			const { terminateWorkerTimeout } = config;
 			clearTerminateTimeout(workerData);
 			if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
 				workerData.terminateTimeout = setTimeout(() => {

package/lib/core/codec-worker.js

@@ -51,13 +51,11 @@ export {
 
 class CodecWorker {
 
-	constructor(workerData, stream, workerOptions, onTaskFinished) {
-		const { readable, writable } = stream;
-		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts } = workerOptions;
+	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, scripts }, onTaskFinished) {
 		const { signal } = streamOptions;
 		Object.assign(workerData, {
 			busy: true,
-			readable: readable.pipeThrough(new ReadableStreamHooks(readable, streamOptions, config), { signal }),
+			readable: readable.pipeThrough(new ProgressWatcherStream(readable, streamOptions, config), { signal }),
 			writable,
 			options: Object.assign({}, options),
 			scripts,
@@ -78,7 +76,7 @@ class CodecWorker {
 	}
 }
 
-class ReadableStreamHooks extends TransformStream {
+class ProgressWatcherStream extends TransformStream {
 
 	constructor(readableSource, { onstart, onprogress, size, onend }, { chunkSize }) {
 		let chunkOffset = 0;
@@ -161,11 +159,11 @@ async function runWebWorker(workerData, config) {
 		rejectResult,
 		result
 	});
-	const { readable, options } = workerData;
-	const { writable, closed } = detectClosedStream(workerData.writable);
+	const { readable, options, scripts } = workerData;
+	const { writable, closed } = watchClosedStream(workerData.writable);
 	const streamsTransferred = sendMessage({
 		type: MESSAGE_START,
-		scripts: workerData.scripts.slice(1),
+		scripts: scripts.slice(1),
 		options,
 		config,
 		readable,
@@ -187,7 +185,7 @@ async function runWebWorker(workerData, config) {
 	return resultValue;
 }
 
-function detectClosedStream(writableSource) {
+function watchClosedStream(writableSource) {
 	const writer = writableSource.getWriter();
 	let resolveStreamClosed;
 	const closed = new Promise(resolve => resolveStreamClosed = resolve);
@@ -201,7 +199,7 @@ function detectClosedStream(writableSource) {
 			resolveStreamClosed();
 		},
 		abort(reason) {
-			writer.abort(reason);
+			return writer.abort(reason);
 		}
 	});
 	return { writable, closed };
@@ -213,6 +211,7 @@ let transferStreamsSupported = true;
 function getWebWorker(url, baseURL, workerData) {
 	const workerOptions = { type: "module" };
 	let scriptUrl, worker;
+	// deno-lint-ignore valid-typeof
 	if (typeof url == FUNCTION_TYPE) {
 		url = url();
 	}
@@ -237,29 +236,29 @@ function getWebWorker(url, baseURL, workerData) {
 
 function sendMessage(message, { worker, writer, onTaskFinished, transferStreams }) {
 	try {
-		let { data, readable, writable } = message;
-		const transferrables = [];
-		if (data) {
-			const { buffer, length } = data;
+		let { value, readable, writable } = message;
+		const transferables = [];
+		if (value) {
+			const { buffer, length } = value;
 			if (length != buffer.byteLength) {
-				data = new Uint8Array(data);
+				value = new Uint8Array(value);
 			}
-			message.data = data.buffer;
-			transferrables.push(message.data);
+			message.value = value.buffer;
+			transferables.push(message.value);
 		}
 		if (transferStreams && transferStreamsSupported) {
 			if (readable) {
-				transferrables.push(readable);
+				transferables.push(readable);
 			}
 			if (writable) {
-				transferrables.push(writable);
+				transferables.push(writable);
 			}
 		} else {
 			message.readable = message.writable = null;
 		}
-		if (transferrables.length) {
+		if (transferables.length) {
 			try {
-				worker.postMessage(message, transferrables);
+				worker.postMessage(message, transferables);
 				return true;
 			} catch (_error) {
 				transferStreamsSupported = false;
@@ -278,25 +277,23 @@ function sendMessage(message, { worker, writer, onTaskFinished, transferStreams
 	}
 }
 
-async function onMessage(event, workerData) {
-	const message = event.data;
+async function onMessage({ data }, workerData) {
+	const { type, value, messageId, result, error } = data;
 	const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
-	const { type, data, messageId, result } = message;
-	const reponseError = message.error;
 	try {
-		if (reponseError) {
-			const { message, stack, code, name } = reponseError;
-			const error = new Error(message);
-			Object.assign(error, { stack, code, name });
-			close(error);
+		if (error) {
+			const { message, stack, code, name } = error;
+			const responseError = new Error(message);
+			Object.assign(responseError, { stack, code, name });
+			close(responseError);
 		} else {
 			if (type == MESSAGE_PULL) {
 				const { value, done } = await reader.read();
-				sendMessage({ type: MESSAGE_DATA, data: value, done, messageId }, workerData);
+				sendMessage({ type: MESSAGE_DATA, value, done, messageId }, workerData);
 			}
 			if (type == MESSAGE_DATA) {
 				await writer.ready;
-				await writer.write(new Uint8Array(data));
+				await writer.write(new Uint8Array(value));
 				sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
 			}
 			if (type == MESSAGE_CLOSE) {

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

@@ -69,14 +69,14 @@ const HmacSha1 = misc.hmacSha1;
 
 class AESDecryptionStream extends TransformStream {
 
-	constructor(password, signed, strength) {
+	constructor({ password, signed, encryptionStrength }) {
 		super({
 			start() {
 				Object.assign(this, {
 					ready: new Promise(resolve => this.resolveReady = resolve),
 					password,
 					signed,
-					strength: strength - 1,
+					strength: encryptionStrength - 1,
 					pending: new Uint8Array()
 				});
 			},
@@ -132,7 +132,7 @@ class AESDecryptionStream extends TransformStream {
 
 class AESEncryptionStream extends TransformStream {
 
-	constructor(password, strength) {
+	constructor({ password, encryptionStrength }) {
 		// deno-lint-ignore prefer-const
 		let stream;
 		super({
@@ -140,7 +140,7 @@ class AESEncryptionStream extends TransformStream {
 				Object.assign(this, {
 					ready: new Promise(resolve => this.resolveReady = resolve),
 					password,
-					strength: strength - 1,
+					strength: encryptionStrength - 1,
 					pending: new Uint8Array()
 				});
 			},

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

@@ -36,7 +36,7 @@ class StreamAdapter {
 
 	constructor(Codec) {
 		return class extends TransformStream {
-			constructor(options) {
+			constructor(_format, options) {
 				const codec = new Codec(options);
 				super({
 					transform(chunk, controller) {

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

@@ -39,7 +39,7 @@ const HEADER_LENGTH = 12;
 
 class ZipCryptoDecryptionStream extends TransformStream {
 
-	constructor(password, passwordVerification) {
+	constructor({ password, passwordVerification }) {
 		super({
 			start() {
 				Object.assign(this, {
@@ -66,7 +66,7 @@ class ZipCryptoDecryptionStream extends TransformStream {
 
 class ZipCryptoEncryptionStream extends TransformStream {
 
-	constructor(password, passwordVerification) {
+	constructor({ password, passwordVerification }) {
 		super({
 			start() {
 				Object.assign(this, {

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

@@ -49,7 +49,7 @@ class DeflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, CompressionStream, CompressionStreamNative }) {
 		super({});
-		const { compressed, encrypted, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed, level } = options;
+		const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream;
 		let readable = filterEmptyChunks(super.readable);
@@ -62,9 +62,9 @@ class DeflateStream extends TransformStream {
 		}
 		if (encrypted) {
 			if (zipCrypto) {
-				readable = pipeThrough(readable, new ZipCryptoEncryptionStream(password, passwordVerification));
+				readable = pipeThrough(readable, new ZipCryptoEncryptionStream(options));
 			} else {
-				encryptionStream = new AESEncryptionStream(password, encryptionStrength);
+				encryptionStream = new AESEncryptionStream(options);
 				readable = pipeThrough(readable, encryptionStream);
 			}
 		}
@@ -86,14 +86,14 @@ class InflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, DecompressionStream, DecompressionStreamNative }) {
 		super({});
-		const { zipCrypto, encrypted, password, passwordVerification, signed, signature, encryptionStrength, compressed, useCompressionStream } = options;
+		const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream } = options;
 		let crc32Stream, decryptionStream;
 		let readable = filterEmptyChunks(super.readable);
 		if (encrypted) {
 			if (zipCrypto) {
-				readable = pipeThrough(readable, new ZipCryptoDecryptionStream(password, passwordVerification));
+				readable = pipeThrough(readable, new ZipCryptoDecryptionStream(options));
 			} else {
-				decryptionStream = new AESDecryptionStream(password, signed, encryptionStrength);
+				decryptionStream = new AESDecryptionStream(options);
 				readable = pipeThrough(readable, decryptionStream);
 			}
 		}

package/lib/core/util/stream-codec-shim.js

@@ -47,10 +47,11 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			const codecAdapter = this;
 			const onData = data => {
 				if (codecAdapter.pendingData) {
+					const previousPendingData = codecAdapter.pendingData;
+					codecAdapter.pendingData = new Uint8Array(previousPendingData.length + data.length);
 					const { pendingData } = codecAdapter;
-					codecAdapter.pendingData = new Uint8Array(pendingData.length + data.length);
-					pendingData.set(pendingData, 0);
-					pendingData.set(data, pendingData.length);
+					pendingData.set(previousPendingData, 0);
+					pendingData.set(data, previousPendingData.length);
 				} else {
 					codecAdapter.pendingData = new Uint8Array(data);
 				}

package/lib/core/z-worker-core.js

@@ -45,17 +45,16 @@ const pendingDataMessages = new Map();
 
 let messageId = 0;
 
-addEventListener(MESSAGE_EVENT_TYPE, event => {
-	const message = event.data;
-	const { type, messageId, data, done } = message;
+addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
+	const { type, messageId, value, done } = data;
 	try {
 		if (type == MESSAGE_START) {
-			init(message);
+			init(data);
 		}
 		if (type == MESSAGE_DATA) {
 			const resolve = pendingPullMessages.get(messageId);
 			pendingPullMessages.delete(messageId);
-			resolve({ value: new Uint8Array(data), done });
+			resolve({ value: new Uint8Array(value), done });
 		}
 		if (type == MESSAGE_ACK_DATA) {
 			const resolve = pendingDataMessages.get(messageId);
@@ -98,11 +97,11 @@ async function init(message) {
 			}
 		}, strategy);
 		const writable = message.writable || new WritableStream({
-			async write(data) {
+			async write(value) {
 				let resolveAckData;
 				const ackData = new Promise(resolve => resolveAckData = resolve);
 				pendingDataMessages.set(messageId, resolveAckData);
-				sendMessage({ type: MESSAGE_DATA, data, messageId });
+				sendMessage({ type: MESSAGE_DATA, value, messageId });
 				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
 				await ackData;
 			}
@@ -131,13 +130,13 @@ async function init(message) {
 }
 
 function sendMessage(message) {
-	if (message.data) {
-		let { data } = message;
-		if (data && data.length) {
+	let { value } = message;
+	if (value) {
+		if (value.length) {
 			try {
-				data = new Uint8Array(data);
-				message.data = data.buffer;
-				postMessage(message, [message.data]);
+				value = new Uint8Array(value);
+				message.value = value.buffer;
+				postMessage(message, [message.value]);
 			} catch (_error) {
 				postMessage(message);
 			}

package/lib/core/zip-writer.js

@@ -354,7 +354,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		keepOrder,
 		dataDescriptor,
-		zipCrypto,
 		signal
 	} = options;
 	const previousFileEntry = Array.from(files.values()).pop();
@@ -409,20 +408,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await requestLockWriter();
 			writingBufferedEntryData = true;
 			if (!dataDescriptor) {
-				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, 26);
-				const arrayBufferView = new DataView(arrayBuffer);
-				if (!fileEntry.encrypted || zipCrypto) {
-					setUint32(arrayBufferView, 14, fileEntry.signature);
-				}
-				if (fileEntry.zip64) {
-					setUint32(arrayBufferView, 18, MAX_32_BITS);
-					setUint32(arrayBufferView, 22, MAX_32_BITS);
-				} else {
-					setUint32(arrayBufferView, 18, fileEntry.compressedSize);
-					setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
-				}
-				await writeData(writable, new Uint8Array(arrayBuffer));
-				blob = blob.slice(arrayBuffer.byteLength);
+				blob = await setMissingInfo(fileEntry, blob, writable, options);
 			}
 			fileEntry.diskNumberStart = writer.diskNumber;
 			diskOffset = writer.diskOffset;
@@ -432,10 +418,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		fileEntry.offset = zipWriter.offset - diskOffset;
 		if (fileEntry.zip64) {
-			const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
-			const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
-			setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
-			setUint32(rawExtraFieldZip64View, 28, diskNumberStart);
+			setZip64Info(fileEntry);
 		} else if (fileEntry.offset >= MAX_32_BITS) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
@@ -811,6 +794,30 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
+async function setMissingInfo(fileEntry, entryData, writable, { zipCrypto }) {
+	const arrayBuffer = await sliceAsArrayBuffer(entryData, 0, 26);
+	const arrayBufferView = new DataView(arrayBuffer);
+	if (!fileEntry.encrypted || zipCrypto) {
+		setUint32(arrayBufferView, 14, fileEntry.signature);
+	}
+	if (fileEntry.zip64) {
+		setUint32(arrayBufferView, 18, MAX_32_BITS);
+		setUint32(arrayBufferView, 22, MAX_32_BITS);
+	} else {
+		setUint32(arrayBufferView, 18, fileEntry.compressedSize);
+		setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
+	}
+	await writeData(writable, new Uint8Array(arrayBuffer));
+	return entryData.slice(arrayBuffer.byteLength);
+}
+
+function setZip64Info(fileEntry) {
+	const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
+	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+	setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
+	setUint32(rawExtraFieldZip64View, 28, diskNumberStart);
+}
+
 async function closeFile(zipWriter, comment, options) {
 	const { files, writer } = zipWriter;
 	let offset = 0;