@zip.js/zip.js 2.8.55 → 2.8.57

package/index.cjs

@@ -229,6 +229,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;
 }
@@ -4715,6 +4727,7 @@ const ERR_UNSAFE_FILENAME = "Unsafe filename";
 const ERR_INVALID_STRICTNESS = "Invalid strictness (must be 'strict', 'balanced' or 'tolerant')";
 const ERR_INVALID_FILENAME_VALIDATION = "Invalid filenameValidation (must be 'strict', 'balanced' or 'tolerant')";
 const ERR_INVALID_MAX_APPENDED_DATA_SIZE = "Invalid maxAppendedDataSize (must be a number greater than or equal to 0)";
+const ERR_UNSUPPORTED_UINT64 = "64-bit value exceeds Number.MAX_SAFE_INTEGER";
 const DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
@@ -4737,6 +4750,7 @@ const ZIP64_EXTRACTION = {
 		bytes: 8
 	}
 };
+const MAX_SAFE_UINT64 = BigInt(Number.MAX_SAFE_INTEGER);
 const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
 const MAX_DEFLATE_EXPANSION_RATIO = 1032;
 const CENTRAL_DIRECTORY_UNREACHABLE = 0;
@@ -4832,7 +4846,7 @@ class ZipReader {
 				zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
 				if (zip64EndOfDirectoryVersion2) {
 					const extensibleDataLength = Math.min(
-						Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
+						getBigUint64(endOfDirectoryView, 4) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
 						reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 					if (extensibleDataLength > 0) {
 						zip64EndOfDirectoryLength += extensibleDataLength;
@@ -5065,8 +5079,15 @@ class ZipReader {
 			yield entry;
 		}
 		let offsetAfterSignature = offset;
-		const digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) ||
+		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;
@@ -5406,8 +5427,8 @@ function getDirectoryEncryptionInfo(rawExtensibleData) {
 		const hashDataLength = getUint16$1(extensibleDataView, 26);
 		Object.assign(directoryEncryptionInfo, {
 			compressionMethod: getUint16$1(extensibleDataView, 0),
-			compressedSize: Number(getBigUint64(extensibleDataView, 2)),
-			uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+			compressedSize: getBigUint64(extensibleDataView, 2),
+			uncompressedSize: getBigUint64(extensibleDataView, 10),
 			encryptionAlgorithm: getUint16$1(extensibleDataView, 18),
 			bitLength: getUint16$1(extensibleDataView, 20),
 			flags: getUint16$1(extensibleDataView, 22),
@@ -6042,7 +6063,11 @@ function getUint32$1(view, offset) {
 }
 
 function getBigUint64(view, offset) {
-	return Number(view.getBigUint64(offset, true));
+	const value = view.getBigUint64(offset, true);
+	if (value > MAX_SAFE_UINT64) {
+		throw new Error(ERR_UNSUPPORTED_UINT64);
+	}
+	return Number(value);
 }
 
 var zipReader = /*#__PURE__*/Object.freeze({
@@ -6071,6 +6096,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	ERR_UNSAFE_FILENAME: ERR_UNSAFE_FILENAME,
 	ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 	ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+	ERR_UNSUPPORTED_UINT64: ERR_UNSUPPORTED_UINT64,
 	ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
 	ZipReader: ZipReader,
 	ZipReaderStream: ZipReaderStream
@@ -6143,6 +6169,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$1 = "infozip";
 const UNIX_EXTRA_FIELD_TYPE = "unix";
@@ -6189,16 +6217,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 {
@@ -6211,7 +6237,7 @@ class ZipWriter {
 				encrypted,
 				uncompressedSize,
 				compressedSize,
-				zip64
+				extraFieldZip64
 			} = entry;
 			let {
 				compressionMethod,
@@ -6228,13 +6254,13 @@ class ZipWriter {
 			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || EMPTY_UINT8_ARRAY;
 			rawExtraFieldNTFS = rawExtraFieldNTFS || EMPTY_UINT8_ARRAY;
 			rawExtraFieldUnix = rawExtraFieldUnix || EMPTY_UINT8_ARRAY;
-			rawExtraField = rawExtraField || EMPTY_UINT8_ARRAY;
+			rawExtraField = removeExtraFieldZip64(rawExtraField || EMPTY_UINT8_ARRAY);
 			if (entry.extraFieldAES) {
 				compressionMethod = COMPRESSION_METHOD_AES;
 			}
 			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
-			const zip64UncompressedSize = zip64 && uncompressedSize >= MAX_32_BITS;
-			const zip64CompressedSize = zip64 && compressedSize >= MAX_32_BITS;
+			const zip64UncompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.uncompressedSize !== UNDEFINED_VALUE;
+			const zip64CompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.compressedSize !== UNDEFINED_VALUE;
 			const bitFlagValue = (getBitFlag(level, languageEncodingFlag, dataDescriptor, encrypted, compressionMethod) & ~BITFLAG_LEVEL) | (level << 1);
 			const {
 				headerArray,
@@ -6440,7 +6466,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);
@@ -6472,15 +6499,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$1 && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 		throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 	}
@@ -6502,9 +6523,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);
 	}
@@ -6644,9 +6663,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);
@@ -6724,9 +6741,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);
 		}
@@ -6801,6 +6816,10 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 			maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
 		}
 	}
+	const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThrough)) && !isCompressed(compressionMethod, level);
+	if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
+		dataDescriptor = false;
+	}
 	const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
 	const zip64CompressedSize = zip64Enabled || maximumCompressedSize >= MAX_32_BITS;
 	if (zip64UncompressedSize || zip64CompressedSize) {
@@ -6815,6 +6834,7 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 		maximumCompressedSize,
 		resolvedOptions: {
 			dataDescriptor,
+			emptyEntry,
 			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
@@ -6841,7 +6861,9 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	const usdz = writerOptions[OPTION_USDZ];
 	const files = new Map();
 	let layoutDependsOnWriteOrder = Boolean(usdz);
-	let offset = 0;
+	const initialOffset = writerOptions[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : writerOptions[OPTION_OFFSET];
+	let offset = initialOffset;
+	let minimumEntrySize = INFINITY_VALUE;
 	for (const entry of entries) {
 		let { name } = entry;
 		const { size } = entry;
@@ -6865,7 +6887,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		if (hasContent && !metadata.passThrough && isCompressed(sizes.compressionMethod, sizes.level)) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
-		const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes);
+		const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes, { [OPTION_USDZ]: usdz });
 		const headerInfo = getHeaderInfo(entryOptions);
 		const dataDescriptorInfo = getDataDescriptorInfo(entryOptions);
 		const entryInfo = {
@@ -6876,15 +6898,17 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 			appendExtraFieldUSDZ(entryInfo, offset);
 		}
 		const compressedSize = hasContent ? maximumCompressedSize : 0;
-		if (offset >= MAX_32_BITS) {
-			layoutDependsOnWriteOrder = true;
-		}
 		files.set(name, Object.assign({}, entryOptions, headerInfo, {
 			offset,
 			diskNumberStart: 0,
 			compressedSize
 		}));
-		offset += entryInfo.metadataSize + compressedSize;
+		const entrySize = entryInfo.metadataSize + compressedSize;
+		minimumEntrySize = Math.min(minimumEntrySize, entrySize);
+		offset += entrySize;
+	}
+	if (files.size && offset - minimumEntrySize >= MAX_32_BITS) {
+		layoutDependsOnWriteOrder = true;
 	}
 	if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
@@ -6898,7 +6922,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 			zip64 = true;
 		}
 	}
