modern-tar 0.7.1 → 0.7.2

package/dist/fs/index.js

@@ -1,19 +1,37 @@
-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-Bn-I_G6u.js";
+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-EHw0ivci.js";
 import * as fs 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";
 
+//#region src/fs/cache.ts
+const createCache = () => {
+	const m = /* @__PURE__ */ new Map();
+	return {
+		get(k) {
+			const v = m.get(k);
+			if (m.delete(k)) m.set(k, v);
+			return v;
+		},
+		set(k, v) {
+			if (m.set(k, v).size > 1e4) m.delete(m.keys().next().value);
+		}
+	};
+};
+
+//#endregion
 //#region src/fs/path.ts
-const unicodeCache = /* @__PURE__ */ new Map();
+const unicodeCache = createCache();
 const normalizeUnicode = (s) => {
-	let result = unicodeCache.get(s);
-	if (result !== void 0) unicodeCache.delete(s);
-	result = result ?? s.normalize("NFD");
-	unicodeCache.set(s, result);
-	if (unicodeCache.size > 1e4) unicodeCache.delete(unicodeCache.keys().next().value);
-	return result;
+	for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) >= 128) {
+		const cached = unicodeCache.get(s);
+		if (cached !== void 0) return cached;
+		const normalized = s.normalize("NFD");
+		unicodeCache.set(s, normalized);
+		return normalized;
+	}
+	return s;
 };
 function validateBounds(targetPath, destDir, errorMessage) {
 	const target = normalizeUnicode(path.resolve(targetPath));
@@ -456,17 +474,18 @@ function createFileSink(path$1, { mode = 438, mtime } = {}) {
 
 //#endregion
 //#region src/fs/path-cache.ts
+const ENOENT = "ENOENT";
 const createPathCache = (destDirPath, options) => {
-	const dirPromises = /* @__PURE__ */ new Map();
-	const pathConflicts = /* @__PURE__ */ new Map();
+	const dirPromises = createCache();
+	const pathConflicts = createCache();
 	const deferredLinks = [];
-	const realDirCache = /* @__PURE__ */ new Map();
+	const realDirCache = createCache();
 	const initializeDestDir = async (destDirPath$1) => {
 		const symbolic = normalizeUnicode(path.resolve(destDirPath$1));
 		try {
 			await fs.mkdir(symbolic, { recursive: true });
 		} catch (err) {
-			if (err.code === "ENOENT") {
+			if (err.code === ENOENT) {
 				const parentDir = path.dirname(symbolic);
 				if (parentDir === symbolic) throw err;
 				await fs.mkdir(parentDir, { recursive: true });
@@ -479,7 +498,7 @@ const createPathCache = (destDirPath, options) => {
 				real: await fs.realpath(symbolic)
 			};
 		} catch (err) {
-			if (err.code === "ENOENT") return {
+			if (err.code === ENOENT) return {
 				symbolic,
 				real: symbolic
 			};
@@ -519,12 +538,12 @@ const createPathCache = (destDirPath, options) => {
 					const realPath = await getRealDir(dirPath, `Symlink "${dirPath}" points outside the extraction directory.`);
 					if ((await fs.stat(realPath)).isDirectory()) return;
 				} catch (err) {
-					if (err.code === "ENOENT") throw new Error(`Symlink "${dirPath}" points outside the extraction directory.`);
+					if (err.code === ENOENT) throw new Error(`Symlink "${dirPath}" points outside the extraction directory.`);
 					throw err;
 				}
 				throw new Error(`"${dirPath}" is not a valid directory component.`);
 			} catch (err) {
-				if (err.code === "ENOENT") {
+				if (err.code === ENOENT) {
 					await fs.mkdir(dirPath, { mode: mode ?? options.dmode });
 					return;
 				}
@@ -535,6 +554,9 @@ const createPathCache = (destDirPath, options) => {
 		return promise;
 	};
 	return {
+		async ready() {
+			await destDirPromise;
+		},
 		async preparePath(header) {
 			const { name, linkname, type, mode, mtime } = header;
 			const { maxDepth = 1024, dmode } = options;
@@ -549,10 +571,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}"`);
-				return {
-					outPath,
-					type: "skip"
-				};
+				return;
 			}
 			const parentDir = path.dirname(outPath);
 			switch (type) {
@@ -560,37 +579,22 @@ const createPathCache = (destDirPath, options) => {
 					pathConflicts.set(normalizedName, DIRECTORY);
 					await prepareDirectory(outPath, dmode ?? mode);
 					if (mtime) await fs.lutimes(outPath, mtime, mtime).catch(() => {});
-					return {
-						outPath,
-						type: "dir"
-					};
+					return;
 				case FILE:
 					pathConflicts.set(normalizedName, FILE);
 					await prepareDirectory(parentDir);
-					return {
-						outPath,
-						type: "file"
-					};
+					return outPath;
 				case SYMLINK:
 					pathConflicts.set(normalizedName, SYMLINK);
-					if (!linkname) return {
-						outPath,
-						type: "symlink"
-					};
+					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(() => {});
-					return {
-						outPath,
-						type: "symlink"
-					};
+					return;
 				case LINK: {
 					pathConflicts.set(normalizedName, LINK);
-					if (!linkname) return {
-						outPath,
-						type: "link"
-					};
+					if (!linkname) return;
 					const normalizedLink = normalizeUnicode(linkname);
 					if (path.isAbsolute(normalizedLink)) throw new Error(`Hardlink "${linkname}" points outside the extraction directory.`);
 					const linkTarget = path.join(destDir.symbolic, normalizedLink);
@@ -605,22 +609,16 @@ const createPathCache = (destDirPath, options) => {
 							outPath
 						});
 					}
-					return {
-						outPath,
-						type: "link"
-					};
+					return;
 				}
-				default: return {
-					outPath,
-					type: "skip"
-				};
+				default: return;
 			}
 		},
 		async applyLinks() {
 			for (const { linkTarget, outPath } of deferredLinks) try {
 				await fs.link(linkTarget, outPath);
 			} catch (err) {
-				if (err.code === "ENOENT") throw new Error(`Hardlink target "${linkTarget}" does not exist for link at "${outPath}".`);
+				if (err.code === ENOENT) throw new Error(`Hardlink target "${linkTarget}" does not exist for link at "${outPath}".`);
 				throw err;
 			}
 		}
@@ -669,11 +667,7 @@ function unpackTar(directoryPath, options = {}) {
 				}
 				while (true) {
 					const header = unpacker.readHeader();
-					if (header === void 0) {
-						cb();
-						return;
-					}
-					if (header === null) {
+					if (header === void 0 || header === null) {
 						cb();
 						return;
 					}
@@ -686,9 +680,9 @@ function unpackTar(directoryPath, options = {}) {
 						}
 						continue;
 					}
-					const prep = await opQueue.add(() => pathCache.preparePath(transformedHeader));
-					if (prep.type === "file") {
-						const fileStream = createFileSink(prep.outPath, {
+					const outPath = await opQueue.add(() => pathCache.preparePath(transformedHeader));
+					if (outPath) {
+						const fileStream = createFileSink(outPath, {
 							mode: options.fmode ?? transformedHeader.mode ?? void 0,
 							mtime: transformedHeader.mtime ?? void 0
 						});
@@ -729,6 +723,7 @@ function unpackTar(directoryPath, options = {}) {
 			try {
 				unpacker.end();
 				unpacker.validateEOF();
+				await pathCache.ready();
 				await opQueue.onIdle();
 				await pathCache.applyLinks();
 				cb();

package/dist/{unpacker-Bn-I_G6u.js → unpacker-EHw0ivci.js}

@@ -91,7 +91,7 @@ function readOctal(view, offset, size) {
 		const charCode = view[i];
 		if (charCode === 0) break;
 		if (charCode === 32) continue;
-		value = (value << 3) + (charCode - 48);
+		value = value * 8 + (charCode - 48);
 	}
 	return value;
 }
@@ -442,8 +442,9 @@ function createTarPacker(onData, onError, onFinalize) {
 
 //#endregion
 //#region src/tar/chunk-queue.ts
+const INITIAL_CAPACITY = 256;
 function createChunkQueue() {
-	let chunks = new Array(256);
+	let chunks = new Array(INITIAL_CAPACITY);
 	let capacityMask = chunks.length - 1;
 	let head = 0;
 	let tail = 0;
@@ -455,6 +456,12 @@ function createChunkQueue() {
 			head = head + 1 & capacityMask;
 		} else chunks[head] = chunk.subarray(count);
 		totalAvailable -= count;
+		if (totalAvailable === 0 && chunks.length > INITIAL_CAPACITY) {
+			chunks = new Array(INITIAL_CAPACITY);
+			capacityMask = INITIAL_CAPACITY - 1;
+			head = 0;
+			tail = 0;
+		}
 	};
 	function pull(bytes, callback) {
 		if (callback) {

package/dist/web/index.js

@@ -1,4 +1,4 @@
-import { a as normalizeBody, i as isBodyless, n as createTarPacker$1, r as transformHeader, t as createUnpacker } from "../unpacker-Bn-I_G6u.js";
+import { a as normalizeBody, i as isBodyless, n as createTarPacker$1, r as transformHeader, t as createUnpacker } from "../unpacker-EHw0ivci.js";
 
 //#region src/web/compression.ts
 function createGzipEncoder() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "modern-tar",
-	"version": "0.7.1",
+	"version": "0.7.2",
 	"description": "Zero dependency streaming tar parser and writer for JavaScript.",
 	"author": "Ayuhito <hello@ayuhito.com>",
 	"license": "MIT",