@zip.js/zip.js 2.8.54 → 2.8.56

package/deno.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zip-js/zip-js",
-	"version": "2.8.54",
+	"version": "2.8.56",
 	"exports": {
 		".": "./index.js",
 		"./external": "./lib/zip-fs-external.js",

package/dist/zip-core-external.js

@@ -76,6 +76,7 @@ const BITFLAG_LEVEL_SUPER_FAST_MASK = 0b110;
 const BITFLAG_DATA_DESCRIPTOR = 0b1000;
 const BITFLAG_STRONG_ENCRYPTION = 0b1000000;
 const BITFLAG_LANG_ENCODING_FLAG = 0b100000000000;
+const BITFLAG_MASKED_LOCAL_HEADERS = 0b10000000000000;
 const FILE_ATTR_MSDOS_DIR_MASK = 0b10000;
 const FILE_ATTR_MSDOS_READONLY_MASK = 0x01;
 const FILE_ATTR_MSDOS_HIDDEN_MASK = 0x02;
@@ -225,6 +226,18 @@ function checkPasswordOption(password, rawPassword) {
 	}
 }
 
+function checkInteger(value, maxValue, errorMessage) {
+	if (!Number.isInteger(value) || value < 0 || value > maxValue) {
+		throw new Error(errorMessage);
+	}
+}
+
+function checkIntegerOption(value, maxValue, errorMessage) {
+	if (value !== UNDEFINED_VALUE) {
+		checkInteger(value, maxValue, errorMessage);
+	}
+}
+
 function toNumber(value) {
 	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
 }
