@zip.js/zip.js 2.6.31 → 2.6.33

package/lib/core/codec-pool-worker.js

@@ -28,6 +28,10 @@
 
 /* global Worker, URL, TransformStream, WritableStream */
 
+import {
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE
+} from "./constants.js";
 import {
 	Codec,
 	MESSAGE_EVENT_TYPE,
@@ -89,8 +93,8 @@ class CodecWorker {
 			}
 		};
 		workerData.readable = readable.pipeThrough(new TransformStream(transformer, { highWaterMark: 1, size: () => config.chunkSize }), { signal });
-		if (workersSupported === undefined) {
-			workersSupported = typeof Worker != "undefined";
+		if (workersSupported === UNDEFINED_VALUE) {
+			workersSupported = typeof Worker != UNDEFINED_TYPE;
 		}
 		return useWebWorkers && workersSupported ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 	}
@@ -149,7 +153,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				const writable = new WritableStream({
 					async write(chunk) {
 						await writer.ready;
-						await writer.write(new Uint8Array(chunk));
+						await writer.write(chunk);
 					},
 					async close() {
 						writer.releaseLock();

package/lib/core/codec-pool.js

@@ -28,6 +28,7 @@
 
 /* global setTimeout, clearTimeout */
 
+import { UNDEFINED_VALUE } from "./constants.js";
 import {
 	CODEC_INFLATE,
 	CODEC_DEFLATE,
@@ -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/configuration.js

@@ -29,12 +29,15 @@
 /* global navigator, CompressionStream, DecompressionStream */
 
 import { getCodecStreamClass } from "./codec-interface.js";
+import {
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE
+} from "./constants.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);

package/lib/core/constants.js

@@ -68,6 +68,9 @@ 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";
+
 export {
 	MAX_32_BITS,
 	MAX_16_BITS,
@@ -102,5 +105,7 @@ export {
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
-	MAX_DATE
+	MAX_DATE,
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE
 };

package/lib/core/io.js

@@ -36,11 +36,15 @@ 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 +92,7 @@ class Writer extends Stream {
 				return writer.writeUint8Array(chunk);
 			}
 		});
-		Object.defineProperty(writer, "writable", {
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
 			get() {
 				return writable;
 			}
@@ -104,21 +108,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 +140,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 +174,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 +194,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 +237,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 +251,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 +268,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 +281,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 +323,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 +335,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 +359,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 +445,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 +482,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 +497,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) {

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

@@ -28,6 +28,7 @@
 
 /* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
+import { UNDEFINED_VALUE } from "./constants.js";
 import {
 	Codec,
 	getCodecStreamClass,
@@ -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();

package/lib/core/zip-reader.js

@@ -54,7 +54,8 @@ import {
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
 	FILE_ATTR_MSDOS_DIR_MASK,
-	DIRECTORY_SIGNATURE
+	DIRECTORY_SIGNATURE,
+	UNDEFINED_VALUE
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -127,7 +128,7 @@ class ZipReader {
 		let { reader } = zipReader;
 		const { config } = zipReader;
 		await initStream(reader);
-		if (reader.size === undefined || !reader.readUint8Array) {
+		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
 			if (Array.isArray(reader)) {
 				reader = new SplitZipReader(reader);
 			} else {
@@ -157,7 +158,7 @@ class ZipReader {
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
 		let diskNumber = getUint16(endOfDirectoryView, 4);
-		if (lastDiskNumber !== undefined && diskNumber != lastDiskNumber) {
+		if (lastDiskNumber !== UNDEFINED_VALUE && diskNumber != lastDiskNumber) {
 			throw new Error(ERR_SPLIT_ZIP_FILE);
 		}
 		let filesLength = getUint16(endOfDirectoryView, 8);
@@ -359,8 +360,9 @@ class ZipEntry {
 			throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
 		}
 		readCommonHeader(localDirectory, dataView, 4);
-		dataArray = await readUint8Array(reader, offset, 30 + localDirectory.filenameLength + localDirectory.extraFieldLength, diskNumberStart);
-		localDirectory.rawExtraField = dataArray.subarray(30 + localDirectory.filenameLength);
+		localDirectory.rawExtraField = localDirectory.extraFieldLength ?
+			await readUint8Array(reader, offset + 30 + localDirectory.filenameLength, localDirectory.extraFieldLength, diskNumberStart) :
+			new Uint8Array();
 		await readCommonFooter(zipEntry, localDirectory, dataView, 4);
 		Object.assign(fileEntry, {
 			lastAccessDate: localDirectory.lastAccessDate,
@@ -369,7 +371,7 @@ class ZipEntry {
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (encrypted) {
-			if (!zipCrypto && extraFieldAES.strength === undefined) {
+			if (!zipCrypto && extraFieldAES.strength === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 			} else if (!password) {
 				throw new Error(ERR_ENCRYPTED);
@@ -386,7 +388,7 @@ class ZipEntry {
 			};
 		}
 		const { writable } = writer;
-		if (writable.size === undefined) {
+		if (writable.size === UNDEFINED_VALUE) {
 			writable.size = 0;
 		}
 		const signal = getOptionValue(zipEntry, options, "signal");
@@ -634,7 +636,7 @@ async function seekSignature(reader, signature, startOffset, minimumBytes, maxim
 }
 
 function getOptionValue(zipReader, options, name) {
-	return options[name] === undefined ? zipReader.options[name] : options[name];
+	return options[name] === UNDEFINED_VALUE ? zipReader.options[name] : options[name];
 }
 
 function getDate(timeRaw) {

package/lib/core/zip-writer.js

@@ -57,7 +57,8 @@ import {
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
-	MAX_DATE
+	MAX_DATE,
+	UNDEFINED_VALUE
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -96,7 +97,7 @@ class ZipWriter {
 		if (writer instanceof WritableStream) {
 			writer = { writable: writer };
 		}
-		if (writer.writable.size === undefined) {
+		if (writer.writable.size === UNDEFINED_VALUE) {
 			writer.writable.size = 0;
 		}
 		Object.assign(this, {
@@ -203,7 +204,7 @@ async function addFile(zipWriter, name, reader, options) {
 	const password = getOptionValue(zipWriter, options, "password");
 	const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength") || 3;
 	const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
-	if (password !== undefined && encryptionStrength !== undefined && (encryptionStrength < 1 || encryptionStrength > 3)) {
+	if (password !== UNDEFINED_VALUE && encryptionStrength !== UNDEFINED_VALUE && (encryptionStrength < 1 || encryptionStrength > 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
 	let rawExtraField = new Uint8Array();
@@ -227,18 +228,18 @@ async function addFile(zipWriter, name, reader, options) {
 		});
 	}
 	let extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp");
-	if (extendedTimestamp === undefined) {
+	if (extendedTimestamp === UNDEFINED_VALUE) {
 		extendedTimestamp = true;
 	}
 	let maximumCompressedSize = 0;
 	let maximumEntrySize = 0;
 	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
-	if (keepOrder === undefined) {
+	if (keepOrder === UNDEFINED_VALUE) {
 		keepOrder = true;
 	}
 	let uncompressedSize = 0;
 	let msDosCompatible = getOptionValue(zipWriter, options, "msDosCompatible");
-	if (msDosCompatible === undefined) {
+	if (msDosCompatible === UNDEFINED_VALUE) {
 		msDosCompatible = true;
 	}
 	const internalFileAttribute = getOptionValue(zipWriter, options, "internalFileAttribute") || 0;
@@ -251,15 +252,16 @@ async function addFile(zipWriter, name, reader, options) {
 			};
 		}
 		await initStream(reader);
-		if (reader.size === undefined) {
+		if (reader.size === UNDEFINED_VALUE) {
 			options.dataDescriptor = true;
-			if (zip64 === undefined) {
+			if (zip64 || zip64 === UNDEFINED_VALUE) {
 				zip64 = true;
+				maximumCompressedSize = MAX_32_BITS;
 			}
 		} else {
 			uncompressedSize = reader.size;
+			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 		}
-		maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 	}
 	if (zipWriter.offset + zipWriter.pendingEntriesSize >= MAX_32_BITS ||
 		uncompressedSize >= MAX_32_BITS ||
@@ -278,10 +280,10 @@ async function addFile(zipWriter, name, reader, options) {
 	let dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature");
 	const signal = getOptionValue(zipWriter, options, "signal");
 	const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
-	if (dataDescriptor === undefined) {
+	if (dataDescriptor === UNDEFINED_VALUE) {
 		dataDescriptor = true;
 	}
-	if (dataDescriptor && dataDescriptorSignature === undefined) {
+	if (dataDescriptor && dataDescriptorSignature === UNDEFINED_VALUE) {
 		dataDescriptorSignature = false;
 	}
 	options = Object.assign({}, options, {
@@ -748,7 +750,7 @@ function setEntryInfo(entryInfo, options) {
 		zipCrypto,
 		dataDescriptor
 	} = options;
-	if ((!encrypted || zipCrypto) && signature !== undefined) {
+	if ((!encrypted || zipCrypto) && signature !== UNDEFINED_VALUE) {
 		setUint32(headerView, 10, signature);
 		if (dataDescriptor) {
 			setUint32(dataDescriptorView, dataDescriptorOffset, signature);
@@ -935,7 +937,7 @@ function getTimeNTFS(date) {
 }
 
 function getOptionValue(zipWriter, options, name) {
-	return options[name] === undefined ? zipWriter.options[name] : options[name];
+	return options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
 }
 
 function getMaximumCompressedSize(uncompressedSize) {

package/package.json

@@ -3,7 +3,7 @@
     "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
     "author": "Gildas Lormeau",
     "license": "BSD-3-Clause",
-    "version": "2.6.31",
+    "version": "2.6.33",
     "type": "module",
     "keywords": [
         "zip",