@zip.js/zip.js 2.5.9 → 2.5.12

package/lib/core/io.js

@@ -55,7 +55,7 @@ class Stream {
 
 class Reader extends Stream {
 
-	getStream({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+	getReadable({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
 		const reader = this;
 		return new ReadableStream({
 			start() {
@@ -76,7 +76,7 @@ class Reader extends Stream {
 
 class WriterStream extends Stream {
 
-	getStream() {
+	get writable() {
 		const writer = this;
 		return new WritableStream({
 			write(chunk) {
@@ -227,9 +227,10 @@ class BlobWriter extends Writer {
 
 	constructor(contentType) {
 		super();
-		this.contentType = contentType;
-		this.arrayBuffersMaxlength = 8;
-		initArrayBuffers(this);
+		const writer = this;
+		writer.contentType = contentType;
+		writer.arrayBuffersMaxlength = 8;
+		initArrayBuffers(writer);
 	}
 
 	writeUint8Array(array) {
@@ -270,8 +271,10 @@ class ReadableStreamReader {
 		const reader = this;
 		reader.readableStream = readableStream.pipeThrough(new TransformStream({
 			transform(chunk, controller) {
-				reader.size += chunk.length;
-				controller.enqueue(chunk);
+				if (chunk) {
+					reader.size += chunk.length;
+					controller.enqueue(chunk);
+				}
 			}
 		}));
 		reader.size = 0;
@@ -281,7 +284,7 @@ class ReadableStreamReader {
 		this.initialized = true;
 	}
 
-	getStream() {
+	getReadable() {
 		return this.readableStream;
 	}
 }
@@ -290,8 +293,11 @@ class WritableStreamWriter extends Writer {
 
 	constructor(writable) {
 		super();
-		const writer = this;
-		writer.writable = writable;
+		Object.defineProperty(this, "writable", {
+			get() {
+				return writable;
+			}
+		});
 	}
 
 	async writeUint8Array(array) {
@@ -301,10 +307,6 @@ class WritableStreamWriter extends Writer {
 		writer.releaseLock();
 	}
 
-	getStream() {
-		return this.writable;
-	}
-
 	async getData() {
 		await this.writable.getWriter().close();
 		return this.writable;
@@ -320,11 +322,11 @@ class FetchReader extends Reader {
 		reader.preventHeadRequest = options.preventHeadRequest;
 		reader.useRangeHeader = options.useRangeHeader;
 		reader.forceRangeRequests = options.forceRangeRequests;
-		reader.options = Object.assign({}, options);
-		delete reader.options.preventHeadRequest;
-		delete reader.options.useRangeHeader;
-		delete reader.options.forceRangeRequests;
-		delete reader.options.useXHR;
+		reader.options = options = Object.assign({}, options);
+		delete options.preventHeadRequest;
+		delete options.useRangeHeader;
+		delete options.forceRangeRequests;
+		delete options.useXHR;
 	}
 
 	async init() {
@@ -492,12 +494,9 @@ class HttpReader extends Reader {
 
 	constructor(url, options = {}) {
 		super();
-		this.url = url;
-		if (options.useXHR) {
-			this.reader = new XHRReader(url, options);
-		} else {
-			this.reader = new FetchReader(url, options);
-		}
+		const reader = this;
+		reader.url = url;
+		reader.reader = options.useXHR ? new XHRReader(url, options) : new FetchReader(url, options);
 	}
 
 	set size(value) {
@@ -588,4 +587,4 @@ export {
 	WritableStreamWriter,
 	ERR_HTTP_RANGE,
 	ERR_NOT_SEEKABLE_READER
-};
+};

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

@@ -1891,7 +1891,7 @@ const ZipDeflate = (() => {
 	}
 
 	ZStream.prototype = {
-		deflateInit: function (level, bits) {
+		deflateInit(level, bits) {
 			const that = this;
 			that.dstate = new Deflate();
 			if (!bits)
@@ -1899,7 +1899,7 @@ const ZipDeflate = (() => {
 			return that.dstate.deflateInit(that, level, bits);
 		},
 
-		deflate: function (flush) {
+		deflate(flush) {
 			const that = this;
 			if (!that.dstate) {
 				return Z_STREAM_ERROR;
@@ -1907,7 +1907,7 @@ const ZipDeflate = (() => {
 			return that.dstate.deflate(that, flush);
 		},
 
-		deflateEnd: function () {
+		deflateEnd() {
 			const that = this;
 			if (!that.dstate)
 				return Z_STREAM_ERROR;
@@ -1916,14 +1916,14 @@ const ZipDeflate = (() => {
 			return ret;
 		},
 
-		deflateParams: function (level, strategy) {
+		deflateParams(level, strategy) {
 			const that = this;
 			if (!that.dstate)
 				return Z_STREAM_ERROR;
 			return that.dstate.deflateParams(that, level, strategy);
 		},
 
-		deflateSetDictionary: function (dictionary, dictLength) {
+		deflateSetDictionary(dictionary, dictLength) {
 			const that = this;
 			if (!that.dstate)
 				return Z_STREAM_ERROR;
@@ -1935,7 +1935,7 @@ const ZipDeflate = (() => {
 		// this function so some applications may wish to modify it to avoid
 		// allocating a large strm->next_in buffer and copying from it.
 		// (See also flush_pending()).
-		read_buf: function (buf, start, size) {
+		read_buf(buf, start, size) {
 			const that = this;
 			let len = that.avail_in;
 			if (len > size)
@@ -1953,7 +1953,7 @@ const ZipDeflate = (() => {
 		// through this function so some applications may wish to modify it
 		// to avoid allocating a large strm->next_out buffer and copying into it.
 		// (See also read_buf()).
-		flush_pending: function () {
+		flush_pending() {
 			const that = this;
 			let len = that.dstate.pending;
 

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

@@ -2055,7 +2055,7 @@ const ZipInflate = (() => {
 	}
 
 	ZStream.prototype = {
-		inflateInit: function (bits) {
+		inflateInit(bits) {
 			const that = this;
 			that.istate = new Inflate();
 			if (!bits)
@@ -2063,14 +2063,14 @@ const ZipInflate = (() => {
 			return that.istate.inflateInit(that, bits);
 		},
 
-		inflate: function (f) {
+		inflate(f) {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
 			return that.istate.inflate(that, f);
 		},
 
-		inflateEnd: function () {
+		inflateEnd() {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
@@ -2079,23 +2079,23 @@ const ZipInflate = (() => {
 			return ret;
 		},
 
-		inflateSync: function () {
+		inflateSync() {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
 			return that.istate.inflateSync(that);
 		},
-		inflateSetDictionary: function (dictionary, dictLength) {
+		inflateSetDictionary(dictionary, dictLength) {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
 			return that.istate.inflateSetDictionary(that, dictionary, dictLength);
 		},
-		read_byte: function (start) {
+		read_byte(start) {
 			const that = this;
 			return that.next_in[start];
 		},
-		read_buf: function (start, size) {
+		read_buf(start, size) {
 			const that = this;
 			return that.next_in.subarray(start, start + size);
 		}

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

@@ -232,7 +232,7 @@ hash.sha1.prototype = {
 	 * Reset the hash state.
 	 * @return this
 	 */
-	reset: function () {
+	reset() {
 		const sha1 = this;
 		sha1._h = this._init.slice(0);
 		sha1._buffer = [];
@@ -245,7 +245,7 @@ hash.sha1.prototype = {
 	 * @param {bitArray|String} data the data to hash.
 	 * @return this
 	 */
-	update: function (data) {
+	update(data) {
 		const sha1 = this;
 		if (typeof data === "string") {
 			data = codec.utf8String.toBits(data);
@@ -271,7 +271,7 @@ hash.sha1.prototype = {
 	 * Complete hashing and output the hash value.
 	 * @return {bitArray} The hash value, an array of 5 big-endian words. TODO
 	 */
-	finalize: function () {
+	finalize() {
 		const sha1 = this;
 		let b = sha1._buffer;
 		const h = sha1._h;
@@ -311,7 +311,7 @@ hash.sha1.prototype = {
 	 * The SHA-1 logical functions f(0), f(1), ..., f(79).
 	 * @private
 	 */
-	_f: function (t, b, c, d) {
+	_f(t, b, c, d) {
 		if (t <= 19) {
 			return (b & c) | (~b & d);
 		} else if (t <= 39) {
@@ -327,7 +327,7 @@ hash.sha1.prototype = {
 	 * Circular left-shift operator.
 	 * @private
 	 */
-	_S: function (n, x) {
+	_S(n, x) {
 		return (x << n) | (x >>> 32 - n);
 	},
 
@@ -336,7 +336,7 @@ hash.sha1.prototype = {
 	 * @param {Uint32Array|bitArray} words one block of words.
 	 * @private
 	 */
-	_block: function (words) {
+	_block(words) {
 		const sha1 = this;
 		const h = sha1._h;
 		// When words is passed to _block, it has 16 elements. SHA1 _block

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

@@ -66,8 +66,7 @@ class DeflateStream extends TransformStream {
 				readable = pipeCodecStream(codecConstructor, readable, chunkSize);
 			} else {
 				try {
-					const compressionStream = new CompressionStream(COMPRESSION_FORMAT);
-					readable = readable.pipeThrough(compressionStream);
+					readable = readable.pipeThrough(new CompressionStream(COMPRESSION_FORMAT));
 				} catch (_error) {
 					DEFLATE_RAW_SUPPORTED = false;
 					readable = pipeCodecStream(codecConstructor, readable, chunkSize);
@@ -153,8 +152,8 @@ export {
 	ERR_INVALID_SIGNATURE
 };
 
-function pipeCodecStream(codecConstructor, stream, chunkSize) {
-	return stream.pipeThrough(new CodecStream(codecConstructor, { chunkSize }));
+function pipeCodecStream(codecConstructor, readable, chunkSize) {
+	return readable.pipeThrough(new CodecStream(codecConstructor, { chunkSize }));
 }
 
 function filterEmptyChunks(readable) {

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

@@ -110,9 +110,12 @@ async function init(message) {
 
 function sendMessage(message) {
 	if (message.data) {
-		const data = message.data;
+		let { data } = message;
 		if (data && data.length) {
 			try {
+				if (data.length != data.buffer.byteLength) {
+					data = new Uint8Array(data);
+				}
 				message.data = data.buffer;
 				postMessage(message, [message.data]);
 			} catch (_error) {

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

@@ -503,11 +503,11 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 			await zipWriter.add(name, child.reader, Object.assign({
 				directory: child.directory
 			}, Object.assign({}, options, {
-				onprogress: indexProgress => {
+				onprogress: async indexProgress => {
 					if (options.onprogress) {
 						entryOffsets.set(name, indexProgress);
 						try {
-							options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
+							await options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
 						} catch (_error) {
 							// ignored
 						}

package/lib/core/zip-reader.js

@@ -201,7 +201,7 @@ class ZipReader {
 			offset = endOffset;
 			if (options.onprogress) {
 				try {
-					options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
+					await options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
 				} catch (_error) {
 					// ignored
 				}
@@ -301,25 +301,31 @@ class ZipEntry {
 		}
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
 		const size = () => compressedSize;
-		const readable = reader.getStream({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
-		const writable = writer.getStream();
+		const readable = reader.getReadable({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
+		const { writable } = writer;
 		const signal = getOptionValue(zipEntry, options, "signal");
 		if (!writer.initialized) {
 			await writer.init();
 		}
-		await runCodec(config.Inflate, readable, writable, {
-			codecType: CODEC_INFLATE,
-			password,
-			zipCrypto,
-			encryptionStrength: extraFieldAES && extraFieldAES.strength,
-			signed: getOptionValue(zipEntry, options, "checkSignature"),
-			passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
-			signature,
-			compressed: compressionMethod != 0,
-			encrypted,
-			useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
-			useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream")
-		}, config, { signal, onprogress: options.onprogress, size });
+		const { onstart, onprogress, onend } = options;
+		const codecOptions = {
+			options: {
+				codecType: CODEC_INFLATE,
+				password,
+				zipCrypto,
+				encryptionStrength: extraFieldAES && extraFieldAES.strength,
+				signed: getOptionValue(zipEntry, options, "checkSignature"),
+				passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
+				signature,
+				compressed: compressionMethod != 0,
+				encrypted,
+				useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
+				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream")
+			},
+			config,
+			streamOptions: { signal, size, onstart, onprogress, onend }
+		};
+		await runCodec(config.Inflate, { readable, writable }, codecOptions);
 		return writer.getData();
 	}
 }

package/lib/core/zip-writer.js

@@ -209,6 +209,9 @@ async function addFile(zipWriter, name, reader, options) {
 	}
 	let maximumCompressedSize = 0;
 	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
+	if (keepOrder === undefined) {
+		keepOrder = true;
+	}
 	let uncompressedSize = 0;
 	let msDosCompatible = getOptionValue(zipWriter, options, "msDosCompatible");
 	if (msDosCompatible === undefined) {
@@ -292,11 +295,10 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	try {
 		let lockPreviousFileEntry;
 		let fileWriter;
-		let lockCurrentFileEntry;
 		if (options.keepOrder) {
 			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
 		}
-		fileEntry.lock = lockCurrentFileEntry = new Promise(resolve => resolveLockCurrentFileEntry = resolve);
+		fileEntry.lock = new Promise(resolve => resolveLockCurrentFileEntry = resolve);
 		if (options.bufferedWrite || zipWriter.lockWrite || !options.dataDescriptor) {
 			fileWriter = new BlobWriter();
 			fileWriter.init();
@@ -308,8 +310,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			}
 			fileWriter = writer;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter.getStream(), zipWriter.config, options);
-		fileEntry.lock = lockCurrentFileEntry;
+		fileEntry = await createFileEntry(reader, fileWriter.writable, zipWriter.config, options);
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
@@ -324,7 +325,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 				}
 			} while (pendingFileEntry && pendingFileEntry.lock);
 			fileEntry.writingBufferedData = true;
-			const writable = writer.getStream();
+			const { writable } = writer;
 			if (!options.dataDescriptor) {
 				const headerLength = 26;
 				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, headerLength);
@@ -388,7 +389,9 @@ async function createFileEntry(reader, writable, config, options) {
 		rawComment,
 		rawExtraField,
 		useWebWorkers,
+		onstart,
 		onprogress,
+		onend,
 		signal,
 		encryptionStrength,
 		extendedTimestamp,
@@ -521,20 +524,25 @@ async function createFileEntry(reader, writable, config, options) {
 		await writeUint8Array(writable, localHeaderArray);
 		fileEntry.dataWritten = true;
 		const size = () => reader.size;
-		const readable = reader.getStream({ offset: 0, size, chunkSize: getChunkSize(config) });
-		result = await runCodec(config.Deflate, readable, writable, {
-			codecType: CODEC_DEFLATE,
-			level,
-			password,
-			encryptionStrength,
-			zipCrypto: encrypted && zipCrypto,
-			passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
-			signed: true,
-			compressed,
-			encrypted,
-			useWebWorkers,
-			useCompressionStream
-		}, config, { signal, onprogress, size });
+		const readable = reader.getReadable({ offset: 0, size, chunkSize: getChunkSize(config) });
+		const codecOptions = {
+			options: {
+				codecType: CODEC_DEFLATE,
+				level,
+				password,
+				encryptionStrength,
+				zipCrypto: encrypted && zipCrypto,
+				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
+				signed: true,
+				compressed,
+				encrypted,
+				useWebWorkers,
+				useCompressionStream
+			},
+			config,
+			streamOptions: { signal, size, onstart, onprogress, onend }
+		};
+		result = await runCodec(config.Deflate, { readable, writable }, codecOptions);
 		uncompressedSize = fileEntry.uncompressedSize = reader.size;
 		compressedSize = result.length;
 	} else {
@@ -677,7 +685,7 @@ async function closeFile(zipWriter, comment, options) {
 		offset += 46 + rawFilename.length + extraFieldLength + rawComment.length;
 		if (options.onprogress) {
 			try {
-				options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
+				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
 			} catch (_error) {
 				// ignored
 			}
@@ -705,7 +713,7 @@ async function closeFile(zipWriter, comment, options) {
 	setUint16(directoryView, offset + 10, filesLength);
 	setUint32(directoryView, offset + 12, directoryDataLength);
 	setUint32(directoryView, offset + 16, directoryOffset);
-	const writable = zipWriter.writer.getStream();
+	const { writable } = zipWriter.writer;
 	await writeUint8Array(writable, directoryArray);
 	if (comment && comment.length) {
 		await writeUint8Array(writable, comment);