screw-up 1.26.0 → 1.28.0

package/dist/main.mjs

@@ -1,1090 +1,989 @@
 #!/usr/bin/env node
 /*!
- * name: screw-up
- * version: 1.26.0
- * description: Simply package metadata inserter on Vite plugin
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/screw-up.git
- * git.commit.hash: 482a79d9b3fc68a60c1b8696b7d95a776b91468e
- */
-
-import { join, dirname, resolve, isAbsolute } from "path";
-import { createWriteStream, createReadStream, existsSync, statSync } from "fs";
-import { mkdir, writeFile, stat, readdir, mkdtemp, copyFile, rm, readFile } from "fs/promises";
+* name: screw-up
+* version: 1.28.0
+* description: Simply package metadata inserter on Vite plugin
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/screw-up.git
+* git.commit.hash: 4bc8c338f32ab8ed9bbf0b9ad0ba4166d584be65
+*/
+import { a as collectWorkspaceSiblings, c as replacePeerDependenciesWildcards, d as require_dist, i as getFetchGitMetadata, l as resolvePackageMetadata, n as generateMetadataFileContent, o as createConsoleLogger, p as __toESM, r as writeFileIfChanged, s as findWorkspaceRoot, t as ensureMetadataGitignore, u as resolveRawPackageJsonObject } from "./metadata-file-DtvzENuT.js";
+import { n as name } from "./packageMetadata-11MbeI_K.js";
+import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "fs/promises";
+import { createReadStream, createWriteStream, existsSync, statSync } from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
+import { glob } from "glob";
 import { spawn } from "child_process";
 import { tmpdir } from "os";
 import { Readable } from "stream";
 import { createGunzip, createGzip } from "zlib";
 import { pipeline } from "stream/promises";
