modern-tar 0.7.4 → 0.7.6

package/dist/fs/index.d.ts

@@ -1,9 +1,8 @@
-import { i as UnpackOptions, n as TarEntryData, r as TarHeader } from "../types-Te8MHQn3.js";
+import { i as UnpackOptions, n as TarEntryData, r as TarHeader } from "../types-D19dF2SE.js";
 import { Readable, Writable } from "node:stream";
 import { Stats } from "node:fs";
 
 //#region src/fs/types.d.ts
-
 /**
  * Filesystem-specific configuration options for packing directories into tar archives.
  *

package/dist/fs/index.js

@@ -1,10 +1,9 @@
-import { a as normalizeBody, c as LINK, l as SYMLINK, n as createTarPacker, o as DIRECTORY, r as transformHeader, s as FILE, t as createUnpacker } from "../unpacker-CEuY-276.js";
-import * as fs from "node:fs/promises";
+import { a as normalizeBody, c as LINK, l as SYMLINK, n as createTarPacker, o as DIRECTORY, r as transformHeader, s as FILE, t as createUnpacker } from "../unpacker-CPCEF5CT.js";
+import * as fs$1 from "node:fs/promises";
 import { cpus } from "node:os";
 import * as path from "node:path";
 import { Readable, Writable } from "node:stream";
-import * as fs$1 from "node:fs";
-
+import * as fs from "node:fs";
 //#region src/fs/cache.ts
 const createCache = () => {
 	const m = /* @__PURE__ */ new Map();
@@ -19,7 +18,6 @@ const createCache = () => {
 		}
 	};
 };
-
 //#endregion
 //#region src/fs/path.ts
 const unicodeCache = createCache();
