@hot-updater/console 0.30.1 → 0.30.3

package/.output/server/_libs/{tar.mjs → tar+yallist.mjs}

@@ -1,5 +1,5 @@
-import { i as Minipass, n as ReadStreamSync, r as WriteStream, t as ReadStream } from "./isaacs__fs-minipass+minipass.mjs";
-import { n as Unzip, r as ZstdDecompress, t as BrotliDecompress } from "./minizlib.mjs";
+import { a as Minipass, i as WriteStreamSync, n as ReadStreamSync, r as WriteStream, t as ReadStream } from "./isaacs__fs-minipass+minipass.mjs";
+import { a as ZstdCompress, i as Unzip, n as BrotliDecompress, o as ZstdDecompress, r as Gzip, t as BrotliCompress } from "./minizlib.mjs";
 import { n as chownrSync, t as chownr } from "./chownr.mjs";
 import { randomBytes } from "node:crypto";
 import fs from "node:fs";
@@ -7,7 +7,7 @@ import path, { basename, join, posix, win32 } from "node:path";
 import fs$1 from "node:fs/promises";
 import { EventEmitter } from "events";
 import fs$2 from "fs";
-import { dirname as dirname$1, parse } from "path";
+import path$1, { dirname as dirname$1, parse } from "path";
 import assert from "node:assert";
 //#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/options.js
 var argmap = new Map([
@@ -36,6 +36,7 @@ var isSyncFile = (o) => !!o.sync && !!o.file;
 var isAsyncFile = (o) => !o.sync && !!o.file;
 var isSyncNoFile = (o) => !!o.sync && !o.file;
 var isAsyncNoFile = (o) => !o.sync && !o.file;
+var isFile = (o) => !!o.file;
 var dealiasKey = (k) => {
 	const d = argmap.get(k);
 	if (d) return d;
@@ -596,8 +597,8 @@ var GEX = Symbol("globalExtendedHeader");
 var META = Symbol("meta");
 var EMITMETA = Symbol("emitMeta");
 var BUFFER = Symbol("buffer");
-var QUEUE = Symbol("queue");
-var ENDED$1 = Symbol("ended");
+var QUEUE$1 = Symbol("queue");
+var ENDED$2 = Symbol("ended");
 var EMITTEDEND = Symbol("emittedEnd");
 var EMIT = Symbol("emit");
 var UNZIP = Symbol("unzip");
@@ -626,7 +627,7 @@ var Parser = class extends EventEmitter {
 	zstd;
 	writable = true;
 	readable = false;
-	[QUEUE] = [];
+	[QUEUE$1] = [];
 	[BUFFER];
 	[READENTRY];
 	[WRITEENTRY];
@@ -634,7 +635,7 @@ var Parser = class extends EventEmitter {
 	[META] = "";
 	[EX];
 	[GEX];
-	[ENDED$1] = false;
+	[ENDED$2] = false;
 	[UNZIP];
 	[ABORTED] = false;
 	[SAW_VALID_ENTRY];
@@ -726,9 +727,9 @@ var Parser = class extends EventEmitter {
 								entry.end();
 							}
 							if (!this[READENTRY]) {
-								this[QUEUE].push(entry);
+								this[QUEUE$1].push(entry);
 								this[NEXTENTRY]();
-							} else this[QUEUE].push(entry);
+							} else this[QUEUE$1].push(entry);
 						}
 					}
 				}
@@ -758,8 +759,8 @@ var Parser = class extends EventEmitter {
 	}
 	[NEXTENTRY]() {
 		do		;
-while (this[PROCESSENTRY](this[QUEUE].shift()));
-		if (!this[QUEUE].length) {
+while (this[PROCESSENTRY](this[QUEUE$1].shift()));
+		if (!this[QUEUE$1].length) {
 			const re = this[READENTRY];
 			if (!re || re.flowing || re.size === re.remain) {
 				if (!this[WRITING]) this.emit("drain");
@@ -788,8 +789,8 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 		return ret;
 	}
 	[EMIT](ev, data, extra) {
-		if (!this[QUEUE].length && !this[READENTRY]) this.emit(ev, data, extra);
-		else this[QUEUE].push([
+		if (!this[QUEUE$1].length && !this[READENTRY]) this.emit(ev, data, extra);
+		else this[QUEUE$1].push([
 			ev,
 			data,
 			extra
@@ -818,6 +819,7 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 				ex.linkpath = this[META].replace(/\0.*/, "");
 				break;
 			}
+			/* c8 ignore start */
 			default: throw new Error("unknown meta: " + entry.type);
 		}
 	}
@@ -862,7 +864,7 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 				}
 			}
 			const maybeBrotli = this.brotli === void 0 && !isZstd;
-			if (this[UNZIP] === false && maybeBrotli) if (chunk.length < 512) if (this[ENDED$1]) this.brotli = true;
+			if (this[UNZIP] === false && maybeBrotli) if (chunk.length < 512) if (this[ENDED$2]) this.brotli = true;
 			else {
 				this[BUFFER] = chunk;
 				/* c8 ignore next */
@@ -876,13 +878,13 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 				this.brotli = true;
 			}
 			if (this[UNZIP] === void 0 || this[UNZIP] === false && (this.brotli || isZstd)) {
-				const ended = this[ENDED$1];
-				this[ENDED$1] = false;
+				const ended = this[ENDED$2];
+				this[ENDED$2] = false;
 				this[UNZIP] = this[UNZIP] === void 0 ? new Unzip({}) : isZstd ? new ZstdDecompress({}) : new BrotliDecompress({});
 				this[UNZIP].on("data", (chunk) => this[CONSUMECHUNK](chunk));
 				this[UNZIP].on("error", (er) => this.abort(er));
 				this[UNZIP].on("end", () => {
-					this[ENDED$1] = true;
+					this[ENDED$2] = true;
 					this[CONSUMECHUNK]();
 				});
 				this[WRITING] = true;
@@ -896,8 +898,8 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 		if (this[UNZIP]) this[UNZIP].write(chunk);
 		else this[CONSUMECHUNK](chunk);
 		this[WRITING] = false;
-		const ret = this[QUEUE].length ? false : this[READENTRY] ? this[READENTRY].flowing : true;
-		if (!ret && !this[QUEUE].length) this[READENTRY]?.once("drain", () => this.emit("drain"));
+		const ret = this[QUEUE$1].length ? false : this[READENTRY] ? this[READENTRY].flowing : true;
+		if (!ret && !this[QUEUE$1].length) this[READENTRY]?.once("drain", () => this.emit("drain"));
 		/* c8 ignore next */
 		cb?.();
 		return ret;
@@ -906,7 +908,7 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 		if (c && !this[ABORTED]) this[BUFFER] = this[BUFFER] ? Buffer.concat([this[BUFFER], c]) : c;
 	}
 	[MAYBEEND]() {
-		if (this[ENDED$1] && !this[EMITTEDEND] && !this[ABORTED] && !this[CONSUMING]) {
+		if (this[ENDED$2] && !this[EMITTEDEND] && !this[ABORTED] && !this[CONSUMING]) {
 			this[EMITTEDEND] = true;
 			const entry = this[WRITEENTRY];
 			if (entry && entry.blockRemain) {
@@ -936,7 +938,7 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 			}
 			this[CONSUMING] = false;
 		}
-		if (!this[BUFFER] || this[ENDED$1]) this[MAYBEEND]();
+		if (!this[BUFFER] || this[ENDED$2]) this[MAYBEEND]();
 	}
 	[CONSUMECHUNKSUB](chunk) {
 		let position = 0;
@@ -954,6 +956,7 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 			case "meta":
 				position += this[CONSUMEMETA](chunk, position);
 				break;
+			/* c8 ignore start */
 			default: throw new Error("invalid state: " + this[STATE]);
 		}
 		if (position < length) if (this[BUFFER]) this[BUFFER] = Buffer.concat([chunk.subarray(position), this[BUFFER]]);
@@ -977,7 +980,7 @@ while (this[PROCESSENTRY](this[QUEUE].shift()));
 			/* c8 ignore stop */
 			this[UNZIP].end();
 		} else {
-			this[ENDED$1] = true;
+			this[ENDED$2] = true;
 			if (this.brotli === void 0 || this.zstd === void 0) chunk = chunk || Buffer.alloc(0);
 			if (chunk) this.write(chunk);
 			this[MAYBEEND]();
@@ -1070,11 +1073,23 @@ var listFile = (opt, _files) => {
 		});
 	});
 };
-makeCommand(listFileSync, listFile, (opt) => new Parser(opt), (opt) => new Parser(opt), (opt, files) => {
+var list = makeCommand(listFileSync, listFile, (opt) => new Parser(opt), (opt) => new Parser(opt), (opt, files) => {
 	if (files?.length) filesFilter(opt, files);
 	if (!opt.noResume) onReadEntryFunction(opt);
 });
 //#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/mode-fix.js
+var modeFix = (mode, isDir, portable) => {
+	mode &= 4095;
+	if (portable) mode = (mode | 384) & -19;
+	if (isDir) {
+		if (mode & 256) mode |= 64;
+		if (mode & 32) mode |= 8;
+		if (mode & 4) mode |= 1;
+	}
+	return mode;
+};
+//#endregion
 //#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/strip-absolute-path.js
 var { isAbsolute, parse: parse$1 } = win32;
 var stripAbsolutePath = (path) => {
@@ -1099,8 +1114,1162 @@ var raw = [
 ];
 var win = raw.map((char) => String.fromCharCode(61440 + char.charCodeAt(0)));
 var toWin = new Map(raw.map((char, i) => [char, win[i]]));
-new Map(win.map((char, i) => [char, raw[i]]));
+var toRaw = new Map(win.map((char, i) => [char, raw[i]]));
 var encode = (s) => raw.reduce((s, c) => s.split(c).join(toWin.get(c)), s);
+var decode = (s) => win.reduce((s, c) => s.split(c).join(toRaw.get(c)), s);
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/write-entry.js
+var prefixPath = (path, prefix) => {
+	if (!prefix) return normalizeWindowsPath(path);
+	path = normalizeWindowsPath(path).replace(/^\.(\/|$)/, "");
+	return stripTrailingSlashes(prefix) + "/" + path;
+};
+var maxReadSize = 16 * 1024 * 1024;
+var PROCESS$1 = Symbol("process");
+var FILE$1 = Symbol("file");
+var DIRECTORY$1 = Symbol("directory");
+var SYMLINK$1 = Symbol("symlink");
+var HARDLINK$1 = Symbol("hardlink");
+var HEADER = Symbol("header");
+var READ = Symbol("read");
+var LSTAT = Symbol("lstat");
+var ONLSTAT = Symbol("onlstat");
+var ONREAD = Symbol("onread");
+var ONREADLINK = Symbol("onreadlink");
+var OPENFILE = Symbol("openfile");
+var ONOPENFILE = Symbol("onopenfile");
+var CLOSE = Symbol("close");
+var MODE = Symbol("mode");
+var AWAITDRAIN = Symbol("awaitDrain");
+var ONDRAIN$1 = Symbol("ondrain");
+var PREFIX = Symbol("prefix");
+var WriteEntry = class extends Minipass {
+	path;
+	portable;
+	myuid = process.getuid && process.getuid() || 0;
+	myuser = process.env.USER || "";
+	maxReadSize;
+	linkCache;
+	statCache;
+	preservePaths;
+	cwd;
+	strict;
+	mtime;
+	noPax;
+	noMtime;
+	prefix;
+	fd;
+	blockLen = 0;
+	blockRemain = 0;
+	buf;
+	pos = 0;
+	remain = 0;
+	length = 0;
+	offset = 0;
+	win32;
+	absolute;
+	header;
+	type;
+	linkpath;
+	stat;
+	onWriteEntry;
+	#hadError = false;
+	constructor(p, opt_ = {}) {
+		const opt = dealias(opt_);
+		super();
+		this.path = normalizeWindowsPath(p);
+		this.portable = !!opt.portable;
+		this.maxReadSize = opt.maxReadSize || maxReadSize;
+		this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
+		this.statCache = opt.statCache || /* @__PURE__ */ new Map();
+		this.preservePaths = !!opt.preservePaths;
+		this.cwd = normalizeWindowsPath(opt.cwd || process.cwd());
+		this.strict = !!opt.strict;
+		this.noPax = !!opt.noPax;
+		this.noMtime = !!opt.noMtime;
+		this.mtime = opt.mtime;
+		this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : void 0;
+		this.onWriteEntry = opt.onWriteEntry;
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		let pathWarn = false;
+		if (!this.preservePaths) {
+			const [root, stripped] = stripAbsolutePath(this.path);
+			if (root && typeof stripped === "string") {
+				this.path = stripped;
+				pathWarn = root;
+			}
+		}
+		this.win32 = !!opt.win32 || process.platform === "win32";
+		if (this.win32) {
+			this.path = decode(this.path.replace(/\\/g, "/"));
+			p = p.replace(/\\/g, "/");
+		}
+		this.absolute = normalizeWindowsPath(opt.absolute || path$1.resolve(this.cwd, p));
+		if (this.path === "") this.path = "./";
+		if (pathWarn) this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
+			entry: this,
+			path: pathWarn + this.path
+		});
+		const cs = this.statCache.get(this.absolute);
+		if (cs) this[ONLSTAT](cs);
+		else this[LSTAT]();
+	}
+	warn(code, message, data = {}) {
+		return warnMethod(this, code, message, data);
+	}
+	emit(ev, ...data) {
+		if (ev === "error") this.#hadError = true;
+		return super.emit(ev, ...data);
+	}
+	[LSTAT]() {
+		fs$2.lstat(this.absolute, (er, stat) => {
+			if (er) return this.emit("error", er);
+			this[ONLSTAT](stat);
+		});
+	}
+	[ONLSTAT](stat) {
+		this.statCache.set(this.absolute, stat);
+		this.stat = stat;
+		if (!stat.isFile()) stat.size = 0;
+		this.type = getType(stat);
+		this.emit("stat", stat);
+		this[PROCESS$1]();
+	}
+	[PROCESS$1]() {
+		switch (this.type) {
+			case "File": return this[FILE$1]();
+			case "Directory": return this[DIRECTORY$1]();
+			case "SymbolicLink": return this[SYMLINK$1]();
+			default: return this.end();
+		}
+	}
+	[MODE](mode) {
+		return modeFix(mode, this.type === "Directory", this.portable);
+	}
+	[PREFIX](path) {
+		return prefixPath(path, this.prefix);
+	}
+	[HEADER]() {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot write header before stat");
+		/* c8 ignore stop */
+		if (this.type === "Directory" && this.portable) this.noMtime = true;
+		this.onWriteEntry?.(this);
+		this.header = new Header({
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			mode: this[MODE](this.stat.mode),
+			uid: this.portable ? void 0 : this.stat.uid,
+			gid: this.portable ? void 0 : this.stat.gid,
+			size: this.stat.size,
+			mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime,
+			type: this.type === "Unsupported" ? void 0 : this.type,
+			uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : "",
+			atime: this.portable ? void 0 : this.stat.atime,
+			ctime: this.portable ? void 0 : this.stat.ctime
+		});
+		if (this.header.encode() && !this.noPax) super.write(new Pax({
+			atime: this.portable ? void 0 : this.header.atime,
+			ctime: this.portable ? void 0 : this.header.ctime,
+			gid: this.portable ? void 0 : this.header.gid,
+			mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime,
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			size: this.header.size,
+			uid: this.portable ? void 0 : this.header.uid,
+			uname: this.portable ? void 0 : this.header.uname,
+			dev: this.portable ? void 0 : this.stat.dev,
+			ino: this.portable ? void 0 : this.stat.ino,
+			nlink: this.portable ? void 0 : this.stat.nlink
+		}).encode());
+		const block = this.header?.block;
+		/* c8 ignore start */
+		if (!block) throw new Error("failed to encode header");
+		/* c8 ignore stop */
+		super.write(block);
+	}
+	[DIRECTORY$1]() {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot create directory entry without stat");
+		/* c8 ignore stop */
+		if (this.path.slice(-1) !== "/") this.path += "/";
+		this.stat.size = 0;
+		this[HEADER]();
+		this.end();
+	}
+	[SYMLINK$1]() {
+		fs$2.readlink(this.absolute, (er, linkpath) => {
+			if (er) return this.emit("error", er);
+			this[ONREADLINK](linkpath);
+		});
+	}
+	[ONREADLINK](linkpath) {
+		this.linkpath = normalizeWindowsPath(linkpath);
+		this[HEADER]();
+		this.end();
+	}
+	[HARDLINK$1](linkpath) {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot create link entry without stat");
+		/* c8 ignore stop */
+		this.type = "Link";
+		this.linkpath = normalizeWindowsPath(path$1.relative(this.cwd, linkpath));
+		this.stat.size = 0;
+		this[HEADER]();
+		this.end();
+	}
+	[FILE$1]() {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot create file entry without stat");
+		/* c8 ignore stop */
+		if (this.stat.nlink > 1) {
+			const linkKey = `${this.stat.dev}:${this.stat.ino}`;
+			const linkpath = this.linkCache.get(linkKey);
+			if (linkpath?.indexOf(this.cwd) === 0) return this[HARDLINK$1](linkpath);
+			this.linkCache.set(linkKey, this.absolute);
+		}
+		this[HEADER]();
+		if (this.stat.size === 0) return this.end();
+		this[OPENFILE]();
+	}
+	[OPENFILE]() {
+		fs$2.open(this.absolute, "r", (er, fd) => {
+			if (er) return this.emit("error", er);
+			this[ONOPENFILE](fd);
+		});
+	}
+	[ONOPENFILE](fd) {
+		this.fd = fd;
+		if (this.#hadError) return this[CLOSE]();
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("should stat before calling onopenfile");
+		/* c8 ignore start */
+		this.blockLen = 512 * Math.ceil(this.stat.size / 512);
+		this.blockRemain = this.blockLen;
+		const bufLen = Math.min(this.blockLen, this.maxReadSize);
+		this.buf = Buffer.allocUnsafe(bufLen);
+		this.offset = 0;
+		this.pos = 0;
+		this.remain = this.stat.size;
+		this.length = this.buf.length;
+		this[READ]();
+	}
+	[READ]() {
+		const { fd, buf, offset, length, pos } = this;
+		if (fd === void 0 || buf === void 0) throw new Error("cannot read file without first opening");
+		fs$2.read(fd, buf, offset, length, pos, (er, bytesRead) => {
+			if (er) return this[CLOSE](() => this.emit("error", er));
+			this[ONREAD](bytesRead);
+		});
+	}
+	/* c8 ignore start */
+	[CLOSE](cb = () => {}) {
+		/* c8 ignore stop */
+		if (this.fd !== void 0) fs$2.close(this.fd, cb);
+	}
+	[ONREAD](bytesRead) {
+		if (bytesRead <= 0 && this.remain > 0) {
+			const er = Object.assign(/* @__PURE__ */ new Error("encountered unexpected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[CLOSE](() => this.emit("error", er));
+		}
+		if (bytesRead > this.remain) {
+			const er = Object.assign(/* @__PURE__ */ new Error("did not encounter expected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[CLOSE](() => this.emit("error", er));
+		}
+		/* c8 ignore start */
+		if (!this.buf) throw new Error("should have created buffer prior to reading");
+		/* c8 ignore stop */
+		if (bytesRead === this.remain) for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) {
+			this.buf[i + this.offset] = 0;
+			bytesRead++;
+			this.remain++;
+		}
+		const chunk = this.offset === 0 && bytesRead === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + bytesRead);
+		if (!this.write(chunk)) this[AWAITDRAIN](() => this[ONDRAIN$1]());
+		else this[ONDRAIN$1]();
+	}
+	[AWAITDRAIN](cb) {
+		this.once("drain", cb);
+	}
+	write(chunk, encoding, cb) {
+		/* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
+		/* c8 ignore stop */
+		if (this.blockRemain < chunk.length) {
+			const er = Object.assign(/* @__PURE__ */ new Error("writing more data than expected"), { path: this.absolute });
+			return this.emit("error", er);
+		}
+		this.remain -= chunk.length;
+		this.blockRemain -= chunk.length;
+		this.pos += chunk.length;
+		this.offset += chunk.length;
+		return super.write(chunk, null, cb);
+	}
+	[ONDRAIN$1]() {
+		if (!this.remain) {
+			if (this.blockRemain) super.write(Buffer.alloc(this.blockRemain));
+			return this[CLOSE]((er) => er ? this.emit("error", er) : this.end());
+		}
+		/* c8 ignore start */
+		if (!this.buf) throw new Error("buffer lost somehow in ONDRAIN");
+		/* c8 ignore stop */
+		if (this.offset >= this.length) {
+			this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
+			this.offset = 0;
+		}
+		this.length = this.buf.length - this.offset;
+		this[READ]();
+	}
+};
+var WriteEntrySync = class extends WriteEntry {
+	sync = true;
+	[LSTAT]() {
+		this[ONLSTAT](fs$2.lstatSync(this.absolute));
+	}
+	[SYMLINK$1]() {
+		this[ONREADLINK](fs$2.readlinkSync(this.absolute));
+	}
+	[OPENFILE]() {
+		this[ONOPENFILE](fs$2.openSync(this.absolute, "r"));
+	}
+	[READ]() {
+		let threw = true;
+		try {
+			const { fd, buf, offset, length, pos } = this;
+			/* c8 ignore start */
+			if (fd === void 0 || buf === void 0) throw new Error("fd and buf must be set in READ method");
+			/* c8 ignore stop */
+			const bytesRead = fs$2.readSync(fd, buf, offset, length, pos);
+			this[ONREAD](bytesRead);
+			threw = false;
+		} finally {
+			if (threw) try {
+				this[CLOSE](() => {});
+			} catch (er) {}
+		}
+	}
+	[AWAITDRAIN](cb) {
+		cb();
+	}
+	/* c8 ignore start */
+	[CLOSE](cb = () => {}) {
+		/* c8 ignore stop */
+		if (this.fd !== void 0) fs$2.closeSync(this.fd);
+		cb();
+	}
+};
+var WriteEntryTar = class extends Minipass {
+	blockLen = 0;
+	blockRemain = 0;
+	buf = 0;
+	pos = 0;
+	remain = 0;
+	length = 0;
+	preservePaths;
+	portable;
+	strict;
+	noPax;
+	noMtime;
+	readEntry;
+	type;
+	prefix;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	header;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	size;
+	onWriteEntry;
+	warn(code, message, data = {}) {
+		return warnMethod(this, code, message, data);
+	}
+	constructor(readEntry, opt_ = {}) {
+		const opt = dealias(opt_);
+		super();
+		this.preservePaths = !!opt.preservePaths;
+		this.portable = !!opt.portable;
+		this.strict = !!opt.strict;
+		this.noPax = !!opt.noPax;
+		this.noMtime = !!opt.noMtime;
+		this.onWriteEntry = opt.onWriteEntry;
+		this.readEntry = readEntry;
+		const { type } = readEntry;
+		/* c8 ignore start */
+		if (type === "Unsupported") throw new Error("writing entry that should be ignored");
+		/* c8 ignore stop */
+		this.type = type;
+		if (this.type === "Directory" && this.portable) this.noMtime = true;
+		this.prefix = opt.prefix;
+		this.path = normalizeWindowsPath(readEntry.path);
+		this.mode = readEntry.mode !== void 0 ? this[MODE](readEntry.mode) : void 0;
+		this.uid = this.portable ? void 0 : readEntry.uid;
+		this.gid = this.portable ? void 0 : readEntry.gid;
+		this.uname = this.portable ? void 0 : readEntry.uname;
+		this.gname = this.portable ? void 0 : readEntry.gname;
+		this.size = readEntry.size;
+		this.mtime = this.noMtime ? void 0 : opt.mtime || readEntry.mtime;
+		this.atime = this.portable ? void 0 : readEntry.atime;
+		this.ctime = this.portable ? void 0 : readEntry.ctime;
+		this.linkpath = readEntry.linkpath !== void 0 ? normalizeWindowsPath(readEntry.linkpath) : void 0;
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		let pathWarn = false;
+		if (!this.preservePaths) {
+			const [root, stripped] = stripAbsolutePath(this.path);
+			if (root && typeof stripped === "string") {
+				this.path = stripped;
+				pathWarn = root;
+			}
+		}
+		this.remain = readEntry.size;
+		this.blockRemain = readEntry.startBlockSize;
+		this.onWriteEntry?.(this);
+		this.header = new Header({
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			mode: this.mode,
+			uid: this.portable ? void 0 : this.uid,
+			gid: this.portable ? void 0 : this.gid,
+			size: this.size,
+			mtime: this.noMtime ? void 0 : this.mtime,
+			type: this.type,
+			uname: this.portable ? void 0 : this.uname,
+			atime: this.portable ? void 0 : this.atime,
+			ctime: this.portable ? void 0 : this.ctime
+		});
+		if (pathWarn) this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
+			entry: this,
+			path: pathWarn + this.path
+		});
+		if (this.header.encode() && !this.noPax) super.write(new Pax({
+			atime: this.portable ? void 0 : this.atime,
+			ctime: this.portable ? void 0 : this.ctime,
+			gid: this.portable ? void 0 : this.gid,
+			mtime: this.noMtime ? void 0 : this.mtime,
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			size: this.size,
+			uid: this.portable ? void 0 : this.uid,
+			uname: this.portable ? void 0 : this.uname,
+			dev: this.portable ? void 0 : this.readEntry.dev,
+			ino: this.portable ? void 0 : this.readEntry.ino,
+			nlink: this.portable ? void 0 : this.readEntry.nlink
+		}).encode());
+		const b = this.header?.block;
+		/* c8 ignore start */
+		if (!b) throw new Error("failed to encode header");
+		/* c8 ignore stop */
+		super.write(b);
+		readEntry.pipe(this);
+	}
+	[PREFIX](path) {
+		return prefixPath(path, this.prefix);
+	}
+	[MODE](mode) {
+		return modeFix(mode, this.type === "Directory", this.portable);
+	}
+	write(chunk, encoding, cb) {
+		/* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
+		/* c8 ignore stop */
+		const writeLen = chunk.length;
+		if (writeLen > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		this.blockRemain -= writeLen;
+		return super.write(chunk, cb);
+	}
+	end(chunk, encoding, cb) {
+		if (this.blockRemain) super.write(Buffer.alloc(this.blockRemain));
+		/* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+		if (typeof chunk === "function") {
+			cb = chunk;
+			encoding = void 0;
+			chunk = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, encoding ?? "utf8");
+		if (cb) this.once("finish", cb);
+		chunk ? super.end(chunk, cb) : super.end(cb);
+		/* c8 ignore stop */
+		return this;
+	}
+};
+var getType = (stat) => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
+//#endregion
+//#region ../../node_modules/.pnpm/yallist@5.0.0/node_modules/yallist/dist/esm/index.js
+var Yallist = class Yallist {
+	tail;
+	head;
+	length = 0;
+	static create(list = []) {
+		return new Yallist(list);
+	}
+	constructor(list = []) {
+		for (const item of list) this.push(item);
+	}
+	*[Symbol.iterator]() {
+		for (let walker = this.head; walker; walker = walker.next) yield walker.value;
+	}
+	removeNode(node) {
+		if (node.list !== this) throw new Error("removing node which does not belong to this list");
+		const next = node.next;
+		const prev = node.prev;
+		if (next) next.prev = prev;
+		if (prev) prev.next = next;
+		if (node === this.head) this.head = next;
+		if (node === this.tail) this.tail = prev;
+		this.length--;
+		node.next = void 0;
+		node.prev = void 0;
+		node.list = void 0;
+		return next;
+	}
+	unshiftNode(node) {
+		if (node === this.head) return;
+		if (node.list) node.list.removeNode(node);
+		const head = this.head;
+		node.list = this;
+		node.next = head;
+		if (head) head.prev = node;
+		this.head = node;
+		if (!this.tail) this.tail = node;
+		this.length++;
+	}
+	pushNode(node) {
+		if (node === this.tail) return;
+		if (node.list) node.list.removeNode(node);
+		const tail = this.tail;
+		node.list = this;
+		node.prev = tail;
+		if (tail) tail.next = node;
+		this.tail = node;
+		if (!this.head) this.head = node;
+		this.length++;
+	}
+	push(...args) {
+		for (let i = 0, l = args.length; i < l; i++) push(this, args[i]);
+		return this.length;
+	}
+	unshift(...args) {
+		for (var i = 0, l = args.length; i < l; i++) unshift(this, args[i]);
+		return this.length;
+	}
+	pop() {
+		if (!this.tail) return;
+		const res = this.tail.value;
+		const t = this.tail;
+		this.tail = this.tail.prev;
+		if (this.tail) this.tail.next = void 0;
+		else this.head = void 0;
+		t.list = void 0;
+		this.length--;
+		return res;
+	}
+	shift() {
+		if (!this.head) return;
+		const res = this.head.value;
+		const h = this.head;
+		this.head = this.head.next;
+		if (this.head) this.head.prev = void 0;
+		else this.tail = void 0;
+		h.list = void 0;
+		this.length--;
+		return res;
+	}
+	forEach(fn, thisp) {
+		thisp = thisp || this;
+		for (let walker = this.head, i = 0; !!walker; i++) {
+			fn.call(thisp, walker.value, i, this);
+			walker = walker.next;
+		}
+	}
+	forEachReverse(fn, thisp) {
+		thisp = thisp || this;
+		for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
+			fn.call(thisp, walker.value, i, this);
+			walker = walker.prev;
+		}
+	}
+	get(n) {
+		let i = 0;
+		let walker = this.head;
+		for (; !!walker && i < n; i++) walker = walker.next;
+		if (i === n && !!walker) return walker.value;
+	}
+	getReverse(n) {
+		let i = 0;
+		let walker = this.tail;
+		for (; !!walker && i < n; i++) walker = walker.prev;
+		if (i === n && !!walker) return walker.value;
+	}
+	map(fn, thisp) {
+		thisp = thisp || this;
+		const res = new Yallist();
+		for (let walker = this.head; !!walker;) {
+			res.push(fn.call(thisp, walker.value, this));
+			walker = walker.next;
+		}
+		return res;
+	}
+	mapReverse(fn, thisp) {
+		thisp = thisp || this;
+		var res = new Yallist();
+		for (let walker = this.tail; !!walker;) {
+			res.push(fn.call(thisp, walker.value, this));
+			walker = walker.prev;
+		}
+		return res;
+	}
+	reduce(fn, initial) {
+		let acc;
+		let walker = this.head;
+		if (arguments.length > 1) acc = initial;
+		else if (this.head) {
+			walker = this.head.next;
+			acc = this.head.value;
+		} else throw new TypeError("Reduce of empty list with no initial value");
+		for (var i = 0; !!walker; i++) {
+			acc = fn(acc, walker.value, i);
+			walker = walker.next;
+		}
+		return acc;
+	}
+	reduceReverse(fn, initial) {
+		let acc;
+		let walker = this.tail;
+		if (arguments.length > 1) acc = initial;
+		else if (this.tail) {
+			walker = this.tail.prev;
+			acc = this.tail.value;
+		} else throw new TypeError("Reduce of empty list with no initial value");
+		for (let i = this.length - 1; !!walker; i--) {
+			acc = fn(acc, walker.value, i);
+			walker = walker.prev;
+		}
+		return acc;
+	}
+	toArray() {
+		const arr = new Array(this.length);
+		for (let i = 0, walker = this.head; !!walker; i++) {
+			arr[i] = walker.value;
+			walker = walker.next;
+		}
+		return arr;
+	}
+	toArrayReverse() {
+		const arr = new Array(this.length);
+		for (let i = 0, walker = this.tail; !!walker; i++) {
+			arr[i] = walker.value;
+			walker = walker.prev;
+		}
+		return arr;
+	}
+	slice(from = 0, to = this.length) {
+		if (to < 0) to += this.length;
+		if (from < 0) from += this.length;
+		const ret = new Yallist();
+		if (to < from || to < 0) return ret;
+		if (from < 0) from = 0;
+		if (to > this.length) to = this.length;
+		let walker = this.head;
+		let i = 0;
+		for (i = 0; !!walker && i < from; i++) walker = walker.next;
+		for (; !!walker && i < to; i++, walker = walker.next) ret.push(walker.value);
+		return ret;
+	}
+	sliceReverse(from = 0, to = this.length) {
+		if (to < 0) to += this.length;
+		if (from < 0) from += this.length;
+		const ret = new Yallist();
+		if (to < from || to < 0) return ret;
+		if (from < 0) from = 0;
+		if (to > this.length) to = this.length;
+		let i = this.length;
+		let walker = this.tail;
+		for (; !!walker && i > to; i--) walker = walker.prev;
+		for (; !!walker && i > from; i--, walker = walker.prev) ret.push(walker.value);
+		return ret;
+	}
+	splice(start, deleteCount = 0, ...nodes) {
+		if (start > this.length) start = this.length - 1;
+		if (start < 0) start = this.length + start;
+		let walker = this.head;
+		for (let i = 0; !!walker && i < start; i++) walker = walker.next;
+		const ret = [];
+		for (let i = 0; !!walker && i < deleteCount; i++) {
+			ret.push(walker.value);
+			walker = this.removeNode(walker);
+		}
+		if (!walker) walker = this.tail;
+		else if (walker !== this.tail) walker = walker.prev;
+		for (const v of nodes) walker = insertAfter(this, walker, v);
+		return ret;
+	}
+	reverse() {
+		const head = this.head;
+		const tail = this.tail;
+		for (let walker = head; !!walker; walker = walker.prev) {
+			const p = walker.prev;
+			walker.prev = walker.next;
+			walker.next = p;
+		}
+		this.head = tail;
+		this.tail = head;
+		return this;
+	}
+};
+function insertAfter(self, node, value) {
+	const inserted = new Node(value, node, node ? node.next : self.head, self);
+	if (inserted.next === void 0) self.tail = inserted;
+	if (inserted.prev === void 0) self.head = inserted;
+	self.length++;
+	return inserted;
+}
+function push(self, item) {
+	self.tail = new Node(item, self.tail, void 0, self);
+	if (!self.head) self.head = self.tail;
+	self.length++;
+}
+function unshift(self, item) {
+	self.head = new Node(item, void 0, self.head, self);
+	if (!self.tail) self.tail = self.head;
+	self.length++;
+}
+var Node = class {
+	list;
+	next;
+	prev;
+	value;
+	constructor(value, prev, next, list) {
+		this.list = list;
+		this.value = value;
+		if (prev) {
+			prev.next = this;
+			this.prev = prev;
+		} else this.prev = void 0;
+		if (next) {
+			next.prev = this;
+			this.next = next;
+		} else this.next = void 0;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/pack.js
+var PackJob = class {
+	path;
+	absolute;
+	entry;
+	stat;
+	readdir;
+	pending = false;
+	ignore = false;
+	piped = false;
+	constructor(path, absolute) {
+		this.path = path || "./";
+		this.absolute = absolute;
+	}
+};
+var EOF = Buffer.alloc(1024);
+var ONSTAT = Symbol("onStat");
+var ENDED$1 = Symbol("ended");
+var QUEUE = Symbol("queue");
+var CURRENT = Symbol("current");
+var PROCESS = Symbol("process");
+var PROCESSING = Symbol("processing");
+var PROCESSJOB = Symbol("processJob");
+var JOBS = Symbol("jobs");
+var JOBDONE = Symbol("jobDone");
+var ADDFSENTRY = Symbol("addFSEntry");
+var ADDTARENTRY = Symbol("addTarEntry");
+var STAT = Symbol("stat");
+var READDIR = Symbol("readdir");
+var ONREADDIR = Symbol("onreaddir");
+var PIPE = Symbol("pipe");
+var ENTRY = Symbol("entry");
+var ENTRYOPT = Symbol("entryOpt");
+var WRITEENTRYCLASS = Symbol("writeEntryClass");
+var WRITE = Symbol("write");
+var ONDRAIN = Symbol("ondrain");
+var Pack = class extends Minipass {
+	opt;
+	cwd;
+	maxReadSize;
+	preservePaths;
+	strict;
+	noPax;
+	prefix;
+	linkCache;
+	statCache;
+	file;
+	portable;
+	zip;
+	readdirCache;
+	noDirRecurse;
+	follow;
+	noMtime;
+	mtime;
+	filter;
+	jobs;
+	[WRITEENTRYCLASS];
+	onWriteEntry;
+	[QUEUE];
+	[JOBS] = 0;
+	[PROCESSING] = false;
+	[ENDED$1] = false;
+	constructor(opt = {}) {
+		super();
+		this.opt = opt;
+		this.file = opt.file || "";
+		this.cwd = opt.cwd || process.cwd();
+		this.maxReadSize = opt.maxReadSize;
+		this.preservePaths = !!opt.preservePaths;
+		this.strict = !!opt.strict;
+		this.noPax = !!opt.noPax;
+		this.prefix = normalizeWindowsPath(opt.prefix || "");
+		this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
+		this.statCache = opt.statCache || /* @__PURE__ */ new Map();
+		this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map();
+		this.onWriteEntry = opt.onWriteEntry;
+		this[WRITEENTRYCLASS] = WriteEntry;
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		this.portable = !!opt.portable;
+		if (opt.gzip || opt.brotli || opt.zstd) {
+			if ((opt.gzip ? 1 : 0) + (opt.brotli ? 1 : 0) + (opt.zstd ? 1 : 0) > 1) throw new TypeError("gzip, brotli, zstd are mutually exclusive");
+			if (opt.gzip) {
+				if (typeof opt.gzip !== "object") opt.gzip = {};
+				if (this.portable) opt.gzip.portable = true;
+				this.zip = new Gzip(opt.gzip);
+			}
+			if (opt.brotli) {
+				if (typeof opt.brotli !== "object") opt.brotli = {};
+				this.zip = new BrotliCompress(opt.brotli);
+			}
+			if (opt.zstd) {
+				if (typeof opt.zstd !== "object") opt.zstd = {};
+				this.zip = new ZstdCompress(opt.zstd);
+			}
+			/* c8 ignore next */
+			if (!this.zip) throw new Error("impossible");
+			const zip = this.zip;
+			zip.on("data", (chunk) => super.write(chunk));
+			zip.on("end", () => super.end());
+			zip.on("drain", () => this[ONDRAIN]());
+			this.on("resume", () => zip.resume());
+		} else this.on("drain", this[ONDRAIN]);
+		this.noDirRecurse = !!opt.noDirRecurse;
+		this.follow = !!opt.follow;
+		this.noMtime = !!opt.noMtime;
+		if (opt.mtime) this.mtime = opt.mtime;
+		this.filter = typeof opt.filter === "function" ? opt.filter : () => true;
+		this[QUEUE] = new Yallist();
+		this[JOBS] = 0;
+		this.jobs = Number(opt.jobs) || 4;
+		this[PROCESSING] = false;
+		this[ENDED$1] = false;
+	}
+	[WRITE](chunk) {
+		return super.write(chunk);
+	}
+	add(path) {
+		this.write(path);
+		return this;
+	}
+	end(path, encoding, cb) {
+		/* c8 ignore start */
+		if (typeof path === "function") {
+			cb = path;
+			path = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		/* c8 ignore stop */
+		if (path) this.add(path);
+		this[ENDED$1] = true;
+		this[PROCESS]();
+		/* c8 ignore next */
+		if (cb) cb();
+		return this;
+	}
+	write(path) {
+		if (this[ENDED$1]) throw new Error("write after end");
+		if (path instanceof ReadEntry) this[ADDTARENTRY](path);
+		else this[ADDFSENTRY](path);
+		return this.flowing;
+	}
+	[ADDTARENTRY](p) {
+		const absolute = normalizeWindowsPath(path$1.resolve(this.cwd, p.path));
+		if (!this.filter(p.path, p)) p.resume();
+		else {
+			const job = new PackJob(p.path, absolute);
+			job.entry = new WriteEntryTar(p, this[ENTRYOPT](job));
+			job.entry.on("end", () => this[JOBDONE](job));
+			this[JOBS] += 1;
+			this[QUEUE].push(job);
+		}
+		this[PROCESS]();
+	}
+	[ADDFSENTRY](p) {
+		const absolute = normalizeWindowsPath(path$1.resolve(this.cwd, p));
+		this[QUEUE].push(new PackJob(p, absolute));
+		this[PROCESS]();
+	}
+	[STAT](job) {
+		job.pending = true;
+		this[JOBS] += 1;
+		fs$2[this.follow ? "stat" : "lstat"](job.absolute, (er, stat) => {
+			job.pending = false;
+			this[JOBS] -= 1;
+			if (er) this.emit("error", er);
+			else this[ONSTAT](job, stat);
+		});
+	}
+	[ONSTAT](job, stat) {
+		this.statCache.set(job.absolute, stat);
+		job.stat = stat;
+		if (!this.filter(job.path, stat)) job.ignore = true;
+		this[PROCESS]();
+	}
+	[READDIR](job) {
+		job.pending = true;
+		this[JOBS] += 1;
+		fs$2.readdir(job.absolute, (er, entries) => {
+			job.pending = false;
+			this[JOBS] -= 1;
+			if (er) return this.emit("error", er);
+			this[ONREADDIR](job, entries);
+		});
+	}
+	[ONREADDIR](job, entries) {
+		this.readdirCache.set(job.absolute, entries);
+		job.readdir = entries;
+		this[PROCESS]();
+	}
+	[PROCESS]() {
+		if (this[PROCESSING]) return;
+		this[PROCESSING] = true;
+		for (let w = this[QUEUE].head; !!w && this[JOBS] < this.jobs; w = w.next) {
+			this[PROCESSJOB](w.value);
+			if (w.value.ignore) {
+				const p = w.next;
+				this[QUEUE].removeNode(w);
+				w.next = p;
+			}
+		}
+		this[PROCESSING] = false;
+		if (this[ENDED$1] && !this[QUEUE].length && this[JOBS] === 0) if (this.zip) this.zip.end(EOF);
+		else {
+			super.write(EOF);
+			super.end();
+		}
+	}
+	get [CURRENT]() {
+		return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value;
+	}
+	[JOBDONE](_job) {
+		this[QUEUE].shift();
+		this[JOBS] -= 1;
+		this[PROCESS]();
+	}
+	[PROCESSJOB](job) {
+		if (job.pending) return;
+		if (job.entry) {
+			if (job === this[CURRENT] && !job.piped) this[PIPE](job);
+			return;
+		}
+		if (!job.stat) {
+			const sc = this.statCache.get(job.absolute);
+			if (sc) this[ONSTAT](job, sc);
+			else this[STAT](job);
+		}
+		if (!job.stat) return;
+		if (job.ignore) return;
+		if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) {
+			const rc = this.readdirCache.get(job.absolute);
+			if (rc) this[ONREADDIR](job, rc);
+			else this[READDIR](job);
+			if (!job.readdir) return;
+		}
+		job.entry = this[ENTRY](job);
+		if (!job.entry) {
+			job.ignore = true;
+			return;
+		}
+		if (job === this[CURRENT] && !job.piped) this[PIPE](job);
+	}
+	[ENTRYOPT](job) {
+		return {
+			onwarn: (code, msg, data) => this.warn(code, msg, data),
+			noPax: this.noPax,
+			cwd: this.cwd,
+			absolute: job.absolute,
+			preservePaths: this.preservePaths,
+			maxReadSize: this.maxReadSize,
+			strict: this.strict,
+			portable: this.portable,
+			linkCache: this.linkCache,
+			statCache: this.statCache,
+			noMtime: this.noMtime,
+			mtime: this.mtime,
+			prefix: this.prefix,
+			onWriteEntry: this.onWriteEntry
+		};
+	}
+	[ENTRY](job) {
+		this[JOBS] += 1;
+		try {
+			return new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job)).on("end", () => this[JOBDONE](job)).on("error", (er) => this.emit("error", er));
+		} catch (er) {
+			this.emit("error", er);
+		}
+	}
+	[ONDRAIN]() {
+		if (this[CURRENT] && this[CURRENT].entry) this[CURRENT].entry.resume();
+	}
+	[PIPE](job) {
+		job.piped = true;
+		if (job.readdir) job.readdir.forEach((entry) => {
+			const p = job.path;
+			const base = p === "./" ? "" : p.replace(/\/*$/, "/");
+			this[ADDFSENTRY](base + entry);
+		});
+		const source = job.entry;
+		const zip = this.zip;
+		/* c8 ignore start */
+		if (!source) throw new Error("cannot pipe without source");
+		/* c8 ignore stop */
+		if (zip) source.on("data", (chunk) => {
+			if (!zip.write(chunk)) source.pause();
+		});
+		else source.on("data", (chunk) => {
+			if (!super.write(chunk)) source.pause();
+		});
+	}
+	pause() {
+		if (this.zip) this.zip.pause();
+		return super.pause();
+	}
+	warn(code, message, data = {}) {
+		warnMethod(this, code, message, data);
+	}
+};
+var PackSync = class extends Pack {
+	sync = true;
+	constructor(opt) {
+		super(opt);
+		this[WRITEENTRYCLASS] = WriteEntrySync;
+	}
+	pause() {}
+	resume() {}
+	[STAT](job) {
+		const stat = this.follow ? "statSync" : "lstatSync";
+		this[ONSTAT](job, fs$2[stat](job.absolute));
+	}
+	[READDIR](job) {
+		this[ONREADDIR](job, fs$2.readdirSync(job.absolute));
+	}
+	[PIPE](job) {
+		const source = job.entry;
+		const zip = this.zip;
+		if (job.readdir) job.readdir.forEach((entry) => {
+			const p = job.path;
+			const base = p === "./" ? "" : p.replace(/\/*$/, "/");
+			this[ADDFSENTRY](base + entry);
+		});
+		/* c8 ignore start */
+		if (!source) throw new Error("Cannot pipe without source");
+		/* c8 ignore stop */
+		if (zip) source.on("data", (chunk) => {
+			zip.write(chunk);
+		});
+		else source.on("data", (chunk) => {
+			super[WRITE](chunk);
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/create.js
+var createFileSync = (opt, files) => {
+	const p = new PackSync(opt);
+	const stream = new WriteStreamSync(opt.file, { mode: opt.mode || 438 });
+	p.pipe(stream);
+	addFilesSync$1(p, files);
+};
+var createFile = (opt, files) => {
+	const p = new Pack(opt);
+	const stream = new WriteStream(opt.file, { mode: opt.mode || 438 });
+	p.pipe(stream);
+	const promise = new Promise((res, rej) => {
+		stream.on("error", rej);
+		stream.on("close", res);
+		p.on("error", rej);
+	});
+	addFilesAsync$1(p, files);
+	return promise;
+};
+var addFilesSync$1 = (p, files) => {
+	files.forEach((file) => {
+		if (file.charAt(0) === "@") list({
+			file: path.resolve(p.cwd, file.slice(1)),
+			sync: true,
+			noResume: true,
+			onReadEntry: (entry) => p.add(entry)
+		});
+		else p.add(file);
+	});
+	p.end();
+};
+var addFilesAsync$1 = async (p, files) => {
+	for (let i = 0; i < files.length; i++) {
+		const file = String(files[i]);
+		if (file.charAt(0) === "@") await list({
+			file: path.resolve(String(p.cwd), file.slice(1)),
+			noResume: true,
+			onReadEntry: (entry) => {
+				p.add(entry);
+			}
+		});
+		else p.add(file);
+	}
+	p.end();
+};
+var createSync = (opt, files) => {
+	const p = new PackSync(opt);
+	addFilesSync$1(p, files);
+	return p;
+};
+var createAsync = (opt, files) => {
+	const p = new Pack(opt);
+	addFilesAsync$1(p, files);
+	return p;
+};
+makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => {
+	if (!files?.length) throw new TypeError("no paths specified to add to archive");
+});
 //#endregion
 //#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/get-write-flag.js
 var isWindows$2 = (process.env.__FAKE_PLATFORM__ || process.platform) === "win32";
@@ -1993,4 +3162,157 @@ var extract = makeCommand(extractFileSync, extractFile, (opt) => new UnpackSync(
 	if (files?.length) filesFilter(opt, files);
 });
 //#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/replace.js
+var replaceSync = (opt, files) => {
+	const p = new PackSync(opt);
+	let threw = true;
+	let fd;
+	let position;
+	try {
+		try {
+			fd = fs.openSync(opt.file, "r+");
+		} catch (er) {
+			if (er?.code === "ENOENT") fd = fs.openSync(opt.file, "w+");
+			else throw er;
+		}
+		const st = fs.fstatSync(fd);
+		const headBuf = Buffer.alloc(512);
+		POSITION: for (position = 0; position < st.size; position += 512) {
+			for (let bufPos = 0, bytes = 0; bufPos < 512; bufPos += bytes) {
+				bytes = fs.readSync(fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos);
+				if (position === 0 && headBuf[0] === 31 && headBuf[1] === 139) throw new Error("cannot append to compressed archives");
+				if (!bytes) break POSITION;
+			}
+			const h = new Header(headBuf);
+			if (!h.cksumValid) break;
+			const entryBlockSize = 512 * Math.ceil((h.size || 0) / 512);
+			if (position + entryBlockSize + 512 > st.size) break;
+			position += entryBlockSize;
+			if (opt.mtimeCache && h.mtime) opt.mtimeCache.set(String(h.path), h.mtime);
+		}
+		threw = false;
+		streamSync(opt, p, position, fd, files);
+	} finally {
+		if (threw) try {
+			fs.closeSync(fd);
+		} catch (er) {}
+	}
+};
+var streamSync = (opt, p, position, fd, files) => {
+	const stream = new WriteStreamSync(opt.file, {
+		fd,
+		start: position
+	});
+	p.pipe(stream);
+	addFilesSync(p, files);
+};
+var replaceAsync = (opt, files) => {
+	files = Array.from(files);
+	const p = new Pack(opt);
+	const getPos = (fd, size, cb_) => {
+		const cb = (er, pos) => {
+			if (er) fs.close(fd, (_) => cb_(er));
+			else cb_(null, pos);
+		};
+		let position = 0;
+		if (size === 0) return cb(null, 0);
+		let bufPos = 0;
+		const headBuf = Buffer.alloc(512);
+		const onread = (er, bytes) => {
+			if (er || typeof bytes === "undefined") return cb(er);
+			bufPos += bytes;
+			if (bufPos < 512 && bytes) return fs.read(fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos, onread);
+			if (position === 0 && headBuf[0] === 31 && headBuf[1] === 139) return cb(/* @__PURE__ */ new Error("cannot append to compressed archives"));
+			if (bufPos < 512) return cb(null, position);
+			const h = new Header(headBuf);
+			if (!h.cksumValid) return cb(null, position);
+			/* c8 ignore next */
+			const entryBlockSize = 512 * Math.ceil((h.size ?? 0) / 512);
+			if (position + entryBlockSize + 512 > size) return cb(null, position);
+			position += entryBlockSize + 512;
+			if (position >= size) return cb(null, position);
+			if (opt.mtimeCache && h.mtime) opt.mtimeCache.set(String(h.path), h.mtime);
+			bufPos = 0;
+			fs.read(fd, headBuf, 0, 512, position, onread);
+		};
+		fs.read(fd, headBuf, 0, 512, position, onread);
+	};
+	return new Promise((resolve, reject) => {
+		p.on("error", reject);
+		let flag = "r+";
+		const onopen = (er, fd) => {
+			if (er && er.code === "ENOENT" && flag === "r+") {
+				flag = "w+";
+				return fs.open(opt.file, flag, onopen);
+			}
+			if (er || !fd) return reject(er);
+			fs.fstat(fd, (er, st) => {
+				if (er) return fs.close(fd, () => reject(er));
+				getPos(fd, st.size, (er, position) => {
+					if (er) return reject(er);
+					const stream = new WriteStream(opt.file, {
+						fd,
+						start: position
+					});
+					p.pipe(stream);
+					stream.on("error", reject);
+					stream.on("close", resolve);
+					addFilesAsync(p, files);
+				});
+			});
+		};
+		fs.open(opt.file, flag, onopen);
+	});
+};
+var addFilesSync = (p, files) => {
+	files.forEach((file) => {
+		if (file.charAt(0) === "@") list({
+			file: path.resolve(p.cwd, file.slice(1)),
+			sync: true,
+			noResume: true,
+			onReadEntry: (entry) => p.add(entry)
+		});
+		else p.add(file);
+	});
+	p.end();
+};
+var addFilesAsync = async (p, files) => {
+	for (let i = 0; i < files.length; i++) {
+		const file = String(files[i]);
+		if (file.charAt(0) === "@") await list({
+			file: path.resolve(String(p.cwd), file.slice(1)),
+			noResume: true,
+			onReadEntry: (entry) => p.add(entry)
+		});
+		else p.add(file);
+	}
+	p.end();
+};
+var replace = makeCommand(
+	replaceSync,
+	replaceAsync,
+	/* c8 ignore start */
+	() => {
+		throw new TypeError("file is required");
+	},
+	() => {
+		throw new TypeError("file is required");
+	},
+	/* c8 ignore stop */
+	(opt, entries) => {
+		if (!isFile(opt)) throw new TypeError("file is required");
+		if (opt.gzip || opt.brotli || opt.zstd || opt.file.endsWith(".br") || opt.file.endsWith(".tbr")) throw new TypeError("cannot append to compressed archives");
+		if (!entries?.length) throw new TypeError("no paths specified to add/replace");
+	}
+);
+makeCommand(replace.syncFile, replace.asyncFile, replace.syncNoFile, replace.asyncNoFile, (opt, entries = []) => {
+	replace.validate?.(opt, entries);
+	mtimeFilter(opt);
+});
+var mtimeFilter = (opt) => {
+	const filter = opt.filter;
+	if (!opt.mtimeCache) opt.mtimeCache = /* @__PURE__ */ new Map();
+	opt.filter = filter ? (path, stat) => filter(path, stat) && !((opt.mtimeCache?.get(path) ?? stat.mtime ?? 0) > (stat.mtime ?? 0)) : (path, stat) => !((opt.mtimeCache?.get(path) ?? stat.mtime ?? 0) > (stat.mtime ?? 0));
+};
+//#endregion
 export { extract as t };