@zip.js/zip.js 2.6.32 → 2.6.34

package/lib/core/io.js

@@ -27,20 +27,26 @@
  */
 
 /* global Blob, atob, btoa, XMLHttpRequest, URL, fetch, ReadableStream, WritableStream, FileReader, TransformStream, Response */
+// deno-lint-ignore-file no-this-alias
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
+const ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
 
 const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
 const HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
 const HTTP_HEADER_CONTENT_RANGE = "Content-Range";
 const HTTP_HEADER_ACCEPT_RANGES = "Accept-Ranges";
 const HTTP_HEADER_RANGE = "Range";
+const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
 const HTTP_METHOD_HEAD = "HEAD";
 const HTTP_METHOD_GET = "GET";
 const HTTP_RANGE_UNIT = "bytes";
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
+const PROPERTY_NAME_WRITABLE = "writable";
+
+import { UNDEFINED_VALUE } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
 
 class Stream {
@@ -88,7 +94,7 @@ class Writer extends Stream {
 				return writer.writeUint8Array(chunk);
 			}
 		});
-		Object.defineProperty(writer, "writable", {
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
 			get() {
 				return writable;
 			}
@@ -104,21 +110,26 @@ class Data64URIReader extends Reader {
 
 	constructor(dataURI) {
 		super();
-		const reader = this;
-		reader.dataURI = dataURI;
 		let dataEnd = dataURI.length;
 		while (dataURI.charAt(dataEnd - 1) == "=") {
 			dataEnd--;
 		}
-		reader.dataStart = dataURI.indexOf(",") + 1;
-		reader.size = Math.floor((dataEnd - reader.dataStart) * 0.75);
+		const dataStart = dataURI.indexOf(",") + 1;
+		Object.assign(this, {
+			dataURI,
+			dataStart,
+			size: Math.floor((dataEnd - dataStart) * 0.75)
+		});
 	}
 
 	readUint8Array(offset, length) {
+		const {
+			dataStart,
+			dataURI
+		} = this;
 		const dataArray = new Uint8Array(length);
 		const start = Math.floor(offset / 3) * 4;
-		const dataStart = this.dataStart;
-		const bytes = atob(this.dataURI.substring(start + dataStart, Math.ceil((offset + length) / 3) * 4 + dataStart));
+		const bytes = atob(dataURI.substring(start + dataStart, Math.ceil((offset + length) / 3) * 4 + dataStart));
 		const delta = offset - Math.floor(start / 4) * 3;
 		for (let indexByte = delta; indexByte < delta + length; indexByte++) {
 			dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
@@ -131,8 +142,10 @@ class Data64URIWriter extends Writer {
 
 	constructor(contentType) {
 		super();
-		this.data = "data:" + (contentType || "") + ";base64,";
-		this.pending = [];
+		Object.assign(this, {
+			data: "data:" + (contentType || "") + ";base64,",
+			pending: []
+		});
 	}
 
 	writeUint8Array(array) {
@@ -163,8 +176,10 @@ class BlobReader extends Reader {
 
 	constructor(blob) {
 		super();
-		this.blob = blob;
-		this.size = blob.size;
+		Object.assign(this, {
+			blob,
+			size: blob.size
+		});
 	}
 
 	async readUint8Array(offset, length) {
@@ -181,9 +196,9 @@ class BlobWriter extends Stream {
 		const transformStream = new TransformStream();
 		const headers = [];
 		if (contentType) {
-			headers.push(["content-type", contentType]);
+			headers.push([HTTP_HEADER_CONTENT_TYPE, contentType]);
 		}
-		Object.defineProperty(writer, "writable", {
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
 			get() {
 				return transformStream.writable;
 			}
@@ -224,8 +239,10 @@ class TextWriter extends BlobWriter {
 		} else {
 			const reader = new FileReader();
 			return new Promise((resolve, reject) => {
-				reader.onload = ({ target }) => resolve(target.result);
-				reader.onerror = () => reject(reader.error);
+				Object.assign(reader, {
+					onload: ({ target }) => resolve(target.result),
+					onerror: () => reject(reader.error)
+				});
 				reader.readAsText(blob, encoding);
 			});
 		}
@@ -236,16 +253,7 @@ class FetchReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		const reader = this;
-		reader.url = url;
-		reader.preventHeadRequest = options.preventHeadRequest;
-		reader.useRangeHeader = options.useRangeHeader;
-		reader.forceRangeRequests = options.forceRangeRequests;
-		reader.options = options = Object.assign({}, options);
-		delete options.preventHeadRequest;
-		delete options.useRangeHeader;
-		delete options.forceRangeRequests;
-		delete options.useXHR;
+		createHtpReader(this, url, options);
 	}
 
 	async init() {
@@ -262,12 +270,7 @@ class XHRReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		const reader = this;
-		reader.url = url;
-		reader.preventHeadRequest = options.preventHeadRequest;
-		reader.useRangeHeader = options.useRangeHeader;
-		reader.forceRangeRequests = options.forceRangeRequests;
-		reader.options = options;
+		createHtpReader(this, url, options);
 	}
 
 	async init() {
@@ -280,14 +283,39 @@ class XHRReader extends Reader {
 	}
 }
 
+function createHtpReader(httpReader, url, options) {
+	const {
+		preventHeadRequest,
+		useRangeHeader,
+		forceRangeRequests
+	} = options;
+	options = Object.assign({}, options);
+	delete options.preventHeadRequest;
+	delete options.useRangeHeader;
+	delete options.forceRangeRequests;
+	delete options.useXHR;
+	Object.assign(httpReader, {
+		url,
+		options,
+		preventHeadRequest,
+		useRangeHeader,
+		forceRangeRequests
+	});
+}
+
 async function initHttpReader(httpReader, sendRequest, getRequestData) {
-	if (isHttpFamily(httpReader.url) && (httpReader.useRangeHeader || httpReader.forceRangeRequests)) {
-		const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader));
-		if (!httpReader.forceRangeRequests && response.headers.get(HTTP_HEADER_ACCEPT_RANGES) != HTTP_RANGE_UNIT) {
+	const {
+		url,
+		useRangeHeader,
+		forceRangeRequests
+	} = httpReader;
+	if (isHttpFamily(url) && (useRangeHeader || forceRangeRequests)) {
+		const { headers } = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader));
+		if (!forceRangeRequests && headers.get(HTTP_HEADER_ACCEPT_RANGES) != HTTP_RANGE_UNIT) {
 			throw new Error(ERR_HTTP_RANGE);
 		} else {
 			let contentSize;
-			const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
+			const contentRangeHeader = headers.get(HTTP_HEADER_CONTENT_RANGE);
 			if (contentRangeHeader) {
 				const splitHeader = contentRangeHeader.trim().split(/\s*\/\s*/);
 				if (splitHeader.length) {
@@ -297,7 +325,7 @@ async function initHttpReader(httpReader, sendRequest, getRequestData) {
 					}
 				}
 			}
-			if (contentSize === undefined) {
+			if (contentSize === UNDEFINED_VALUE) {
 				await getContentLength(httpReader, sendRequest, getRequestData);
 			} else {
 				httpReader.size = contentSize;
@@ -309,17 +337,23 @@ async function initHttpReader(httpReader, sendRequest, getRequestData) {
 }
 
 async function readUint8ArrayHttpReader(httpReader, index, length, sendRequest, getRequestData) {
-	if (httpReader.useRangeHeader || httpReader.forceRangeRequests) {
+	const {
+		data,
+		useRangeHeader,
+		forceRangeRequests,
+		options
+	} = httpReader;
+	if (useRangeHeader || forceRangeRequests) {
 		const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, index, length));
 		if (response.status != 206) {
 			throw new Error(ERR_HTTP_RANGE);
 		}
 		return new Uint8Array(await response.arrayBuffer());
 	} else {
-		if (!httpReader.data) {
-			await getRequestData(httpReader, httpReader.options);
+		if (!data) {
+			await getRequestData(httpReader, options);
 		}
-		return new Uint8Array(httpReader.data.subarray(index, index + length));
+		return new Uint8Array(data.subarray(index, index + length));
 	}
 }
 
@@ -327,8 +361,8 @@ function getRangeHeaders(httpReader, index = 0, length = 1) {
 	return Object.assign({}, getHeaders(httpReader), { [HTTP_HEADER_RANGE]: HTTP_RANGE_UNIT + "=" + index + "-" + (index + length - 1) });
 }
 
-function getHeaders(httpReader) {
-	const headers = httpReader.options.headers;
+function getHeaders({ options }) {
+	const { headers } = options;
 	if (headers) {
 		if (Symbol.iterator in headers) {
 			return Object.fromEntries(headers);
@@ -413,9 +447,10 @@ class HttpReader extends Reader {
 
 	constructor(url, options = {}) {
 		super();
-		const reader = this;
-		reader.url = url;
-		reader.reader = options.useXHR ? new XHRReader(url, options) : new FetchReader(url, options);
+		Object.assign(this, {
+			url,
+			reader: options.useXHR ? new XHRReader(url, options) : new FetchReader(url, options)
+		});
 	}
 
 	set size(value) {
@@ -449,8 +484,10 @@ class Uint8ArrayReader extends Reader {
 
 	constructor(array) {
 		super();
-		this.array = array;
-		this.size = array.length;
+		Object.assign(this, {
+			array,
+			size: array.length
+		});
 	}
 
 	readUint8Array(index, length) {
@@ -462,9 +499,10 @@ class Uint8ArrayWriter extends Writer {
 
 	init(initSize = 0) {
 		super.init();
-		const writer = this;
-		writer.offset = 0;
-		writer.array = new Uint8Array(initSize);
+		Object.assign(this, {
+			offset: 0,
+			array: new Uint8Array(initSize)
+		});
 	}
 
 	writeUint8Array(array) {
@@ -529,6 +567,65 @@ class SplitZipReader extends Reader {
 	}
 }
 
+class SplitZipWriter extends Stream {
+
+	constructor(writerGenerator, maxSize = 4294967296) {
+		super();
+		const writer = this;
+		Object.assign(writer, {
+			diskNumber: 0,
+			diskOffset: 0,
+			size: 0,
+			availableSize: maxSize
+		});
+		let currentWriter, diskWritable, diskWriter;
+		const writable = new WritableStream({
+			async write(chunk) {
+				if (!diskWriter) {
+					const { value, done } = await writerGenerator.next();
+					if (done && !value) {
+						throw new Error(ERR_ITERATOR_COMPLETED_TOO_SOON);
+					} else {
+						currentWriter = value;
+						currentWriter.size = 0;
+						diskWritable = value.writable;
+						diskWriter = diskWritable.getWriter();
+					}
+					await this.write(chunk);
+				} else if (diskWriter && currentWriter.size + chunk.length > maxSize) {
+					await diskWriter.ready;
+					const chunkLength = maxSize - currentWriter.size;
+					await diskWriter.write(chunk.slice(0, chunkLength));
+					chunk = chunk.slice(chunkLength);
+					currentWriter.size += chunkLength;
+					writer.size += chunkLength;
+					writer.diskOffset += diskWritable.size = currentWriter.size;
+					writer.diskNumber++;
+					await diskWriter.close();
+					diskWriter = null;
+					await this.write(chunk);
+				} else {
+					await diskWriter.ready;
+					await diskWriter.write(chunk);
+					currentWriter.size += chunk.length;
+					writer.size += chunk.length;
+				}
+				writer.availableSize = maxSize - currentWriter.size;
+			},
+			async close() {
+				await diskWriter.ready;
+				diskWritable.size = currentWriter.size;
+				await diskWriter.close();
+			}
+		});
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+			get() {
+				return writable;
+			}
+		});
+	}
+}
+
 function isHttpFamily(url) {
 	const { baseURL } = getConfiguration();
 	const { protocol } = new URL(url, baseURL);
@@ -561,5 +658,7 @@ export {
 	HttpReader,
 	HttpRangeReader,
 	SplitZipReader,
-	ERR_HTTP_RANGE
+	SplitZipWriter,
+	ERR_HTTP_RANGE,
+	ERR_ITERATOR_COMPLETED_TOO_SOON
 };

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

@@ -56,6 +56,7 @@ const SIGNATURE_LENGTH = 10;
 const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
 const UNDEFINED_TYPE = "undefined";
 const FUNCTION_TYPE = "function";
+// deno-lint-ignore valid-typeof
 const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
 const subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
 const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE;
@@ -132,6 +133,7 @@ class AESDecryptionStream extends TransformStream {
 class AESEncryptionStream extends TransformStream {
 
 	constructor(password, strength) {
+		// deno-lint-ignore prefer-const
 		let stream;
 		super({
 			start() {

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

@@ -34,25 +34,72 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
+
+import {
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	InflateStream,
+	DeflateStream
+} from "./zip-entry-stream.js";
+
+const MESSAGE_EVENT_TYPE = "message";
+const MESSAGE_START = "start";
+const MESSAGE_PULL = "pull";
+const MESSAGE_DATA = "data";
+const MESSAGE_ACK_DATA = "ack";
+const MESSAGE_CLOSE = "close";
+const CODEC_DEFLATE = "deflate";
+const CODEC_INFLATE = "inflate";
+
+export {
+	CODEC_DEFLATE,
+	CODEC_INFLATE,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	CodecStream
+};
 
 class CodecStream extends TransformStream {
 
-	constructor(Codec, options) {
-		const codec = new Codec(options);
-		super({
+	constructor(options, config) {
+		super({});
+		const codec = this;
+		const { codecType } = options;
+		let Stream;
+		if (codecType.startsWith(CODEC_DEFLATE)) {
+			Stream = DeflateStream;
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
+			Stream = InflateStream;
+		}
+		let size = 0;
+		const stream = new Stream(options, config);
+		const readable = super.readable;
+		const transformStream = new TransformStream({
 			transform(chunk, controller) {
-				controller.enqueue(codec.append(chunk));
-			},
-			flush(controller) {
-				const chunk = codec.flush();
-				if (chunk) {
+				if (chunk && chunk.length) {
+					size += chunk.length;
 					controller.enqueue(chunk);
 				}
+			},
+			flush() {
+				const { signature } = stream;
+				Object.assign(codec, {
+					signature,
+					size
+				});
+			}
+		});
+		Object.defineProperty(codec, "readable", {
+			get() {
+				return readable.pipeThrough(stream).pipeThrough(transformStream);
 			}
 		});
 	}
-}
-
-export {
-	CodecStream
-};
+}

package/lib/core/streams/codecs/sjcl.js

@@ -1,6 +1,6 @@
 // Derived from https://github.com/xqdoo00o/jszip/blob/master/lib/sjcl.js and https://github.com/bitwiseshiftleft/sjcl
 
-/*// deno-lint-ignore-file no-this-alias *
+// deno-lint-ignore-file no-this-alias
 
 /*
  * SJCL is open. You can use, modify and redistribute it under a BSD

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

@@ -0,0 +1,55 @@
+/*
+ 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 TransformStream */
+
+export {
+	StreamAdapter
+};
+
+class StreamAdapter {
+
+	constructor(Codec) {
+		return class extends TransformStream {
+			constructor(options) {
+				const codec = new Codec(options);
+				super({
+					transform(chunk, controller) {
+						controller.enqueue(codec.append(chunk));
+					},
+					flush(controller) {
+						const chunk = codec.flush();
+						if (chunk) {
+							controller.enqueue(chunk);
+						}
+					}
+				});
+			}
+		};
+	}
+}

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

@@ -27,6 +27,7 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
 
 import { Crc32 } from "./codecs/crc32.js";
 import {

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

@@ -27,6 +27,7 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
 
 import { Crc32Stream } from "./crc32-stream.js";
 import {

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

@@ -27,6 +27,8 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+// deno-lint-ignore-file no-this-alias
+
 export {
 	initShimAsyncCodec
 };

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

@@ -28,23 +28,24 @@
 
 /* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
+import { UNDEFINED_VALUE } from "./constants.js";
+import { StreamAdapter } from "./streams/stream-adapter.js";
 import {
-	Codec,
-	getCodecStreamClass,
+	CodecStream,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
 	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE
-} from "./codec-interface.js";
+} from "./streams/codec-stream.js";
 
 const pendingPullMessages = new Map();
 const pendingDataMessages = new Map();
-let codec;
+
 let messageId = 0;
 
-addEventListener(MESSAGE_EVENT_TYPE, async event => {
+addEventListener(MESSAGE_EVENT_TYPE, event => {
 	const message = event.data;
 	const { type, messageId, data, done } = message;
 	try {
@@ -70,7 +71,7 @@ async function init(message) {
 	try {
 		const { options, scripts, config } = message;
 		if (scripts && scripts.length) {
-			importScripts.apply(undefined, scripts);
+			importScripts.apply(UNDEFINED_VALUE, scripts);
 		}
 		if (self.initCodec) {
 			self.initCodec();
@@ -78,15 +79,15 @@ async function init(message) {
 		config.CompressionStreamNative = self.CompressionStream;
 		config.DecompressionStreamNative = self.DecompressionStream;
 		if (self.Deflate) {
-			config.CompressionStream = getCodecStreamClass(self.Deflate);
+			config.CompressionStream = new StreamAdapter(self.Deflate);
 		}
 		if (self.Inflate) {
-			config.DecompressionStream = getCodecStreamClass(self.Inflate);
+			config.DecompressionStream = new StreamAdapter(self.Inflate);
 		}
 		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = message.readable || new ReadableStream({
 			async pull(controller) {
-				let result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
+				const result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
 				sendMessage({ type: MESSAGE_PULL, messageId });
 				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
 				const { value, done } = await result;
@@ -106,14 +107,24 @@ async function init(message) {
 				await ackData;
 			}
 		}, strategy);
-		codec = new Codec(readable, writable, options, config);
-		const result = await codec.run();
+		const codecStream = new CodecStream(options, config);
+		await readable.pipeThrough(codecStream).pipeTo(writable, { preventAbort: true });
 		try {
 			await writable.close();
 		} catch (_error) {
 			// ignored
 		}
-		sendMessage({ type: MESSAGE_CLOSE, result });
+		const {
+			signature,
+			size
+		} = codecStream;
+		sendMessage({
+			type: MESSAGE_CLOSE,
+			result: {
+				signature,
+				size
+			}
+		});
 	} catch (error) {
 		sendErrorMessage(error);
 	}

package/lib/core/zip-entry.js

@@ -32,7 +32,8 @@ const PROPERTY_NAMES = [
 	"rawExtraField", "bitFlag", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment",
 	"extraFieldAES", "filenameUTF8", "commentUTF8", "offset", "zip64", "compressionMethod",
 	"extraFieldNTFS", "lastAccessDate", "creationDate", "extraFieldExtendedTimestamp",
-	"version", "versionMadeBy", "msDosCompatible", "internalFileAttribute", "externalFileAttribute"];
+	"version", "versionMadeBy", "msDosCompatible", "internalFileAttribute", "externalFileAttribute",
+	"diskNumberStart"];
 
 class Entry {
 

package/lib/core/zip-fs-core.js

@@ -27,6 +27,7 @@
  */
 
 /* global WritableStream */
+// deno-lint-ignore-file no-this-alias
 
 import {
 	initStream,