-import { glob } from "glob";
-import { d as resolveRawPackageJsonObject, f as findWorkspaceRoot, h as collectWorkspaceSiblings, i as replacePeerDependenciesWildcards, g as getFetchGitMetadata, l as lib, r as resolvePackageMetadata, b as generateMetadataFileContent, w as writeFileIfChanged, e as ensureMetadataGitignore, c as createConsoleLogger, n as name } from "./metadata-file-B4RbKbol.js";
-const MAX_NAME = 100;
-const MAX_PREFIX = 155;
-const getUName = (candidateName, candidateId, reflectStat) => {
-  return candidateName != null ? candidateName : reflectStat === "all" ? candidateId.toString() : "root";
+//#region node_modules/tar-vern/dist/index.js
+/*!
+* name: tar-vern
+* version: 1.3.0
+* description: Tape archiver library for Typescript
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/tar-vern.git
+* git.commit.hash: 7ac8b1f258e17c93767650ef047a2db9f0ffd417
+*/
+var MAX_NAME = 100;
+var MAX_PREFIX = 155;
+var getUName = (candidateName, candidateId, reflectStat) => {
+	return candidateName !== null && candidateName !== void 0 ? candidateName : reflectStat === "all" ? candidateId.toString() : "root";
 };
-const getBuffer = (data) => {
-  return Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+var getBuffer = (data) => {
+	return Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
 };
-const createDirectoryItem = async (path, reflectStat, options, signal) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  const rs = reflectStat;
-  if (options == null ? void 0 : options.directoryPath) {
-    const stats = await stat(options.directoryPath);
-    const mode = (_a = options == null ? void 0 : options.mode) != null ? _a : stats.mode;
-    const uid = (_b = options == null ? void 0 : options.uid) != null ? _b : stats.uid;
-    const gid = (_c = options == null ? void 0 : options.gid) != null ? _c : stats.gid;
-    const date = (_d = options == null ? void 0 : options.date) != null ? _d : stats.mtime;
-    const uname = getUName(options == null ? void 0 : options.uname, stats.uid, rs);
-    const gname = getUName(options == null ? void 0 : options.gname, stats.gid, rs);
-    return {
-      kind: "directory",
-      path,
-      mode,
-      uname,
-      gname,
-      uid,
-      gid,
-      date
-    };
-  } else {
-    const mode = (_e = options == null ? void 0 : options.mode) != null ? _e : 493;
-    const uid = (_f = options == null ? void 0 : options.uid) != null ? _f : 0;
-    const gid = (_g = options == null ? void 0 : options.gid) != null ? _g : 0;
-    const date = (_h = options == null ? void 0 : options.date) != null ? _h : /* @__PURE__ */ new Date();
-    const uname = getUName(options == null ? void 0 : options.uname, void 0, rs);
-    const gname = getUName(options == null ? void 0 : options.gname, void 0, rs);
-    return {
-      kind: "directory",
-      path,
-      mode,
-      uname,
-      gname,
-      uid,
-      gid,
-      date
-    };
-  }
+var createDirectoryItem = async (path, reflectStat, options, signal) => {
+	const rs = reflectStat !== null && reflectStat !== void 0 ? reflectStat : "none";
+	if (rs !== "none" && (options === null || options === void 0 ? void 0 : options.directoryPath)) {
+		var _options$mode, _options$uid, _options$gid, _options$date;
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const stats = await stat(options.directoryPath);
+		const mode = (_options$mode = options === null || options === void 0 ? void 0 : options.mode) !== null && _options$mode !== void 0 ? _options$mode : stats.mode;
+		const uid = (_options$uid = options === null || options === void 0 ? void 0 : options.uid) !== null && _options$uid !== void 0 ? _options$uid : stats.uid;
+		const gid = (_options$gid = options === null || options === void 0 ? void 0 : options.gid) !== null && _options$gid !== void 0 ? _options$gid : stats.gid;
+		const date = (_options$date = options === null || options === void 0 ? void 0 : options.date) !== null && _options$date !== void 0 ? _options$date : stats.mtime;
+		return {
+			kind: "directory",
+			path,
+			mode,
+			uname: getUName(options === null || options === void 0 ? void 0 : options.uname, stats.uid, rs),
+			gname: getUName(options === null || options === void 0 ? void 0 : options.gname, stats.gid, rs),
+			uid,
+			gid,
+			date
+		};
+	} else {
+		var _options$mode2, _options$uid2, _options$gid2, _options$date2;
+		const mode = (_options$mode2 = options === null || options === void 0 ? void 0 : options.mode) !== null && _options$mode2 !== void 0 ? _options$mode2 : 493;
+		const uid = (_options$uid2 = options === null || options === void 0 ? void 0 : options.uid) !== null && _options$uid2 !== void 0 ? _options$uid2 : 0;
+		const gid = (_options$gid2 = options === null || options === void 0 ? void 0 : options.gid) !== null && _options$gid2 !== void 0 ? _options$gid2 : 0;
+		const date = (_options$date2 = options === null || options === void 0 ? void 0 : options.date) !== null && _options$date2 !== void 0 ? _options$date2 : /* @__PURE__ */ new Date();
+		return {
+			kind: "directory",
+			path,
+			mode,
+			uname: getUName(options === null || options === void 0 ? void 0 : options.uname, void 0, rs),
+			gname: getUName(options === null || options === void 0 ? void 0 : options.gname, void 0, rs),
+			uid,
+			gid,
+			date
+		};
+	}
 };
-const createReadableFileItem = async (path, readable, options, signal) => {
-  var _a, _b, _c, _d, _e, _f;
-  const mode = (_a = options == null ? void 0 : options.mode) != null ? _a : 420;
-  const uid = (_b = options == null ? void 0 : options.uid) != null ? _b : 0;
-  const gid = (_c = options == null ? void 0 : options.gid) != null ? _c : 0;
-  const date = (_d = options == null ? void 0 : options.date) != null ? _d : /* @__PURE__ */ new Date();
-  const uname = (_e = options == null ? void 0 : options.uname) != null ? _e : "root";
-  const gname = (_f = options == null ? void 0 : options.gname) != null ? _f : "root";
-  let length = options == null ? void 0 : options.length;
-  if (!length) {
-    const chunks = [];
-    length = 0;
-    for await (const chunk of readable) {
-      const buffer = getBuffer(chunk);
-      chunks.push(buffer);
-      length += buffer.length;
-    }
-    return {
-      kind: "file",
-      path,
-      mode,
-      uname,
-      gname,
-      uid,
-      gid,
-      date,
-      content: {
-        kind: "readable",
-        length,
-        readable: Readable.from(chunks, { signal })
-      }
-    };
-  } else {
-    return {
-      kind: "file",
-      path,
-      mode,
-      uname,
-      gname,
-      uid,
-      gid,
-      date,
-      content: {
-        kind: "readable",
-        length,
-        readable
-      }
-    };
-  }
+var createReadableFileItem = async (path, readable, options, signal) => {
+	var _options$mode4, _options$uid4, _options$gid4, _options$date4, _options$uname2, _options$gname2;
+	const mode = (_options$mode4 = options === null || options === void 0 ? void 0 : options.mode) !== null && _options$mode4 !== void 0 ? _options$mode4 : 420;
+	const uid = (_options$uid4 = options === null || options === void 0 ? void 0 : options.uid) !== null && _options$uid4 !== void 0 ? _options$uid4 : 0;
+	const gid = (_options$gid4 = options === null || options === void 0 ? void 0 : options.gid) !== null && _options$gid4 !== void 0 ? _options$gid4 : 0;
+	const date = (_options$date4 = options === null || options === void 0 ? void 0 : options.date) !== null && _options$date4 !== void 0 ? _options$date4 : /* @__PURE__ */ new Date();
+	const uname = (_options$uname2 = options === null || options === void 0 ? void 0 : options.uname) !== null && _options$uname2 !== void 0 ? _options$uname2 : "root";
+	const gname = (_options$gname2 = options === null || options === void 0 ? void 0 : options.gname) !== null && _options$gname2 !== void 0 ? _options$gname2 : "root";
+	let length = options === null || options === void 0 ? void 0 : options.length;
+	if (!length) {
+		const chunks = [];
+		length = 0;
+		for await (const chunk of readable) {
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			const buffer = getBuffer(chunk);
+			chunks.push(buffer);
+			length += buffer.length;
+		}
+		return {
+			kind: "file",
+			path,
+			mode,
+			uname,
+			gname,
+			uid,
+			gid,
+			date,
+			content: {
+				kind: "readable",
+				length,
+				readable: Readable.from(chunks, { signal })
+			}
+		};
+	} else return {
+		kind: "file",
+		path,
+		mode,
+		uname,
+		gname,
+		uid,
+		gid,
+		date,
+		content: {
+			kind: "readable",
+			length,
+			readable
+		}
+	};
 };
-const createReadFileItem = async (path, filePath, reflectStat, options, signal) => {
-  const rs = reflectStat;
-  const stats = await stat(filePath);
-  const reader = createReadStream(filePath, { signal });
-  const mode = stats.mode;
-  const uid = stats.uid;
-  const gid = stats.gid;
-  const date = stats.mtime;
-  const uname = getUName(options == null ? void 0 : options.uname, stats.uid, rs);
-  const gname = getUName(options == null ? void 0 : options.gname, stats.gid, rs);
-  return await createReadableFileItem(path, reader, {
-    length: stats.size,
-    mode,
-    uname,
-    gname,
-    uid,
-    gid,
-    date
-  }, signal);
+var createReadFileItem = async (path, filePath, reflectStat, options, signal) => {
+	var _options$mode6, _options$uid6, _options$gid6, _options$date6;
+	const rs = reflectStat !== null && reflectStat !== void 0 ? reflectStat : "exceptName";
+	signal === null || signal === void 0 || signal.throwIfAborted();
+	const stats = await stat(filePath);
+	const reader = createReadStream(filePath, { signal });
+	const mode = (_options$mode6 = options === null || options === void 0 ? void 0 : options.mode) !== null && _options$mode6 !== void 0 ? _options$mode6 : rs !== "none" ? stats.mode : void 0;
+	const uid = (_options$uid6 = options === null || options === void 0 ? void 0 : options.uid) !== null && _options$uid6 !== void 0 ? _options$uid6 : rs !== "none" ? stats.uid : void 0;
+	const gid = (_options$gid6 = options === null || options === void 0 ? void 0 : options.gid) !== null && _options$gid6 !== void 0 ? _options$gid6 : rs !== "none" ? stats.gid : void 0;
+	const date = (_options$date6 = options === null || options === void 0 ? void 0 : options.date) !== null && _options$date6 !== void 0 ? _options$date6 : rs !== "none" ? stats.mtime : void 0;
+	const uname = getUName(options === null || options === void 0 ? void 0 : options.uname, stats.uid, rs);
+	const gname = getUName(options === null || options === void 0 ? void 0 : options.gname, stats.gid, rs);
+	return await createReadableFileItem(path, reader, {
+		length: stats.size,
+		mode,
+		uname,
+		gname,
+		uid,
+		gid,
+		date
+	}, signal);
 };
-const storeReaderToFile = async (reader, path, signal) => {
-  const writer = createWriteStream(path, { signal });
-  await pipeline(reader, writer, { signal });
+var storeReaderToFile = async (reader, path, signal) => {
+	await pipeline(reader, createWriteStream(path, { signal }), { signal });
 };
-const getAllFilesInDirectory = async (baseDir, signal) => {
-  const collectFiles = async (currentDir, relativePath) => {
-    try {
-      const entries = await readdir(currentDir, { withFileTypes: true });
-      const result = [];
-      const tasks = entries.map(async (entry) => {
-        signal == null ? void 0 : signal.throwIfAborted();
-        const entryRelativePath = join(relativePath, entry.name);
-        if (entry.isDirectory()) {
-          const entryFullPath = join(currentDir, entry.name);
-          const directoryContents = await collectFiles(entryFullPath, entryRelativePath);
-          return [entryRelativePath, ...directoryContents];
-        } else {
-          return [entryRelativePath];
-        }
-      });
-      const allResults = await Promise.all(tasks);
-      for (const entryResults of allResults) {
-        result.push(...entryResults);
-      }
-      return result;
-    } catch (error) {
-      console.warn(`Warning: Could not read directory ${currentDir}:`, error);
-      return [];
-    }
-  };
-  return await collectFiles(baseDir, "");
+var getAllFilesInDirectory = async (baseDir, signal) => {
+	const collectFiles = async (currentDir, relativePath) => {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		try {
+			const entries = await readdir(currentDir, { withFileTypes: true });
+			const result = [];
+			const tasks = entries.map(async (entry) => {
+				signal === null || signal === void 0 || signal.throwIfAborted();
+				const entryRelativePath = join(relativePath, entry.name);
+				if (entry.isDirectory()) return [entryRelativePath, ...await collectFiles(join(currentDir, entry.name), entryRelativePath)];
+				else return [entryRelativePath];
+			});
+			const allResults = await Promise.all(tasks);
+			for (const entryResults of allResults) result.push(...entryResults);
+			return result;
+		} catch (error) {
+			console.warn(`Warning: Could not read directory ${currentDir}:`, error);
+			return [];
+		}
+	};
+	return await collectFiles(baseDir, "");
 };
-const createEntryItemGenerator = async function* (baseDir, relativePaths, includeDirectory, reflectStat, signal) {
-  const rs = "exceptName";
-  const includeDir = true;
-  const pathsToProcess = await getAllFilesInDirectory(baseDir, signal);
-  for (const relativePath of pathsToProcess) {
-    const fsPath = join(baseDir, relativePath);
-    try {
-      signal == null ? void 0 : signal.throwIfAborted();
-      const stats = await stat(fsPath);
-      if (includeDir && stats.isDirectory()) {
-        yield await createDirectoryItem(relativePath, rs, {
-          directoryPath: fsPath
-        }, signal);
-      } else if (stats.isFile()) {
-        yield await createReadFileItem(relativePath, fsPath, rs, void 0, signal);
-      }
-    } catch (error) {
-      console.warn(`Warning: Could not access ${fsPath}:`, error);
-      continue;
-    }
-  }
+var createEntryItemGenerator = async function* (baseDir, relativePaths, includeDirectory, reflectStat, signal) {
+	const rs = reflectStat !== null && reflectStat !== void 0 ? reflectStat : "exceptName";
+	const includeDir = includeDirectory !== null && includeDirectory !== void 0 ? includeDirectory : true;
+	const pathsToProcess = relativePaths !== null && relativePaths !== void 0 ? relativePaths : await getAllFilesInDirectory(baseDir, signal);
+	for (const relativePath of pathsToProcess) {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const fsPath = join(baseDir, relativePath);
+		try {
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			const stats = await stat(fsPath);
+			if (includeDir && stats.isDirectory()) yield await createDirectoryItem(relativePath, rs, { directoryPath: fsPath }, signal);
+			else if (stats.isFile()) yield await createReadFileItem(relativePath, fsPath, rs, void 0, signal);
+		} catch (error) {
+			console.warn(`Warning: Could not access ${fsPath}:`, error);
+			continue;
+		}
+	}
 };
-const extractTo = async (iterator, basePath, signal) => {
-  for await (const entry of iterator) {
-    const targetPath = join(basePath, entry.path);
-    if (entry.kind === "directory") {
-      try {
-        signal == null ? void 0 : signal.throwIfAborted();
-        await mkdir(targetPath, { recursive: true, mode: entry.mode });
-      } catch (error) {
-        if (error.code !== "EEXIST") {
-          throw error;
-        }
-      }
-    } else if (entry.kind === "file") {
-      const parentDir = dirname(targetPath);
-      await mkdir(parentDir, { recursive: true });
-      const fileEntry = entry;
-      const content = await fileEntry.getContent("buffer");
-      await writeFile(targetPath, content, { mode: entry.mode, signal });
-    }
-  }
+var extractTo = async (iterator, basePath, signal) => {
+	for await (const entry of iterator) {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const targetPath = join(basePath, entry.path);
+		if (entry.kind === "directory") try {
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			await mkdir(targetPath, {
+				recursive: true,
+				mode: entry.mode
+			});
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+		else if (entry.kind === "file") {
+			const parentDir = dirname(targetPath);
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			await mkdir(parentDir, { recursive: true });
+			await writeFile(targetPath, await entry.getContent("buffer"), {
+				mode: entry.mode,
+				signal
+			});
+		}
+	}
 };
-const utf8ByteLength = (str) => {
-  return Buffer.byteLength(str, "utf8");
+var utf8ByteLength = (str) => {
+	return Buffer.byteLength(str, "utf8");
 };
-const truncateUtf8Safe = (str, maxBytes) => {
-  let total = 0;
-  let i = 0;
-  while (i < str.length) {
-    const codePoint = str.codePointAt(i);
-    const char = String.fromCodePoint(codePoint);
-    const charBytes = Buffer.byteLength(char, "utf8");
-    if (total + charBytes > maxBytes) break;
-    total += charBytes;
-    i += char.length;
-  }
-  return str.slice(0, i);
+var truncateUtf8Safe = (str, maxBytes) => {
+	let total = 0;
+	let i = 0;
+	while (i < str.length) {
+		const codePoint = str.codePointAt(i);
+		const char = String.fromCodePoint(codePoint);
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (total + charBytes > maxBytes) break;
+		total += charBytes;
+		i += char.length;
+	}
+	return str.slice(0, i);
 };
-const splitPath = (path) => {
-  var _a;
-  if (utf8ByteLength(path) <= MAX_NAME) {
-    return { prefix: "", name: path };
-  }
-  const parts = path.split("/");
-  let name2 = (_a = parts.pop()) != null ? _a : "";
-  let prefix = parts.join("/");
-  if (utf8ByteLength(name2) > MAX_NAME) {
-    name2 = truncateUtf8Safe(name2, MAX_NAME);
-  }
-  while (utf8ByteLength(prefix) > MAX_PREFIX) {
-    prefix = truncateUtf8Safe(prefix, MAX_PREFIX);
-  }
-  return { prefix, name: name2 };
+var splitPath = (path) => {
+	var _parts$pop;
+	if (utf8ByteLength(path) <= MAX_NAME) return {
+		prefix: "",
+		name: path
+	};
+	const parts = path.split("/");
+	let name = (_parts$pop = parts.pop()) !== null && _parts$pop !== void 0 ? _parts$pop : "";
+	let prefix = parts.join("/");
+	if (utf8ByteLength(name) > MAX_NAME) name = truncateUtf8Safe(name, MAX_NAME);
+	while (utf8ByteLength(prefix) > MAX_PREFIX) prefix = truncateUtf8Safe(prefix, MAX_PREFIX);
+	return {
+		prefix,
+		name
+	};
 };
-const getOctalBytes = (value, length) => {
-  const str = value.toString(8).padStart(length - 1, "0") + "\0";
-  return Buffer.from(str, "ascii");
+var getOctalBytes = (value, length) => {
+	const str = value.toString(8).padStart(length - 1, "0") + "\0";
+	return Buffer.from(str, "ascii");
 };
-const getPaddedBytes = (buffer) => {
-  const extra = buffer.length % 512;
-  if (extra === 0) {
-    return buffer;
-  } else {
-    return Buffer.concat([buffer, Buffer.alloc(512 - extra, 0)]);
-  }
+var getPaddedBytes = (buffer) => {
+	const extra = buffer.length % 512;
+	if (extra === 0) return buffer;
+	else return Buffer.concat([buffer, Buffer.alloc(512 - extra, 0)]);
 };
-const terminatorBytes = Buffer.alloc(1024, 0);
-const createTarHeader = (type, path, size, mode, uname, gname, uid, gid, date) => {
-  const buffer = Buffer.alloc(512, 0);
-  const { name: name2, prefix } = splitPath(path);
-  buffer.write(name2, 0, 100, "utf8");
-  getOctalBytes(mode & 4095, 8).copy(buffer, 100);
-  getOctalBytes(uid, 8).copy(buffer, 108);
-  getOctalBytes(gid, 8).copy(buffer, 116);
-  getOctalBytes(size, 12).copy(buffer, 124);
-  getOctalBytes(Math.floor(date.getTime() / 1e3), 12).copy(buffer, 136);
-  Buffer.from("        ", "ascii").copy(buffer, 148);
-  if (type === "file") {
-    buffer.write("0", 156, 1, "ascii");
-  } else {
-    buffer.write("5", 156, 1, "ascii");
-  }
-  buffer.write("ustar\0", 257, 6, "ascii");
-  buffer.write("00", 263, 2, "ascii");
-  buffer.write(uname, 265, 32, "utf8");
-  buffer.write(gname, 297, 32, "utf8");
-  buffer.write(prefix, 345, 155, "utf8");
-  let sum = 0;
-  for (let i = 0; i < 512; i++) {
-    sum += buffer[i];
-  }
-  getOctalBytes(sum, 8).copy(buffer, 148);
-  return buffer;
+var terminatorBytes = Buffer.alloc(1024, 0);
+var createTarHeader = (type, path, size, mode, uname, gname, uid, gid, date) => {
+	const buffer = Buffer.alloc(512, 0);
+	const { name, prefix } = splitPath(path);
+	buffer.write(name, 0, 100, "utf8");
+	getOctalBytes(mode & 4095, 8).copy(buffer, 100);
+	getOctalBytes(uid, 8).copy(buffer, 108);
+	getOctalBytes(gid, 8).copy(buffer, 116);
+	getOctalBytes(size, 12).copy(buffer, 124);
+	getOctalBytes(Math.floor(date.getTime() / 1e3), 12).copy(buffer, 136);
+	Buffer.from("        ", "ascii").copy(buffer, 148);
+	if (type === "file") buffer.write("0", 156, 1, "ascii");
+	else buffer.write("5", 156, 1, "ascii");
+	buffer.write("ustar\0", 257, 6, "ascii");
+	buffer.write("00", 263, 2, "ascii");
+	buffer.write(uname, 265, 32, "utf8");
+	buffer.write(gname, 297, 32, "utf8");
+	buffer.write(prefix, 345, 155, "utf8");
+	let sum = 0;
+	for (let i = 0; i < 512; i++) sum += buffer[i];
+	getOctalBytes(sum, 8).copy(buffer, 148);
+	return buffer;
 };
-const createTarPacker = (entryItemGenerator, compressionType, signal) => {
-  const entryItemIterator = async function* () {
-    for await (const entryItem of entryItemGenerator) {
-      switch (entryItem.kind) {
-        // Entry is a file
-        case "file": {
-          const entryItemContent = entryItem.content;
-          if (typeof entryItemContent === "string" || Buffer.isBuffer(entryItemContent)) {
-            const contentBytes = getBuffer(entryItemContent);
-            const tarHeaderBytes = createTarHeader(
-              "file",
-              entryItem.path,
-              contentBytes.length,
-              entryItem.mode,
-              entryItem.uname,
-              entryItem.gname,
-              entryItem.uid,
-              entryItem.gid,
-              entryItem.date
-            );
-            yield tarHeaderBytes;
-            const totalPaddedContentBytes = getPaddedBytes(contentBytes);
-            yield totalPaddedContentBytes;
-          } else {
-            const content = entryItemContent;
-            const tarHeaderBytes = createTarHeader(
-              "file",
-              entryItem.path,
-              content.length,
-              entryItem.mode,
-              entryItem.uname,
-              entryItem.gname,
-              entryItem.uid,
-              entryItem.gid,
-              entryItem.date
-            );
-            yield tarHeaderBytes;
-            let position = 0;
-            switch (content.kind) {
-              // Content is a generator
-              case "generator": {
-                for await (const contentBytes of content.generator) {
-                  yield contentBytes;
-                  position += contentBytes.length;
-                }
-                break;
-              }
-              // Content is a readable stream
-              case "readable": {
-                for await (const chunk of content.readable) {
-                  const contentBytes = getBuffer(chunk);
-                  yield contentBytes;
-                  position += contentBytes.length;
-                }
-                break;
-              }
-            }
-            if (position % 512 !== 0) {
-              yield Buffer.alloc(512 - position % 512, 0);
-            }
-          }
-          break;
-        }
-        // Entry is a directory
-        case "directory": {
-          const tarHeaderBytes = createTarHeader(
-            "directory",
-            entryItem.path,
-            0,
-            entryItem.mode,
-            entryItem.uname,
-            entryItem.gname,
-            entryItem.uid,
-            entryItem.gid,
-            entryItem.date
-          );
-          yield tarHeaderBytes;
-          break;
-        }
-      }
-    }
-    yield terminatorBytes;
-  };
-  const ct = compressionType;
-  switch (ct) {
-    // No compression
-    case "none": {
-      return Readable.from(entryItemIterator(), { signal });
-    }
-    // Gzip compression
-    case "gzip": {
-      const gzipStream = createGzip({ level: 9 });
-      const entryItemStream = Readable.from(entryItemIterator(), { signal });
-      entryItemStream.pipe(gzipStream);
-      return gzipStream;
-    }
-  }
+var createTarPacker = (entryItemGenerator, compressionType, signal) => {
+	const entryItemIterator = async function* () {
+		for await (const entryItem of entryItemGenerator) {
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			switch (entryItem.kind) {
+				case "file": {
+					const entryItemContent = entryItem.content;
+					if (typeof entryItemContent === "string" || Buffer.isBuffer(entryItemContent)) {
+						const contentBytes = getBuffer(entryItemContent);
+						yield createTarHeader("file", entryItem.path, contentBytes.length, entryItem.mode, entryItem.uname, entryItem.gname, entryItem.uid, entryItem.gid, entryItem.date);
+						yield getPaddedBytes(contentBytes);
+					} else {
+						const content = entryItemContent;
+						yield createTarHeader("file", entryItem.path, content.length, entryItem.mode, entryItem.uname, entryItem.gname, entryItem.uid, entryItem.gid, entryItem.date);
+						let position = 0;
+						switch (content.kind) {
+							case "generator":
+								for await (const contentBytes of content.generator) {
+									signal === null || signal === void 0 || signal.throwIfAborted();
+									yield contentBytes;
+									position += contentBytes.length;
+								}
+								break;
+							case "readable":
+								for await (const chunk of content.readable) {
+									signal === null || signal === void 0 || signal.throwIfAborted();
+									const contentBytes = getBuffer(chunk);
+									yield contentBytes;
+									position += contentBytes.length;
+								}
+								break;
+						}
+						if (position % 512 !== 0) {
+							signal === null || signal === void 0 || signal.throwIfAborted();
+							yield Buffer.alloc(512 - position % 512, 0);
+						}
+					}
+					break;
+				}
+				case "directory":
+					yield createTarHeader("directory", entryItem.path, 0, entryItem.mode, entryItem.uname, entryItem.gname, entryItem.uid, entryItem.gid, entryItem.date);
+					break;
+			}
+		}
+		yield terminatorBytes;
+	};
+	switch (compressionType !== null && compressionType !== void 0 ? compressionType : "none") {
+		case "none": return Readable.from(entryItemIterator(), { signal });
+		case "gzip": {
+			const gzipStream = createGzip({ level: 9 });
+			Readable.from(entryItemIterator(), { signal }).pipe(gzipStream);
+			return gzipStream;
+		}
+	}
 };
-const parseOctalBytes = (buffer, offset, length) => {
-  const str = buffer.subarray(offset, offset + length).toString("ascii").replace(/\0/g, "").trim();
-  return str ? parseInt(str, 8) : 0;
+var parseOctalBytes = (buffer, offset, length) => {
+	const str = buffer.subarray(offset, offset + length).toString("ascii").replace(/\0/g, "").trim();
+	return str ? parseInt(str, 8) : 0;
 };
-const parseString = (buffer, offset, length) => {
-  return buffer.subarray(offset, offset + length).toString("utf8").replace(/\0/g, "").trim();
+var parseString = (buffer, offset, length) => {
+	return buffer.subarray(offset, offset + length).toString("utf8").replace(/\0/g, "").trim();
 };
-const readExactBytes = async (iterator, size, signal) => {
-  var _a;
-  const chunks = [];
-  let totalRead = 0;
-  while (totalRead < size) {
-    const { value, done } = await iterator.next();
-    if (done) {
-      if (totalRead === 0) {
-        return void 0;
-      } else {
-        throw new Error(`Unexpected end of stream: expected ${size} bytes, got ${totalRead} bytes`);
-      }
-    }
-    const chunk = getBuffer(value);
-    const needed = size - totalRead;
-    if (chunk.length <= needed) {
-      chunks.push(chunk);
-      totalRead += chunk.length;
-    } else {
-      chunks.push(chunk.subarray(0, needed));
-      await ((_a = iterator.return) == null ? void 0 : _a.call(iterator, chunk.subarray(needed)));
-      totalRead = size;
-    }
-  }
-  return Buffer.concat(chunks, size);
+var readExactBytes = async (iterator, size, signal) => {
+	const chunks = [];
+	let totalRead = 0;
+	while (totalRead < size) {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const { value, done } = await iterator.next();
+		if (done) if (totalRead === 0) return;
+		else throw new Error(`Unexpected end of stream: expected ${size} bytes, got ${totalRead} bytes`);
+		const chunk = getBuffer(value);
+		const needed = size - totalRead;
+		if (chunk.length <= needed) {
+			chunks.push(chunk);
+			totalRead += chunk.length;
+		} else {
+			var _iterator$return;
+			chunks.push(chunk.subarray(0, needed));
+			await ((_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator, chunk.subarray(needed)));
+			totalRead = size;
+		}
+	}
+	return Buffer.concat(chunks, size);
 };
-const skipExactBytes = async (iterator, size, signal) => {
-  var _a;
-  let totalSkipped = 0;
-  while (totalSkipped < size) {
-    const { value, done } = await iterator.next();
-    if (done) {
-      throw new Error(`Unexpected end of stream: expected to skip ${size} bytes, skipped ${totalSkipped} bytes`);
-    }
-    const chunk = getBuffer(value);
-    const needed = size - totalSkipped;
-    if (chunk.length <= needed) {
-      totalSkipped += chunk.length;
-    } else {
-      await ((_a = iterator.return) == null ? void 0 : _a.call(iterator, chunk.subarray(needed)));
-      totalSkipped = size;
-    }
-  }
+var skipExactBytes = async (iterator, size, signal) => {
+	let totalSkipped = 0;
+	while (totalSkipped < size) {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		const { value, done } = await iterator.next();
+		if (done) throw new Error(`Unexpected end of stream: expected to skip ${size} bytes, skipped ${totalSkipped} bytes`);
+		const chunk = getBuffer(value);
+		const needed = size - totalSkipped;
+		if (chunk.length <= needed) totalSkipped += chunk.length;
+		else {
+			var _iterator$return2;
+			await ((_iterator$return2 = iterator.return) === null || _iterator$return2 === void 0 ? void 0 : _iterator$return2.call(iterator, chunk.subarray(needed)));
+			totalSkipped = size;
+		}
+	}
 };
-const skipPaddingBytesTo512Boundary = async (iterator, contentSize, signal) => {
-  const padding = (512 - contentSize % 512) % 512;
-  if (padding > 0) {
-    await skipExactBytes(iterator, padding);
-  }
+var skipPaddingBytesTo512Boundary = async (iterator, contentSize, signal) => {
+	const padding = (512 - contentSize % 512) % 512;
+	if (padding > 0) await skipExactBytes(iterator, padding, signal);
 };
-const parseTarHeader = (buffer) => {
-  if (buffer.every((b) => b === 0)) {
-    return void 0;
-  }
-  const name2 = parseString(buffer, 0, 100);
-  const mode = parseOctalBytes(buffer, 100, 8);
-  const uid = parseOctalBytes(buffer, 108, 8);
-  const gid = parseOctalBytes(buffer, 116, 8);
-  const size = parseOctalBytes(buffer, 124, 12);
-  const mtime = new Date(parseOctalBytes(buffer, 136, 12) * 1e3);
-  const checksum = parseOctalBytes(buffer, 148, 8);
-  const typeflag = parseString(buffer, 156, 1);
-  const magic = parseString(buffer, 257, 6);
-  const uname = parseString(buffer, 265, 32);
-  const gname = parseString(buffer, 297, 32);
-  const prefix = parseString(buffer, 345, 155);
-  if (magic !== "ustar") {
-    throw new Error(`Invalid tar format: magic="${magic}"`);
-  }
-  let calculatedSum = 0;
-  for (let i = 0; i < 512; i++) {
-    if (i >= 148 && i < 156) {
-      calculatedSum += 32;
-    } else {
-      calculatedSum += buffer[i];
-    }
-  }
-  if (calculatedSum !== checksum) {
-    throw new Error(`Invalid checksum: expected ${checksum}, got ${calculatedSum}`);
-  }
-  let path = prefix ? `${prefix}/${name2}` : name2;
-  if (path.endsWith("/")) {
-    path = path.slice(0, -1);
-  }
-  const kind = typeflag === "5" ? "directory" : "file";
-  return {
-    kind,
-    path,
-    size,
-    mode,
-    uid,
-    gid,
-    mtime,
-    uname: uname || uid.toString(),
-    gname: gname || gid.toString(),
-    checksum,
-    consumed: false
-  };
+var parseTarHeader = (buffer) => {
+	if (buffer.every((b) => b === 0)) return;
+	const name = parseString(buffer, 0, 100);
+	const mode = parseOctalBytes(buffer, 100, 8);
+	const uid = parseOctalBytes(buffer, 108, 8);
+	const gid = parseOctalBytes(buffer, 116, 8);
+	const size = parseOctalBytes(buffer, 124, 12);
+	const mtime = /* @__PURE__ */ new Date(parseOctalBytes(buffer, 136, 12) * 1e3);
+	const checksum = parseOctalBytes(buffer, 148, 8);
+	const typeflag = parseString(buffer, 156, 1);
+	const magic = parseString(buffer, 257, 6);
+	const uname = parseString(buffer, 265, 32);
+	const gname = parseString(buffer, 297, 32);
+	const prefix = parseString(buffer, 345, 155);
+	if (magic !== "ustar") throw new Error(`Invalid tar format: magic="${magic}"`);
+	let calculatedSum = 0;
+	for (let i = 0; i < 512; i++) if (i >= 148 && i < 156) calculatedSum += 32;
+	else calculatedSum += buffer[i];
+	if (calculatedSum !== checksum) throw new Error(`Invalid checksum: expected ${checksum}, got ${calculatedSum}`);
+	let path = prefix ? `${prefix}/${name}` : name;
+	if (path.endsWith("/")) path = path.slice(0, -1);
+	return {
+		kind: typeflag === "5" ? "directory" : "file",
+		path,
+		size,
+		mode,
+		uid,
+		gid,
+		mtime,
+		uname: uname || uid.toString(),
+		gname: gname || gid.toString(),
+		checksum,
+		consumed: false
+	};
 };
-const createBufferedAsyncIterator = (iterable, signal) => {
-  const buffer = [];
-  const iterator = iterable[Symbol.asyncIterator]();
-  return {
-    next: async () => {
-      if (buffer.length > 0) {
-        return { value: buffer.shift(), done: false };
-      }
-      return iterator.next();
-    },
-    return: async (value) => {
-      if (value !== void 0) {
-        buffer.unshift(value);
-      }
-      return { value: void 0, done: false };
-    }
-  };
+var createBufferedAsyncIterator = (iterable, signal) => {
+	const buffer = [];
+	const iterator = iterable[Symbol.asyncIterator]();
+	return {
+		next: async () => {
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			if (buffer.length > 0) return {
+				value: buffer.shift(),
+				done: false
+			};
+			return iterator.next();
+		},
+		return: async (value) => {
+			if (value !== void 0) buffer.unshift(value);
+			return {
+				value: void 0,
+				done: false
+			};
+		}
+	};
 };
-const createReadableFromIterator = (iterator, size, signal, consumedRef) => {
-  const generator = async function* () {
-    var _a;
-    let remainingBytes = size;
-    while (remainingBytes > 0) {
-      const { value, done } = await iterator.next();
-      if (done) {
-        throw new Error(`Unexpected end of stream: expected ${size} bytes, remaining ${remainingBytes} bytes`);
-      }
-      const chunk = getBuffer(value);
-      if (chunk.length <= remainingBytes) {
-        remainingBytes -= chunk.length;
-        yield chunk;
-      } else {
-        const needed = chunk.subarray(0, remainingBytes);
-        const excess = chunk.subarray(remainingBytes);
-        remainingBytes = 0;
-        await ((_a = iterator.return) == null ? void 0 : _a.call(iterator, excess));
-        yield needed;
-        break;
-      }
-    }
-    await skipPaddingBytesTo512Boundary(iterator, size);
-    consumedRef.consumed = true;
-  };
-  return Readable.from(generator(), { signal });
+var createReadableFromIterator = (iterator, size, signal, consumedRef) => {
+	const generator = async function* () {
+		let remainingBytes = size;
+		while (remainingBytes > 0) {
+			signal === null || signal === void 0 || signal.throwIfAborted();
+			const { value, done } = await iterator.next();
+			if (done) throw new Error(`Unexpected end of stream: expected ${size} bytes, remaining ${remainingBytes} bytes`);
+			const chunk = getBuffer(value);
+			if (chunk.length <= remainingBytes) {
+				remainingBytes -= chunk.length;
+				yield chunk;
+			} else {
+				var _iterator$return3;
+				const needed = chunk.subarray(0, remainingBytes);
+				const excess = chunk.subarray(remainingBytes);
+				remainingBytes = 0;
+				await ((_iterator$return3 = iterator.return) === null || _iterator$return3 === void 0 ? void 0 : _iterator$return3.call(iterator, excess));
+				yield needed;
+				break;
+			}
+		}
+		await skipPaddingBytesTo512Boundary(iterator, size, signal);
+		consumedRef.consumed = true;
+	};
+	return Readable.from(generator(), { signal });
 };
-const createTarExtractor = async function* (readable, compressionType, signal) {
-  const ct = compressionType;
-  let inputStream;
-  switch (ct) {
-    case "gzip":
-      const gunzip = createGunzip();
-      readable.pipe(gunzip);
-      inputStream = gunzip;
-      break;
-    case "none":
-    default:
-      inputStream = readable;
-      break;
-  }
-  const iterator = createBufferedAsyncIterator(inputStream);
-  let header;
-  while (true) {
-    if ((header == null ? void 0 : header.kind) === "file" && !header.consumed) {
-      await skipExactBytes(iterator, header.size);
-      await skipPaddingBytesTo512Boundary(iterator, header.size);
-      header.consumed = true;
-    }
-    let headerBuffer;
-    try {
-      headerBuffer = await readExactBytes(iterator, 512, signal);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Unexpected end of stream")) {
-        throw new Error("Invalid tar format: incomplete header");
-      }
-      throw error;
-    }
-    if (headerBuffer === void 0) {
-      break;
-    }
-    header = parseTarHeader(headerBuffer);
-    if (!header) {
-      const secondBlock = await readExactBytes(iterator, 512);
-      if (secondBlock === void 0 || secondBlock.every((b) => b === 0)) {
-        break;
-      }
-      throw new Error("Invalid tar format: expected terminator block");
-    }
-    if (header.kind === "directory") {
-      yield {
-        kind: "directory",
-        path: header.path,
-        mode: header.mode,
-        uid: header.uid,
-        gid: header.gid,
-        uname: header.uname,
-        gname: header.gname,
-        date: header.mtime
-      };
-    } else {
-      const currentHeader = header;
-      yield {
-        kind: "file",
-        path: currentHeader.path,
-        mode: currentHeader.mode,
-        uid: currentHeader.uid,
-        gid: currentHeader.gid,
-        uname: currentHeader.uname,
-        gname: currentHeader.gname,
-        date: currentHeader.mtime,
-        getContent: async (type) => {
-          if (currentHeader.consumed) {
-            throw new Error("Content has already been consumed. Multiple calls to getContent are not supported.");
-          }
-          switch (type) {
-            // For string
-            case "string": {
-              const dataBuffer = await readExactBytes(iterator, currentHeader.size);
-              if (dataBuffer === void 0) {
-                throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
-              }
-              await skipPaddingBytesTo512Boundary(iterator, currentHeader.size);
-              currentHeader.consumed = true;
-              return dataBuffer.toString("utf8");
-            }
-            // For buffer
-            case "buffer": {
-              const dataBuffer = await readExactBytes(iterator, currentHeader.size);
-              if (dataBuffer === void 0) {
-                throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
-              }
-              await skipPaddingBytesTo512Boundary(iterator, currentHeader.size);
-              currentHeader.consumed = true;
-              return dataBuffer;
-            }
-            // For Readble stream
-            case "readable": {
-              const readable2 = createReadableFromIterator(iterator, currentHeader.size, signal, currentHeader);
-              return readable2;
-            }
-            default:
-              throw new Error(`Unsupported content type: ${type}`);
-          }
-        }
-      };
-    }
-  }
+var createTarExtractor = async function* (readable, compressionType, signal) {
+	const ct = compressionType !== null && compressionType !== void 0 ? compressionType : "none";
+	let inputStream;
+	switch (ct) {
+		case "gzip":
+			const gunzip = createGunzip();
+			readable.pipe(gunzip);
+			inputStream = gunzip;
+			break;
+		default:
+			inputStream = readable;
+			break;
+	}
+	const iterator = createBufferedAsyncIterator(inputStream, signal);
+	let header;
+	while (true) {
+		signal === null || signal === void 0 || signal.throwIfAborted();
+		if ((header === null || header === void 0 ? void 0 : header.kind) === "file" && !header.consumed) {
+			await skipExactBytes(iterator, header.size, signal);
+			await skipPaddingBytesTo512Boundary(iterator, header.size, signal);
+			header.consumed = true;
+		}
+		let headerBuffer;
+		try {
+			headerBuffer = await readExactBytes(iterator, 512, signal);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("Unexpected end of stream")) throw new Error("Invalid tar format: incomplete header");
+			throw error;
+		}
+		if (headerBuffer === void 0) break;
+		header = parseTarHeader(headerBuffer);
+		if (!header) {
+			const secondBlock = await readExactBytes(iterator, 512, signal);
+			if (secondBlock === void 0 || secondBlock.every((b) => b === 0)) break;
+			throw new Error("Invalid tar format: expected terminator block");
+		}
+		if (header.kind === "directory") yield {
+			kind: "directory",
+			path: header.path,
+			mode: header.mode,
+			uid: header.uid,
+			gid: header.gid,
+			uname: header.uname,
+			gname: header.gname,
+			date: header.mtime
+		};
+		else {
+			const currentHeader = header;
+			yield {
+				kind: "file",
+				path: currentHeader.path,
+				mode: currentHeader.mode,
+				uid: currentHeader.uid,
+				gid: currentHeader.gid,
+				uname: currentHeader.uname,
+				gname: currentHeader.gname,
+				date: currentHeader.mtime,
+				getContent: async (type) => {
+					if (currentHeader.consumed) throw new Error("Content has already been consumed. Multiple calls to getContent are not supported.");
+					switch (type) {
+						case "string": {
+							const dataBuffer = await readExactBytes(iterator, currentHeader.size, signal);
+							if (dataBuffer === void 0) throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
+							await skipPaddingBytesTo512Boundary(iterator, currentHeader.size, signal);
+							currentHeader.consumed = true;
+							return dataBuffer.toString("utf8");
+						}
+						case "buffer": {
+							const dataBuffer = await readExactBytes(iterator, currentHeader.size, signal);
+							if (dataBuffer === void 0) throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
+							await skipPaddingBytesTo512Boundary(iterator, currentHeader.size, signal);
+							currentHeader.consumed = true;
+							return dataBuffer;
+						}
+						case "readable": return createReadableFromIterator(iterator, currentHeader.size, signal, currentHeader);
+						default: throw new Error(`Unsupported content type: ${type}`);
+					}
+				}
+			};
+		}
+	}
 };
-const JSON5 = __resolveDefaultExport(lib);
+var JSON5 = __resolveDefaultExport((/* @__PURE__ */ __toESM(require_dist(), 1)).default, false);
 globalThis.__screwUpIsInCJS_8e26734beef0 = false;
 function __resolveDefaultExport(module, isESM) {
-  const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_8e26734beef0 === true;
-  const maybe = module;
-  const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
-  const unwrapNamespaceDefault = (value) => {
-    if (!value || typeof value !== "object") {
-      return value;
-    }
-    const inner = value;
-    const isModule = inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module";
-    if (isModule && "default" in inner) {
-      return inner.default;
-    }
-    return value;
-  };
-  const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
-  if (__isInCJS) {
-    return hasDefault ? resolvedDefault != null ? resolvedDefault : module : module;
-  }
-  return hasDefault ? resolvedDefault != null ? resolvedDefault : module : module;
+	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_8e26734beef0 === true;
+	const maybe = module;
+	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+	const unwrapNamespaceDefault = (value) => {
+		if (!value || typeof value !== "object") return value;
+		const inner = value;
+		if ((inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module") && "default" in inner) return inner.default;
+		return value;
+	};
+	const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+	if (__isInCJS) return hasDefault ? resolvedDefault !== null && resolvedDefault !== void 0 ? resolvedDefault : module : module;
+	if (isESM) {
+		if (hasDefault) return resolvedDefault;
+		throw new Error("Default export not found.");
+	}
+	return hasDefault ? resolvedDefault !== null && resolvedDefault !== void 0 ? resolvedDefault : module : module;
 }
-const readPackageJsonFile = async (packageJsonPath) => {
-  const content = await readFile(packageJsonPath, "utf-8");
-  return JSON5.parse(content);
+var readPackageJsonFile = async (packageJsonPath) => {
+	const content = await readFile(packageJsonPath, "utf-8");
+	return JSON5.parse(content);
+};
+var dependencySectionKeys = new Set([
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+]);
+var clonePackageJson = (packageJson) => JSON5.parse(JSON.stringify(packageJson));
+var mergeResolvedPackageJson = (packedPackageJson, resolvedPackageJson) => {
+	const mergedPackageJson = clonePackageJson(packedPackageJson);
+	for (const [key, value] of Object.entries(resolvedPackageJson !== null && resolvedPackageJson !== void 0 ? resolvedPackageJson : {})) {
+		if (dependencySectionKeys.has(key)) continue;
+		mergedPackageJson[key] = value;
+	}
+	return mergedPackageJson;
+};
+var workspaceProtocolPrefix = "workspace:";
+var inferVersionPrefix = (dependencySpec) => {
+	if (dependencySpec.startsWith("^")) return "^";
+	if (dependencySpec.startsWith("~")) return "~";
+	return "";
 };
-const getFilesArray = (packageJson) => {
-  if (!packageJson || !Array.isArray(packageJson.files)) {
-    return void 0;
-  }
-  const entries = packageJson.files.filter(
-    (entry) => typeof entry === "string"
-  );
-  return entries.length > 0 ? entries : void 0;
+var looksLikeWorkspaceProtocolAlias = (rawSpecifier) => {
+	if (!rawSpecifier) return false;
+	if (rawSpecifier === "*" || rawSpecifier === "^" || rawSpecifier === "~" || rawSpecifier.startsWith("^") || rawSpecifier.startsWith("~") || /^[0-9]/.test(rawSpecifier)) return false;
+	return true;
 };
-const isGlobPattern = (pattern) => /[*?[\]{}()]/.test(pattern);
-const normalizeFilesPattern = (pattern, cwd) => {
-  const trimmed = pattern.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  const isNegated = trimmed.startsWith("!");
-  const raw = isNegated ? trimmed.slice(1) : trimmed;
-  if (!raw) {
-    return void 0;
-  }
-  if (isGlobPattern(raw)) {
-    return trimmed;
-  }
-  const fullPath = join(cwd, raw);
-  if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
-    const dirPattern = `${raw.replace(/\/+$/, "")}/**`;
-    return isNegated ? `!${dirPattern}` : dirPattern;
-  }
-  return trimmed;
+var parseWorkspaceProtocolDependencyReference = (dependencyName, workspaceProtocolSpecifier) => {
+	if (!workspaceProtocolSpecifier.startsWith(workspaceProtocolPrefix)) return;
+	const rawSpecifier = workspaceProtocolSpecifier.slice(10).trim();
+	if (!looksLikeWorkspaceProtocolAlias(rawSpecifier)) return {
+		targetPackageName: dependencyName,
+		alias: false
+	};
+	if (rawSpecifier.startsWith("@")) {
+		const secondAt = rawSpecifier.indexOf("@", 1);
+		const targetPackageName = secondAt >= 0 ? rawSpecifier.slice(0, secondAt) : rawSpecifier;
+		return {
+			targetPackageName,
+			alias: targetPackageName !== dependencyName
+		};
+	}
+	const atIndex = rawSpecifier.indexOf("@");
+	const targetPackageName = atIndex >= 0 ? rawSpecifier.slice(0, atIndex) : rawSpecifier;
+	return {
+		targetPackageName,
+		alias: targetPackageName !== dependencyName
+	};
 };
-const isSafeRelativePath = (value) => {
-  if (isAbsolute(value)) {
-    return false;
-  }
-  const segments = value.split(/[\\/]+/);
-  if (segments.some((segment) => segment === "..")) {
-    return false;
-  }
-  return true;
+var formatResolvedWorkspaceDependency = (packedDependencySpecifier, reference, sibling) => {
+	const aliasPrefix = `npm:${reference.targetPackageName}@`;
+	if (packedDependencySpecifier.startsWith(aliasPrefix)) return `${aliasPrefix}${inferVersionPrefix(packedDependencySpecifier.slice(aliasPrefix.length))}${sibling.version}`;
+	return `${inferVersionPrefix(packedDependencySpecifier)}${sibling.version}`;
 };
-const expandFilesPatterns = async (patterns, cwd) => {
-  const includePatterns = [];
-  const excludePatterns = [];
-  for (const pattern of patterns) {
-    const normalized = normalizeFilesPattern(pattern, cwd);
-    if (!normalized) {
-      continue;
-    }
-    if (normalized.startsWith("!")) {
-      excludePatterns.push(normalized.slice(1));
-    } else {
-      includePatterns.push(normalized);
-    }
-  }
-  const result = /* @__PURE__ */ new Set();
-  for (const pattern of includePatterns) {
-    const matches = await glob(pattern, { cwd, nodir: true });
-    for (const match of matches) {
-      if (isSafeRelativePath(match)) {
-        result.add(match);
-      }
-    }
-  }
-  for (const pattern of excludePatterns) {
-    const matches = await glob(pattern, { cwd, nodir: true });
-    for (const match of matches) {
-      result.delete(match);
-    }
-  }
-  return result;
+var replaceWorkspaceProtocolDependencies = (packageJson, resolvedPackageJson, siblings) => {
+	const modifiedPackageJson = clonePackageJson(packageJson);
+	for (const sectionKey of dependencySectionKeys) {
+		const modifiedSection = modifiedPackageJson[sectionKey];
+		const resolvedSection = resolvedPackageJson === null || resolvedPackageJson === void 0 ? void 0 : resolvedPackageJson[sectionKey];
+		if (!modifiedSection || typeof modifiedSection !== "object" || !resolvedSection || typeof resolvedSection !== "object") continue;
+		for (const [dependencyName, dependencySpecifier] of Object.entries(resolvedSection)) {
+			if (typeof dependencySpecifier !== "string") continue;
+			const reference = parseWorkspaceProtocolDependencyReference(dependencyName, dependencySpecifier);
+			if (!reference) continue;
+			const sibling = siblings.get(reference.targetPackageName);
+			const packedDependencySpecifier = modifiedSection[dependencyName];
+			if (!sibling || typeof packedDependencySpecifier !== "string") continue;
+			modifiedSection[dependencyName] = formatResolvedWorkspaceDependency(packedDependencySpecifier, reference, sibling);
+		}
+	}
+	return modifiedPackageJson;
 };
-const mergeFilesPatterns = (parentFiles, childFiles) => {
-  const merged = [];
-  if (parentFiles == null ? void 0 : parentFiles.length) {
-    merged.push(...parentFiles);
-  }
-  if (childFiles == null ? void 0 : childFiles.length) {
-    merged.push(...childFiles);
-  }
-  return merged.length > 0 ? merged : void 0;
+var getFilesArray = (packageJson) => {
+	if (!packageJson || !Array.isArray(packageJson.files)) return;
+	const entries = packageJson.files.filter((entry) => typeof entry === "string");
+	return entries.length > 0 ? entries : void 0;
 };
-const resolveWorkspaceFilesMerge = async (targetDir, logger2) => {
-  const workspaceRoot = await findWorkspaceRoot(targetDir, logger2);
-  if (!workspaceRoot) {
-    return void 0;
-  }
-  const rootPackagePath = join(workspaceRoot, "package.json");
-  const targetPackagePath = join(targetDir, "package.json");
-  if (resolve(rootPackagePath) === resolve(targetPackagePath)) {
-    return void 0;
-  }
-  const [rootPackageJson, childPackageJson] = await Promise.all([
-    readPackageJsonFile(rootPackagePath),
-    readPackageJsonFile(targetPackagePath)
-  ]);
-  const parentFiles = getFilesArray(rootPackageJson);
-  const childFiles = getFilesArray(childPackageJson);
-  const mergedFiles = mergeFilesPatterns(parentFiles, childFiles);
-  if (!parentFiles && !childFiles) {
-    return void 0;
-  }
-  return {
-    workspaceRoot,
-    parentFiles,
-    childFiles,
-    mergedFiles
-  };
+var isGlobPattern = (pattern) => /[*?[\]{}()]/.test(pattern);
+var normalizeFilesPattern = (pattern, cwd) => {
+	const trimmed = pattern.trim();
+	if (!trimmed) return;
+	const isNegated = trimmed.startsWith("!");
+	const raw = isNegated ? trimmed.slice(1) : trimmed;
+	if (!raw) return;
+	if (isGlobPattern(raw)) return trimmed;
+	const fullPath = join(cwd, raw);
+	if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
+		const dirPattern = `${raw.replace(/\/+$/, "")}/**`;
+		return isNegated ? `!${dirPattern}` : dirPattern;
+	}
+	return trimmed;
 };
-const runNpmPack = async (targetDir, packDestDir) => {
-  return new Promise((res, rej) => {
-    const npmProcess = spawn(
-      "npm",
-      ["pack", "--pack-destination", packDestDir],
-      {
-        cwd: targetDir,
-        stdio: ["ignore", "pipe", "pipe"]
-      }
-    );
-    let stdout = "";
-    let stderr = "";
-    npmProcess.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    npmProcess.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    npmProcess.on("close", (code) => {
-      if (code === 0) {
-        const lines = stdout.trim().split("\n");
-        const filename = lines.find((line) => line.trim().endsWith(".tgz")) || lines[lines.length - 1];
-        if (filename && filename.trim().endsWith(".tgz")) {
-          const fullPath = join(packDestDir, filename.trim());
-          res(fullPath);
-        } else {
-          rej(new Error("npm pack did not output a valid .tgz filename"));
-        }
-      } else {
-        const errorMessage = `npm pack failed with exit code ${code}`;
-        const fullError = stderr ? `${errorMessage}
-stderr: ${stderr}` : errorMessage;
-        if (stdout) {
-          rej(new Error(`${fullError}
-stdout: ${stdout}`));
-        } else {
-          rej(new Error(fullError));
-        }
-      }
-    });
-    npmProcess.on("error", (error) => {
-      rej(new Error(`Failed to spawn npm pack: ${error.message}`));
-    });
-  });
+var isSafeRelativePath = (value) => {
+	if (isAbsolute(value)) return false;
+	if (value.split(/[\\/]+/).some((segment) => segment === "..")) return false;
+	return true;
 };
-const packAssets = async (targetDir, outputDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, readmeReplacementPath, replacePeerDepsWildcards, peerDepsVersionPrefix, logger2, mergeFiles = true) => {
-  var _a, _b, _c, _d;
-  if (!existsSync(targetDir)) {
-    throw new Error(`Target directory is not found: ${targetDir}`);
-  }
-  let readmeReplacementCandidatePath = readmeReplacementPath;
-  if (readmeReplacementCandidatePath && !existsSync(readmeReplacementCandidatePath)) {
-    throw new Error(
-      `README replacement file is not found: ${readmeReplacementCandidatePath}`
-    );
-  }
-  const fetchGitMetadata = getFetchGitMetadata(
-    targetDir,
-    checkWorkingDirectoryStatus,
-    logger2
-  );
-  const result = await resolveRawPackageJsonObject(
-    targetDir,
-    fetchGitMetadata,
-    alwaysOverrideVersionFromGit,
-    inheritableFields,
-    logger2
-  );
-  let resolvedPackageJson = result.metadata;
-  if (resolvedPackageJson == null ? void 0 : resolvedPackageJson.private) {
-    return void 0;
-  }
-  const packageJsonReadme = resolvedPackageJson.readme;
-  if (packageJsonReadme) {
-    if (!readmeReplacementCandidatePath) {
-      const packageJsonReadmeDir = result.sourceMap.get("readme");
-      const packageJsonReadmePath = join(
-        packageJsonReadmeDir,
-        packageJsonReadme
-      );
-      if (!existsSync(packageJsonReadmePath)) {
-        throw new Error(
-          `README replacement file is not found: ${packageJsonReadmePath}`
-        );
-      }
-      readmeReplacementCandidatePath = packageJsonReadmePath;
-    }
-    delete resolvedPackageJson.readme;
-  }
-  if (replacePeerDepsWildcards) {
-    const workspaceRoot = await findWorkspaceRoot(targetDir, logger2);
-    if (workspaceRoot) {
-      const siblings = await collectWorkspaceSiblings(
-        workspaceRoot,
-        fetchGitMetadata,
-        alwaysOverrideVersionFromGit,
-        inheritableFields,
-        logger2
-      );
-      if (siblings.size > 0) {
-        resolvedPackageJson = replacePeerDependenciesWildcards(
-          resolvedPackageJson,
-          siblings,
-          peerDepsVersionPrefix
-        );
-      }
-    }
-  }
-  const filesMergeEnabled = mergeFiles && inheritableFields.has("files");
-  const workspaceFilesMerge = filesMergeEnabled ? await resolveWorkspaceFilesMerge(targetDir, logger2) : void 0;
-  if (filesMergeEnabled && (workspaceFilesMerge == null ? void 0 : workspaceFilesMerge.mergedFiles)) {
-    resolvedPackageJson.files = workspaceFilesMerge.mergedFiles;
-  }
-  const baseTempDir = await mkdtemp(join(tmpdir(), "screw-up-npm-pack-"));
-  await mkdir(baseTempDir, { recursive: true });
-  try {
-    const npmTarballPath = await runNpmPack(targetDir, baseTempDir);
-    const stagingDir = join(baseTempDir, "staging");
-    await mkdir(stagingDir, { recursive: true });
-    const stream = createReadStream(npmTarballPath);
-    await extractTo(createTarExtractor(stream, "gzip"), stagingDir);
-    const packageRoot = join(stagingDir, "package");
-    if (filesMergeEnabled && ((_a = workspaceFilesMerge == null ? void 0 : workspaceFilesMerge.parentFiles) == null ? void 0 : _a.length)) {
-      const parentFiles = await expandFilesPatterns(
-        workspaceFilesMerge.parentFiles,
-        workspaceFilesMerge.workspaceRoot
-      );
-      for (const parentFile of parentFiles) {
-        const destPath = join(packageRoot, parentFile);
-        if (existsSync(destPath)) {
-          continue;
-        }
-        await mkdir(dirname(destPath), { recursive: true });
-        await copyFile(
-          join(workspaceFilesMerge.workspaceRoot, parentFile),
-          destPath
-        );
-      }
-    }
-    const packageJsonPath = join(packageRoot, "package.json");
-    if (existsSync(packageJsonPath)) {
-      await writeFile(
-        packageJsonPath,
-        JSON.stringify(resolvedPackageJson, null, 2)
-      );
-    }
-    if (readmeReplacementCandidatePath) {
-      const readmeDestPath = join(packageRoot, "README.md");
-      await copyFile(readmeReplacementCandidatePath, readmeDestPath);
-    }
-    const outputFileName = `${(_c = (_b = resolvedPackageJson == null ? void 0 : resolvedPackageJson.name) == null ? void 0 : _b.replace("/", "-")) != null ? _c : "package"}-${(_d = resolvedPackageJson == null ? void 0 : resolvedPackageJson.version) != null ? _d : "0.0.0"}.tgz`;
-    await mkdir(outputDir, { recursive: true });
-    const outputFile = join(outputDir, outputFileName);
-    const itemGenerator = createEntryItemGenerator(stagingDir);
-    const packer = createTarPacker(itemGenerator, "gzip");
-    await storeReaderToFile(packer, outputFile);
-    return {
-      packageFileName: outputFileName,
-      metadata: resolvedPackageJson
-    };
-  } finally {
-    await rm(baseTempDir, { recursive: true, force: true });
-  }
+var expandFilesPatterns = async (patterns, cwd) => {
+	const includePatterns = [];
+	const excludePatterns = [];
+	for (const pattern of patterns) {
+		const normalized = normalizeFilesPattern(pattern, cwd);
+		if (!normalized) continue;
+		if (normalized.startsWith("!")) excludePatterns.push(normalized.slice(1));
+		else includePatterns.push(normalized);
+	}
+	const result = /* @__PURE__ */ new Set();
+	for (const pattern of includePatterns) {
+		const matches = await glob(pattern, {
+			cwd,
+			nodir: true
+		});
+		for (const match of matches) if (isSafeRelativePath(match)) result.add(match);
+	}
+	for (const pattern of excludePatterns) {
+		const matches = await glob(pattern, {
+			cwd,
+			nodir: true
+		});
+		for (const match of matches) result.delete(match);
+	}
+	return result;
 };
-const getComputedPackageJsonObject = async (targetDir, fetchGitMetadata, alwaysOverrideVersionFromGit, inheritableFields, logger2, ignoreNotExist = false) => {
-  if (!existsSync(targetDir)) {
-    return void 0;
-  }
-  const result = await resolveRawPackageJsonObject(
-    targetDir,
-    fetchGitMetadata,
-    alwaysOverrideVersionFromGit,
-    inheritableFields,
-    logger2,
-    ignoreNotExist
-  );
-  return result.metadata;
+var mergeFilesPatterns = (parentFiles, childFiles) => {
+	const merged = [];
+	if (parentFiles === null || parentFiles === void 0 ? void 0 : parentFiles.length) merged.push(...parentFiles);
+	if (childFiles === null || childFiles === void 0 ? void 0 : childFiles.length) merged.push(...childFiles);
+	return merged.length > 0 ? merged : void 0;
 };
-const parseArgs = (args, argOptionMap2) => {
-  const result = {
-    argv: args,
-    positional: [],
-    options: {}
-  };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const optionName = arg.slice(2);
-      if (!result.command) {
-        result.options[optionName] = true;
-      } else {
-        const argOptions = argOptionMap2.get(result.command);
-        if (argOptions == null ? void 0 : argOptions.has(optionName)) {
-          i++;
-          result.options[optionName] = args[i];
-        } else {
-          result.options[optionName] = true;
-        }
-      }
-    } else if (arg.startsWith("-")) {
-      const optionName = arg.slice(1);
-      if (optionName.length == 1) {
-        const argOptions = result.command ? argOptionMap2.get(result.command) : void 0;
-        if (argOptions == null ? void 0 : argOptions.has(optionName)) {
-          i++;
-          result.options[optionName] = args[i];
-        } else {
-          result.options[optionName] = true;
-        }
-      }
-    } else if (!result.command) {
-      result.command = arg;
-    } else {
-      result.positional.push(arg);
-    }
-  }
-  return result;
+var resolveWorkspaceFilesMerge = async (targetDir, logger) => {
+	const workspaceRoot = await findWorkspaceRoot(targetDir, logger);
+	if (!workspaceRoot) return;
+	const rootPackagePath = join(workspaceRoot, "package.json");
+	const targetPackagePath = join(targetDir, "package.json");
+	if (resolve(rootPackagePath) === resolve(targetPackagePath)) return;
+	const [rootPackageJson, childPackageJson] = await Promise.all([readPackageJsonFile(rootPackagePath), readPackageJsonFile(targetPackagePath)]);
+	const parentFiles = getFilesArray(rootPackageJson);
+	const childFiles = getFilesArray(childPackageJson);
+	const mergedFiles = mergeFilesPatterns(parentFiles, childFiles);
+	if (!parentFiles && !childFiles) return;
+	return {
+		workspaceRoot,
+		parentFiles,
+		childFiles,
+		mergedFiles
+	};
 };
-const defaultInheritableFields = /* @__PURE__ */ new Set([
-  "version",
-  "description",
-  "author",
-  "license",
-  "repository",
-  "keywords",
-  "homepage",
-  "bugs",
-  "readme",
-  "files"
+var readPackResultPath = (packageManager, packDestDir, stdout) => {
+	if (packageManager === "pnpm") {
+		const parsed = JSON5.parse(stdout);
+		const packResult = Array.isArray(parsed) ? parsed[0] : parsed;
+		if (!(packResult === null || packResult === void 0 ? void 0 : packResult.filename) || typeof packResult.filename !== "string") throw new Error("pnpm pack did not output a valid filename");
+		return isAbsolute(packResult.filename) ? packResult.filename : join(packDestDir, packResult.filename);
+	}
+	const lines = stdout.trim().split("\n");
+	const filename = lines.find((line) => line.trim().endsWith(".tgz")) || lines[lines.length - 1];
+	if (!filename || !filename.trim().endsWith(".tgz")) throw new Error("npm pack did not output a valid .tgz filename");
+	return join(packDestDir, filename.trim());
+};
+/**
+* Execute package manager pack and return the generated tarball path
+* @param packageManager - Package manager to use
+* @param targetDir - Target directory to pack
+* @param packDestDir - Directory to store the generated tarball (must exist)
+* @returns Path to generated tarball
+*/
+var runPack = async (packageManager, targetDir, packDestDir) => {
+	const packArgs = packageManager === "pnpm" ? [
+		"pack",
+		"--json",
+		"--pack-destination",
+		packDestDir
+	] : [
+		"pack",
+		"--pack-destination",
+		packDestDir
+	];
+	return new Promise((res, rej) => {
+		const packProcess = spawn(packageManager, packArgs, {
+			cwd: targetDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		packProcess.stdout.on("data", (data) => {
+			stdout += data.toString();
+		});
+		packProcess.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+		packProcess.on("close", (code) => {
+			if (code === 0) try {
+				res(readPackResultPath(packageManager, packDestDir, stdout.trim()));
+			} catch (error) {
+				rej(error);
+			}
+			else {
+				const errorMessage = `${packageManager} pack failed with exit code ${code}`;
+				const fullError = stderr ? `${errorMessage}\nstderr: ${stderr}` : errorMessage;
+				if (stdout) rej(/* @__PURE__ */ new Error(`${fullError}\nstdout: ${stdout}`));
+				else rej(new Error(fullError));
+			}
+		});
+		packProcess.on("error", (error) => {
+			rej(/* @__PURE__ */ new Error(`Failed to spawn ${packageManager} pack: ${error.message}`));
+		});
+	});
+};
+/**
+* Pack assets using npm pack delegation method
+* @param targetDir - Target directory to pack
+* @param outputDir - Output directory to write the tarball
+* @param checkWorkingDirectoryStatus - Check working directory status
+* @param inheritableFields - Package metadata fields that should be inherited from parent
+* @param readmeReplacementPath - Optional path to replacement README file
+* @param replacePeerDepsWildcards - Replace "*" in peerDependencies with actual versions
+* @param peerDepsVersionPrefix - Version prefix for replaced peerDependencies
+* @param alwaysOverrideVersionFromGit - Always override version from Git (default: true)
+* @param packageManager - Package manager backend used for the initial pack
+* @returns Package metadata (package.json) or undefined if failed
+*/
+var packAssets = async (targetDir, outputDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, readmeReplacementPath, replacePeerDepsWildcards, peerDepsVersionPrefix, logger, mergeFiles = true, packageManager = "npm") => {
+	if (!existsSync(targetDir)) throw new Error(`Target directory is not found: ${targetDir}`);
+	let readmeReplacementCandidatePath = readmeReplacementPath;
+	if (readmeReplacementCandidatePath && !existsSync(readmeReplacementCandidatePath)) throw new Error(`README replacement file is not found: ${readmeReplacementCandidatePath}`);
+	const fetchGitMetadata = getFetchGitMetadata(targetDir, checkWorkingDirectoryStatus, logger);
+	const result = await resolveRawPackageJsonObject(targetDir, fetchGitMetadata, alwaysOverrideVersionFromGit, inheritableFields, logger);
+	let resolvedPackageJson = result.metadata;
+	if (resolvedPackageJson === null || resolvedPackageJson === void 0 ? void 0 : resolvedPackageJson.private) return;
+	const packageJsonReadme = resolvedPackageJson.readme;
+	if (packageJsonReadme) {
+		if (!readmeReplacementCandidatePath) {
+			const packageJsonReadmeDir = result.sourceMap.get("readme");
+			if (!packageJsonReadmeDir) throw new Error(`README replacement source directory is unknown: ${packageJsonReadme}`);
+			const packageJsonReadmePath = join(packageJsonReadmeDir, packageJsonReadme);
+			if (!existsSync(packageJsonReadmePath)) throw new Error(`README replacement file is not found: ${packageJsonReadmePath}`);
+			readmeReplacementCandidatePath = packageJsonReadmePath;
+		}
+		delete resolvedPackageJson.readme;
+	}
+	const workspaceRoot = replacePeerDepsWildcards || packageManager === "pnpm" ? await findWorkspaceRoot(targetDir, logger) : void 0;
+	const workspaceSiblings = workspaceRoot ? await collectWorkspaceSiblings(workspaceRoot, fetchGitMetadata, alwaysOverrideVersionFromGit, inheritableFields, logger) : void 0;
+	const filesMergeEnabled = mergeFiles && inheritableFields.has("files");
+	const workspaceFilesMerge = filesMergeEnabled ? await resolveWorkspaceFilesMerge(targetDir, logger) : void 0;
+	if (filesMergeEnabled && (workspaceFilesMerge === null || workspaceFilesMerge === void 0 ? void 0 : workspaceFilesMerge.mergedFiles)) resolvedPackageJson.files = workspaceFilesMerge.mergedFiles;
+	const baseTempDir = await mkdtemp(join(tmpdir(), "screw-up-npm-pack-"));
+	await mkdir(baseTempDir, { recursive: true });
+	try {
+		var _workspaceFilesMerge$, _finalPackageJson$nam, _finalPackageJson$nam2, _finalPackageJson$ver;
+		const packedTarballPath = await runPack(packageManager, targetDir, baseTempDir);
+		const stagingDir = join(baseTempDir, "staging");
+		await mkdir(stagingDir, { recursive: true });
+		await extractTo(createTarExtractor(createReadStream(packedTarballPath), "gzip"), stagingDir);
+		const packageRoot = join(stagingDir, "package");
+		if (filesMergeEnabled && (workspaceFilesMerge === null || workspaceFilesMerge === void 0 || (_workspaceFilesMerge$ = workspaceFilesMerge.parentFiles) === null || _workspaceFilesMerge$ === void 0 ? void 0 : _workspaceFilesMerge$.length)) {
+			const parentFiles = await expandFilesPatterns(workspaceFilesMerge.parentFiles, workspaceFilesMerge.workspaceRoot);
+			for (const parentFile of parentFiles) {
+				const destPath = join(packageRoot, parentFile);
+				if (existsSync(destPath)) continue;
+				await mkdir(dirname(destPath), { recursive: true });
+				await copyFile(join(workspaceFilesMerge.workspaceRoot, parentFile), destPath);
+			}
+		}
+		const packageJsonPath = join(packageRoot, "package.json");
+		let finalPackageJson = resolvedPackageJson;
+		if (existsSync(packageJsonPath)) {
+			finalPackageJson = mergeResolvedPackageJson(await readPackageJsonFile(packageJsonPath), resolvedPackageJson);
+			if (packageManager === "pnpm" && (workspaceSiblings === null || workspaceSiblings === void 0 ? void 0 : workspaceSiblings.size)) finalPackageJson = replaceWorkspaceProtocolDependencies(finalPackageJson, resolvedPackageJson, workspaceSiblings);
+			if (workspaceSiblings && workspaceSiblings.size > 0) finalPackageJson = replacePeerDependenciesWildcards(finalPackageJson, workspaceSiblings, peerDepsVersionPrefix);
+			if (packageJsonReadme) delete finalPackageJson.readme;
+			await writeFile(packageJsonPath, JSON.stringify(finalPackageJson, null, 2));
+		}
+		if (readmeReplacementCandidatePath) {
+			const readmeDestPath = join(packageRoot, "README.md");
+			await copyFile(readmeReplacementCandidatePath, readmeDestPath);
+		}
+		const outputFileName = `${(_finalPackageJson$nam = finalPackageJson === null || finalPackageJson === void 0 || (_finalPackageJson$nam2 = finalPackageJson.name) === null || _finalPackageJson$nam2 === void 0 ? void 0 : _finalPackageJson$nam2.replace("/", "-")) !== null && _finalPackageJson$nam !== void 0 ? _finalPackageJson$nam : "package"}-${(_finalPackageJson$ver = finalPackageJson === null || finalPackageJson === void 0 ? void 0 : finalPackageJson.version) !== null && _finalPackageJson$ver !== void 0 ? _finalPackageJson$ver : "0.0.0"}.tgz`;
+		await mkdir(outputDir, { recursive: true });
+		const outputFile = join(outputDir, outputFileName);
+		await storeReaderToFile(createTarPacker(createEntryItemGenerator(stagingDir), "gzip"), outputFile);
+		return {
+			packageFileName: outputFileName,
+			metadata: finalPackageJson
+		};
+	} finally {
+		await rm(baseTempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+/**
+* Get computed package.json object
+* @param targetDir - Target directory to resolve package metadata
+* @param fetchGitMetadata - Git metadata fetcher
+* @param inheritableFields - Package metadata fields that should be inherited from parent
+* @returns Computed package.json object or undefined if failed
+*/
+var getComputedPackageJsonObject = async (targetDir, fetchGitMetadata, alwaysOverrideVersionFromGit, inheritableFields, logger, ignoreNotExist = false) => {
+	if (!existsSync(targetDir)) return;
+	return (await resolveRawPackageJsonObject(targetDir, fetchGitMetadata, alwaysOverrideVersionFromGit, inheritableFields, logger, ignoreNotExist)).metadata;
+};
+/**
+* Parse command line arguments
+* @param args - Command line arguments
+* @param argOptionMap - Map of command options to their argument options
+* @returns Parsed arguments
+*/
+var parseArgs = (args, argOptionMap) => {
+	const result = {
+		argv: args,
+		positional: [],
+		options: {}
+	};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const optionName = arg.slice(2);
+			if (!result.command) result.options[optionName] = true;
+			else {
+				const argOptions = argOptionMap.get(result.command);
+				if (argOptions === null || argOptions === void 0 ? void 0 : argOptions.has(optionName)) {
+					i++;
+					result.options[optionName] = args[i];
+				} else result.options[optionName] = true;
+			}
+		} else if (arg.startsWith("-")) {
+			const optionName = arg.slice(1);
+			if (optionName.length == 1) {
+				const argOptions = result.command ? argOptionMap.get(result.command) : void 0;
+				if (argOptions === null || argOptions === void 0 ? void 0 : argOptions.has(optionName)) {
+					i++;
+					result.options[optionName] = args[i];
+				} else result.options[optionName] = true;
+			}
+		} else if (!result.command) result.command = arg;
+		else result.positional.push(arg);
+	}
+	return result;
+};
+//#endregion
+//#region src/cli.ts
+var defaultInheritableFields = new Set([
+	"version",
+	"description",
+	"author",
+	"license",
+	"repository",
+	"keywords",
+	"homepage",
+	"bugs",
+	"readme",
+	"files"
 ]);
-const defaultOutputMetadataKeys = [
-  "name",
-  "version",
-  "description",
-  "author",
-  "license",
-  "repository.url",
-  "git.commit.hash"
+var defaultOutputMetadataKeys = [
+	"name",
+	"version",
+	"description",
+	"author",
+	"license",
+	"repository.url",
+	"git.commit.hash"
 ];
-const parseInheritableFields = (inheritableFieldsOption) => {
-  if (typeof inheritableFieldsOption !== "string") {
-    return defaultInheritableFields;
-  }
-  if (!inheritableFieldsOption.trim()) {
-    return /* @__PURE__ */ new Set();
-  }
-  return new Set(
-    inheritableFieldsOption.split(",").map((field) => field.trim()).filter((field) => field.length > 0)
-  );
+var parseInheritableFields = (inheritableFieldsOption) => {
+	if (typeof inheritableFieldsOption !== "string") return defaultInheritableFields;
+	if (!inheritableFieldsOption.trim()) return /* @__PURE__ */ new Set();
+	return new Set(inheritableFieldsOption.split(",").map((field) => field.trim()).filter((field) => field.length > 0));
 };
-const parseOutputMetadataKeys = (outputMetadataKeysOption) => {
-  if (typeof outputMetadataKeysOption !== "string") {
-    return defaultOutputMetadataKeys;
-  }
-  if (!outputMetadataKeysOption.trim()) {
-    return [];
-  }
-  return outputMetadataKeysOption.split(",").map((key) => key.trim()).filter((key) => key.length > 0);
+var parseOutputMetadataKeys = (outputMetadataKeysOption) => {
+	if (typeof outputMetadataKeysOption !== "string") return defaultOutputMetadataKeys;
+	if (!outputMetadataKeysOption.trim()) return [];
+	return outputMetadataKeysOption.split(",").map((key) => key.trim()).filter((key) => key.length > 0);
 };
-const readInputText = async (inputPath) => {
-  if (inputPath) {
-    const resolvedPath = resolve(inputPath);
-    return await readFile(resolvedPath, "utf-8");
-  }
-  return await new Promise((resolvePromise, rejectPromise) => {
-    let data = "";
-    process.stdin.setEncoding("utf-8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => resolvePromise(data));
-    process.stdin.on("error", (err) => rejectPromise(err));
-  });
+var readInputText = async (inputPath) => {
+	if (inputPath) return await readFile(resolve(inputPath), "utf-8");
+	return await new Promise((resolvePromise, rejectPromise) => {
+		let data = "";
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("data", (chunk) => {
+			data += chunk;
+		});
+		process.stdin.on("end", () => resolvePromise(data));
+		process.stdin.on("error", (err) => rejectPromise(err));
+	});
 };
-const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const getValueByPath = (source, path) => {
-  return path.split(".").reduce((current, key) => {
-    if (current === void 0 || current === null) {
-      return void 0;
-    }
-    if (typeof current !== "object" && !Array.isArray(current)) {
-      return void 0;
-    }
-    return current[key];
-  }, source);
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var getValueByPath = (source, path) => {
+	return path.split(".").reduce((current, key) => {
+		if (current === void 0 || current === null) return;
+		if (typeof current !== "object" && !Array.isArray(current)) return;
+		return current[key];
+	}, source);
 };
-const stringifyValue = (value) => {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "object") {
-    try {
-      return JSON.stringify(value);
-    } catch (e) {
-      return String(value);
-    }
-  }
-  return String(value);
+var stringifyValue = (value) => {
+	if (value === void 0) return;
+	if (value === null) return "null";
+	if (typeof value === "object") try {
+		return JSON.stringify(value);
+	} catch (_unused) {
+		return String(value);
+	}
+	return String(value);
 };
-const replacePlaceholders = (text, values, openBracket, closeBracket) => {
-  const pattern = new RegExp(
-    `${escapeRegExp(openBracket)}(.*?)${escapeRegExp(closeBracket)}`,
-    "g"
-  );
-  return text.replace(pattern, (match, key) => {
-    const trimmedKey = String(key).trim();
-    const resolvedValue = stringifyValue(getValueByPath(values, trimmedKey));
-    return resolvedValue !== void 0 ? resolvedValue : match;
-  });
+var replacePlaceholders = (text, values, openBracket, closeBracket) => {
+	const pattern = new RegExp(`${escapeRegExp(openBracket)}(.*?)${escapeRegExp(closeBracket)}`, "g");
+	return text.replace(pattern, (match, key) => {
+		const resolvedValue = stringifyValue(getValueByPath(values, String(key).trim()));
+		return resolvedValue !== void 0 ? resolvedValue : match;
+	});
 };
-const showFormatHelp = () => {
-  console.info(`Usage: screw-up format [options] [output]
+var showFormatHelp = () => {
+	console.info(`Usage: screw-up format [options] [output]
 
 Format input text by replacing placeholders with package metadata
 
@@ -1101,95 +1000,65 @@ Options:
   -h, --help                    Show help for format command
 `);
 };
-const parseBracketOption = (bracketOption) => {
-  if (!bracketOption) {
-    return { openBracket: "{", closeBracket: "}" };
-  }
-  const delimiterIndex = bracketOption.indexOf(",");
-  if (delimiterIndex === -1) {
-    return void 0;
-  }
-  const openBracket = bracketOption.slice(0, delimiterIndex);
-  const closeBracket = bracketOption.slice(delimiterIndex + 1);
-  if (!openBracket || !closeBracket) {
-    return void 0;
-  }
-  return { openBracket, closeBracket };
+var parseBracketOption = (bracketOption) => {
+	if (!bracketOption) return {
+		openBracket: "{",
+		closeBracket: "}"
+	};
+	const delimiterIndex = bracketOption.indexOf(",");
+	if (delimiterIndex === -1) return;
+	const openBracket = bracketOption.slice(0, delimiterIndex);
+	const closeBracket = bracketOption.slice(delimiterIndex + 1);
+	if (!openBracket || !closeBracket) return;
+	return {
+		openBracket,
+		closeBracket
+	};
 };
-const formatCommand = async (args, logger2) => {
-  var _a, _b;
-  if (args.options.help || args.options.h) {
-    showFormatHelp();
-    return 1;
-  }
-  const outputPath = args.positional[0];
-  const inputPathOption = (_a = args.options["input"]) != null ? _a : args.options["i"];
-  const bracketOption = (_b = args.options["bracket"]) != null ? _b : args.options["b"];
-  const inheritableFieldsOption = args.options["inheritable-fields"];
-  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
-  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
-  const ignorePackageJsonNotExist = args.options["force"] || args.options["f"] ? true : false;
-  const bracket = parseBracketOption(
-    typeof bracketOption === "string" ? bracketOption : void 0
-  );
-  if (!bracket) {
-    logger2.error(
-      'format: Invalid bracket option, expected "open,close" pattern.'
-    );
-    return 1;
-  }
-  const { openBracket, closeBracket } = bracket;
-  const targetDir = resolve(process.cwd());
-  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
-  const _logger = {
-    debug: (msg) => {
-    },
-    info: (msg) => {
-    },
-    warn: (msg) => {
-    },
-    error: logger2.error
-  };
-  try {
-    const fetchGitMetadata = getFetchGitMetadata(
-      targetDir,
-      checkWorkingDirectoryStatus,
-      _logger
-    );
-    const computedPackageJson = await getComputedPackageJsonObject(
-      targetDir,
-      fetchGitMetadata,
-      alwaysOverrideVersionFromGit,
-      inheritableFields,
-      _logger,
-      ignorePackageJsonNotExist
-    );
-    if (!computedPackageJson) {
-      _logger.error(`format: Unable to read package.json from: ${targetDir}`);
-      return 1;
-    }
-    const inputText = await readInputText(
-      typeof inputPathOption === "string" ? inputPathOption : void 0
-    );
-    const formattedText = replacePlaceholders(
-      inputText,
-      computedPackageJson,
-      openBracket,
-      closeBracket
-    );
-    if (outputPath) {
-      const resolvedOutputPath = resolve(outputPath);
-      await writeFile(resolvedOutputPath, formattedText);
-    }
-    process.stdout.write(formattedText);
-  } catch (error) {
-    _logger.error(`format: Failed to format text: ${error}`);
-    return 1;
-  }
-  return 0;
+var formatCommand = async (args, logger) => {
+	var _args$options$input, _args$options$bracket;
+	if (args.options.help || args.options.h) {
+		showFormatHelp();
+		return 1;
+	}
+	const outputPath = args.positional[0];
+	const inputPathOption = (_args$options$input = args.options["input"]) !== null && _args$options$input !== void 0 ? _args$options$input : args.options["i"];
+	const bracketOption = (_args$options$bracket = args.options["bracket"]) !== null && _args$options$bracket !== void 0 ? _args$options$bracket : args.options["b"];
+	const inheritableFieldsOption = args.options["inheritable-fields"];
+	const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+	const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+	const ignorePackageJsonNotExist = args.options["force"] || args.options["f"] ? true : false;
+	const bracket = parseBracketOption(typeof bracketOption === "string" ? bracketOption : void 0);
+	if (!bracket) {
+		logger.error("format: Invalid bracket option, expected \"open,close\" pattern.");
+		return 1;
+	}
+	const { openBracket, closeBracket } = bracket;
+	const targetDir = resolve(process.cwd());
+	const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+	const _logger = {
+		debug: (msg) => {},
+		info: (msg) => {},
+		warn: (msg) => {},
+		error: logger.error
+	};
+	try {
+		const computedPackageJson = await getComputedPackageJsonObject(targetDir, getFetchGitMetadata(targetDir, checkWorkingDirectoryStatus, _logger), alwaysOverrideVersionFromGit, inheritableFields, _logger, ignorePackageJsonNotExist);
+		if (!computedPackageJson) {
+			_logger.error(`format: Unable to read package.json from: ${targetDir}`);
+			return 1;
+		}
+		const formattedText = replacePlaceholders(await readInputText(typeof inputPathOption === "string" ? inputPathOption : void 0), computedPackageJson, openBracket, closeBracket);
+		if (outputPath) await writeFile(resolve(outputPath), formattedText);
+		process.stdout.write(formattedText);
+	} catch (error) {
+		_logger.error(`format: Failed to format text: ${error}`);
+		return 1;
+	}
+	return 0;
 };
-const showDumpHelp = () => {
-  console.info(`Usage: screw-up dump [options] [directory]
+var showDumpHelp = () => {
+	console.info(`Usage: screw-up dump [options] [directory]
 
 Dump computed package.json as JSON
 
@@ -1205,65 +1074,45 @@ Options:
   -h, --help                    Show help for dump command
 `);
 };
-const dumpCommand = async (args, logger2) => {
-  if (args.options.help || args.options.h) {
-    showDumpHelp();
-    return 1;
-  }
-  const directory = args.positional[0];
-  const inheritableFieldsOption = args.options["inheritable-fields"];
-  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
-  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
-  const mergeFiles = !args.options["no-merge-files"];
-  const ignorePackageJsonNotExist = args.options["force"] || args.options["f"] ? true : false;
-  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
-  const targetDir = resolve(directory != null ? directory : process.cwd());
-  const _logger = {
-    debug: (msg) => {
-    },
-    info: (msg) => {
-    },
-    warn: (msg) => {
-    },
-    error: logger2.error
-  };
-  try {
-    const fetchGitMetadata = getFetchGitMetadata(
-      targetDir,
-      checkWorkingDirectoryStatus,
-      _logger
-    );
-    const computedPackageJson = await getComputedPackageJsonObject(
-      targetDir,
-      fetchGitMetadata,
-      alwaysOverrideVersionFromGit,
-      inheritableFields,
-      _logger,
-      ignorePackageJsonNotExist
-    );
-    if (computedPackageJson) {
-      if (mergeFiles && inheritableFields.has("files") && existsSync(join(targetDir, "package.json"))) {
-        const workspaceFilesMerge = await resolveWorkspaceFilesMerge(
-          targetDir,
-          _logger
-        );
-        if (workspaceFilesMerge == null ? void 0 : workspaceFilesMerge.mergedFiles) {
-          computedPackageJson.files = workspaceFilesMerge.mergedFiles;
-        }
-      }
-      console.info(JSON.stringify(computedPackageJson, null, 2));
-    } else {
-      _logger.error(`dump: Unable to read package.json from: ${targetDir}`);
-      return 1;
-    }
-  } catch (error) {
-    _logger.error(`dump: Failed to dump package.json: ${error}`);
-    return 1;
-  }
-  return 0;
+var dumpCommand = async (args, logger) => {
+	if (args.options.help || args.options.h) {
+		showDumpHelp();
+		return 1;
+	}
+	const directory = args.positional[0];
+	const inheritableFieldsOption = args.options["inheritable-fields"];
+	const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+	const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+	const mergeFiles = !args.options["no-merge-files"];
+	const ignorePackageJsonNotExist = args.options["force"] || args.options["f"] ? true : false;
+	const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+	const targetDir = resolve(directory !== null && directory !== void 0 ? directory : process.cwd());
+	const _logger = {
+		debug: (msg) => {},
+		info: (msg) => {},
+		warn: (msg) => {},
+		error: logger.error
+	};
+	try {
+		const computedPackageJson = await getComputedPackageJsonObject(targetDir, getFetchGitMetadata(targetDir, checkWorkingDirectoryStatus, _logger), alwaysOverrideVersionFromGit, inheritableFields, _logger, ignorePackageJsonNotExist);
+		if (computedPackageJson) {
+			if (mergeFiles && inheritableFields.has("files") && existsSync(join(targetDir, "package.json"))) {
+				const workspaceFilesMerge = await resolveWorkspaceFilesMerge(targetDir, _logger);
+				if (workspaceFilesMerge === null || workspaceFilesMerge === void 0 ? void 0 : workspaceFilesMerge.mergedFiles) computedPackageJson.files = workspaceFilesMerge.mergedFiles;
+			}
+			console.info(JSON.stringify(computedPackageJson, null, 2));
+		} else {
+			_logger.error(`dump: Unable to read package.json from: ${targetDir}`);
+			return 1;
+		}
+	} catch (error) {
+		_logger.error(`dump: Failed to dump package.json: ${error}`);
+		return 1;
+	}
+	return 0;
 };
-const showMetadataHelp = () => {
-  console.info(`Usage: screw-up metadata [options] [directory]
+var showMetadataHelp = () => {
+	console.info(`Usage: screw-up metadata [options] [directory]
 
 Generate TypeScript metadata file from package metadata
 
@@ -1278,78 +1127,40 @@ Options:
   -h, --help                         Show help for metadata command
 `);
 };
-const metadataCommand = async (args, logger2) => {
-  if (args.options.help || args.options.h) {
-    showMetadataHelp();
-    return 1;
-  }
-  const directory = args.positional[0];
-  const outputMetadataFilePathOption = args.options["output-metadata-file-path"];
-  const outputMetadataKeysOption = args.options["output-metadata-keys"];
-  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
-  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
-  const outputMetadataFilePath = typeof outputMetadataFilePathOption === "string" && outputMetadataFilePathOption.trim() ? outputMetadataFilePathOption : "src/generated/packageMetadata.ts";
-  const outputMetadataKeys = parseOutputMetadataKeys(outputMetadataKeysOption);
-  const targetDir = resolve(directory != null ? directory : process.cwd());
-  try {
-    const fetchGitMetadata = getFetchGitMetadata(
-      targetDir,
-      checkWorkingDirectoryStatus,
-      logger2
-    );
-    const result = await resolvePackageMetadata(
-      targetDir,
-      fetchGitMetadata,
-      alwaysOverrideVersionFromGit,
-      logger2
-    );
-    const metadataSourceContent = generateMetadataFileContent(
-      result.metadata,
-      outputMetadataKeys
-    );
-    const metadataSourcePath = join(targetDir, outputMetadataFilePath);
-    const metadataWritten = await writeFileIfChanged(
-      metadataSourcePath,
-      metadataSourceContent,
-      "metadata source file",
-      logger2
-    );
-    if (existsSync(metadataSourcePath)) {
-      const gitignoreWritten = await ensureMetadataGitignore(
-        metadataSourcePath,
-        logger2
-      );
-      if (gitignoreWritten) {
-        logger2.info(
-          `metadata: .gitignore is generated: ${join(
-            dirname(outputMetadataFilePath),
-            ".gitignore"
-          )}`
-        );
-      }
-    }
-    if (metadataWritten) {
-      logger2.info(
-        `metadata: Metadata source file is generated: ${outputMetadataFilePath}`
-      );
-    } else if (existsSync(metadataSourcePath)) {
-      logger2.info(
-        `metadata: Metadata source file is unchanged: ${outputMetadataFilePath}`
-      );
-    } else {
-      logger2.error(
-        `metadata: Failed to write metadata file: ${outputMetadataFilePath}`
-      );
-      return 1;
-    }
-  } catch (error) {
-    logger2.error(`metadata: Failed to generate metadata file: ${error}`);
-    return 1;
-  }
-  return 0;
+var metadataCommand = async (args, logger) => {
+	if (args.options.help || args.options.h) {
+		showMetadataHelp();
+		return 1;
+	}
+	const directory = args.positional[0];
+	const outputMetadataFilePathOption = args.options["output-metadata-file-path"];
+	const outputMetadataKeysOption = args.options["output-metadata-keys"];
+	const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+	const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+	const outputMetadataFilePath = typeof outputMetadataFilePathOption === "string" && outputMetadataFilePathOption.trim() ? outputMetadataFilePathOption : "src/generated/packageMetadata.ts";
+	const outputMetadataKeys = parseOutputMetadataKeys(outputMetadataKeysOption);
+	const targetDir = resolve(directory !== null && directory !== void 0 ? directory : process.cwd());
+	try {
+		const metadataSourceContent = generateMetadataFileContent((await resolvePackageMetadata(targetDir, getFetchGitMetadata(targetDir, checkWorkingDirectoryStatus, logger), alwaysOverrideVersionFromGit, logger)).metadata, outputMetadataKeys);
+		const metadataSourcePath = join(targetDir, outputMetadataFilePath);
+		const metadataWritten = await writeFileIfChanged(metadataSourcePath, metadataSourceContent, "metadata source file", logger);
+		if (existsSync(metadataSourcePath)) {
+			if (await ensureMetadataGitignore(metadataSourcePath, logger)) logger.info(`metadata: .gitignore is generated: ${join(dirname(outputMetadataFilePath), ".gitignore")}`);
+		}
+		if (metadataWritten) logger.info(`metadata: Metadata source file is generated: ${outputMetadataFilePath}`);
+		else if (existsSync(metadataSourcePath)) logger.info(`metadata: Metadata source file is unchanged: ${outputMetadataFilePath}`);
+		else {
+			logger.error(`metadata: Failed to write metadata file: ${outputMetadataFilePath}`);
+			return 1;
+		}
+	} catch (error) {
+		logger.error(`metadata: Failed to generate metadata file: ${error}`);
+		return 1;
+	}
+	return 0;
 };
-const showPackHelp = () => {
-  console.info(`Usage: screw-up pack [options] [directory]
+var showPackHelp = () => {
+	console.info(`Usage: screw-up pack [options] [directory]
 
 Pack the project into a tar archive
 
@@ -1359,6 +1170,7 @@ Arguments:
 Options:
   --pack-destination <path>     Directory to write the tarball
   --readme <path>               Replace README.md with specified file
+  --use-pnpm                    Use pnpm pack and preserve workspace protocol resolution
   --inheritable-fields <list>   Comma-separated list of fields to inherit from parent
   --no-wds                      Do not check working directory status to increase version
   --no-git-version-override     Do not override version from Git (use package.json version)
@@ -1369,62 +1181,44 @@ Options:
   -h, --help                    Show help for pack command
 `);
 };
-const packCommand = async (args, logger2) => {
-  var _a;
-  if (args.options.help || args.options.h) {
-    showPackHelp();
-    return 1;
-  }
-  const directory = args.positional[0];
-  const packDestination = args.options["pack-destination"];
-  const readmeOption = args.options["readme"];
-  const inheritableFieldsOption = args.options["inheritable-fields"];
-  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
-  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
-  const mergeFiles = !args.options["no-merge-files"];
-  const replacePeerDepsWildcards = !args.options["no-replace-peer-deps"];
-  const peerDepsVersionPrefix = (_a = args.options["peer-deps-prefix"]) != null ? _a : "^";
-  const verbose = args.options["verbose"] ? true : false;
-  const targetDir = resolve(directory != null ? directory : process.cwd());
-  const outputDir = packDestination ? resolve(packDestination) : process.cwd();
-  const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
-  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
-  if (verbose) {
-    logger2.info(`pack: Creating archive of ${targetDir}...`);
-  }
-  try {
-    const result = await packAssets(
-      targetDir,
-      outputDir,
-      checkWorkingDirectoryStatus,
-      alwaysOverrideVersionFromGit,
-      inheritableFields,
-      readmeReplacementPath,
-      replacePeerDepsWildcards,
-      peerDepsVersionPrefix,
-      logger2,
-      mergeFiles
-    );
-    if (result) {
-      if (verbose) {
-        logger2.info(
-          `pack: Archive created successfully: ${result.packageFileName}`
-        );
-      } else {
-        logger2.info(result.packageFileName);
-      }
-    } else {
-      logger2.error(`pack: Unable to find any files to pack: ${targetDir}`);
-      return 1;
-    }
-  } catch (error) {
-    logger2.error(`pack: Failed to create archive: ${error}`);
-    return 1;
-  }
-  return 0;
+var packCommand = async (args, logger) => {
+	var _args$options$peerDe;
+	if (args.options.help || args.options.h) {
+		showPackHelp();
+		return 1;
+	}
+	const directory = args.positional[0];
+	const packDestination = args.options["pack-destination"];
+	const readmeOption = args.options["readme"];
+	const inheritableFieldsOption = args.options["inheritable-fields"];
+	const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+	const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+	const mergeFiles = !args.options["no-merge-files"];
+	const replacePeerDepsWildcards = !args.options["no-replace-peer-deps"];
+	const peerDepsVersionPrefix = (_args$options$peerDe = args.options["peer-deps-prefix"]) !== null && _args$options$peerDe !== void 0 ? _args$options$peerDe : "^";
+	const packageManager = args.options["use-pnpm"] ? "pnpm" : "npm";
+	const verbose = args.options["verbose"] ? true : false;
+	const targetDir = resolve(directory !== null && directory !== void 0 ? directory : process.cwd());
+	const outputDir = packDestination ? resolve(packDestination) : process.cwd();
+	const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
+	const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+	if (verbose) logger.info(`pack: Creating archive of ${targetDir}...`);
+	try {
+		const result = await packAssets(targetDir, outputDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, readmeReplacementPath, replacePeerDepsWildcards, peerDepsVersionPrefix, logger, mergeFiles, packageManager);
+		if (result) if (verbose) logger.info(`pack: Archive created successfully: ${result.packageFileName}`);
+		else logger.info(result.packageFileName);
+		else {
+			logger.error(`pack: Unable to find any files to pack: ${targetDir}`);
+			return 1;
+		}
+	} catch (error) {
+		logger.error(`pack: Failed to create archive: ${error}`);
+		return 1;
+	}
+	return 0;
 };
-const showPublishHelp = () => {
-  console.info(`Usage: screw-up publish [options] [directory|package.tgz]
+var showPublishHelp = () => {
+	console.info(`Usage: screw-up publish [options] [directory|package.tgz]
 
 Publish the project
 
@@ -1432,6 +1226,7 @@ Arguments:
   directory|package.tgz         Directory to pack and publish, or existing tarball to publish
 
 Options:
+  --use-pnpm                    Use pnpm pack before publish; final publish still targets npm-compatible registries
   All npm publish options are supported, including:
   --dry-run                     Perform a dry run
   --tag <tag>                   Tag for the published version
@@ -1446,162 +1241,124 @@ Examples:
   screw-up publish --dry-run --tag beta  # Publish with options
 `);
 };
-const runNpmPublish = async (tarballPath, npmOptions, verbose, logger2) => {
-  if (verbose) {
-    logger2.info(`publish: Publishing ${tarballPath} to npm...`);
-  }
-  const publishArgs = ["publish", tarballPath, ...npmOptions];
-  if (process.env.SCREW_UP_TEST_MODE === "true") {
-    logger2.info(`TEST_MODE: Would execute: npm ${publishArgs.join(" ")}`);
-    logger2.info(`TEST_MODE: Tarball path: ${tarballPath}`);
-    logger2.info(`TEST_MODE: Options: ${npmOptions.join(" ")}`);
-    logger2.info(`publish: Successfully published ${tarballPath}`);
-    return 0;
-  }
-  const npmProcess = spawn("npm", publishArgs, { stdio: "inherit" });
-  return new Promise((resolve2, reject) => {
-    npmProcess.on("close", (code) => {
-      if (code === 0) {
-        if (verbose) {
-          logger2.info(`publish: Successfully published ${tarballPath}`);
-        }
-        resolve2(code);
-      } else {
-        logger2.error(`publish: npm publish failed: ${tarballPath}`);
-        resolve2(code);
-      }
-    });
-    npmProcess.on("error", reject);
-  });
+var runNpmPublish = async (tarballPath, npmOptions, verbose, logger) => {
+	if (verbose) logger.info(`publish: Publishing ${tarballPath} to npm...`);
+	const publishArgs = [
+		"publish",
+		tarballPath,
+		...npmOptions
+	];
+	if (process.env.SCREW_UP_TEST_MODE === "true") {
+		logger.info(`TEST_MODE: Would execute: npm ${publishArgs.join(" ")}`);
+		logger.info(`TEST_MODE: Tarball path: ${tarballPath}`);
+		logger.info(`TEST_MODE: Options: ${npmOptions.join(" ")}`);
+		logger.info(`publish: Successfully published ${tarballPath}`);
+		return 0;
+	}
+	const npmProcess = spawn("npm", publishArgs, { stdio: "inherit" });
+	return new Promise((resolve, reject) => {
+		npmProcess.on("close", (code, signal) => {
+			if (code === 0) {
+				if (verbose) logger.info(`publish: Successfully published ${tarballPath}`);
+				resolve(0);
+				return;
+			}
+			if (signal) {
+				logger.error(`publish: npm publish terminated by signal ${signal}: ${tarballPath}`);
+				resolve(1);
+				return;
+			}
+			const exitCode = code !== null && code !== void 0 ? code : 1;
+			logger.error(`publish: npm publish failed with exit code ${exitCode}: ${tarballPath}`);
+			resolve(exitCode);
+		});
+		npmProcess.on("error", reject);
+	});
 };
-const publishCommand = async (args, logger2) => {
-  var _a;
-  if (args.options.help || args.options.h) {
-    showPublishHelp();
-    return 1;
-  }
-  const path = args.positional[0];
-  const readmeOption = args.options["readme"];
-  const inheritableFieldsOption = args.options["inheritable-fields"];
-  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
-  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
-  const mergeFiles = !args.options["no-merge-files"];
-  const replacePeerDepsWildcards = !args.options["no-replace-peer-deps"];
-  const peerDepsVersionPrefix = (_a = args.options["peer-deps-prefix"]) != null ? _a : "^";
-  const verbose = args.options["verbose"] ? true : false;
-  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
-  const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
-  const npmOptions = [];
-  for (let i = 0; i < args.argv.length; i++) {
-    const arg = args.argv[i];
-    if (arg === "publish") ;
-    else if (arg === "--help" || arg === "--verbose" || arg === "-h" || arg === "--no-wds" || arg === "--no-git-version-override" || arg === "--no-merge-files" || arg === "--no-replace-peer-deps") ;
-    else if (arg === "--readme" || arg === "--inheritable-fields" || arg === "--peer-deps-prefix") {
-      i++;
-    } else {
-      npmOptions.push(arg);
-    }
-  }
-  try {
-    if (!path) {
-      const targetDir = process.cwd();
-      const outputDir = await mkdtemp(join(tmpdir(), "screw-up-publish-"));
-      if (verbose) {
-        logger2.info(`publish: Creating archive of ${targetDir}...`);
-      }
-      try {
-        const result = await packAssets(
-          targetDir,
-          outputDir,
-          checkWorkingDirectoryStatus,
-          alwaysOverrideVersionFromGit,
-          inheritableFields,
-          readmeReplacementPath,
-          replacePeerDepsWildcards,
-          peerDepsVersionPrefix,
-          logger2,
-          mergeFiles
-        );
-        if (result == null ? void 0 : result.metadata) {
-          if (verbose) {
-            logger2.info(
-              `publish: Archive created successfully: ${result.packageFileName}`
-            );
-          }
-          const archivePath = join(outputDir, result.packageFileName);
-          return await runNpmPublish(archivePath, npmOptions, verbose, logger2);
-        } else {
-          logger2.error(
-            `publish: Unable to find any files to pack: ${targetDir}`
-          );
-          return 1;
-        }
-      } finally {
-        await rm(outputDir, { recursive: true, force: true });
-      }
-    } else if (existsSync(path)) {
-      const pathStat = await stat(path);
-      if (pathStat.isFile() && (path.endsWith(".tgz") || path.endsWith(".tar.gz"))) {
-        return await runNpmPublish(resolve(path), npmOptions, verbose, logger2);
-      } else if (pathStat.isDirectory()) {
-        const targetDir = resolve(path);
-        const outputDir = await mkdtemp(join(tmpdir(), "screw-up-publish-"));
-        if (verbose) {
-          logger2.info(`publish: Creating archive of ${targetDir}...`);
-        }
-        try {
-          const result = await packAssets(
-            targetDir,
-            outputDir,
-            checkWorkingDirectoryStatus,
-            alwaysOverrideVersionFromGit,
-            inheritableFields,
-            readmeReplacementPath,
-            replacePeerDepsWildcards,
-            peerDepsVersionPrefix,
-            logger2,
-            mergeFiles
-          );
-          if (result == null ? void 0 : result.metadata) {
-            if (verbose) {
-              logger2.info(
-                `publish: Archive created successfully: ${result.packageFileName}`
-              );
-            }
-            const archivePath = join(outputDir, result.packageFileName);
-            return await runNpmPublish(
-              archivePath,
-              npmOptions,
-              verbose,
-              logger2
-            );
-          } else {
-            logger2.error(
-              `publish: Unable to find any files to pack: ${targetDir}`
-            );
-            return 1;
-          }
-        } finally {
-          await rm(outputDir, { recursive: true, force: true });
-        }
-      } else {
-        logger2.error(
-          `publish: Invalid path - must be a directory or .tgz/.tar.gz file: ${path}`
-        );
-        return 1;
-      }
-    } else {
-      logger2.error(`publish: Path does not exist: ${path}`);
-      return 1;
-    }
-  } catch (error) {
-    logger2.error(`publish: Failed to publish: ${error}`);
-    return 1;
-  }
+var publishCommand = async (args, logger) => {
+	var _args$options$peerDe2;
+	if (args.options.help || args.options.h) {
+		showPublishHelp();
+		return 1;
+	}
+	const path = args.positional[0];
+	const readmeOption = args.options["readme"];
+	const inheritableFieldsOption = args.options["inheritable-fields"];
+	const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+	const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+	const mergeFiles = !args.options["no-merge-files"];
+	const replacePeerDepsWildcards = !args.options["no-replace-peer-deps"];
+	const peerDepsVersionPrefix = (_args$options$peerDe2 = args.options["peer-deps-prefix"]) !== null && _args$options$peerDe2 !== void 0 ? _args$options$peerDe2 : "^";
+	const packageManager = args.options["use-pnpm"] ? "pnpm" : "npm";
+	const verbose = args.options["verbose"] ? true : false;
+	const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+	const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
+	const npmOptions = [];
+	let pathSkipped = false;
+	for (let i = 0; i < args.argv.length; i++) {
+		const arg = args.argv[i];
+		if (arg === "publish") {} else if (arg === "--help" || arg === "--verbose" || arg === "--use-pnpm" || arg === "-h" || arg === "--no-wds" || arg === "--no-git-version-override" || arg === "--no-merge-files" || arg === "--no-replace-peer-deps") {} else if (arg === "--readme" || arg === "--inheritable-fields" || arg === "--peer-deps-prefix") i++;
+		else if (!pathSkipped && path && arg === path) pathSkipped = true;
+		else npmOptions.push(arg);
+	}
+	try {
+		if (!path) {
+			const targetDir = process.cwd();
+			const outputDir = await mkdtemp(join(tmpdir(), "screw-up-publish-"));
+			if (verbose) logger.info(`publish: Creating archive of ${targetDir}...`);
+			try {
+				const result = await packAssets(targetDir, outputDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, readmeReplacementPath, replacePeerDepsWildcards, peerDepsVersionPrefix, logger, mergeFiles, packageManager);
+				if (result === null || result === void 0 ? void 0 : result.metadata) {
+					if (verbose) logger.info(`publish: Archive created successfully: ${result.packageFileName}`);
+					return await runNpmPublish(join(outputDir, result.packageFileName), npmOptions, verbose, logger);
+				} else {
+					logger.error(`publish: Unable to find any files to pack: ${targetDir}`);
+					return 1;
+				}
+			} finally {
+				await rm(outputDir, {
+					recursive: true,
+					force: true
+				});
+			}
+		} else if (existsSync(path)) {
+			const pathStat = await stat(path);
+			if (pathStat.isFile() && (path.endsWith(".tgz") || path.endsWith(".tar.gz"))) return await runNpmPublish(resolve(path), npmOptions, verbose, logger);
+			else if (pathStat.isDirectory()) {
+				const targetDir = resolve(path);
+				const outputDir = await mkdtemp(join(tmpdir(), "screw-up-publish-"));
+				if (verbose) logger.info(`publish: Creating archive of ${targetDir}...`);
+				try {
+					const result = await packAssets(targetDir, outputDir, checkWorkingDirectoryStatus, alwaysOverrideVersionFromGit, inheritableFields, readmeReplacementPath, replacePeerDepsWildcards, peerDepsVersionPrefix, logger, mergeFiles, packageManager);
+					if (result === null || result === void 0 ? void 0 : result.metadata) {
+						if (verbose) logger.info(`publish: Archive created successfully: ${result.packageFileName}`);
+						return await runNpmPublish(join(outputDir, result.packageFileName), npmOptions, verbose, logger);
+					} else {
+						logger.error(`publish: Unable to find any files to pack: ${targetDir}`);
+						return 1;
+					}
+				} finally {
+					await rm(outputDir, {
+						recursive: true,
+						force: true
+					});
+				}
+			} else {
+				logger.error(`publish: Invalid path - must be a directory or .tgz/.tar.gz file: ${path}`);
+				return 1;
+			}
+		} else {
+			logger.error(`publish: Path does not exist: ${path}`);
+			return 1;
+		}
+	} catch (error) {
+		logger.error(`publish: Failed to publish: ${error}`);
+		return 1;
+	}
 };
-const showHelp = async () => {
-  const { author, license, repository_url, version, git_commit_hash } = await import("./metadata-file-B4RbKbol.js").then((n) => n.p);
-  console.info(`screw-up [${version}-${git_commit_hash}]
+var showHelp = async () => {
+	const { author, license, repository_url, version, git_commit_hash } = await import("./packageMetadata-11MbeI_K.js").then((n) => n.r);
+	console.info(`screw-up [${version}-${git_commit_hash}]
 Easy package metadata inserter CLI
 Copyright (c) ${author}
 Repository: ${repository_url}
@@ -1629,56 +1386,50 @@ Examples:
   screw-up publish package.tgz             # Publish existing tarball
 `);
 };
-const argOptionMap = /* @__PURE__ */ new Map([
-  ["dump", /* @__PURE__ */ new Set(["inheritable-fields"])],
-  ["metadata", /* @__PURE__ */ new Set(["output-metadata-file-path", "output-metadata-keys"])],
-  [
-    "pack",
-    /* @__PURE__ */ new Set([
-      "pack-destination",
-      "readme",
-      "inheritable-fields",
-      "peer-deps-prefix"
-    ])
-  ],
-  ["format", /* @__PURE__ */ new Set(["input", "i", "bracket", "b", "inheritable-fields"])],
-  ["publish", /* @__PURE__ */ new Set(["inheritable-fields", "peer-deps-prefix"])]
+var argOptionMap = new Map([
+	["dump", new Set(["inheritable-fields"])],
+	["metadata", new Set(["output-metadata-file-path", "output-metadata-keys"])],
+	["pack", new Set([
+		"pack-destination",
+		"readme",
+		"inheritable-fields",
+		"peer-deps-prefix"
+	])],
+	["format", new Set([
+		"input",
+		"i",
+		"bracket",
+		"b",
+		"inheritable-fields"
+	])],
+	["publish", new Set(["inheritable-fields", "peer-deps-prefix"])]
 ]);
-const cliMain = async (args, logger2) => {
-  const parsedArgs = parseArgs(args, argOptionMap);
-  if (!parsedArgs.command && (parsedArgs.options.help || parsedArgs.options.h)) {
-    await showHelp();
-    return 1;
-  }
-  switch (parsedArgs.command) {
-    case "format":
-      return await formatCommand(parsedArgs, logger2);
-    case "dump":
-      return await dumpCommand(parsedArgs, logger2);
-    case "metadata":
-      return await metadataCommand(parsedArgs, logger2);
-    case "pack":
-      return await packCommand(parsedArgs, logger2);
-    case "publish":
-      return await publishCommand(parsedArgs, logger2);
-    default:
-      if (parsedArgs.command) {
-        logger2.error(`Unknown command: ${parsedArgs.command}`);
-      } else {
-        logger2.error(`Unknown command`);
-      }
-      logger2.error('Run "screw-up --help" for usage information.');
-      return 1;
-  }
+var cliMain = async (args, logger) => {
+	const parsedArgs = parseArgs(args, argOptionMap);
+	if (!parsedArgs.command && (parsedArgs.options.help || parsedArgs.options.h)) {
+		await showHelp();
+		return 1;
+	}
+	switch (parsedArgs.command) {
+		case "format": return await formatCommand(parsedArgs, logger);
+		case "dump": return await dumpCommand(parsedArgs, logger);
+		case "metadata": return await metadataCommand(parsedArgs, logger);
+		case "pack": return await packCommand(parsedArgs, logger);
+		case "publish": return await publishCommand(parsedArgs, logger);
+		default:
+			if (parsedArgs.command) logger.error(`Unknown command: ${parsedArgs.command}`);
+			else logger.error(`Unknown command`);
+			logger.error("Run \"screw-up --help\" for usage information.");
+			return 1;
+	}
 };
-const loggerPrefix = `${name}-cli`;
-const logger = createConsoleLogger(loggerPrefix);
-cliMain(
-  process.argv.slice(2),
-  // Remove 'node' and script path
-  logger
-).then((code) => process.exit(code)).catch((error) => {
-  logger.error(`CLI error: ${error}`);
-  process.exit(1);
+//#endregion
+//#region src/main.ts
+var logger = createConsoleLogger(`${name}-cli`);
+cliMain(process.argv.slice(2), logger).then((code) => process.exit(code)).catch((error) => {
+	logger.error(`CLI error: ${error}`);
+	process.exit(1);
 });
-//# sourceMappingURL=main.mjs.map
+//#endregion
+
+//# sourceMappingURL=main.mjs.map