pkg-zip / lib / zip.ts

import { getDayOfMonth, getHours, getMinutes, getMonth, getSeconds, getYear } from '@mary/date-fns';
import { textEncoder } from './utils/buffer.ts';

/**
 * file attributes for zip entries
 */
export interface ZipFileAttributes {
	/** file permissions mode */
	mode?: number;
	/** user id of the file owner */
	uid?: number;
	/** group id of the file owner */
	gid?: number;
	/** modification time as unix timestamp */
	mtime?: number;
	/** owner username */
	owner?: string;
	/** group name */
	group?: string;
}

/**
 * represents a single entry in a zip archive
 */
export interface ZipEntry {
	/** path and name of the file in the zip archive */
	filename: string;
	/** file content as string, bytes, or stream */
	data: string | Uint8Array | ReadableStream<Uint8Array>;
	/** file attributes like permissions and timestamps */
	attrs?: ZipFileAttributes;
	/** whether to compress the file data */
	compress?: false | 'deflate';
}

const DEFAULT_ATTRS: ZipFileAttributes = {};

// deno-lint-ignore no-control-regex
const INVALID_FILENAME_CHARS = /[<>:"|?*\x00-\x1f]/;
const INVALID_FILENAME_TRAVERSAL = /(?:^|[/\\])\.\.(?:[/\\]|$)/;
// deno-lint-ignore no-control-regex
const NON_ASCII_CHARS = /[^\x00-\x7f]/;

function writeUtf8String(view: DataView, offset: number, length: number, str: string) {
	const u8 = new Uint8Array(view.buffer, view.byteOffset + offset, length);
	textEncoder.encodeInto(str, u8);
}

function writeUint32LE(view: DataView, offset: number, value: number) {
	view.setUint32(offset, value, true);
}
function writeUint16LE(view: DataView, offset: number, value: number) {
	view.setUint16(offset, value, true);
}

const CRC32_TABLE = /*#__PURE__*/ (() => {
	const t = new Int32Array(256);

	for (let i = 0; i < 256; ++i) {
		let c = i, k = 9;
		while (--k) c = (c & 1 ? 0xedb88320 : 0) ^ (c >>> 1);
		t[i] = c;
	}

	return t;
})();

function crc32(chunk: Uint8Array, crc: number = 0xffffffff): number {
	for (let idx = 0, len = chunk.length; idx < len; idx++) {
		crc = CRC32_TABLE[(crc ^ chunk[idx]) & 0xff] ^ (crc >>> 8);
	}

	return crc ^ -1;
}

function unixToDosTime(unixTimestamp: number): { time: number; date: number } {
	const date = new Date(unixTimestamp * 1000);

	const dosTime = ((getSeconds(date) >> 1) & 0x1f) | ((getMinutes(date) & 0x3f) << 5) |
		((getHours(date) & 0x1f) << 11);

	const dosDate = (getDayOfMonth(date) & 0x1f) |
		(((getMonth(date) + 1) & 0x0f) << 5) |
		(((getYear(date) - 1980) & 0x7f) << 9);

	return { time: dosTime, date: dosDate };
}

function validateFilename(filename: string): void {
	if (filename.length === 0) {
		throw new Error(`invalid filename: cannot be empty`);
	}

	if (filename.length > 65535) {
		throw new Error(`invalid filename: too long (max 65535 bytes)`);
	}

	if (INVALID_FILENAME_TRAVERSAL.test(filename)) {
		throw new Error(`invalid filename: contains path traversal`);
	}

	if (filename.startsWith('/')) {
		throw new Error(`invalid filename: is an absolute path`);
	}

	if (INVALID_FILENAME_CHARS.test(filename)) {
		throw new Error('invalid filename: contains invalid characters');
	}
}

function isNonAscii(filename: string): boolean {
	// check if filename contains non-ASCII characters
	return NON_ASCII_CHARS.test(filename);
}

/**
 * creates a zip archive from entries and yields chunks as Uint8Array
 * @param entries iterable of zip entries to include in the archive
 * @returns async generator that yields zip file chunks
 */
export async function* zip(
	entries: Iterable<ZipEntry> | AsyncIterable<ZipEntry>,
): AsyncGenerator<Uint8Array> {
	const listing: Uint8Array[] = [];
	let offset: number = 0;

	for await (const { filename, data, compress = 'deflate', attrs = DEFAULT_ATTRS } of entries) {
		validateFilename(filename);

		const startOffset = offset;

		const fname = textEncoder.encode(filename);
		const fnameLen = fname.length;

		const mtimeSeconds = attrs?.mtime ?? Math.floor(Date.now() / 1000);
		const { time: dosTime, date: dosDate } = unixToDosTime(mtimeSeconds);

		let method: number = 0;
		let crc: number = 0xffffffff;
		let flags = 0x0008;

		let uncompressedSize: number = 0;
		let compressedSize: number = 0;

		if (compress === 'deflate') {
			method = 8;
		}

		if (isNonAscii(filename)) {
			flags |= 0x0800;
		}

		// local header
		{
			const header = new ArrayBuffer(30 + fnameLen);
			const view = new DataView(header);

			writeUint32LE(view, 0, 0x04034b50); // local file header signature
			writeUint16LE(view, 4, 20); // version needed to extract (2.0)
			writeUint16LE(view, 6, flags); // general purpose bit flag
			writeUint16LE(view, 8, method); // compression method (0=stored, 8=deflate)
			writeUint16LE(view, 10, dosTime); // last mod file time (DOS format)
			writeUint16LE(view, 12, dosDate); // last mod file date (DOS format)
			writeUint32LE(view, 14, 0); // crc-32 (set to 0, actual value in data descriptor)
			writeUint32LE(view, 18, 0); // compressed size (set to 0, actual value in data descriptor)
			writeUint32LE(view, 22, 0); // uncompressed size (set to 0, actual value in data descriptor)
			writeUint16LE(view, 26, fnameLen); // file name length
			writeUint16LE(view, 28, 0); // extra field length

			writeUtf8String(view, 30, fnameLen, filename);

			offset += 30 + fnameLen;

			yield new Uint8Array(header);
		}

		// data
		if (compress === 'deflate') {
			let stream: ReadableStream<Uint8Array>;
			if (data instanceof ReadableStream) {
				stream = data.pipeThrough(
					new TransformStream({
						transform(chunk, controller) {
							uncompressedSize += chunk.length;
							crc = crc32(chunk, crc);

							controller.enqueue(chunk);
						},
					}),
				);
			} else {
				const chunk = typeof data === 'string' ? textEncoder.encode(data) : data;

				uncompressedSize = chunk.length;
				crc = crc32(chunk, crc);

				stream = new ReadableStream({
					start(controller) {
						controller.enqueue(chunk);
						controller.close();
					},
				});
			}

			// @ts-expect-error: I don't knowwww
			yield* stream.pipeThrough(new CompressionStream('deflate-raw')).pipeThrough(
				new TransformStream({
					transform(chunk, controller) {
						controller.enqueue(chunk);

						compressedSize += chunk.length;
					},
				}),
			);
		} else {
			if (data instanceof ReadableStream) {
				yield* data.pipeThrough(
					new TransformStream({
						transform(chunk, controller) {
							uncompressedSize += chunk.length;
							crc = crc32(chunk, crc);

							controller.enqueue(chunk);
						},
					}),
				);

				compressedSize = uncompressedSize;
			} else {
				const chunk = typeof data === 'string' ? textEncoder.encode(data) : data;

				uncompressedSize = chunk.length;
				compressedSize = uncompressedSize;
				crc = crc32(chunk, crc);

				yield chunk;
			}
		}

		offset += compressedSize;

		// data descriptor
		{
			const descriptor = new ArrayBuffer(16);
			const view = new DataView(descriptor);

			//  0 - data descriptor signature
			//  4 - CRC32 of uncompressed data
			//  8 - compressed size
			// 12 - uncompressed size
			writeUint32LE(view, 0, 0x08074b50);
			writeUint32LE(view, 4, crc);
			writeUint32LE(view, 8, compressedSize);
			writeUint32LE(view, 12, uncompressedSize);

			offset += 16;

			yield new Uint8Array(descriptor);
		}

		// central directory record
		{
			const record = new ArrayBuffer(46 + fnameLen);
			const view = new DataView(record);

			const mode = attrs?.mode ?? 0o100644;
			const externalAttrs = (mode & 0xffff) << 16;

			//  0 - central directory record signature
			//  4 - version used to create this archive
			//  6 - minimum required version for extraction
			//  8 - general purpose bitflag
			// 10 - compression method
			// 12 - file last modification time
			// 14 - file last modification date
			// 16 - CRC32 of uncompressed data
			// 20 - compressed size
			// 24 - uncompressed size
			// 28 - file name length
			// 30 - extra fields length
			// 32 - file comment length
			// 34 - disk number containing start of file
			// 36 - internal file attributes
			// 38 - external file attributes
			// 42 - offset to start of entry
			writeUint32LE(view, 0, 0x02014b50);
			writeUint16LE(view, 4, (3 << 8) | 20);
			writeUint16LE(view, 6, 20);
			writeUint16LE(view, 8, flags);
			writeUint16LE(view, 10, method);
			writeUint16LE(view, 12, dosTime);
			writeUint16LE(view, 14, dosDate);
			writeUint32LE(view, 16, crc);
			writeUint32LE(view, 20, compressedSize);
			writeUint32LE(view, 24, uncompressedSize);
			writeUint16LE(view, 28, fnameLen);
			writeUint16LE(view, 30, 0);
			writeUint16LE(view, 32, 0);
			writeUint16LE(view, 34, 0);
			writeUint16LE(view, 36, 0);
			writeUint32LE(view, 38, externalAttrs);
			writeUint32LE(view, 42, startOffset);

			writeUtf8String(view, 46, fnameLen, filename);

			listing.push(new Uint8Array(record));
		}
	}

	// central directory
	{
		const startCentralOffset = offset;
		const recordCount = listing.length;

		let centralSize = 0;

		for (let idx = 0; idx < recordCount; idx++) {
			const record = listing[idx];
			const recordLen = record.length;

			offset += recordLen;
			centralSize += recordLen;

			yield record;
		}

		{
			const directory = new ArrayBuffer(22);
			const view = new DataView(directory);

			//  0 - end of central directory signature
			//  4 - this disk's number
			//  6 - disk number containing start of central directory
			//  8 - amount of records in this disk's central directory
			// 10 - total amount of central directory records
			// 12 - total size of this disk's central directory records
			// 16 - offset of this disk's central directory records
			// 20 - comment length
			writeUint32LE(view, 0, 0x06054b50);
			writeUint16LE(view, 4, 0);
			writeUint16LE(view, 6, 0);
			writeUint16LE(view, 8, recordCount);
			writeUint16LE(view, 10, recordCount);
			writeUint32LE(view, 12, centralSize);
			writeUint32LE(view, 16, startCentralOffset);
			writeUint16LE(view, 20, 0);

			yield new Uint8Array(directory);
		}
	}
}