@zip.js/zip.js 2.8.34 → 2.8.35

package/lib/core/zip-reader.js

@@ -85,10 +85,7 @@ import {
 	FILE_ATTR_UNIX_STICKY_MASK,
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
-import {
-	getConfiguration,
-	getChunkSize
-} from "./configuration.js";
+import { getConfiguration } from "./configuration.js";
 import {
 	runWorker,
 	CODEC_INFLATE,
@@ -106,6 +103,7 @@ import {
 	GenericWriter
 } from "./io.js";
 import { decodeText } from "./util/decode-text.js";
+import { getDataView } from "./util/array.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
 import {
 	PROPERTY_NAME_RAW_FILENAME,
@@ -239,17 +237,21 @@ class ZipReader {
 		let prependedDataLength = 0;
 		let startOffset;
 		let zip64EndOfDirectory;
-		if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS) {
+		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) {
+			directoryDataOffset += getDiskOffset(reader, diskNumber);
+		}
+		if (requiresZip64) {
 			const endOfDirectoryLocatorArray = endOfDirectoryInfo.offset >= ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH ?
 				await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH) :
 				EMPTY_UINT8_ARRAY;
 			const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
 			if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
 				getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
-				directoryDataOffset = getBigUint64(endOfDirectoryLocatorView, 8);
-				let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
+				directoryDataOffset = getDiskOffset(reader, getUint32(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
+				let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 				let endOfDirectoryView = getDataView(endOfDirectoryArray);
-				const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH - (reader.lastDiskOffset || 0);
+				const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 				if ((endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) &&
 					directoryDataOffset != expectedDirectoryDataOffset && expectedDirectoryDataOffset >= 0) {
 					const originalDirectoryDataOffset = directoryDataOffset;
@@ -257,7 +259,7 @@ class ZipReader {
 					if (directoryDataOffset > originalDirectoryDataOffset) {
 						prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
 					}
-					endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
+					endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 					endOfDirectoryView = getDataView(endOfDirectoryArray);
 				}
 				if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
@@ -284,7 +286,7 @@ class ZipReader {
 				} else if (checkAmbiguity && directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
 					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
-				directoryDataOffset = getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
+				directoryDataOffset = getDiskOffset(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 			}
 		}
 		const declaredDirectoryDataLength = directoryDataLength;
@@ -301,18 +303,18 @@ class ZipReader {
 			throw new Error(ERR_BAD_FORMAT);
 		}
 		let offset = 0;
-		let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
+		let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
 		let directoryView = getDataView(directoryArray);
 		if (directoryDataLength) {
 			if (directoryArray.length < 4) {
 				throw new Error(ERR_BAD_FORMAT);
 			}
-			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength - (reader.lastDiskOffset || 0);
+			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
 				const storedPointsAtDirectory = getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
 				let reconcile = !storedPointsAtDirectory;
 				if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
-					const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4, diskNumber);
+					const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
 					reconcile = getUint32(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
 				}
 				if (reconcile) {
@@ -321,15 +323,15 @@ class ZipReader {
 					if (directoryDataOffset > originalDirectoryDataOffset) {
 						prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
 					}
-					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
+					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
 					directoryView = getDataView(directoryArray);
 				}
 			}
 		}
-		const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset - (reader.lastDiskOffset || 0);
+		const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset;
 		if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0 && diskNumber == lastDiskNumber) {
 			directoryDataLength = expectedDirectoryDataLength;
-			directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
+			directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
 			directoryView = getDataView(directoryArray);
 		}
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
@@ -403,7 +405,7 @@ class ZipReader {
 			});
 			readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
 			fileEntry.offset += prependedDataLength;
-			startOffset = Math.min(fileEntry.offset, startOffset);
+			startOffset = Math.min(getDiskOffset(reader, fileEntry.diskNumberStart) + fileEntry.offset, startOffset);
 			if (checkAmbiguity) {
 				if (filenames.has(fileEntry.filename)) {
 					duplicateFilename = true;
@@ -578,7 +580,8 @@ class ZipEntry {
 			dataDescriptor
 		} = bitFlag;
 		const localDirectory = fileEntry.localDirectory = {};
-		const dataArray = await readUint8Array(reader, offset, HEADER_SIZE, diskNumberStart);
+		const localHeaderOffset = getDiskOffset(reader, diskNumberStart) + offset;
+		const dataArray = await readUint8Array(reader, localHeaderOffset, HEADER_SIZE);
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, OPTION_PASSWORD);
 		let rawPassword = getOptionValue(zipEntry, options, OPTION_RAW_PASSWORD);
@@ -604,12 +607,12 @@ class ZipEntry {
 		const checkAmbiguity = getStrictness(getOptionValue(zipEntry, options, OPTION_STRICTNESS), getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
 		let rawLocalFilename = EMPTY_UINT8_ARRAY;
 		if (checkAmbiguity && (filenameLength || extraFieldLength)) {
-			const trailingDataArray = await readUint8Array(reader, offset + HEADER_SIZE, filenameLength + extraFieldLength, diskNumberStart);
+			const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
 			rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
 			localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
 		} else {
 			localDirectory.rawExtraField = extraFieldLength ?
-				await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
+				await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) :
 				EMPTY_UINT8_ARRAY;
 		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
@@ -635,9 +638,9 @@ class ZipEntry {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
-		const dataOffset = offset + HEADER_SIZE + filenameLength + extraFieldLength;
+		const dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
 		const size = compressedSize;
-		const readable = reader.createReadable({ offset: dataOffset, size, diskNumberStart, chunkSize: getChunkSize(config) });
+		const readable = reader.createReadable({ offset: dataOffset, size });
 		const signal = getOptionValue(zipEntry, options, OPTION_SIGNAL);
 		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
@@ -678,8 +681,7 @@ class ZipEntry {
 				reader,
 				fileEntry,
 				index,
-				offset,
-				diskNumberStart,
+				offset: localHeaderOffset,
 				signature,
 				compressedSize,
 				uncompressedSize,
@@ -743,7 +745,7 @@ function readCommonHeader(directory, dataView, offset) {
 function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory) {
 	const { rawExtraField } = directory;
 	const extraField = directory.extraField = new Map();
-	const rawExtraFieldView = getDataView(new Uint8Array(rawExtraField));
+	const rawExtraFieldView = getDataView(rawExtraField);
 	let offsetExtraField = 0;
 	try {
 		while (offsetExtraField < rawExtraField.length) {
@@ -905,7 +907,7 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 
 function readExtraFieldUnix(extraField, directory, isInfoZip) {
 	try {
-		const view = getDataView(new Uint8Array(extraField.data));
+		const view = getDataView(extraField.data);
 		let uid, gid;
 		if (isInfoZip) {
 			let offset = 0;
@@ -981,7 +983,6 @@ async function detectOverlappingEntry({
 	fileEntry,
 	index,
 	offset,
-	diskNumberStart,
 	signature,
 	compressedSize,
 	uncompressedSize,
@@ -990,12 +991,6 @@ async function detectOverlappingEntry({
 	extraFieldZip64,
 	readRanges
 }) {
-	let diskOffset = 0;
-	if (diskNumberStart && reader.readers) {
-		for (let indexReader = 0; indexReader < Math.min(diskNumberStart, reader.readers.length); indexReader++) {
-			diskOffset += reader.readers[indexReader].size;
-		}
-	}
 	let dataDescriptorLength = 0;
 	if (dataDescriptor) {
 		if (extraFieldZip64) {
@@ -1005,7 +1000,7 @@ async function detectOverlappingEntry({
 		}
 	}
 	if (dataDescriptorLength) {
-		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, diskNumberStart);
+		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
 		const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
 			getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
 		if (dataDescriptorSignature) {
@@ -1028,8 +1023,8 @@ async function detectOverlappingEntry({
 		}
 	}
 	const range = {
-		start: diskOffset + offset,
-		end: diskOffset + dataOffset + compressedSize + dataDescriptorLength,
+		start: offset,
+		end: dataOffset + compressedSize + dataDescriptorLength,
 		fileEntry
 	};
 	for (const [otherIndex, otherRange] of readRanges) {
@@ -1042,6 +1037,10 @@ async function detectOverlappingEntry({
 	readRanges.set(index, range);
 }
 
+function getDiskOffset(reader, diskNumber) {
+	return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
+}
+
 function getStrictness(strictness, checkAmbiguity) {
 	if (strictness === UNDEFINED_VALUE) {
 		return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
@@ -1148,7 +1147,8 @@ async function getCentralDirectoryReachability(reader, view, anchoredOffset, ind
 	if (!filesLength && !directoryDataLength) {
 		return CENTRAL_DIRECTORY_PLAUSIBLE;
 	}
-	for (const centralDirectoryOffset of [offset - directoryDataLength, directoryDataOffset]) {
+	const directoryDiskNumber = getUint16(view, indexByte + 6);
+	for (const centralDirectoryOffset of [offset - directoryDataLength, getDiskOffset(reader, directoryDiskNumber) + directoryDataOffset]) {
 		if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
 			return CENTRAL_DIRECTORY_REACHABLE;
 		}
@@ -1231,6 +1231,3 @@ function getBigUint64(view, offset) {
 	return Number(view.getBigUint64(offset, true));
 }
 
-function getDataView(array) {
-	return new DataView(array.buffer, array.byteOffset, array.byteLength);
-}

package/lib/core/zip-writer.js

@@ -44,9 +44,10 @@
  *   the other segments do not, see getSegmentOffset().
  * - For split archives, `writer.diskOffset` is the total size of the closed segments and
  *   `writer.diskNumber` the index of the current segment. `writer.availableSize` is the remaining
- *   capacity of the current segment (Infinity otherwise); setting it to 0 and writing an empty
- *   chunk starts a new segment. This is how header records are kept whole within a segment, as
- *   required by APPNOTE section 8.5.2.
+ *   capacity of the current segment; `writer.closeDisk()` ends it, the next segment being opened
+ *   when more data is written. This is how header records are kept whole within a segment, as
+ *   required by APPNOTE section 8.5.2. These properties only exist on split writers; the
+ *   getDiskNumber(), getDiskOffset() and exceedsAvailableSize() accessors default them otherwise.
  * - The segment coordinates of an entry (`diskNumberStart` and `offset`) must be read after
  *   calling skipDiskIfNeeded() and while holding the writer lock; they are unstable otherwise.
  *
@@ -140,10 +141,7 @@ import {
 	OBJECT_TYPE,
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
-import {
-	getConfiguration,
-	getChunkSize
-} from "./configuration.js";
+import { getConfiguration } from "./configuration.js";
 import {
 	CODEC_DEFLATE,
 	runWorker
@@ -154,6 +152,7 @@ import {
 	GenericReader
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
+import { getDataView } from "./util/array.js";
 import {
 	PROPERTY_NAME_LAST_MODIFICATION_DATE,
 	PROPERTY_NAME_LAST_ACCESS_DATE,
@@ -207,9 +206,6 @@ import {
 	OPTION_USDZ,
 	OPTION_UNIX_EXTRA_FIELD_TYPE
 } from "./options.js";
-import {
-	ZipReader
-} from "./zip-reader.js";
 
 const ERR_DUPLICATED_NAME = "File already exists";
 const ERR_INVALID_COMMENT = "Zip file comment exceeds 64KB";
@@ -245,9 +241,10 @@ class ZipWriter {
 
 	constructor(writer, options = {}) {
 		writer = new GenericWriter(writer);
+		const { availableSize = INFINITY_VALUE, maxSize = INFINITY_VALUE } = writer;
 		const addSplitZipSignature =
-			writer.availableSize !== UNDEFINED_VALUE && writer.availableSize > 0 && writer.availableSize !== INFINITY_VALUE &&
-			writer.maxSize !== UNDEFINED_VALUE && writer.maxSize > 0 && writer.maxSize !== INFINITY_VALUE;
+			availableSize > 0 && availableSize !== INFINITY_VALUE &&
+			maxSize > 0 && maxSize !== INFINITY_VALUE;
 		Object.assign(this, {
 			writer,
 			addSplitZipSignature,
@@ -269,6 +266,7 @@ class ZipWriter {
 		}
 		reader = new GenericReader(reader);
 		await initStream(reader);
+		const { ZipReader } = await import("./zip-reader.js");
 		const zipReader = new ZipReader(reader.readable);
 		const entries = await zipReader.getEntries();
 		await zipReader.close();
@@ -287,8 +285,6 @@ class ZipWriter {
 				encrypted,
 				uncompressedSize,
 				compressedSize,
-				diskOffset,
-				diskNumber,
 				zip64
 			} = entry;
 			let {
@@ -336,8 +332,9 @@ class ZipWriter {
 			Object.assign(entry, {
 				zip64UncompressedSize,
 				zip64CompressedSize,
-				zip64Offset: zip64 && this.offset - diskOffset >= MAX_32_BITS,
-				zip64DiskNumberStart: zip64 && diskNumber >= MAX_16_BITS,
+				zip64Offset: zip64 && entry.offset >= MAX_32_BITS,
+				diskNumberStart: 0,
+				zip64DiskNumberStart: false,
 				rawExtraFieldZip64,
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
@@ -521,7 +518,8 @@ async function addFile(zipWriter, name, reader, options) {
 	try {
 		const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
 		({ reader } = sizesInfo);
-		const { diskOffset, diskNumber } = zipWriter.writer;
+		const diskOffset = getDiskOffset(zipWriter.writer);
+		const diskNumber = getDiskNumber(zipWriter.writer);
 		options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
 			internalFileAttribute: metadataInfo.resolvedOptions.internalFileAttributes,
 			externalFileAttribute: attributesInfo.resolvedOptions.externalFileAttributes,
@@ -698,7 +696,7 @@ function resolveMetadata(zipWriter, name, options) {
 	const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
 	const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
 	const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
-	const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS, true);
+	const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
 	const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
 	const createTempStream = getOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
@@ -896,7 +894,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await requestLockWriter();
 		}
 		await initStream(fileWriter);
-		const { diskOffset } = writer;
+		const diskOffset = getDiskOffset(writer);
 		if (zipWriter.addSplitZipSignature) {
 			delete zipWriter.addSplitZipSignature;
 			const signatureArray = new Uint8Array(4);
@@ -913,7 +911,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await lockPreviousFileEntry;
 			await skipDiskIfNeeded();
 		}
-		const diskNumberStart = writer.diskNumber;
+		const diskNumberStart = getDiskNumber(writer);
 		const entryOffset = getSegmentOffset(zipWriter, writer);
 		fileEntry.diskNumberStart = diskNumberStart;
 		if (!bufferedWrite) {
@@ -933,11 +931,11 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			writingBufferedEntryData = true;
 			writerSizeBeforeEntry = writer.size;
 			await skipDiskIfNeeded();
-			fileEntry.diskNumberStart = writer.diskNumber;
+			fileEntry.diskNumberStart = getDiskNumber(writer);
 			fileEntry.offset = getSegmentOffset(zipWriter, writer);
 			if (usdz) {
 				const previousMetadataSize = entryInfo.metadataSize;
-				appendExtraFieldUSDZ(entryInfo, zipWriter.offset - writer.diskOffset);
+				appendExtraFieldUSDZ(entryInfo, zipWriter.offset - getDiskOffset(writer));
 				fileEntry.size += entryInfo.metadataSize - previousMetadataSize;
 			}
 			updateLocalHeader(fileEntry, headerInfo.localHeaderView, options);
@@ -1002,9 +1000,8 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	}
 
 	async function skipDiskIfNeeded() {
-		if (getLength(headerInfo.localHeaderArray) > writer.availableSize) {
-			writer.availableSize = 0;
-			await writeData(writer, EMPTY_UINT8_ARRAY);
+		if (exceedsAvailableSize(writer, getLength(headerInfo.localHeaderArray))) {
+			await writer.closeDisk();
 		}
 	}
 }
@@ -1115,7 +1112,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	}
 	const { writable } = writer;
 	if (reader) {
-		const readable = reader.createReadable ? reader.createReadable({ chunkSize: getChunkSize(config) }) : reader.readable;
+		const readable = reader.createReadable ? reader.createReadable() : reader.readable;
 		const size = reader.size;
 		const workerOptions = {
 			options: {
@@ -1547,8 +1544,8 @@ function updateLocalHeader({
 
 async function closeFile(zipWriter, comment, options) {
 	const directoryDataLength = createDirectoryRecords(zipWriter.files);
-	const { cdStartDiskNumber, cdStartDiskOffset } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
-	await writeEndOfDirectoryRecord(zipWriter, comment, options, { cdStartDiskNumber, cdStartDiskOffset, directoryDataLength });
+	const directoryStart = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength });
 }
 
 function createDirectoryRecords(files) {
@@ -1630,8 +1627,8 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 	await initStream(writer);
 	let offset = 0;
 	let directoryDiskOffset = 0;
-	let cdStartDiskNumber = writer.diskNumber;
-	let cdStartDiskOffset = writer.diskOffset;
+	let directoryStartDiskNumber = getDiskNumber(writer);
+	let directoryStartDiskOffset = getDiskOffset(writer);
 	for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
 		const {
 			offset: fileEntryOffset,
@@ -1658,15 +1655,14 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		} = fileEntry;
 		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
 		const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
-		if (offset + directoryRecordLength - directoryDiskOffset > writer.availableSize) {
+		if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 			directoryDiskOffset = offset;
-			writer.availableSize = 0;
-			await writeData(writer, EMPTY_UINT8_ARRAY);
+			await writer.closeDisk();
 		}
 		if (indexFileEntry == 0) {
-			cdStartDiskNumber = writer.diskNumber;
-			cdStartDiskOffset = writer.diskOffset;
+			directoryStartDiskNumber = getDiskNumber(writer);
+			directoryStartDiskOffset = getDiskOffset(writer);
 		}
 		if (!zip64UncompressedSize) {
 			setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, uncompressedSize);
@@ -1706,18 +1702,18 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		}
 	}
 	await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
-	return { cdStartDiskNumber, cdStartDiskOffset };
+	return { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset };
 }
 
 async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const { writer } = zipWriter;
-	const { cdStartDiskNumber, cdStartDiskOffset } = cdInfo;
+	const { directoryStart } = cdInfo;
 	let { directoryDataLength } = cdInfo;
 	let filesLength = zipWriter.files.size;
-	let diskNumber = cdStartDiskNumber;
-	let directoryOffset = zipWriter.offset - cdStartDiskOffset - (cdStartDiskNumber ? zipWriter.initialOffset : 0);
-	let lastDiskNumber = writer.diskNumber;
-	if (writer.availableSize < END_OF_CENTRAL_DIR_LENGTH) {
+	let diskNumber = directoryStart.diskNumber;
+	let directoryOffset = getSegmentOffset(zipWriter, directoryStart);
+	let lastDiskNumber = getDiskNumber(writer);
+	if (exceedsAvailableSize(writer, END_OF_CENTRAL_DIR_LENGTH)) {
 		lastDiskNumber++;
 	}
 	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
@@ -1733,11 +1729,10 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		throw new Error(ERR_INVALID_COMMENT);
 	}
 	const endOfdirectoryRecord = createRecordWriter(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
-	if (getLength(endOfdirectoryRecord.array) + commentLength > writer.availableSize) {
-		writer.availableSize = 0;
-		await writeData(writer, EMPTY_UINT8_ARRAY);
+	if (exceedsAvailableSize(writer, getLength(endOfdirectoryRecord.array) + commentLength)) {
+		await writer.closeDisk();
 	}
-	lastDiskNumber = writer.diskNumber;
+	lastDiskNumber = getDiskNumber(writer);
 	if (zip64) {
 		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
 		endOfdirectoryRecord.uint64(44);
@@ -1751,7 +1746,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		endOfdirectoryRecord.uint64(directoryOffset);
 		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 		endOfdirectoryRecord.uint32(lastDiskNumber);
-		endOfdirectoryRecord.uint64(BigInt(zipWriter.offset) + BigInt(directoryDataLength) - BigInt(writer.diskOffset) - BigInt(writer.diskNumber ? zipWriter.initialOffset : 0));
+		endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength));
 		endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 		const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 		if (supportZip64SplitFile) {
@@ -1791,8 +1786,23 @@ function createRecordWriter(length) {
 	};
 }
 
-function getSegmentOffset(zipWriter, writer) {
-	return zipWriter.offset - writer.diskOffset - (writer.diskNumber ? zipWriter.initialOffset : 0);
+function getDiskNumber(writer) {
+	const { diskNumber = 0 } = writer;
+	return diskNumber;
+}
+
+function getDiskOffset(writer) {
+	const { diskOffset = 0 } = writer;
+	return diskOffset;
+}
+
+function exceedsAvailableSize(writer, length) {
+	const { availableSize = INFINITY_VALUE } = writer;
+	return length > availableSize;
+}
+
+function getSegmentOffset(zipWriter, { diskNumber = 0, diskOffset = 0 }) {
+	return zipWriter.offset - diskOffset - (diskNumber ? zipWriter.initialOffset : 0);
 }
 
 async function writeData(writer, array) {
@@ -1869,9 +1879,6 @@ function arraySet(array, typedArray, offset) {
 	array.set(typedArray, offset);
 }
 
-function getDataView(array) {
-	return new DataView(array.buffer, array.byteOffset, array.byteLength);
-}
 
 function getLength(...arrayLikes) {
 	let result = 0;