-	return offset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+	return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 }
 
 async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
@@ -6909,6 +6933,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		keepOrder,
 		dataDescriptor,
+		emptyEntry,
 		signal
 	} = options;
 	const {
@@ -6933,7 +6958,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lockFileEntry;
 			requestLockCurrentFileEntry();
 		}
-		if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || !dataDescriptor) {
+		if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || (!dataDescriptor && !emptyEntry)) {
 			bufferedWrite = true;
 			zipWriter.bufferedWrites++;
 			if (options.createTempStream) {
@@ -7355,8 +7380,8 @@ function getHeaderInfo(options) {
 	try {
 		const { uid, gid, unixExtraFieldType } = options;
 		if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE$1 && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
-			const uidBytes = packUnixId(uid);
-			const gidBytes = packUnixId(gid);
+			const uidBytes = packUnixId(uid === UNDEFINED_VALUE ? 0 : uid);
+			const gidBytes = packUnixId(gid === UNDEFINED_VALUE ? 0 : gid);
 			const payloadLength = 3 + uidBytes.length + gidBytes.length;
 			const extraFieldUnix = createRecordWriter(4 + payloadLength);
 			extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_INFOZIP);
@@ -7395,12 +7420,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);
@@ -7486,18 +7512,14 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 }
 
 function packUnixId(id) {
-	if (id === UNDEFINED_VALUE) {
-		return EMPTY_UINT8_ARRAY;
-	} else {
-		const dataArray = new Uint8Array(4);
-		const dataView = getDataView(dataArray);
-		dataView.setUint32(0, id, true);
-		let length = 4;
-		while (length > 1 && dataArray[length - 1] === 0) {
-			length--;
-		}
-		return dataArray.subarray(0, length);
+	const dataArray = new Uint8Array(4);
+	const dataView = getDataView(dataArray);
+	dataView.setUint32(0, id, true);
+	let length = 4;
+	while (length > 1 && dataArray[length - 1] === 0) {
+		length--;
 	}
+	return dataArray.subarray(0, length);
 }
 
 function normalizeMsdosAttributes(msdosAttributesRaw, msdosAttributes) {
@@ -7801,7 +7823,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;
@@ -7912,7 +7938,22 @@ async function startsWithSplitZipSignature(reader) {
 	return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 }
 
-async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZipSignatureLength) {
+function removeExtraFieldZip64(rawExtraField) {
+	const rawExtraFieldView = getDataView(rawExtraField);
+	let offsetExtraField = 0;
+	while (offsetExtraField + 4 <= getLength(rawExtraField)) {
+		const size = 4 + getUint16(rawExtraFieldView, offsetExtraField + 2);
+		if (getUint16(rawExtraFieldView, offsetExtraField) == EXTRAFIELD_TYPE_ZIP64) {
+			return removeExtraFieldZip64(concat(
+				rawExtraField.subarray(0, offsetExtraField),
+				rawExtraField.subarray(Math.min(offsetExtraField + size, getLength(rawExtraField)))));
+		}
+		offsetExtraField += size;
+	}
+	return rawExtraField;
+}
+
+async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 	const { writer } = zipWriter;
 	const entryPositions = new Map();
 	if (writer.closeDisk) {
@@ -7933,9 +7974,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
 		}));
 	}
@@ -9843,7 +9885,7 @@ function keepsContentType(writer, data) {
 	} else if (writer.constructor == BlobWriter) {
 		return data.type == contentType;
 	} else if (writer.constructor == Data64URIWriter) {
-		return data.startsWith(writer.data);
+		return data.startsWith("data:" + (contentType || "") + ";base64,");
 	} else {
 		return true;
 	}
@@ -10516,6 +10558,7 @@ exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+exports.ERR_UNSUPPORTED_UINT64 = ERR_UNSUPPORTED_UINT64;
 exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
 exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;

package/index.d.cts

@@ -265,6 +265,11 @@ export interface CodecDefinition {
    * The URL of a module exporting the `CompressionStream` and/or `DecompressionStream` classes of
    * the codec. Relative URLs are resolved against {@link Configuration#baseURI}; passing an absolute
    * URL (e.g. via `import.meta.resolve()`) is recommended.
+   *
+   * @remarks
+   * The module is imported dynamically at runtime. Bundlers and single-file builds (e.g.
+   * `deno compile`) cannot follow this import, so the module must be included explicitly
+   * (e.g. with `deno compile --include` or the equivalent option of the bundler).
    */
   codecURI?: string;
   /**
@@ -2947,7 +2952,9 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    *
    * When set to `false`, the {@link ZipWriterConstructorOptions#bufferedWrite} option will automatically be
    * set to `true`. It will be automatically set to `false` when it is `undefined` and the
-   * {@link ZipWriterConstructorOptions#bufferedWrite} option is set to `true`, or when the
+   * {@link ZipWriterConstructorOptions#bufferedWrite} option is set to `true`, or when the entry is a folder
+   * or an empty entry stored without compression or encryption, since the header can then carry the sizes and
+   * the CRC-32 directly. It will be automatically set to `true` when the
    * {@link ZipWriterConstructorOptions#zipCrypto} option is set to `true`. Otherwise, the default value is `true`.
    */
   dataDescriptor?: boolean;
@@ -3024,6 +3031,9 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * - "unix": Info-ZIP Unix extra field type 2 (0x7855), storing fixed 2-byte uid/gid (0..65535); a
    *   larger uid or gid is rejected. The Unix mode is not part of this field; it is written to the
    *   external file attributes.
+   *
+   * When {@link ZipFS} exports imported entries, their uid/gid are re-emitted as "infozip" regardless
+   * of the field type found in the imported zip file, unless this option is set explicitly.
    */
   unixExtraFieldType?: "infozip" | "unix";
   /**
@@ -4315,6 +4325,13 @@ export const ERR_INVALID_FILENAME_VALIDATION: string;
  * Invalid maxAppendedDataSize error (thrown when the `maxAppendedDataSize` option is not a number greater than or equal to 0)
  */
 export const ERR_INVALID_MAX_APPENDED_DATA_SIZE: string;
+/**
+ * Unsupported 64-bit value error
+ *
+ * @remarks Thrown when a 64-bit size, offset, or entry count read from a zip file exceeds `Number.MAX_SAFE_INTEGER`,
+ * instead of processing the value with a loss of precision.
+ */
+export const ERR_UNSUPPORTED_UINT64: string;
 /**
  * Iteration completed too soon error
  */

package/index.d.ts

@@ -265,6 +265,11 @@ export interface CodecDefinition {
    * The URL of a module exporting the `CompressionStream` and/or `DecompressionStream` classes of
    * the codec. Relative URLs are resolved against {@link Configuration#baseURI}; passing an absolute
    * URL (e.g. via `import.meta.resolve()`) is recommended.
+   *
+   * @remarks
+   * The module is imported dynamically at runtime. Bundlers and single-file builds (e.g.
+   * `deno compile`) cannot follow this import, so the module must be included explicitly
+   * (e.g. with `deno compile --include` or the equivalent option of the bundler).
    */
   codecURI?: string;
   /**
@@ -2947,7 +2952,9 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    *
    * When set to `false`, the {@link ZipWriterConstructorOptions#bufferedWrite} option will automatically be
    * set to `true`. It will be automatically set to `false` when it is `undefined` and the
-   * {@link ZipWriterConstructorOptions#bufferedWrite} option is set to `true`, or when the
+   * {@link ZipWriterConstructorOptions#bufferedWrite} option is set to `true`, or when the entry is a folder
+   * or an empty entry stored without compression or encryption, since the header can then carry the sizes and
+   * the CRC-32 directly. It will be automatically set to `true` when the
    * {@link ZipWriterConstructorOptions#zipCrypto} option is set to `true`. Otherwise, the default value is `true`.
    */
   dataDescriptor?: boolean;
@@ -3024,6 +3031,9 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * - "unix": Info-ZIP Unix extra field type 2 (0x7855), storing fixed 2-byte uid/gid (0..65535); a
    *   larger uid or gid is rejected. The Unix mode is not part of this field; it is written to the
    *   external file attributes.
+   *
+   * When {@link ZipFS} exports imported entries, their uid/gid are re-emitted as "infozip" regardless
+   * of the field type found in the imported zip file, unless this option is set explicitly.
    */
   unixExtraFieldType?: "infozip" | "unix";
   /**
@@ -4315,6 +4325,13 @@ export const ERR_INVALID_FILENAME_VALIDATION: string;
  * Invalid maxAppendedDataSize error (thrown when the `maxAppendedDataSize` option is not a number greater than or equal to 0)
  */
 export const ERR_INVALID_MAX_APPENDED_DATA_SIZE: string;
+/**
+ * Unsupported 64-bit value error
+ *
+ * @remarks Thrown when a 64-bit size, offset, or entry count read from a zip file exceeds `Number.MAX_SAFE_INTEGER`,
+ * instead of processing the value with a loss of precision.
+ */
+export const ERR_UNSUPPORTED_UINT64: string;
 /**
  * Iteration completed too soon error
  */