@@ -4808,6 +4821,7 @@ class ZipReader {
 		let startOffset;
 		let zip64EndOfDirectory;
 		let zip64EndOfDirectoryVersion2;
+		let zip64EndOfDirectoryLength = ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 		let directoryEncryptionInfo;
 		const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
 		if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
@@ -4844,6 +4858,7 @@ class ZipReader {
 						Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
 						reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 					if (extensibleDataLength > 0) {
+						zip64EndOfDirectoryLength += extensibleDataLength;
 						const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
 						directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
 					}
@@ -4873,7 +4888,7 @@ class ZipReader {
 		}
 		let declaredDirectoryDataLength = directoryDataLength;
 		const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
-			(zip64EndOfDirectory ? ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
+			(zip64EndOfDirectory ? zip64EndOfDirectoryLength + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
 		if (directoryDataOffset >= reader.size) {
 			prependedDataLength = reader.size - directoryDataOffset - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
 			directoryDataOffset = reader.size - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
@@ -4893,7 +4908,9 @@ class ZipReader {
 			}
 			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
-				const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
+				const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
+					Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) ||
+					detectEncryptedCentralDirectory(directoryView);
 				let reconcile = !storedPointsAtDirectory;
 				if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
 					const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
@@ -4922,11 +4939,13 @@ class ZipReader {
 		zipReader.directoryOffset = directoryDataOffset;
 		zipReader.directoryLength = declaredDirectoryDataLength;
 		const decryptCentralDirectory = getFunctionOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
-		let decryptedDirectory;
+		let decryptedDirectory, dataAfterEncryptedDirectory;
 		if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
 			getUint32$1(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
 			(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
-			directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
+			const encryptedDirectoryDataLength = getEncryptedDirectoryDataLength(directoryEncryptionInfo, declaredDirectoryDataLength, directoryArray.length);
+			dataAfterEncryptedDirectory = directoryArray.subarray(encryptedDirectoryDataLength);
+			directoryArray = await decryptCentralDirectory(directoryArray.subarray(0, encryptedDirectoryDataLength), directoryEncryptionInfo);
 			directoryView = getDataView(directoryArray);
 			declaredDirectoryDataLength = directoryArray.length;
 			decryptedDirectory = true;
@@ -4992,6 +5011,7 @@ class ZipReader {
 			}
 			Object.assign(fileEntry, {
 				index: indexFile,
+				decryptedDirectory,
 				versionMadeBy,
 				msDosCompatible,
 				zip64: false,
@@ -5068,13 +5088,19 @@ class ZipReader {
 			yield entry;
 		}
 		let offsetAfterSignature = offset;
-		if (offset + 6 <= directoryArray.length && getUint32$1(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
-			const signatureDataLength = getUint16$1(directoryView, offset + 4);
-			if (offset + 6 + signatureDataLength <= directoryArray.length) {
-				zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
-				offsetAfterSignature = offset + 6 + signatureDataLength;
+		let digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) ||
+			(decryptedDirectory ? readDigitalSignature(dataAfterEncryptedDirectory) : UNDEFINED_VALUE);
+		if (!digitalSignature && !decryptedDirectory) {
+			const signatureRecordOffset = directoryDataOffset + offset;
+			const signatureRecordLength = Math.min(centralDirectoryEndOffset - signatureRecordOffset, 6 + MAX_16_BITS);
+			if (signatureRecordLength >= 6) {
+				digitalSignature = readDigitalSignature(await readUint8Array(reader, signatureRecordOffset, signatureRecordLength));
 			}
 		}
+		if (digitalSignature) {
+			zipReader.digitalSignature = digitalSignature;
+			offsetAfterSignature = offset + 6 + digitalSignature.length;
+		}
 		if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
 			throwAmbiguousArchive("trailing central directory data");
 		}
@@ -5382,6 +5408,27 @@ function detectEncryptedCentralDirectory(directoryView) {
 	return false;
 }
 
+function readDigitalSignature(signatureRecordArray) {
+	if (signatureRecordArray.length >= 6) {
+		const signatureRecordView = getDataView(signatureRecordArray);
+		if (getUint32$1(signatureRecordView, 0) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+			const signatureDataLength = getUint16$1(signatureRecordView, 4);
+			if (6 + signatureDataLength <= signatureRecordArray.length) {
+				return signatureRecordArray.subarray(6, 6 + signatureDataLength);
+			}
+		}
+	}
+}
+
+function getEncryptedDirectoryDataLength(directoryEncryptionInfo, declaredDirectoryDataLength, directoryDataLength) {
+	const encryptedDirectoryDataLength = directoryEncryptionInfo && directoryEncryptionInfo.compressedSize ?
+		directoryEncryptionInfo.compressedSize :
+		declaredDirectoryDataLength;
+	return encryptedDirectoryDataLength > 0 && encryptedDirectoryDataLength <= directoryDataLength ?
+		encryptedDirectoryDataLength :
+		directoryDataLength;
+}
+
 function getDirectoryEncryptionInfo(rawExtensibleData) {
 	const directoryEncryptionInfo = { rawExtensibleData };
 	if (rawExtensibleData.length >= 28) {
@@ -5966,7 +6013,9 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 
 function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
 	const { rawFilename } = zipEntry;
-	if (checkLocalFilename &&
+	const maskedLocalDirectory = zipEntry.decryptedDirectory &&
+		(localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
+	if (checkLocalFilename && !maskedLocalDirectory &&
 		(rawLocalFilename.length != rawFilename.length ||
 			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
 		throwAmbiguousArchive("mismatched local file header (filename)");
@@ -5977,7 +6026,7 @@ function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, chec
 	if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
 		throwAmbiguousArchive("mismatched local file header (compression method)");
 	}
-	if (!localDirectory.bitFlag.dataDescriptor &&
+	if (!localDirectory.bitFlag.dataDescriptor && !maskedLocalDirectory &&
 		(localDirectory.crc32 || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
 		(localDirectory.crc32 != zipEntry.crc32 ||
 			localDirectory.compressedSize != zipEntry.compressedSize ||
@@ -6108,6 +6157,7 @@ const MIN_NTFS_TIME = BigInt(0);
 const MAX_NTFS_TIME = BigInt("0x7fffffffffffffff");
 const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
+const ERR_UNDEFINED_COMPRESSION_METHOD = "Undefined compression method";
 const ERR_UNDETERMINED_SIZE = "Undetermined size";
 const ERR_UNDEFINED_READER = "Undefined reader";
 const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
@@ -6123,6 +6173,8 @@ const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
+const EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD = 9;
+const EXTRAFIELD_USDZ_MAX_LENGTH = 67;
 const VENDOR_VERSION_AE_1 = 1;
 const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 const UNIX_EXTRA_FIELD_TYPE = "unix";
@@ -6169,16 +6221,14 @@ class ZipWriter {
 		await zipReader$1.close();
 		await initStream(this.writer);
 		const { directoryOffset } = zipReader$1;
-		let splitZipSignatureLength = 0;
 		if (this.addSplitZipSignature) {
 			delete this.addSplitZipSignature;
 			if (!await startsWithSplitZipSignature(reader)) {
 				await writeData(this.writer, getSplitZipSignatureArray());
-				splitZipSignatureLength = SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
-				this.offset += splitZipSignatureLength;
+				this.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
 			}
 		}
-		const entryPositions = await copyZipData(this, reader, entries, directoryOffset, splitZipSignatureLength);
+		const entryPositions = await copyZipData(this, reader, entries, directoryOffset);
 		this.filenames = new Set(entries.map(entry => entry.filename));
 		this.fileEntries = new Map(entries.map(entry => {
 			const {
@@ -6420,7 +6470,8 @@ async function addFile(zipWriter, name, reader, options) {
 			signature: options[PROPERTY_NAME_SIGNATURE],
 			crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 			offset: zipWriter.offset - diskOffset,
-			diskNumberStart: diskNumber
+			diskNumberStart: diskNumber,
+			[OPTION_USDZ]: zipWriter.options[OPTION_USDZ]
 		});
 		const headerInfo = getHeaderInfo(options);
 		const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -6452,15 +6503,9 @@ function resolveAttributes(zipWriter, name, options) {
 	let setuid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETUID);
 	let setgid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETGID);
 	let sticky = getOptionValue(zipWriter, options, PROPERTY_NAME_STICKY);
-	if (uid !== UNDEFINED_VALUE && (!Number.isInteger(uid) || uid < 0 || uid > MAX_32_BITS)) {
-		throw new Error(ERR_INVALID_UID);
-	}
-	if (gid !== UNDEFINED_VALUE && (!Number.isInteger(gid) || gid < 0 || gid > MAX_32_BITS)) {
-		throw new Error(ERR_INVALID_GID);
-	}
-	if (unixMode !== UNDEFINED_VALUE && (!Number.isInteger(unixMode) || unixMode < 0 || unixMode > MAX_16_BITS)) {
-		throw new Error(ERR_INVALID_UNIX_MODE);
-	}
+	checkIntegerOption(uid, MAX_32_BITS, ERR_INVALID_UID);
+	checkIntegerOption(gid, MAX_32_BITS, ERR_INVALID_GID);
+	checkIntegerOption(unixMode, MAX_16_BITS, ERR_INVALID_UNIX_MODE);
 	if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 		throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 	}
@@ -6482,9 +6527,7 @@ function resolveAttributes(zipWriter, name, options) {
 		msDosCompatible = true;
 		versionMadeBy = (versionMadeBy & MAX_8_BITS);
 	}
-	if (msdosAttributesRaw !== UNDEFINED_VALUE && (!Number.isInteger(msdosAttributesRaw) || msdosAttributesRaw < 0 || msdosAttributesRaw > MAX_8_BITS)) {
-		throw new Error(ERR_INVALID_MSDOS_ATTRIBUTES);
-	}
+	checkIntegerOption(msdosAttributesRaw, MAX_8_BITS, ERR_INVALID_MSDOS_ATTRIBUTES);
 	if (msdosAttributes && (typeof msdosAttributes !== OBJECT_TYPE || Array.isArray(msdosAttributes))) {
 		throw new Error(ERR_INVALID_MSDOS_DATA);
 	}
@@ -6624,9 +6667,7 @@ function resolveMetadata(zipWriter, name, options) {
 		throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 	}
 	let level = getNumberOptionValue(zipWriter, options, OPTION_LEVEL);
-	if (level !== UNDEFINED_VALUE && (!Number.isInteger(level) || level < 0 || level > MAX_LEVEL)) {
-		throw new Error(ERR_INVALID_LEVEL);
-	}
+	checkIntegerOption(level, MAX_LEVEL, ERR_INVALID_LEVEL);
 	if (zipWriter.options[OPTION_USDZ]) {
 		if (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) {
 			throw new Error(ERR_UNSUPPORTED_ENCRYPTION_USDZ);
@@ -6635,6 +6676,9 @@ function resolveMetadata(zipWriter, name, options) {
 			level = 0;
 		}
 	}
+	if (passThrough) {
+		level = UNDEFINED_VALUE;
+	}
 	let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 	let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 	if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
@@ -6701,9 +6745,7 @@ function serializeExtraField(extraField) {
 	let extraFieldSize = 0;
 	let offset = 0;
 	extraField.forEach((data, type) => {
-		if (!Number.isInteger(type) || type < 0 || type > MAX_16_BITS) {
-			throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
-		}
+		checkInteger(type, MAX_16_BITS, ERR_INVALID_EXTRAFIELD_TYPE);
 		if (!(data instanceof Uint8Array)) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA_TYPE);
 		}
@@ -6746,6 +6788,9 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 		if (uncompressedSize === UNDEFINED_VALUE) {
 			throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
 		}
+		if (compressionMethod === UNDEFINED_VALUE) {
+			throw new Error(ERR_UNDEFINED_COMPRESSION_METHOD);
+		}
 	}
 	const zip64Enabled = zip64 === true;
 	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
@@ -7294,12 +7339,13 @@ function getHeaderInfo(options) {
 		if (passThrough && crc32 !== UNDEFINED_VALUE) {
 			rawExtraFieldAES[EXTRAFIELD_OFFSET_AES_VENDOR_VERSION] = VENDOR_VERSION_AE_1;
 		}
-		rawExtraFieldAES[9] = compressionMethod;
+		setUint16(getDataView(rawExtraFieldAES), EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD, compressionMethod);
 		compressionMethod = COMPRESSION_METHOD_AES;
 	}
 	const localExtraFieldZip64Length = writeLocalExtraFieldZip64 ? getLength(rawLocalExtraFieldZip64) : 0;
 	const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawLocalExtraField);
-	if (extraFieldLength > MAX_16_BITS) {
+	const maximumUsdzExtraFieldLength = options[OPTION_USDZ] ? EXTRAFIELD_USDZ_MAX_LENGTH : 0;
+	if (extraFieldLength + maximumUsdzExtraFieldLength > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 	}
 	const dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
@@ -7700,7 +7746,11 @@ async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
 		signatureRecord.writeUint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
 		signatureRecord.writeUint16(signatureDataLength);
 		signatureRecord.writeBytes(signatureData);
-		await writeData(zipWriter.writer, signatureRecord.array);
+		const { writer } = zipWriter;
+		if (exceedsAvailableSize(writer, getLength(signatureRecord.array))) {
+			await writer.closeDisk();
+		}
+		await writeData(writer, signatureRecord.array);
 		return 6 + signatureDataLength;
 	}
 	return 0;
@@ -7811,7 +7861,7 @@ async function startsWithSplitZipSignature(reader) {
 	return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 }
 
-async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZipSignatureLength) {
+async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 	const { writer } = zipWriter;
 	const entryPositions = new Map();
 	if (writer.closeDisk) {
@@ -7832,9 +7882,10 @@ async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZip
 		}
 		await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
 	} else {
+		const baseOffset = zipWriter.offset;
 		await copyData(zipWriter, reader, 0, directoryOffset);
 		entries.forEach(entry => entryPositions.set(entry, {
-			offset: splitZipSignatureLength + getSourceOffset(reader, entry),
+			offset: baseOffset + getSourceOffset(reader, entry),
 			diskNumberStart: 0
 		}));
 	}
@@ -8924,4 +8975,4 @@ function terminateWorkersAndModule() {
 
 configureExternalAssets();
 
-export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND, ERR_EOCDR_NOT_FOUND, ERR_EXTRAFIELD_ZIP64_NOT_FOUND, ERR_HTTP_RANGE, ERR_HTTP_RESOURCE_CHANGED, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_DATE, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_COMMENT_TYPE, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_DATA_TYPE, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_FUNCTION_OPTION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MAX_WORKERS, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_SIGNAL, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_STRICTNESS, ERR_INVALID_UID, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_UNIX_EXTRA_FIELD_TYPE, ERR_INVALID_UNIX_ID_SIZE, ERR_INVALID_UNIX_MODE, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };
+export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND, ERR_EOCDR_NOT_FOUND, ERR_EXTRAFIELD_ZIP64_NOT_FOUND, ERR_HTTP_RANGE, ERR_HTTP_RESOURCE_CHANGED, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_DATE, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_COMMENT_TYPE, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_DATA_TYPE, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_FUNCTION_OPTION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MAX_WORKERS, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_SIGNAL, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_STRICTNESS, ERR_INVALID_UID, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_UNIX_EXTRA_FIELD_TYPE, ERR_INVALID_UNIX_ID_SIZE, ERR_INVALID_UNIX_MODE, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, ERR_UNDEFINED_COMPRESSION_METHOD, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };