@zip.js/zip.js 2.6.32 → 2.6.34

package/index.d.ts

@@ -7,6 +7,7 @@ declare global {
      * 
      * @see {@link https://wicg.github.io/entries-api/#api-entry|specification}
      */
+    // deno-lint-ignore no-empty-interface
     interface FileSystemEntry { }
 }
 
@@ -141,6 +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
 
 /**
@@ -273,7 +275,6 @@ export function getMimeType(fileExtension: string): string
 interface DataProcessor {
     /**
      * Initializes the instance asynchronously
-     * 
      */
     init?(): Promise<void>
 }
@@ -295,17 +296,17 @@ interface ReadableReader {
  * Here is an example of custom `Reader` class used to read binary strings:
  * ```
  * class BinaryStringReader extends Reader {
- *
+ * 
  *   constructor(binaryString) {
  *     super();
  *     this.binaryString = binaryString;
  *   }
- *
+ * 
  *   init() {
  *     super.init();
  *     this.size = this.binaryString.length;
  *   }
- *
+ * 
  *   readUint8Array(offset, length) {
  *     const result = new Uint8Array(length);
  *     for (let indexCharacter = 0; indexCharacter < length; indexCharacter++) {
@@ -333,7 +334,6 @@ export class Reader<Type> implements ReadableReader, DataProcessor {
     size: number
     /**
      * Initializes the instance asynchronously
-     * 
      */
     init?(): Promise<void>
     /**
@@ -369,11 +369,13 @@ 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[]> { }
 
 /** 
  * Represents a URL stored into a `string`.
  */
+// deno-lint-ignore no-empty-interface
 interface URLString extends String { }
 
 /**
@@ -540,6 +542,27 @@ export class Data64URIWriter extends Writer<string> {
     constructor(mimeString?: string)
 }
 
+/**
+ * Represents a `Writer` instance used to retrieve the written data from a generator of `Writer` instances  (i.e. split zip files).
+ */
+export class SplitZipWriter implements DataProcessor, WritableWriter {
+    /**
+    * The `WritableStream` instance.
+    */
+    writable: WritableStream
+    /**
+     * Initializes the instance asynchronously
+     */
+    init(): Promise<void>
+    /**
+     * Creates the `SplitZipWriter` instance
+     * 
+     * @param writerGenerator The MIME type of the content.
+     * @param maxSize The maximum size of the data written into `Writer` instances.
+     */
+    constructor(writerGenerator: AsyncGenerator<Writer<any> | WritableWriter | WritableStream, boolean>, maxSize: number)
+}
+
 /**
  * Represents a `Writer` instance used to retrieve the written data as a `Uint8Array` instance.
  */
@@ -584,6 +607,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)
     /**
      * The global comment of the zip file.
@@ -794,6 +818,10 @@ export interface Entry {
      * The external file attribute (raw).
      */
     externalFileAttribute: number
+    /**
+     * The number of the disk where the entry data starts.
+     */
+    diskNumberStart: number
     /**
      * Returns the content of the entry
      * 
@@ -836,7 +864,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, options?: ZipWriterConstructorOptions)
+    constructor(writer: Writer<Type> | WritableWriter | WritableStream | SplitZipWriter | AsyncGenerator<Writer<any> | WritableWriter | WritableStream, boolean>, options?: ZipWriterConstructorOptions)
     /**
      * `true` if the zip contains at least one entry that has been partially written.
      */
@@ -1446,4 +1474,5 @@ export const ERR_INVALID_EXTRAFIELD_TYPE: string
 export const ERR_INVALID_EXTRAFIELD_DATA: string
 export const ERR_INVALID_ENCRYPTION_STRENGTH: string
 export const ERR_UNSUPPORTED_FORMAT: string
-export const ERR_SPLIT_ZIP_FILE: string
+export const ERR_SPLIT_ZIP_FILE: string
+export const ERR_ITERATOR_COMPLETED_TOO_SOON: string

package/index.js

@@ -55,6 +55,7 @@ export {
 	Uint8ArrayWriter,
 	Uint8ArrayReader,
 	SplitZipReader,
+	SplitZipWriter,
 	ERR_HTTP_RANGE,
 	ERR_BAD_FORMAT,
 	ERR_EOCDR_NOT_FOUND,
@@ -77,6 +78,7 @@ export {
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_FORMAT,
-	ERR_SPLIT_ZIP_FILE
+	ERR_SPLIT_ZIP_FILE,
+	ERR_ITERATOR_COMPLETED_TOO_SOON
 } from "./lib/zip-fs.js";
 export { getMimeType, terminateWorkers };

package/lib/core/codec-pool.js

@@ -28,13 +28,14 @@
 
 /* global setTimeout, clearTimeout */
 
+import { UNDEFINED_VALUE } from "./constants.js";
 import {
 	CODEC_INFLATE,
 	CODEC_DEFLATE,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD
-} from "./codec-interface.js";
-import { CodecWorker } from "./codec-pool-worker.js";
+} from "./streams/codec-stream.js";
+import { CodecWorker } from "./codec-worker.js";
 
 let pool = [];
 const pendingRequests = [];
@@ -54,11 +55,11 @@ async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
 	const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options;
 	const { workerScripts } = config;
-	workerOptions.transferStreams = transferStreams || transferStreams === undefined;
+	workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE;
 	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
-	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
+	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
-	options.useCompressionStream = useCompressionStream || (useCompressionStream === undefined && config.useCompressionStream);
+	options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 	let worker;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };

package/lib/core/codec-worker.js

@@ -0,0 +1,321 @@
+/*
+ Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* global Worker, URL, TransformStream, WritableStream */
+
+import {
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE
+} from "./constants.js";
+import {
+	CodecStream,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE
+} from "./streams/codec-stream.js";
+
+// deno-lint-ignore valid-typeof
+const WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
+
+export {
+	CodecWorker
+};
+
+class CodecWorker {
+
+	constructor(workerData, stream, workerOptions, onTaskFinished) {
+		const { readable, writable } = stream;
+		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts } = workerOptions;
+		const { signal } = streamOptions;
+		Object.assign(workerData, {
+			busy: true,
+			readable: readable.pipeThrough(new ReadableStreamHooks(readable, streamOptions, config), { signal }),
+			writable,
+			options: Object.assign({}, options),
+			scripts,
+			transferStreams,
+			terminate() {
+				const { worker, busy } = workerData;
+				if (worker && !busy) {
+					worker.terminate();
+					workerData.interface = null;
+				}
+			},
+			onTaskFinished() {
+				workerData.busy = false;
+				onTaskFinished(workerData);
+			}
+		});
+		return (useWebWorkers && WEB_WORKERS_SUPPORTED ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+	}
+}
+
+class ReadableStreamHooks extends TransformStream {
+
+	constructor(readableSource, { onstart, onprogress, size, onend }, { chunkSize }) {
+		let chunkOffset = 0;
+		super({
+			start() {
+				if (onstart) {
+					callHandler(onstart, size);
+				}
+			},
+			async transform(chunk, controller) {
+				chunkOffset += chunk.length;
+				if (onprogress) {
+					await callHandler(onprogress, chunkOffset, size);
+				}
+				controller.enqueue(chunk);
+			},
+			flush() {
+				readableSource.size = chunkOffset;
+				if (onend) {
+					callHandler(onend, chunkOffset);
+				}
+			}
+		}, { highWaterMark: 1, size: () => chunkSize });
+	}
+}
+
+async function callHandler(handler, ...parameters) {
+	try {
+		await handler(...parameters);
+	} catch (_error) {
+		// ignored
+	}
+}
+
+function createWorkerInterface(workerData, config) {
+	return {
+		run: () => runWorker(workerData, config)
+	};
+}
+
+function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
+	if (!workerData.interface) {
+		Object.assign(workerData, {
+			worker: getWebWorker(workerData.scripts[0], baseURL, workerData),
+			interface: {
+				run: () => runWebWorker(workerData, { chunkSize })
+			}
+		});
+	}
+	return workerData.interface;
+}
+
+async function runWorker({ options, readable, writable, onTaskFinished }, config) {
+	const codecStream = new CodecStream(options, config);
+	try {
+		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
+		const {
+			signature,
+			size
+		} = codecStream;
+		return {
+			signature,
+			size
+		};
+	} finally {
+		onTaskFinished();
+	}
+}
+
+async function runWebWorker(workerData, config) {
+	let resolveResult, rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	Object.assign(workerData, {
+		reader: null,
+		writer: null,
+		resolveResult,
+		rejectResult,
+		result
+	});
+	const { readable, options } = workerData;
+	const { writable, closed } = detectClosedStream(workerData.writable);
+	const streamsTransferred = sendMessage({
+		type: MESSAGE_START,
+		scripts: workerData.scripts.slice(1),
+		options,
+		config,
+		readable,
+		writable
+	}, workerData);
+	if (!streamsTransferred) {
+		Object.assign(workerData, {
+			reader: readable.getReader(),
+			writer: writable.getWriter()
+		});
+	}
+	const resultValue = await result;
+	try {
+		await writable.close();
+	} catch (_error) {
+		// ignored
+	}
+	await closed;
+	return resultValue;
+}
+
+function detectClosedStream(writableSource) {
+	const writer = writableSource.getWriter();
+	let resolveStreamClosed;
+	const closed = new Promise(resolve => resolveStreamClosed = resolve);
+	const writable = new WritableStream({
+		async write(chunk) {
+			await writer.ready;
+			await writer.write(chunk);
+		},
+		close() {
+			writer.releaseLock();
+			resolveStreamClosed();
+		},
+		abort(reason) {
+			writer.abort(reason);
+		}
+	});
+	return { writable, closed };
+}
+
+let classicWorkersSupported = true;
+let transferStreamsSupported = true;
+
+function getWebWorker(url, baseURL, workerData) {
+	const workerOptions = { type: "module" };
+	let scriptUrl, worker;
+	if (typeof url == FUNCTION_TYPE) {
+		url = url();
+	}
+	try {
+		scriptUrl = new URL(url, baseURL);
+	} catch (_error) {
+		scriptUrl = url;
+	}
+	if (classicWorkersSupported) {
+		try {
+			worker = new Worker(scriptUrl);
+		} catch (_error) {
+			classicWorkersSupported = false;
+			worker = new Worker(scriptUrl, workerOptions);
+		}
+	} else {
+		worker = new Worker(scriptUrl, workerOptions);
+	}
+	worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));
+	return worker;
+}
+
+function sendMessage(message, { worker, writer, onTaskFinished, transferStreams }) {
+	try {
+		let { data, readable, writable } = message;
+		const transferrables = [];
+		if (data) {
+			const { buffer, length } = data;
+			if (length != buffer.byteLength) {
+				data = new Uint8Array(data);
+			}
+			message.data = data.buffer;
+			transferrables.push(message.data);
+		}
+		if (transferStreams && transferStreamsSupported) {
+			if (readable) {
+				transferrables.push(readable);
+			}
+			if (writable) {
+				transferrables.push(writable);
+			}
+		} else {
+			message.readable = message.writable = null;
+		}
+		if (transferrables.length) {
+			try {
+				worker.postMessage(message, transferrables);
+				return true;
+			} catch (_error) {
+				transferStreamsSupported = false;
+				message.readable = message.writable = null;
+				worker.postMessage(message);
+			}
+		} else {
+			worker.postMessage(message);
+		}
+	} catch (error) {
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+		throw error;
+	}
+}
+
+async function onMessage(event, workerData) {
+	const message = event.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);
+		} else {
+			if (type == MESSAGE_PULL) {
+				const { value, done } = await reader.read();
+				sendMessage({ type: MESSAGE_DATA, data: value, done, messageId }, workerData);
+			}
+			if (type == MESSAGE_DATA) {
+				await writer.ready;
+				await writer.write(new Uint8Array(data));
+				sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
+			}
+			if (type == MESSAGE_CLOSE) {
+				close(null, result);
+			}
+		}
+	} catch (error) {
+		close(error);
+	}
+
+	function close(error, result) {
+		if (error) {
+			rejectResult(error);
+		} else {
+			resolveResult(result);
+		}
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+	}
+}

package/lib/core/configuration.js

@@ -28,13 +28,16 @@
 
 /* global navigator, CompressionStream, DecompressionStream */
 
-import { getCodecStreamClass } from "./codec-interface.js";
+import {
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE
+} from "./constants.js";
+import { StreamAdapter } from "./streams/stream-adapter.js";
 
 const MINIMUM_CHUNK_SIZE = 64;
-const UNDEFINED_VALUE = undefined;
 let maxWorkers = 2;
 try {
-	if (typeof navigator != "undefined" && navigator.hardwareConcurrency) {
+	if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
 		maxWorkers = navigator.hardwareConcurrency;
 	}
 } catch (_error) {
@@ -46,9 +49,9 @@ const DEFAULT_CONFIGURATION = {
 	terminateWorkerTimeout: 5000,
 	useWebWorkers: true,
 	useCompressionStream: true,
-	workerScripts: undefined,
-	CompressionStreamNative: typeof CompressionStream != "undefined" && CompressionStream,
-	DecompressionStreamNative: typeof DecompressionStream != "undefined" && DecompressionStream
+	workerScripts: UNDEFINED_VALUE,
+	CompressionStreamNative: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
+	DecompressionStreamNative: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 };
 
 const config = Object.assign({}, DEFAULT_CONFIGURATION);
@@ -88,10 +91,10 @@ function configure(configuration) {
 	setIfDefined("useCompressionStream", useCompressionStream);
 	setIfDefined("useWebWorkers", useWebWorkers);
 	if (Deflate) {
-		config.CompressionStream = getCodecStreamClass(Deflate);
+		config.CompressionStream = new StreamAdapter(Deflate);
 	}
 	if (Inflate) {
-		config.DecompressionStream = getCodecStreamClass(Inflate);
+		config.DecompressionStream = new StreamAdapter(Inflate);
 	}
 	setIfDefined("CompressionStream", CompressionStream);
 	setIfDefined("DecompressionStream", DecompressionStream);

package/lib/core/constants.js

@@ -33,7 +33,8 @@ const COMPRESSION_METHOD_STORE = 0x00;
 const COMPRESSION_METHOD_AES = 0x63;
 
 const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
-const DATA_DESCRIPTOR_RECORD_SIGNATURE = 0x08074b50;
+const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
+const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -43,8 +44,6 @@ const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
 const ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
 const ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 
-const ZIP64_TOTAL_NUMBER_OF_DISKS = 1;
-
 const EXTRAFIELD_TYPE_ZIP64 = 0x0001;
 const EXTRAFIELD_TYPE_AES = 0x9901;
 const EXTRAFIELD_TYPE_NTFS = 0x000a;
@@ -68,12 +67,17 @@ const DIRECTORY_SIGNATURE = "/";
 const MAX_DATE = new Date(2107, 11, 31);
 const MIN_DATE = new Date(1980, 0, 1);
 
+const UNDEFINED_VALUE = undefined;
+const UNDEFINED_TYPE = "undefined";
+const FUNCTION_TYPE = "function";
+
 export {
 	MAX_32_BITS,
 	MAX_16_BITS,
 	COMPRESSION_METHOD_DEFLATE,
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
+	SPLIT_ZIP_FILE_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
@@ -91,7 +95,6 @@ export {
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH,
-	ZIP64_TOTAL_NUMBER_OF_DISKS,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_LEVEL,
 	BITFLAG_DATA_DESCRIPTOR,
@@ -102,5 +105,8 @@ export {
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
-	MAX_DATE
+	MAX_DATE,
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE
 };