@@ -48,16 +46,15 @@ const win32Reserved = {
 	"\"": ""
 };
 function normalizeName(name) {
-	const path$1 = name.replace(/\\/g, "/");
-	if (path$1.split("/").includes("..") || /^[a-zA-Z]:\.\./.test(path$1)) throw new Error(`${name} points outside extraction directory`);
-	let relative = path$1;
+	const path = name.replace(/\\/g, "/");
+	if (path.split("/").includes("..") || /^[a-zA-Z]:\.\./.test(path)) throw new Error(`${name} points outside extraction directory`);
+	let relative = path;
 	if (/^[a-zA-Z]:/.test(relative)) relative = relative.replace(/^[a-zA-Z]:[/\\]?/, "");
 	else if (relative.startsWith("/")) relative = relative.replace(/^\/+/, "");
 	if (process.platform === "win32") return relative.replace(/[<>:"|?*]/g, (char) => win32Reserved[char]);
 	return relative;
 }
 const normalizeHeaderName = (s) => normalizeUnicode(normalizeName(s.replace(/\/+$/, "")));
-
 //#endregion
 //#region src/fs/pack.ts
 const packTarSources = packTar;
@@ -68,7 +65,7 @@ function packTar(sources, options = {}) {
 		const { dereference = false, filter, map, baseDir, concurrency = cpus().length || 8 } = options;
 		const isDir = typeof sources === "string";
 		const directoryPath = isDir ? path.resolve(sources) : null;
-		const jobs = isDir ? (await fs.readdir(directoryPath, { withFileTypes: true })).map((entry) => ({
+		const jobs = isDir ? (await fs$1.readdir(directoryPath, { withFileTypes: true })).map((entry) => ({
 			type: entry.isDirectory() ? DIRECTORY : FILE,
 			source: path.join(directoryPath, entry.name),
 			target: entry.name
@@ -152,56 +149,56 @@ function packTar(sources, options = {}) {
 			const target = normalizeName(job.target);
 			try {
 				if (job.type === "content" || job.type === "stream") {
-					let body$1;
+					let body;
 					let size;
-					const isDir$1 = target.endsWith("/");
+					const isDir = target.endsWith("/");
 					if (job.type === "stream") {
-						if (typeof job.size !== "number" || !isDir$1 && job.size <= 0 || isDir$1 && job.size !== 0) throw new Error(isDir$1 ? "Streams for directories must have size 0." : "Streams require a positive size.");
+						if (!isDir && job.size <= 0 || isDir && job.size !== 0) throw new Error(isDir ? "Streams for directories must have size 0." : "Streams require a positive size.");
 						size = job.size;
-						body$1 = job.content;
+						body = job.content;
 					} else {
 						const content = await normalizeBody(job.content);
 						size = content.length;
-						body$1 = content;
+						body = content;
 					}
-					const stat$1 = {
-						size: isDir$1 ? 0 : size,
-						isFile: () => !isDir$1,
-						isDirectory: () => isDir$1,
+					const stat = {
+						size: isDir ? 0 : size,
+						isFile: () => !isDir,
+						isDirectory: () => isDir,
 						isSymbolicLink: () => false,
 						mode: job.mode,
 						mtime: job.mtime ?? /* @__PURE__ */ new Date(),
 						uid: job.uid ?? 0,
 						gid: job.gid ?? 0
 					};
-					if (filter && !filter(target, stat$1)) return;
-					let header$1 = {
+					if (filter && !filter(target, stat)) return;
+					let header = {
 						name: target,
-						type: isDir$1 ? DIRECTORY : FILE,
-						size: isDir$1 ? 0 : size,
-						mode: stat$1.mode,
-						mtime: stat$1.mtime,
-						uid: stat$1.uid,
-						gid: stat$1.gid,
+						type: isDir ? DIRECTORY : FILE,
+						size: isDir ? 0 : size,
+						mode: stat.mode,
+						mtime: stat.mtime,
+						uid: stat.uid,
+						gid: stat.gid,
 						uname: job.uname,
 						gname: job.gname
 					};
-					if (map) header$1 = map(header$1);
+					if (map) header = map(header);
 					jobResult = {
-						header: header$1,
-						body: isDir$1 ? void 0 : body$1
+						header,
+						body: isDir ? void 0 : body
 					};
 					return;
 				}
-				let stat = await fs.lstat(job.source, { bigint: true });
+				let stat = await fs$1.lstat(job.source, { bigint: true });
 				if (dereference && stat.isSymbolicLink()) {
-					const linkTarget = await fs.readlink(job.source);
+					const linkTarget = await fs$1.readlink(job.source);
 					const resolved = path.resolve(path.dirname(job.source), linkTarget);
 					const resolvedBase = baseDir ?? directoryPath ?? process.cwd();
 					if (!resolved.startsWith(resolvedBase + path.sep) && resolved !== resolvedBase) return;
-					stat = await fs.stat(job.source, { bigint: true });
+					stat = await fs$1.stat(job.source, { bigint: true });
 				}
-				if (filter && !filter(target, stat)) return;
+				if (filter && !filter(job.source, stat)) return;
 				let header = {
 					name: target,
 					size: 0,
@@ -218,7 +215,7 @@ function packTar(sources, options = {}) {
 					header.type = DIRECTORY;
 					header.name = target.endsWith("/") ? target : `${target}/`;
 					try {
-						for (const d of await fs.readdir(job.source, { withFileTypes: true })) jobs.push({
+						for (const d of await fs$1.readdir(job.source, { withFileTypes: true })) jobs.push({
 							type: d.isDirectory() ? DIRECTORY : FILE,
 							source: path.join(job.source, d.name),
 							target: `${header.name}${d.name}`
@@ -226,7 +223,7 @@ function packTar(sources, options = {}) {
 					} catch {}
 				} else if (stat.isSymbolicLink()) {
 					header.type = SYMLINK;
-					header.linkname = await fs.readlink(job.source);
+					header.linkname = await fs$1.readlink(job.source);
 				} else if (stat.isFile()) {
 					header.size = Number(stat.size);
 					if (stat.nlink > 1 && seenInodes.has(stat.ino)) {
@@ -235,9 +232,9 @@ function packTar(sources, options = {}) {
 						header.size = 0;
 					} else {
 						if (stat.nlink > 1) seenInodes.set(stat.ino, target);
-						if (header.size > 0) if (header.size < 32 * 1024) body = await fs.readFile(job.source);
+						if (header.size > 0) if (header.size < 32 * 1024) body = await fs$1.readFile(job.source);
 						else body = {
-							handle: await fs.open(job.source, "r"),
+							handle: await fs$1.open(job.source, "r"),
 							size: header.size
 						};
 					}
@@ -258,7 +255,6 @@ function packTar(sources, options = {}) {
 	})().catch((error) => stream.destroy(error));
 	return stream;
 }
-
 //#endregion
 //#region src/fs/concurrency.ts
 const createOperationQueue = (concurrency) => {
@@ -301,17 +297,17 @@ const createOperationQueue = (concurrency) => {
 		}
 	};
 };
-
 //#endregion
 //#region src/fs/file-sink.ts
 const BATCH_BYTES = 256 * 1024;
+const OPEN_FLAGS = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | (fs.constants.O_NOFOLLOW ?? 0);
 const STATE_UNOPENED = 0;
 const STATE_OPENING = 1;
 const STATE_OPEN = 2;
 const STATE_CLOSED = 3;
 const STATE_FAILED = 4;
 const DRAINED_PROMISE = Promise.resolve();
-function createFileSink(path$1, { mode = 438, mtime } = {}) {
+function createFileSink(path, { mode = 438, mtime } = {}) {
 	let state = STATE_UNOPENED;
 	let flushing = false;
 	let fd = null;
@@ -361,7 +357,7 @@ function createFileSink(path$1, { mode = 438, mtime } = {}) {
 		flushing = false;
 		const fdToClose = fd;
 		fd = null;
-		if (fdToClose !== null) fs$1.ftruncate(fdToClose, 0, () => fs$1.close(fdToClose));
+		if (fdToClose !== null) fs.ftruncate(fdToClose, 0, () => fs.close(fdToClose));
 		endReject?.(error);
 		failWaiters(error);
 	};
@@ -372,14 +368,14 @@ function createFileSink(path$1, { mode = 438, mtime } = {}) {
 		}
 		const fdToClose = fd;
 		fd = null;
-		if (mtime) fs$1.futimes(fdToClose, mtime, mtime, (err) => {
+		if (mtime) fs.futimes(fdToClose, mtime, mtime, (err) => {
 			if (err) return fail(err);
-			fs$1.close(fdToClose, (closeErr) => {
+			fs.close(fdToClose, (closeErr) => {
 				if (closeErr) fail(closeErr);
 				else finish();
 			});
 		});
-		else fs$1.close(fdToClose, (err) => {
+		else fs.close(fdToClose, (err) => {
 			if (err) fail(err);
 			else finish();
 		});
@@ -399,16 +395,16 @@ function createFileSink(path$1, { mode = 438, mtime } = {}) {
 		};
 		if (bufs.length === 1) {
 			const buf = bufs[0];
-			fs$1.write(fd, buf, 0, buf.length, null, onDone);
-		} else fs$1.writev(fd, bufs, onDone);
+			fs.write(fd, buf, 0, buf.length, null, onDone);
+		} else fs.writev(fd, bufs, onDone);
 	};
 	const open = () => {
 		if (state !== STATE_UNOPENED) return;
 		state = STATE_OPENING;
-		fs$1.open(path$1, "w", mode, (err, openFd) => {
+		fs.open(path, OPEN_FLAGS, mode, (err, openFd) => {
 			if (err) return fail(err);
 			if (state === STATE_CLOSED || state === STATE_FAILED) {
-				fs$1.close(openFd);
+				fs.close(openFd);
 				return;
 			}
 			fd = openFd;
@@ -460,7 +456,7 @@ function createFileSink(path$1, { mode = 438, mtime } = {}) {
 		if (fd !== null) {
 			const fdToClose = fd;
 			fd = null;
-			fs$1.close(fdToClose);
+			fs.close(fdToClose);
 		}
 		finish();
 	};
@@ -471,31 +467,31 @@ function createFileSink(path$1, { mode = 438, mtime } = {}) {
 		waitDrain
 	};
 }
-
 //#endregion
 //#region src/fs/path-cache.ts
 const ENOENT = "ENOENT";
 const createPathCache = (destDirPath, options) => {
+	const { maxDepth = 1024, dmode } = options;
 	const dirPromises = createCache();
-	const pathConflicts = createCache();
+	const pathConflicts = /* @__PURE__ */ new Map();
 	const deferredLinks = [];
 	const realDirCache = createCache();
-	const initializeDestDir = async (destDirPath$1) => {
-		const symbolic = normalizeUnicode(path.resolve(destDirPath$1));
+	const initializeDestDir = async (destDirPath) => {
+		const symbolic = normalizeUnicode(path.resolve(destDirPath));
 		try {
-			await fs.mkdir(symbolic, { recursive: true });
+			await fs$1.mkdir(symbolic, { recursive: true });
 		} catch (err) {
 			if (err.code === ENOENT) {
 				const parentDir = path.dirname(symbolic);
 				if (parentDir === symbolic) throw err;
-				await fs.mkdir(parentDir, { recursive: true });
-				await fs.mkdir(symbolic, { recursive: true });
+				await fs$1.mkdir(parentDir, { recursive: true });
+				await fs$1.mkdir(symbolic, { recursive: true });
 			} else throw err;
 		}
 		try {
 			return {
 				symbolic,
-				real: await fs.realpath(symbolic)
+				real: await fs$1.realpath(symbolic)
 			};
 		} catch (err) {
 			if (err.code === ENOENT) return {
@@ -515,7 +511,7 @@ const createPathCache = (destDirPath, options) => {
 		}
 		let promise = realDirCache.get(dirPath);
 		if (!promise) {
-			promise = fs.realpath(dirPath).then((realPath) => {
+			promise = fs$1.realpath(dirPath).then((realPath) => {
 				validateBounds(realPath, destDir.real, errorMessage);
 				return realPath;
 			});
@@ -532,11 +528,11 @@ const createPathCache = (destDirPath, options) => {
 			if (dirPath === (await destDirPromise).symbolic) return;
 			await prepareDirectory(path.dirname(dirPath));
 			try {
-				const stat = await fs.lstat(dirPath);
+				const stat = await fs$1.lstat(dirPath);
 				if (stat.isDirectory()) return;
 				if (stat.isSymbolicLink()) try {
 					const realPath = await getRealDir(dirPath, `Symlink "${dirPath}" points outside the extraction directory.`);
-					if ((await fs.stat(realPath)).isDirectory()) return;
+					if ((await fs$1.stat(realPath)).isDirectory()) return;
 				} catch (err) {
 					if (err.code === ENOENT) throw new Error(`Symlink "${dirPath}" points outside the extraction directory.`);
 					throw err;
@@ -544,7 +540,7 @@ const createPathCache = (destDirPath, options) => {
 				throw new Error(`"${dirPath}" is not a valid directory component.`);
 			} catch (err) {
 				if (err.code === ENOENT) {
-					await fs.mkdir(dirPath, { mode: mode ?? options.dmode });
+					await fs$1.mkdir(dirPath, { mode: mode ?? options.dmode });
 					return;
 				}
 				throw err;
@@ -559,7 +555,6 @@ const createPathCache = (destDirPath, options) => {
 		},
 		async preparePath(header) {
 			const { name, linkname, type, mode, mtime } = header;
-			const { maxDepth = 1024, dmode } = options;
 			const normalizedName = normalizeHeaderName(name);
 			const destDir = await destDirPromise;
 			const outPath = path.join(destDir.symbolic, normalizedName);
@@ -570,7 +565,7 @@ const createPathCache = (destDirPath, options) => {
 			}
 			const prevOp = pathConflicts.get(normalizedName);
 			if (prevOp) {
-				if (prevOp === DIRECTORY && type !== DIRECTORY || prevOp !== DIRECTORY && type === DIRECTORY) throw new Error(`Path conflict ${type} over existing ${prevOp} at "${name}"`);
+				if (prevOp === "directory" && type !== "directory" || prevOp !== "directory" && type === "directory") throw new Error(`Path conflict ${type} over existing ${prevOp} at "${name}"`);
 				return;
 			}
 			const parentDir = path.dirname(outPath);
@@ -579,7 +574,7 @@ const createPathCache = (destDirPath, options) => {
 					pathConflicts.set(normalizedName, DIRECTORY);
 					const safeMode = mode ? mode & 511 : void 0;
 					await prepareDirectory(outPath, dmode ?? safeMode);
-					if (mtime) await fs.lutimes(outPath, mtime, mtime).catch(() => {});
+					if (mtime) await fs$1.lutimes(outPath, mtime, mtime).catch(() => {});
 					return;
 				}
 				case FILE:
@@ -591,8 +586,8 @@ const createPathCache = (destDirPath, options) => {
 					if (!linkname) return;
 					await prepareDirectory(parentDir);
 					validateBounds(path.resolve(parentDir, linkname), destDir.symbolic, `Symlink "${linkname}" points outside the extraction directory.`);
-					await fs.symlink(linkname, outPath);
-					if (mtime) await fs.lutimes(outPath, mtime, mtime).catch(() => {});
+					await fs$1.symlink(linkname, outPath);
+					if (mtime) await fs$1.lutimes(outPath, mtime, mtime).catch(() => {});
 					return;
 				case LINK: {
 					pathConflicts.set(normalizedName, LINK);
@@ -618,7 +613,7 @@ const createPathCache = (destDirPath, options) => {
 		},
 		async applyLinks() {
 			for (const { linkTarget, outPath } of deferredLinks) try {
-				await fs.link(linkTarget, outPath);
+				await fs$1.link(linkTarget, outPath);
 			} catch (err) {
 				if (err.code === ENOENT) throw new Error(`Hardlink target "${linkTarget}" does not exist for link at "${outPath}".`);
 				throw err;
@@ -626,7 +621,6 @@ const createPathCache = (destDirPath, options) => {
 		}
 	};
 };
-
 //#endregion
 //#region src/fs/unpack.ts
 function unpackTar(directoryPath, options = {}) {
@@ -635,7 +629,12 @@ function unpackTar(directoryPath, options = {}) {
 	const pathCache = createPathCache(directoryPath, options);
 	let currentFileStream = null;
 	let currentWriteCallback = null;
-	return new Writable({
+	let queuedError = null;
+	const onQueuedError = (err) => {
+		queuedError ??= err;
+		if (!writable.destroyed) writable.destroy(err);
+	};
+	const writable = new Writable({
 		async write(chunk, _, cb) {
 			try {
 				unpacker.write(chunk);
@@ -656,7 +655,7 @@ function unpackTar(directoryPath, options = {}) {
 							return;
 						}
 						const streamToClose = currentFileStream;
-						if (streamToClose) opQueue.add(() => streamToClose.end());
+						if (streamToClose) opQueue.add(() => streamToClose.end()).catch(onQueuedError);
 						currentFileStream = null;
 						currentWriteCallback = null;
 					} else if (!unpacker.skipEntry()) {
@@ -686,8 +685,8 @@ function unpackTar(directoryPath, options = {}) {
 							mtime: transformedHeader.mtime ?? void 0
 						});
 						let needsDrain = false;
-						const writeCallback = (chunk$1) => {
-							const writeOk = fileStream.write(chunk$1);
+						const writeCallback = (chunk) => {
+							const writeOk = fileStream.write(chunk);
 							if (!writeOk) needsDrain = true;
 							return writeOk;
 						};
@@ -707,7 +706,7 @@ function unpackTar(directoryPath, options = {}) {
 							cb();
 							return;
 						}
-						opQueue.add(() => fileStream.end());
+						opQueue.add(() => fileStream.end()).catch(onQueuedError);
 					} else if (!unpacker.skipEntry()) {
 						cb();
 						return;
@@ -723,6 +722,7 @@ function unpackTar(directoryPath, options = {}) {
 				unpacker.validateEOF();
 				await pathCache.ready();
 				await opQueue.onIdle();
+				if (queuedError) throw queuedError;
 				await pathCache.applyLinks();
 				cb();
 			} catch (err) {
@@ -740,7 +740,7 @@ function unpackTar(directoryPath, options = {}) {
 			})().then(() => callback(error ?? null), (e) => callback(error ?? (e instanceof Error ? e : /* @__PURE__ */ new Error("Stream destroyed"))));
 		}
 	});
+	return writable;
 }
-
 //#endregion
-export { packTar, packTarSources, unpackTar };
+export { packTar, packTarSources, unpackTar };

package/dist/{types-Te8MHQn3.d.ts → types-D19dF2SE.d.ts}

@@ -1,5 +1,4 @@
 //#region src/tar/constants.d.ts
-
 /** Type flag constants for file types. */
 declare const TYPEFLAG: {
   readonly file: "0";

package/dist/{unpacker-CEuY-276.js → unpacker-CPCEF5CT.js}

@@ -1,39 +1,3 @@
-//#region src/tar/constants.ts
-const BLOCK_SIZE = 512;
-const BLOCK_SIZE_MASK = 511;
-const DEFAULT_FILE_MODE = 420;
-const DEFAULT_DIR_MODE = 493;
-const USTAR_NAME_OFFSET = 0;
-const USTAR_NAME_SIZE = 100;
-const USTAR_MODE_OFFSET = 100;
-const USTAR_MODE_SIZE = 8;
-const USTAR_UID_OFFSET = 108;
-const USTAR_UID_SIZE = 8;
-const USTAR_GID_OFFSET = 116;
-const USTAR_GID_SIZE = 8;
-const USTAR_SIZE_OFFSET = 124;
-const USTAR_SIZE_SIZE = 12;
-const USTAR_MTIME_OFFSET = 136;
-const USTAR_MTIME_SIZE = 12;
-const USTAR_CHECKSUM_OFFSET = 148;
-const USTAR_CHECKSUM_SIZE = 8;
-const USTAR_TYPEFLAG_OFFSET = 156;
-const USTAR_TYPEFLAG_SIZE = 1;
-const USTAR_LINKNAME_OFFSET = 157;
-const USTAR_LINKNAME_SIZE = 100;
-const USTAR_MAGIC_OFFSET = 257;
-const USTAR_MAGIC_SIZE = 6;
-const USTAR_VERSION_OFFSET = 263;
-const USTAR_VERSION_SIZE = 2;
-const USTAR_UNAME_OFFSET = 265;
-const USTAR_UNAME_SIZE = 32;
-const USTAR_GNAME_OFFSET = 297;
-const USTAR_GNAME_SIZE = 32;
-const USTAR_PREFIX_OFFSET = 345;
-const USTAR_PREFIX_SIZE = 155;
-const USTAR_VERSION = "00";
-const USTAR_MAX_UID_GID = 2097151;
-const USTAR_MAX_SIZE = 8589934591;
 const FILE = "file";
 const LINK = "link";
 const SYMLINK = "symlink";
@@ -64,9 +28,8 @@ const FLAGTYPE = {
 	L: "gnu-long-name",
 	K: "gnu-long-link-name"
 };
-const ZERO_BLOCK = new Uint8Array(BLOCK_SIZE);
+const ZERO_BLOCK = new Uint8Array(512);
 const EMPTY = new Uint8Array(0);
-
 //#endregion
 //#region src/tar/encoding.ts
 const encoder = new TextEncoder();
@@ -105,10 +68,9 @@ function readNumeric(view, offset, size) {
 	}
 	return readOctal(view, offset, size);
 }
-
 //#endregion
 //#region src/tar/body.ts
-const isBodyless = (header) => header.type === DIRECTORY || header.type === SYMLINK || header.type === LINK || header.type === "character-device" || header.type === "block-device" || header.type === "fifo";
+const isBodyless = (header) => header.type === "directory" || header.type === "symlink" || header.type === "link" || header.type === "character-device" || header.type === "block-device" || header.type === "fifo";
 async function normalizeBody(body) {
 	if (body === null || body === void 0) return EMPTY;
 	if (body instanceof Uint8Array) return body;
@@ -117,21 +79,26 @@ async function normalizeBody(body) {
 	if (body instanceof Blob) return new Uint8Array(await body.arrayBuffer());
 	throw new TypeError("Unsupported content type for entry body.");
 }
-
 //#endregion
 //#region src/tar/options.ts
+const stripPath = (p, n) => {
+	const parts = p.split("/").filter(Boolean);
+	return n >= parts.length ? "" : parts.slice(n).join("/");
+};
 function transformHeader(header, options) {
 	const { strip, filter, map } = options;
 	if (!strip && !filter && !map) return header;
 	const h = { ...header };
 	if (strip && strip > 0) {
-		const components = h.name.split("/").filter(Boolean);
-		if (strip >= components.length) return null;
-		const newName = components.slice(strip).join("/");
-		h.name = h.type === DIRECTORY && !newName.endsWith("/") ? `${newName}/` : newName;
-		if (h.linkname?.startsWith("/")) {
-			const linkComponents = h.linkname.split("/").filter(Boolean);
-			h.linkname = strip >= linkComponents.length ? "/" : `/${linkComponents.slice(strip).join("/")}`;
+		const newName = stripPath(h.name, strip);
+		if (!newName) return null;
+		h.name = h.type === "directory" && !newName.endsWith("/") ? `${newName}/` : newName;
+		if (h.linkname) {
+			const isAbsolute = h.linkname.startsWith("/");
+			if (isAbsolute || h.type === "link") {
+				const stripped = stripPath(h.linkname, strip);
+				h.linkname = isAbsolute ? `/${stripped}` || "/" : stripped;
+			}
 		}
 	}
 	if (filter?.(h) === false) return null;
@@ -139,43 +106,42 @@ function transformHeader(header, options) {
 	if (result && (!result.name || !result.name.trim() || result.name === "." || result.name === "/")) return null;
 	return result;
 }
-
 //#endregion
 //#region src/tar/checksum.ts
 const CHECKSUM_SPACE = 32;
 const ASCII_ZERO = 48;
 function validateChecksum(block) {
-	const stored = readOctal(block, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_SIZE);
+	const stored = readOctal(block, 148, 8);
 	let sum = 0;
-	for (let i = 0; i < block.length; i++) if (i >= USTAR_CHECKSUM_OFFSET && i < USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE) sum += CHECKSUM_SPACE;
+	for (let i = 0; i < block.length; i++) if (i >= 148 && i < 156) sum += CHECKSUM_SPACE;
 	else sum += block[i];
 	return stored === sum;
 }
 function writeChecksum(block) {
-	block.fill(CHECKSUM_SPACE, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE);
+	block.fill(CHECKSUM_SPACE, 148, 156);
 	let checksum = 0;
 	for (const byte of block) checksum += byte;
-	for (let i = USTAR_CHECKSUM_OFFSET + 6 - 1; i >= USTAR_CHECKSUM_OFFSET; i--) {
+	for (let i = 153; i >= 148; i--) {
 		block[i] = (checksum & 7) + ASCII_ZERO;
 		checksum >>= 3;
 	}
-	block[USTAR_CHECKSUM_OFFSET + 6] = 0;
-	block[USTAR_CHECKSUM_OFFSET + 7] = CHECKSUM_SPACE;
+	block[154] = 0;
+	block[155] = CHECKSUM_SPACE;
 }
-
 //#endregion
 //#region src/tar/pax.ts
+const USTAR_SPLIT_MAX_SIZE = 256;
 function generatePax(header) {
 	const paxRecords = {};
-	if (header.name.length > USTAR_NAME_SIZE) {
+	if (encoder.encode(header.name).length > 100) {
 		if (findUstarSplit(header.name) === null) paxRecords.path = header.name;
 	}
-	if (header.linkname && header.linkname.length > USTAR_NAME_SIZE) paxRecords.linkpath = header.linkname;
-	if (header.uname && header.uname.length > USTAR_UNAME_SIZE) paxRecords.uname = header.uname;
-	if (header.gname && header.gname.length > USTAR_GNAME_SIZE) paxRecords.gname = header.gname;
-	if (header.uid != null && header.uid > USTAR_MAX_UID_GID) paxRecords.uid = String(header.uid);
-	if (header.gid != null && header.gid > USTAR_MAX_UID_GID) paxRecords.gid = String(header.gid);
-	if (header.size != null && header.size > USTAR_MAX_SIZE) paxRecords.size = String(header.size);
+	if (header.linkname && encoder.encode(header.linkname).length > 100) paxRecords.linkpath = header.linkname;
+	if (header.uname && encoder.encode(header.uname).length > 32) paxRecords.uname = header.uname;
+	if (header.gname && encoder.encode(header.gname).length > 32) paxRecords.gname = header.gname;
+	if (header.uid != null && header.uid > 2097151) paxRecords.uid = String(header.uid);
+	if (header.gid != null && header.gid > 2097151) paxRecords.gid = String(header.gid);
+	if (header.size != null && header.size > 8589934591) paxRecords.size = String(header.size);
 	if (header.pax) Object.assign(paxRecords, header.pax);
 	const paxEntries = Object.entries(paxRecords);
 	if (paxEntries.length === 0) return null;
@@ -202,20 +168,23 @@ function generatePax(header) {
 	};
 }
 function findUstarSplit(path) {
-	if (path.length <= USTAR_NAME_SIZE) return null;
-	const minSlashIndex = path.length - USTAR_NAME_SIZE - 1;
-	const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE);
-	if (slashIndex > 0 && slashIndex >= minSlashIndex) return {
-		prefix: path.slice(0, slashIndex),
-		name: path.slice(slashIndex + 1)
-	};
+	const totalPathBytes = encoder.encode(path).length;
+	if (totalPathBytes <= 100 || totalPathBytes > USTAR_SPLIT_MAX_SIZE) return null;
+	for (let i = path.length - 1; i > 0; i--) {
+		if (path[i] !== "/") continue;
+		const prefix = path.slice(0, i);
+		const name = path.slice(i + 1);
+		if (encoder.encode(prefix).length <= 155 && encoder.encode(name).length <= 100) return {
+			prefix,
+			name
+		};
+	}
 	return null;
 }
-
 //#endregion
 //#region src/tar/header.ts
 function createTarHeader(header) {
-	const view = new Uint8Array(BLOCK_SIZE);
+	const view = new Uint8Array(512);
 	const size = isBodyless(header) ? 0 : header.size ?? 0;
 	let name = header.name;
 	let prefix = "";
@@ -226,42 +195,42 @@ function createTarHeader(header) {
 			prefix = split.prefix;
 		}
 	}
-	writeString(view, USTAR_NAME_OFFSET, USTAR_NAME_SIZE, name);
-	writeOctal(view, USTAR_MODE_OFFSET, USTAR_MODE_SIZE, header.mode ?? (header.type === DIRECTORY ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE));
-	writeOctal(view, USTAR_UID_OFFSET, USTAR_UID_SIZE, header.uid ?? 0);
-	writeOctal(view, USTAR_GID_OFFSET, USTAR_GID_SIZE, header.gid ?? 0);
-	writeOctal(view, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE, size);
-	writeOctal(view, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1e3));
-	writeString(view, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE, TYPEFLAG[header.type ?? FILE]);
-	writeString(view, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE, header.linkname);
-	writeString(view, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE, "ustar\0");
-	writeString(view, USTAR_VERSION_OFFSET, USTAR_VERSION_SIZE, USTAR_VERSION);
-	writeString(view, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE, header.uname);
-	writeString(view, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE, header.gname);
-	writeString(view, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE, prefix);
+	writeString(view, 0, 100, name);
+	writeOctal(view, 100, 8, header.mode ?? (header.type === "directory" ? 493 : 420));
+	writeOctal(view, 108, 8, header.uid ?? 0);
+	writeOctal(view, 116, 8, header.gid ?? 0);
+	writeOctal(view, 124, 12, size);
+	writeOctal(view, 136, 12, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1e3));
+	writeString(view, 156, 1, TYPEFLAG[header.type ?? "file"]);
+	writeString(view, 157, 100, header.linkname);
+	writeString(view, 257, 6, "ustar\0");
+	writeString(view, 263, 2, "00");
+	writeString(view, 265, 32, header.uname);
+	writeString(view, 297, 32, header.gname);
+	writeString(view, 345, 155, prefix);
 	writeChecksum(view);
 	return view;
 }
 function parseUstarHeader(block, strict) {
 	if (strict && !validateChecksum(block)) throw new Error("Invalid tar header checksum.");
-	const typeflag = readString(block, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE);
+	const typeflag = readString(block, 156, 1);
 	const header = {
-		name: readString(block, USTAR_NAME_OFFSET, USTAR_NAME_SIZE),
-		mode: readOctal(block, USTAR_MODE_OFFSET, USTAR_MODE_SIZE),
-		uid: readNumeric(block, USTAR_UID_OFFSET, USTAR_UID_SIZE),
-		gid: readNumeric(block, USTAR_GID_OFFSET, USTAR_GID_SIZE),
-		size: readNumeric(block, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE),
-		mtime: /* @__PURE__ */ new Date(readNumeric(block, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE) * 1e3),
-		type: FLAGTYPE[typeflag] || FILE,
-		linkname: readString(block, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE)
+		name: readString(block, 0, 100),
+		mode: readOctal(block, 100, 8),
+		uid: readNumeric(block, 108, 8),
+		gid: readNumeric(block, 116, 8),
+		size: readNumeric(block, 124, 12),
+		mtime: /* @__PURE__ */ new Date(readNumeric(block, 136, 12) * 1e3),
+		type: FLAGTYPE[typeflag] || "file",
+		linkname: readString(block, 157, 100)
 	};
-	const magic = readString(block, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE);
+	const magic = readString(block, 257, 6);
 	if (isBodyless(header)) header.size = 0;
 	if (magic.trim() === "ustar") {
-		header.uname = readString(block, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE);
-		header.gname = readString(block, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE);
+		header.uname = readString(block, 265, 32);
+		header.gname = readString(block, 297, 32);
 	}
-	if (magic === "ustar") header.prefix = readString(block, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE);
+	if (magic === "ustar") header.prefix = readString(block, 345, 155);
 	return header;
 }
 const PAX_MAPPING = {
@@ -275,17 +244,17 @@ const PAX_MAPPING = {
 	gname: ["gname", (v) => v]
 };
 function parsePax(buffer) {
-	const decoder$1 = new TextDecoder("utf-8");
+	const decoder = new TextDecoder("utf-8");
 	const overrides = Object.create(null);
 	const pax = Object.create(null);
 	let offset = 0;
 	while (offset < buffer.length) {
 		const spaceIndex = buffer.indexOf(32, offset);
 		if (spaceIndex === -1) break;
-		const length = parseInt(decoder$1.decode(buffer.subarray(offset, spaceIndex)), 10);
+		const length = parseInt(decoder.decode(buffer.subarray(offset, spaceIndex)), 10);
 		if (Number.isNaN(length) || length === 0) break;
 		const recordEnd = offset + length;
-		const [key, value] = decoder$1.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
+		const [key, value] = decoder.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
 		if (key && value !== void 0) {
 			pax[key] = value;
 			if (Object.hasOwn(PAX_MAPPING, key)) {
@@ -323,7 +292,7 @@ function getHeaderBlocks(header) {
 	const base = createTarHeader(header);
 	const pax = generatePax(header);
 	if (!pax) return [base];
-	const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK;
+	const paxPadding = -pax.paxBody.length & 511;
 	const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK.subarray(0, paxPadding)] : [];
 	return [
 		pax.paxHeader,
@@ -332,28 +301,25 @@ function getHeaderBlocks(header) {
 		base
 	];
 }
-
 //#endregion
 //#region src/tar/packer.ts
-const EOF_BUFFER = new Uint8Array(BLOCK_SIZE * 2);
+const EOF_BUFFER = new Uint8Array(512 * 2);
 function createTarPacker(onData, onError, onFinalize) {
 	let currentHeader = null;
 	let bytesWritten = 0;
 	let finalized = false;
+	const fail = (message) => {
+		const error = new Error(message);
+		onError(error);
+		throw error;
+	};
 	return {
 		add(header) {
-			if (finalized) {
-				const error = /* @__PURE__ */ new Error("No new tar entries after finalize.");
-				onError(error);
-				throw error;
-			}
-			if (currentHeader !== null) {
-				const error = /* @__PURE__ */ new Error("Previous entry must be completed before adding a new one");
-				onError(error);
-				throw error;
-			}
+			if (finalized) fail("No new tar entries after finalize.");
+			if (currentHeader !== null) fail("Previous entry must be completed before adding a new one");
+			const size = isBodyless(header) ? 0 : header.size;
+			if (!Number.isSafeInteger(size) || size < 0) fail("Invalid tar entry size.");
 			try {
-				const size = isBodyless(header) ? 0 : header.size ?? 0;
 				const headerBlocks = getHeaderBlocks({
 					...header,
 					size
@@ -369,22 +335,10 @@ function createTarPacker(onData, onError, onFinalize) {
 			}
 		},
 		write(chunk) {
-			if (!currentHeader) {
-				const error = /* @__PURE__ */ new Error("No active tar entry.");
-				onError(error);
-				throw error;
-			}
-			if (finalized) {
-				const error = /* @__PURE__ */ new Error("Cannot write data after finalize.");
-				onError(error);
-				throw error;
-			}
+			if (!currentHeader) fail("No active tar entry.");
+			if (finalized) fail("Cannot write data after finalize.");
 			const newTotal = bytesWritten + chunk.length;
-			if (newTotal > currentHeader.size) {
-				const error = /* @__PURE__ */ new Error(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
-				onError(error);
-				throw error;
-			}
+			if (newTotal > currentHeader.size) fail(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
 			try {
 				bytesWritten = newTotal;
 				onData(chunk);
@@ -393,23 +347,11 @@ function createTarPacker(onData, onError, onFinalize) {
 			}
 		},
 		endEntry() {
-			if (!currentHeader) {
-				const error = /* @__PURE__ */ new Error("No active entry to end.");
-				onError(error);
-				throw error;
-			}
-			if (finalized) {
-				const error = /* @__PURE__ */ new Error("Cannot end entry after finalize.");
-				onError(error);
-				throw error;
-			}
+			if (!currentHeader) fail("No active entry to end.");
+			if (finalized) fail("Cannot end entry after finalize.");
 			try {
-				if (bytesWritten !== currentHeader.size) {
-					const error = /* @__PURE__ */ new Error(`Size mismatch for "${currentHeader.name}".`);
-					onError(error);
-					throw error;
-				}
-				const paddingSize = -currentHeader.size & BLOCK_SIZE_MASK;
+				if (bytesWritten !== currentHeader.size) fail(`Size mismatch for "${currentHeader.name}".`);
+				const paddingSize = -currentHeader.size & 511;
 				if (paddingSize > 0) onData(new Uint8Array(paddingSize));
 				currentHeader = null;
 				bytesWritten = 0;
@@ -419,16 +361,8 @@ function createTarPacker(onData, onError, onFinalize) {
 			}
 		},
 		finalize() {
-			if (finalized) {
-				const error = /* @__PURE__ */ new Error("Archive has already been finalized");
-				onError(error);
-				throw error;
-			}
-			if (currentHeader !== null) {
-				const error = /* @__PURE__ */ new Error("Cannot finalize while an entry is still active");
-				onError(error);
-				throw error;
-			}
+			if (finalized) fail("Archive has already been finalized");
+			if (currentHeader !== null) fail("Cannot finalize while an entry is still active");
 			try {
 				onData(EOF_BUFFER);
 				finalized = true;
@@ -439,7 +373,6 @@ function createTarPacker(onData, onError, onFinalize) {
 		}
 	};
 }
-
 //#endregion
 //#region src/tar/chunk-queue.ts
 const INITIAL_CAPACITY = 256;
@@ -466,13 +399,13 @@ function createChunkQueue() {
 	function pull(bytes, callback) {
 		if (callback) {
 			let fed = 0;
-			let remaining$1 = Math.min(bytes, totalAvailable);
-			while (remaining$1 > 0) {
+			let remaining = Math.min(bytes, totalAvailable);
+			while (remaining > 0) {
 				const chunk = chunks[head];
-				const toFeed = Math.min(remaining$1, chunk.length);
+				const toFeed = Math.min(remaining, chunk.length);
 				const segment = toFeed === chunk.length ? chunk : chunk.subarray(0, toFeed);
 				consumeFromHead(toFeed);
-				remaining$1 -= toFeed;
+				remaining -= toFeed;
 				fed += toFeed;
 				if (!callback(segment)) break;
 			}
@@ -557,7 +490,6 @@ function createChunkQueue() {
 		pull
 	};
 }
-
 //#endregion
 //#region src/tar/unpacker.ts
 const STATE_HEADER = 0;
@@ -576,6 +508,7 @@ function createUnpacker(options = {}) {
 	const unpacker = {
 		isEntryActive: () => state === STATE_BODY,
 		isBodyComplete: () => !currentEntry || currentEntry.remaining === 0,
+		canFinish: () => !currentEntry || available() >= currentEntry.remaining + currentEntry.padding,
 		write(chunk) {
 			if (ended) throw new Error("Archive already ended.");
 			push(chunk);
@@ -587,7 +520,7 @@ function createUnpacker(options = {}) {
 			if (state !== STATE_HEADER) throw new Error("Cannot read header while an entry is active");
 			if (done) return void 0;
 			while (!done) {
-				if (available() < BLOCK_SIZE) {
+				if (available() < 512) {
 					if (ended) {
 						if (available() > 0 && strict) throw truncateErr;
 						done = true;
@@ -595,9 +528,9 @@ function createUnpacker(options = {}) {
 					}
 					return null;
 				}
-				const headerBlock = peek(BLOCK_SIZE);
+				const headerBlock = peek(512);
 				if (isZeroBlock(headerBlock)) {
-					if (available() < BLOCK_SIZE * 2) {
+					if (available() < 512 * 2) {
 						if (ended) {
 							if (strict) throw truncateErr;
 							done = true;
@@ -605,14 +538,14 @@ function createUnpacker(options = {}) {
 						}
 						return null;
 					}
-					if (isZeroBlock(peek(BLOCK_SIZE * 2).subarray(BLOCK_SIZE))) {
-						discard(BLOCK_SIZE * 2);
+					if (isZeroBlock(peek(512 * 2).subarray(512))) {
+						discard(512 * 2);
 						done = true;
 						eof = true;
 						return;
 					}
 					if (strict) throw new Error("Invalid tar header.");
-					discard(BLOCK_SIZE);
+					discard(512);
 					continue;
 				}
 				let internalHeader;
@@ -620,33 +553,33 @@ function createUnpacker(options = {}) {
 					internalHeader = parseUstarHeader(headerBlock, strict);
 				} catch (err) {
 					if (strict) throw err;
-					discard(BLOCK_SIZE);
+					discard(512);
 					continue;
 				}
 				const metaParser = getMetaParser(internalHeader.type);
 				if (metaParser) {
-					const paddedSize = internalHeader.size + BLOCK_SIZE_MASK & ~BLOCK_SIZE_MASK;
-					if (available() < BLOCK_SIZE + paddedSize) {
+					const paddedSize = internalHeader.size + (-internalHeader.size & 511);
+					if (available() < 512 + paddedSize) {
 						if (ended && strict) throw truncateErr;
 						return null;
 					}
-					discard(BLOCK_SIZE);
+					discard(512);
 					const overrides = metaParser(pull(paddedSize).subarray(0, internalHeader.size));
 					const target = internalHeader.type === "pax-global-header" ? paxGlobals : nextEntryOverrides;
 					for (const key in overrides) target[key] = overrides[key];
 					continue;
 				}
-				discard(BLOCK_SIZE);
+				discard(512);
 				const header = internalHeader;
 				if (internalHeader.prefix) header.name = `${internalHeader.prefix}/${header.name}`;
 				applyOverrides(header, paxGlobals);
 				applyOverrides(header, nextEntryOverrides);
-				if (header.name.endsWith("/") && header.type === FILE) header.type = DIRECTORY;
+				if (header.name.endsWith("/") && header.type === "file") header.type = DIRECTORY;
 				nextEntryOverrides = {};
 				currentEntry = {
 					header,
 					remaining: header.size,
-					padding: -header.size & BLOCK_SIZE_MASK
+					padding: -header.size & 511
 				};
 				state = STATE_BODY;
 				return header;
@@ -699,6 +632,5 @@ function isZeroBlock(block) {
 	for (let i = 0; i < block.length; i++) if (block[i] !== 0) return false;
 	return true;
 }
-
 //#endregion
-export { normalizeBody as a, LINK as c, isBodyless as i, SYMLINK as l, createTarPacker as n, DIRECTORY as o, transformHeader as r, FILE as s, createUnpacker as t };
+export { normalizeBody as a, LINK as c, isBodyless as i, SYMLINK as l, createTarPacker as n, DIRECTORY as o, transformHeader as r, FILE as s, createUnpacker as t };

package/dist/web/index.d.ts

@@ -1,7 +1,6 @@
-import { i as UnpackOptions, n as TarEntryData, r as TarHeader, t as DecoderOptions } from "../types-Te8MHQn3.js";
+import { i as UnpackOptions, n as TarEntryData, r as TarHeader, t as DecoderOptions } from "../types-D19dF2SE.js";
 
 //#region src/web/compression.d.ts
-
 /**
  * Creates a gzip compression stream that is compatible with Uint8Array streams.
  *

package/dist/web/index.js

@@ -1,5 +1,4 @@
-import { a as normalizeBody, i as isBodyless, n as createTarPacker$1, r as transformHeader, t as createUnpacker } from "../unpacker-CEuY-276.js";
-
+import { a as normalizeBody, i as isBodyless, n as createTarPacker$1, r as transformHeader, t as createUnpacker } from "../unpacker-CPCEF5CT.js";
 //#region src/web/compression.ts
 function createGzipEncoder() {
 	return new CompressionStream("gzip");
@@ -7,7 +6,6 @@ function createGzipEncoder() {
 function createGzipDecoder() {
 	return new DecompressionStream("gzip");
 }
-
 //#endregion
 //#region src/web/pack.ts
 function createTarPacker() {
@@ -21,9 +19,7 @@ function createTarPacker() {
 		controller: {
 			add(header) {
 				const bodyless = isBodyless(header);
-				const h = { ...header };
-				if (bodyless) h.size = 0;
-				packer.add(h);
+				packer.add(header);
 				if (bodyless) packer.endEntry();
 				return new WritableStream({
 					write(chunk) {
@@ -46,7 +42,6 @@ function createTarPacker() {
 		}
 	};
 }
-
 //#endregion
 //#region src/web/stream-utils.ts
 async function streamToBuffer(stream) {
@@ -72,86 +67,159 @@ async function streamToBuffer(stream) {
 	}
 }
 const drain = (stream) => stream.pipeTo(new WritableStream());
-
 //#endregion
 //#region src/web/unpack.ts
 function createTarDecoder(options = {}) {
 	const unpacker = createUnpacker(options);
+	const strict = options.strict ?? false;
+	let controller = null;
 	let bodyController = null;
 	let pumping = false;
-	const pump = (controller) => {
-		if (pumping) return;
+	let eofReached = false;
+	let sourceEnded = false;
+	let closed = false;
+	const closeBody = () => {
+		try {
+			bodyController?.close();
+		} catch {}
+		bodyController = null;
+	};
+	const fail = (reason) => {
+		if (closed) return;
+		closed = true;
+		try {
+			bodyController?.error(reason);
+		} catch {}
+		bodyController = null;
+		try {
+			controller.error(reason);
+		} catch {}
+		controller = null;
+	};
+	const finish = () => {
+		if (closed) return;
+		closed = true;
+		closeBody();
+		try {
+			controller.close();
+		} catch {}
+		controller = null;
+	};
+	const truncateOrFinish = () => {
+		if (strict) throw new Error("Tar archive is truncated.");
+		finish();
+	};
+	const pump = () => {
+		if (pumping || closed || !controller) return;
 		pumping = true;
 		try {
-			while (true) if (unpacker.isEntryActive()) {
-				if (bodyController) {
-					if (unpacker.streamBody((c) => (bodyController.enqueue(c), true)) === 0 && !unpacker.isBodyComplete()) break;
-				} else if (!unpacker.skipEntry()) break;
-				if (unpacker.isBodyComplete()) {
-					try {
-						bodyController?.close();
-					} catch {}
-					bodyController = null;
-					if (!unpacker.skipPadding()) break;
+			while (true) {
+				if (eofReached) {
+					if (sourceEnded) {
+						unpacker.validateEOF();
+						finish();
+					}
+					break;
 				}
-			} else {
-				const header = unpacker.readHeader();
-				if (header === null || header === void 0) break;
-				controller.enqueue({
-					header,
-					body: new ReadableStream({
-						start(c) {
-							if (header.size === 0) c.close();
-							else bodyController = c;
-						},
-						pull: () => pump(controller),
-						cancel() {
-							bodyController = null;
-							pump(controller);
+				if (unpacker.isEntryActive()) {
+					if (sourceEnded && !unpacker.canFinish()) {
+						truncateOrFinish();
+						break;
+					}
+					if (bodyController) {
+						if ((bodyController.desiredSize ?? 1) <= 0) break;
+						if (unpacker.streamBody((c) => (bodyController.enqueue(c), (bodyController.desiredSize ?? 1) > 0)) === 0 && !unpacker.isBodyComplete()) {
+							if (sourceEnded) truncateOrFinish();
+							break;
 						}
-					})
-				});
+					} else if (!unpacker.skipEntry()) {
+						if (sourceEnded) truncateOrFinish();
+						break;
+					}
+					if (unpacker.isBodyComplete()) {
+						closeBody();
+						if (!unpacker.skipPadding()) {
+							if (sourceEnded) truncateOrFinish();
+							break;
+						}
+					}
+				} else {
+					if ((controller.desiredSize ?? 0) < 0) break;
+					const header = unpacker.readHeader();
+					if (header === null) {
+						if (sourceEnded) finish();
+						break;
+					}
+					if (header === void 0) {
+						if (sourceEnded) {
+							unpacker.validateEOF();
+							finish();
+							break;
+						}
+						eofReached = true;
+						break;
+					}
+					controller.enqueue({
+						header,
+						body: new ReadableStream({
+							start(c) {
+								if (header.size === 0) c.close();
+								else bodyController = c;
+							},
+							pull: pump,
+							cancel() {
+								bodyController = null;
+								pump();
+							}
+						})
+					});
+				}
 			}
 		} catch (error) {
-			try {
-				bodyController?.error(error);
-			} catch {}
-			bodyController = null;
+			fail(error);
 			throw error;
 		} finally {
 			pumping = false;
 		}
 	};
-	return new TransformStream({
-		transform(chunk, controller) {
-			try {
-				unpacker.write(chunk);
-				pump(controller);
-			} catch (error) {
-				try {
-					bodyController?.error(error);
-				} catch {}
-				throw error;
+	return {
+		readable: new ReadableStream({
+			start(c) {
+				controller = c;
+			},
+			pull: pump,
+			cancel(reason) {
+				if (reason !== void 0) fail(reason);
+				else finish();
 			}
-		},
-		flush(controller) {
-			try {
-				unpacker.end();
-				pump(controller);
-				unpacker.validateEOF();
-				if (unpacker.isEntryActive() && !unpacker.isBodyComplete()) try {
-					bodyController?.close();
-				} catch {}
-			} catch (error) {
+		}, { highWaterMark: 2 }),
+		writable: new WritableStream({
+			write(chunk) {
 				try {
-					bodyController?.error(error);
-				} catch {}
-				throw error;
+					if (eofReached && strict && chunk.some((byte) => byte !== 0)) throw new Error("Invalid EOF.");
+					unpacker.write(chunk);
+					pump();
+				} catch (error) {
+					fail(error);
+					throw error;
+				}
+			},
+			close() {
+				try {
+					sourceEnded = true;
+					unpacker.end();
+					pump();
+				} catch (error) {
+					fail(error);
+					throw error;
+				}
+			},
+			abort(reason) {
+				fail(reason);
 			}
-		}
-	}, void 0, { highWaterMark: 1 });
+		})
+	};
 }
-
 //#endregion
 //#region src/web/helpers.ts
 async function packTar(entries) {
@@ -209,6 +277,5 @@ async function unpackTar(archive, options = {}) {
 	}
 	return results;
 }
-
 //#endregion
-export { createGzipDecoder, createGzipEncoder, createTarDecoder, createTarPacker, packTar, unpackTar };
+export { createGzipDecoder, createGzipEncoder, createTarDecoder, createTarPacker, packTar, unpackTar };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "modern-tar",
-	"version": "0.7.4",
+	"version": "0.7.6",
 	"description": "Zero dependency streaming tar parser and writer for JavaScript.",
 	"author": "Ayuhito <hello@ayuhito.com>",
 	"license": "MIT",
@@ -25,18 +25,20 @@
 		}
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.3.8",
-		"@types/node": "^25.0.2",
-		"@vitest/browser-playwright": "4.0.15",
-		"@vitest/coverage-v8": "4.0.15",
-		"tsdown": "^0.18.0",
+		"@biomejs/biome": "2.4.7",
+		"@types/node": "^25.5.0",
+		"@vitest/browser-playwright": "4.1.0",
+		"@vitest/coverage-v8": "4.1.0",
+		"miniflare": "^4.20260312.0",
+		"tsdown": "^0.21.3",
 		"typescript": "^5.9.3",
-		"vitest": "4.0.15"
+		"vitest": "4.1.0"
 	},
 	"scripts": {
 		"build": "tsdown",
 		"dev": "tsdown --watch",
 		"test": "vitest",
+		"test:workers": "tsdown && vitest --config vitest.workers.config.ts --run",
 		"coverage": "vitest run --coverage",
 		"check": "biome check --write",
 		"typecheck": "tsc --noEmit",