@hot-updater/console 0.27.1 → 0.29.0

package/.output/server/_libs/tar.mjs

@@ -0,0 +1,1996 @@
+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 { n as chownrSync, t as chownr } from "./chownr.mjs";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+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 assert from "node:assert";
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/options.js
+var argmap = new Map([
+	["C", "cwd"],
+	["f", "file"],
+	["z", "gzip"],
+	["P", "preservePaths"],
+	["U", "unlink"],
+	["strip-components", "strip"],
+	["stripComponents", "strip"],
+	["keep-newer", "newer"],
+	["keepNewer", "newer"],
+	["keep-newer-files", "newer"],
+	["keepNewerFiles", "newer"],
+	["k", "keep"],
+	["keep-existing", "keep"],
+	["keepExisting", "keep"],
+	["m", "noMtime"],
+	["no-mtime", "noMtime"],
+	["p", "preserveOwner"],
+	["L", "follow"],
+	["h", "follow"],
+	["onentry", "onReadEntry"]
+]);
+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 dealiasKey = (k) => {
+	const d = argmap.get(k);
+	if (d) return d;
+	return k;
+};
+var dealias = (opt = {}) => {
+	if (!opt) return {};
+	const result = {};
+	for (const [key, v] of Object.entries(opt)) {
+		const k = dealiasKey(key);
+		result[k] = v;
+	}
+	if (result.chmod === void 0 && result.noChmod === false) result.chmod = true;
+	delete result.noChmod;
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/make-command.js
+var makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => {
+	return Object.assign((opt_ = [], entries, cb) => {
+		if (Array.isArray(opt_)) {
+			entries = opt_;
+			opt_ = {};
+		}
+		if (typeof entries === "function") {
+			cb = entries;
+			entries = void 0;
+		}
+		if (!entries) entries = [];
+		else entries = Array.from(entries);
+		const opt = dealias(opt_);
+		validate?.(opt, entries);
+		if (isSyncFile(opt)) {
+			if (typeof cb === "function") throw new TypeError("callback not supported for sync tar functions");
+			return syncFile(opt, entries);
+		} else if (isAsyncFile(opt)) {
+			const p = asyncFile(opt, entries);
+			const c = cb ? cb : void 0;
+			return c ? p.then(() => c(), c) : p;
+		} else if (isSyncNoFile(opt)) {
+			if (typeof cb === "function") throw new TypeError("callback not supported for sync tar functions");
+			return syncNoFile(opt, entries);
+		} else if (isAsyncNoFile(opt)) {
+			if (typeof cb === "function") throw new TypeError("callback only supported with file option");
+			return asyncNoFile(opt, entries);
+		} else throw new Error("impossible options??");
+		/* c8 ignore stop */
+	}, {
+		syncFile,
+		asyncFile,
+		syncNoFile,
+		asyncNoFile,
+		validate
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/large-numbers.js
+var encode$1 = (num, buf) => {
+	if (!Number.isSafeInteger(num)) throw Error("cannot encode number outside of javascript safe integer range");
+	else if (num < 0) encodeNegative(num, buf);
+	else encodePositive(num, buf);
+	return buf;
+};
+var encodePositive = (num, buf) => {
+	buf[0] = 128;
+	for (var i = buf.length; i > 1; i--) {
+		buf[i - 1] = num & 255;
+		num = Math.floor(num / 256);
+	}
+};
+var encodeNegative = (num, buf) => {
+	buf[0] = 255;
+	var flipped = false;
+	num = num * -1;
+	for (var i = buf.length; i > 1; i--) {
+		var byte = num & 255;
+		num = Math.floor(num / 256);
+		if (flipped) buf[i - 1] = onesComp(byte);
+		else if (byte === 0) buf[i - 1] = 0;
+		else {
+			flipped = true;
+			buf[i - 1] = twosComp(byte);
+		}
+	}
+};
+var parse$2 = (buf) => {
+	const pre = buf[0];
+	const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
+	if (value === null) throw Error("invalid base256 encoding");
+	if (!Number.isSafeInteger(value)) throw Error("parsed number outside of javascript safe integer range");
+	return value;
+};
+var twos = (buf) => {
+	var len = buf.length;
+	var sum = 0;
+	var flipped = false;
+	for (var i = len - 1; i > -1; i--) {
+		var byte = Number(buf[i]);
+		var f;
+		if (flipped) f = onesComp(byte);
+		else if (byte === 0) f = byte;
+		else {
+			flipped = true;
+			f = twosComp(byte);
+		}
+		if (f !== 0) sum -= f * Math.pow(256, len - i - 1);
+	}
+	return sum;
+};
+var pos = (buf) => {
+	var len = buf.length;
+	var sum = 0;
+	for (var i = len - 1; i > -1; i--) {
+		var byte = Number(buf[i]);
+		if (byte !== 0) sum += byte * Math.pow(256, len - i - 1);
+	}
+	return sum;
+};
+var onesComp = (byte) => (255 ^ byte) & 255;
+var twosComp = (byte) => (255 ^ byte) + 1 & 255;
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/types.js
+var isCode = (c) => name.has(c);
+var name = new Map([
+	["0", "File"],
+	["", "OldFile"],
+	["1", "Link"],
+	["2", "SymbolicLink"],
+	["3", "CharacterDevice"],
+	["4", "BlockDevice"],
+	["5", "Directory"],
+	["6", "FIFO"],
+	["7", "ContiguousFile"],
+	["g", "GlobalExtendedHeader"],
+	["x", "ExtendedHeader"],
+	["A", "SolarisACL"],
+	["D", "GNUDumpDir"],
+	["I", "Inode"],
+	["K", "NextFileHasLongLinkpath"],
+	["L", "NextFileHasLongPath"],
+	["M", "ContinuationFile"],
+	["N", "OldGnuLongPath"],
+	["S", "SparseFile"],
+	["V", "TapeVolumeHeader"],
+	["X", "OldExtendedHeader"]
+]);
+var code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/header.js
+var Header = class {
+	cksumValid = false;
+	needPax = false;
+	nullBlock = false;
+	block;
+	path;
+	mode;
+	uid;
+	gid;
+	size;
+	cksum;
+	#type = "Unsupported";
+	linkpath;
+	uname;
+	gname;
+	devmaj = 0;
+	devmin = 0;
+	atime;
+	ctime;
+	mtime;
+	charset;
+	comment;
+	constructor(data, off = 0, ex, gex) {
+		if (Buffer.isBuffer(data)) this.decode(data, off || 0, ex, gex);
+		else if (data) this.#slurp(data);
+	}
+	decode(buf, off, ex, gex) {
+		if (!off) off = 0;
+		if (!buf || !(buf.length >= off + 512)) throw new Error("need 512 bytes for header");
+		this.path = decString(buf, off, 100);
+		this.mode = decNumber(buf, off + 100, 8);
+		this.uid = decNumber(buf, off + 108, 8);
+		this.gid = decNumber(buf, off + 116, 8);
+		this.size = decNumber(buf, off + 124, 12);
+		this.mtime = decDate(buf, off + 136, 12);
+		this.cksum = decNumber(buf, off + 148, 12);
+		if (gex) this.#slurp(gex, true);
+		if (ex) this.#slurp(ex);
+		const t = decString(buf, off + 156, 1);
+		if (isCode(t)) this.#type = t || "0";
+		if (this.#type === "0" && this.path.slice(-1) === "/") this.#type = "5";
+		if (this.#type === "5") this.size = 0;
+		this.linkpath = decString(buf, off + 157, 100);
+		if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
+			this.uname = decString(buf, off + 265, 32);
+			this.gname = decString(buf, off + 297, 32);
+			/* c8 ignore start */
+			this.devmaj = decNumber(buf, off + 329, 8) ?? 0;
+			this.devmin = decNumber(buf, off + 337, 8) ?? 0;
+			/* c8 ignore stop */
+			if (buf[off + 475] !== 0) this.path = decString(buf, off + 345, 155) + "/" + this.path;
+			else {
+				const prefix = decString(buf, off + 345, 130);
+				if (prefix) this.path = prefix + "/" + this.path;
+				this.atime = decDate(buf, off + 476, 12);
+				this.ctime = decDate(buf, off + 488, 12);
+			}
+		}
+		let sum = 256;
+		for (let i = off; i < off + 148; i++) sum += buf[i];
+		for (let i = off + 156; i < off + 512; i++) sum += buf[i];
+		this.cksumValid = sum === this.cksum;
+		if (this.cksum === void 0 && sum === 256) this.nullBlock = true;
+	}
+	#slurp(ex, gex = false) {
+		Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+			return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global");
+		})));
+	}
+	encode(buf, off = 0) {
+		if (!buf) buf = this.block = Buffer.alloc(512);
+		if (this.#type === "Unsupported") this.#type = "0";
+		if (!(buf.length >= off + 512)) throw new Error("need 512 bytes for header");
+		const prefixSize = this.ctime || this.atime ? 130 : 155;
+		const split = splitPrefix(this.path || "", prefixSize);
+		const path = split[0];
+		const prefix = split[1];
+		this.needPax = !!split[2];
+		this.needPax = encString(buf, off, 100, path) || this.needPax;
+		this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
+		this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
+		this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
+		this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
+		this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
+		buf[off + 156] = this.#type.charCodeAt(0);
+		this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax;
+		buf.write("ustar\x0000", off + 257, 8);
+		this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax;
+		this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax;
+		this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
+		this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
+		this.needPax = encString(buf, off + 345, prefixSize, prefix) || this.needPax;
+		if (buf[off + 475] !== 0) this.needPax = encString(buf, off + 345, 155, prefix) || this.needPax;
+		else {
+			this.needPax = encString(buf, off + 345, 130, prefix) || this.needPax;
+			this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax;
+			this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax;
+		}
+		let sum = 256;
+		for (let i = off; i < off + 148; i++) sum += buf[i];
+		for (let i = off + 156; i < off + 512; i++) sum += buf[i];
+		this.cksum = sum;
+		encNumber(buf, off + 148, 8, this.cksum);
+		this.cksumValid = true;
+		return this.needPax;
+	}
+	get type() {
+		return this.#type === "Unsupported" ? this.#type : name.get(this.#type);
+	}
+	get typeKey() {
+		return this.#type;
+	}
+	set type(type) {
+		const c = String(code.get(type));
+		if (isCode(c) || c === "Unsupported") this.#type = c;
+		else if (isCode(type)) this.#type = type;
+		else throw new TypeError("invalid entry type: " + type);
+	}
+};
+var splitPrefix = (p, prefixSize) => {
+	const pathSize = 100;
+	let pp = p;
+	let prefix = "";
+	let ret = void 0;
+	const root = posix.parse(p).root || ".";
+	if (Buffer.byteLength(pp) < pathSize) ret = [
+		pp,
+		prefix,
+		false
+	];
+	else {
+		prefix = posix.dirname(pp);
+		pp = posix.basename(pp);
+		do
+			if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix) <= prefixSize) ret = [
+				pp,
+				prefix,
+				false
+			];
+			else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix) <= prefixSize) ret = [
+				pp.slice(0, pathSize - 1),
+				prefix,
+				true
+			];
+			else {
+				pp = posix.join(posix.basename(prefix), pp);
+				prefix = posix.dirname(prefix);
+			}
+		while (prefix !== root && ret === void 0);
+		if (!ret) ret = [
+			p.slice(0, pathSize - 1),
+			"",
+			true
+		];
+	}
+	return ret;
+};
+var decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
+var decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
+var numToDate = (num) => num === void 0 ? void 0 : /* @__PURE__ */ new Date(num * 1e3);
+var decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse$2(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
+var nanUndef = (value) => isNaN(value) ? void 0 : value;
+var decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
+var MAXNUM = {
+	12: 8589934591,
+	8: 2097151
+};
+var encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode$1(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
+var encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
+var octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
+var padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
+var encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
+var NULLS = new Array(156).join("\0");
+var encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/pax.js
+var Pax = class Pax {
+	atime;
+	mtime;
+	ctime;
+	charset;
+	comment;
+	gid;
+	uid;
+	gname;
+	uname;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	path;
+	size;
+	mode;
+	global;
+	constructor(obj, global = false) {
+		this.atime = obj.atime;
+		this.charset = obj.charset;
+		this.comment = obj.comment;
+		this.ctime = obj.ctime;
+		this.dev = obj.dev;
+		this.gid = obj.gid;
+		this.global = global;
+		this.gname = obj.gname;
+		this.ino = obj.ino;
+		this.linkpath = obj.linkpath;
+		this.mtime = obj.mtime;
+		this.nlink = obj.nlink;
+		this.path = obj.path;
+		this.size = obj.size;
+		this.uid = obj.uid;
+		this.uname = obj.uname;
+	}
+	encode() {
+		const body = this.encodeBody();
+		if (body === "") return Buffer.allocUnsafe(0);
+		const bodyLen = Buffer.byteLength(body);
+		const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+		const buf = Buffer.allocUnsafe(bufLen);
+		for (let i = 0; i < 512; i++) buf[i] = 0;
+		new Header({
+			path: ("PaxHeader/" + basename(this.path ?? "")).slice(0, 99),
+			mode: this.mode || 420,
+			uid: this.uid,
+			gid: this.gid,
+			size: bodyLen,
+			mtime: this.mtime,
+			type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
+			linkpath: "",
+			uname: this.uname || "",
+			gname: this.gname || "",
+			devmaj: 0,
+			devmin: 0,
+			atime: this.atime,
+			ctime: this.ctime
+		}).encode(buf);
+		buf.write(body, 512, bodyLen, "utf8");
+		for (let i = bodyLen + 512; i < buf.length; i++) buf[i] = 0;
+		return buf;
+	}
+	encodeBody() {
+		return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
+	}
+	encodeField(field) {
+		if (this[field] === void 0) return "";
+		const r = this[field];
+		const v = r instanceof Date ? r.getTime() / 1e3 : r;
+		const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
+		const byteLen = Buffer.byteLength(s);
+		let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
+		if (byteLen + digits >= Math.pow(10, digits)) digits += 1;
+		return digits + byteLen + s;
+	}
+	static parse(str, ex, g = false) {
+		return new Pax(merge(parseKV(str), ex), g);
+	}
+};
+var merge = (a, b) => b ? Object.assign({}, b, a) : a;
+var parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, Object.create(null));
+var parseKVLine = (set, line) => {
+	const n = parseInt(line, 10);
+	if (n !== Buffer.byteLength(line) + 1) return set;
+	line = line.slice((n + " ").length);
+	const kv = line.split("=");
+	const r = kv.shift();
+	if (!r) return set;
+	const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1");
+	const v = kv.join("=");
+	set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? /* @__PURE__ */ new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v;
+	return set;
+};
+var normalizeWindowsPath = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/");
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/read-entry.js
+var ReadEntry = class extends Minipass {
+	extended;
+	globalExtended;
+	header;
+	startBlockSize;
+	blockRemain;
+	remain;
+	type;
+	meta = false;
+	ignore = false;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	size = 0;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	invalid = false;
+	absolute;
+	unsupported = false;
+	constructor(header, ex, gex) {
+		super({});
+		this.pause();
+		this.extended = ex;
+		this.globalExtended = gex;
+		this.header = header;
+		/* c8 ignore start */
+		this.remain = header.size ?? 0;
+		/* c8 ignore stop */
+		this.startBlockSize = 512 * Math.ceil(this.remain / 512);
+		this.blockRemain = this.startBlockSize;
+		this.type = header.type;
+		switch (this.type) {
+			case "File":
+			case "OldFile":
+			case "Link":
+			case "SymbolicLink":
+			case "CharacterDevice":
+			case "BlockDevice":
+			case "Directory":
+			case "FIFO":
+			case "ContiguousFile":
+			case "GNUDumpDir": break;
+			case "NextFileHasLongLinkpath":
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath":
+			case "GlobalExtendedHeader":
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this.meta = true;
+				break;
+			default: this.ignore = true;
+		}
+		/* c8 ignore start */
+		if (!header.path) throw new Error("no path provided for tar.ReadEntry");
+		/* c8 ignore stop */
+		this.path = normalizeWindowsPath(header.path);
+		this.mode = header.mode;
+		if (this.mode) this.mode = this.mode & 4095;
+		this.uid = header.uid;
+		this.gid = header.gid;
+		this.uname = header.uname;
+		this.gname = header.gname;
+		this.size = this.remain;
+		this.mtime = header.mtime;
+		this.atime = header.atime;
+		this.ctime = header.ctime;
+		/* c8 ignore start */
+		this.linkpath = header.linkpath ? normalizeWindowsPath(header.linkpath) : void 0;
+		/* c8 ignore stop */
+		this.uname = header.uname;
+		this.gname = header.gname;
+		if (ex) this.#slurp(ex);
+		if (gex) this.#slurp(gex, true);
+	}
+	write(data) {
+		const writeLen = data.length;
+		if (writeLen > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		const r = this.remain;
+		const br = this.blockRemain;
+		this.remain = Math.max(0, r - writeLen);
+		this.blockRemain = Math.max(0, br - writeLen);
+		if (this.ignore) return true;
+		if (r >= writeLen) return super.write(data);
+		return super.write(data.subarray(0, r));
+	}
+	#slurp(ex, gex = false) {
+		if (ex.path) ex.path = normalizeWindowsPath(ex.path);
+		if (ex.linkpath) ex.linkpath = normalizeWindowsPath(ex.linkpath);
+		Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+			return !(v === null || v === void 0 || k === "path" && gex);
+		})));
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/warn-method.js
+var warnMethod = (self, code, message, data = {}) => {
+	if (self.file) data.file = self.file;
+	if (self.cwd) data.cwd = self.cwd;
+	data.code = message instanceof Error && message.code || code;
+	data.tarCode = code;
+	if (!self.strict && data.recoverable !== false) {
+		if (message instanceof Error) {
+			data = Object.assign(message, data);
+			message = message.message;
+		}
+		self.emit("warn", code, message, data);
+	} else if (message instanceof Error) self.emit("error", Object.assign(message, data));
+	else self.emit("error", Object.assign(/* @__PURE__ */ new Error(`${code}: ${message}`), data));
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/parse.js
+var maxMetaEntrySize = 1024 * 1024;
+var gzipHeader = Buffer.from([31, 139]);
+var zstdHeader = Buffer.from([
+	40,
+	181,
+	47,
+	253
+]);
+var ZIP_HEADER_LEN = Math.max(gzipHeader.length, zstdHeader.length);
+var STATE = Symbol("state");
+var WRITEENTRY = Symbol("writeEntry");
+var READENTRY = Symbol("readEntry");
+var NEXTENTRY = Symbol("nextEntry");
+var PROCESSENTRY = Symbol("processEntry");
+var EX = Symbol("extendedHeader");
+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 EMITTEDEND = Symbol("emittedEnd");
+var EMIT = Symbol("emit");
+var UNZIP = Symbol("unzip");
+var CONSUMECHUNK = Symbol("consumeChunk");
+var CONSUMECHUNKSUB = Symbol("consumeChunkSub");
+var CONSUMEBODY = Symbol("consumeBody");
+var CONSUMEMETA = Symbol("consumeMeta");
+var CONSUMEHEADER = Symbol("consumeHeader");
+var CONSUMING = Symbol("consuming");
+var BUFFERCONCAT = Symbol("bufferConcat");
+var MAYBEEND = Symbol("maybeEnd");
+var WRITING = Symbol("writing");
+var ABORTED = Symbol("aborted");
+var DONE = Symbol("onDone");
+var SAW_VALID_ENTRY = Symbol("sawValidEntry");
+var SAW_NULL_BLOCK = Symbol("sawNullBlock");
+var SAW_EOF = Symbol("sawEOF");
+var CLOSESTREAM = Symbol("closeStream");
+var noop = () => true;
+var Parser = class extends EventEmitter {
+	file;
+	strict;
+	maxMetaEntrySize;
+	filter;
+	brotli;
+	zstd;
+	writable = true;
+	readable = false;
+	[QUEUE] = [];
+	[BUFFER];
+	[READENTRY];
+	[WRITEENTRY];
+	[STATE] = "begin";
+	[META] = "";
+	[EX];
+	[GEX];
+	[ENDED$1] = false;
+	[UNZIP];
+	[ABORTED] = false;
+	[SAW_VALID_ENTRY];
+	[SAW_NULL_BLOCK] = false;
+	[SAW_EOF] = false;
+	[WRITING] = false;
+	[CONSUMING] = false;
+	[EMITTEDEND] = false;
+	constructor(opt = {}) {
+		super();
+		this.file = opt.file || "";
+		this.on(DONE, () => {
+			if (this[STATE] === "begin" || this[SAW_VALID_ENTRY] === false) this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format");
+		});
+		if (opt.ondone) this.on(DONE, opt.ondone);
+		else this.on(DONE, () => {
+			this.emit("prefinish");
+			this.emit("finish");
+			this.emit("end");
+		});
+		this.strict = !!opt.strict;
+		this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
+		this.filter = typeof opt.filter === "function" ? opt.filter : noop;
+		const isTBR = opt.file && (opt.file.endsWith(".tar.br") || opt.file.endsWith(".tbr"));
+		this.brotli = !(opt.gzip || opt.zstd) && opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false;
+		const isTZST = opt.file && (opt.file.endsWith(".tar.zst") || opt.file.endsWith(".tzst"));
+		this.zstd = !(opt.gzip || opt.brotli) && opt.zstd !== void 0 ? opt.zstd : isTZST ? true : void 0;
+		this.on("end", () => this[CLOSESTREAM]());
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		if (typeof opt.onReadEntry === "function") this.on("entry", opt.onReadEntry);
+	}
+	warn(code, message, data = {}) {
+		warnMethod(this, code, message, data);
+	}
+	[CONSUMEHEADER](chunk, position) {
+		if (this[SAW_VALID_ENTRY] === void 0) this[SAW_VALID_ENTRY] = false;
+		let header;
+		try {
+			header = new Header(chunk, position, this[EX], this[GEX]);
+		} catch (er) {
+			return this.warn("TAR_ENTRY_INVALID", er);
+		}
+		if (header.nullBlock) if (this[SAW_NULL_BLOCK]) {
+			this[SAW_EOF] = true;
+			if (this[STATE] === "begin") this[STATE] = "header";
+			this[EMIT]("eof");
+		} else {
+			this[SAW_NULL_BLOCK] = true;
+			this[EMIT]("nullBlock");
+		}
+		else {
+			this[SAW_NULL_BLOCK] = false;
+			if (!header.cksumValid) this.warn("TAR_ENTRY_INVALID", "checksum failure", { header });
+			else if (!header.path) this.warn("TAR_ENTRY_INVALID", "path is required", { header });
+			else {
+				const type = header.type;
+				if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath required", { header });
+				else if (!/^(Symbolic)?Link$/.test(type) && !/^(Global)?ExtendedHeader$/.test(type) && header.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", { header });
+				else {
+					const entry = this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]);
+					if (!this[SAW_VALID_ENTRY]) if (entry.remain) {
+						const onend = () => {
+							if (!entry.invalid) this[SAW_VALID_ENTRY] = true;
+						};
+						entry.on("end", onend);
+					} else this[SAW_VALID_ENTRY] = true;
+					if (entry.meta) {
+						if (entry.size > this.maxMetaEntrySize) {
+							entry.ignore = true;
+							this[EMIT]("ignoredEntry", entry);
+							this[STATE] = "ignore";
+							entry.resume();
+						} else if (entry.size > 0) {
+							this[META] = "";
+							entry.on("data", (c) => this[META] += c);
+							this[STATE] = "meta";
+						}
+					} else {
+						this[EX] = void 0;
+						entry.ignore = entry.ignore || !this.filter(entry.path, entry);
+						if (entry.ignore) {
+							this[EMIT]("ignoredEntry", entry);
+							this[STATE] = entry.remain ? "ignore" : "header";
+							entry.resume();
+						} else {
+							if (entry.remain) this[STATE] = "body";
+							else {
+								this[STATE] = "header";
+								entry.end();
+							}
+							if (!this[READENTRY]) {
+								this[QUEUE].push(entry);
+								this[NEXTENTRY]();
+							} else this[QUEUE].push(entry);
+						}
+					}
+				}
+			}
+		}
+	}
+	[CLOSESTREAM]() {
+		queueMicrotask(() => this.emit("close"));
+	}
+	[PROCESSENTRY](entry) {
+		let go = true;
+		if (!entry) {
+			this[READENTRY] = void 0;
+			go = false;
+		} else if (Array.isArray(entry)) {
+			const [ev, ...args] = entry;
+			this.emit(ev, ...args);
+		} else {
+			this[READENTRY] = entry;
+			this.emit("entry", entry);
+			if (!entry.emittedEnd) {
+				entry.on("end", () => this[NEXTENTRY]());
+				go = false;
+			}
+		}
+		return go;
+	}
+	[NEXTENTRY]() {
+		do		;
+while (this[PROCESSENTRY](this[QUEUE].shift()));
+		if (!this[QUEUE].length) {
+			const re = this[READENTRY];
+			if (!re || re.flowing || re.size === re.remain) {
+				if (!this[WRITING]) this.emit("drain");
+			} else re.once("drain", () => this.emit("drain"));
+		}
+	}
+	[CONSUMEBODY](chunk, position) {
+		const entry = this[WRITEENTRY];
+		/* c8 ignore start */
+		if (!entry) throw new Error("attempt to consume body without entry??");
+		const br = entry.blockRemain ?? 0;
+		/* c8 ignore stop */
+		const c = br >= chunk.length && position === 0 ? chunk : chunk.subarray(position, position + br);
+		entry.write(c);
+		if (!entry.blockRemain) {
+			this[STATE] = "header";
+			this[WRITEENTRY] = void 0;
+			entry.end();
+		}
+		return c.length;
+	}
+	[CONSUMEMETA](chunk, position) {
+		const entry = this[WRITEENTRY];
+		const ret = this[CONSUMEBODY](chunk, position);
+		if (!this[WRITEENTRY] && entry) this[EMITMETA](entry);
+		return ret;
+	}
+	[EMIT](ev, data, extra) {
+		if (!this[QUEUE].length && !this[READENTRY]) this.emit(ev, data, extra);
+		else this[QUEUE].push([
+			ev,
+			data,
+			extra
+		]);
+	}
+	[EMITMETA](entry) {
+		this[EMIT]("meta", this[META]);
+		switch (entry.type) {
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this[EX] = Pax.parse(this[META], this[EX], false);
+				break;
+			case "GlobalExtendedHeader":
+				this[GEX] = Pax.parse(this[META], this[GEX], true);
+				break;
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath": {
+				const ex = this[EX] ?? Object.create(null);
+				this[EX] = ex;
+				ex.path = this[META].replace(/\0.*/, "");
+				break;
+			}
+			case "NextFileHasLongLinkpath": {
+				const ex = this[EX] || Object.create(null);
+				this[EX] = ex;
+				ex.linkpath = this[META].replace(/\0.*/, "");
+				break;
+			}
+			default: throw new Error("unknown meta: " + entry.type);
+		}
+	}
+	abort(error) {
+		this[ABORTED] = true;
+		this.emit("abort", error);
+		this.warn("TAR_ABORT", error, { recoverable: false });
+	}
+	write(chunk, encoding, cb) {
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(
+			chunk,
+			/* c8 ignore next */
+			typeof encoding === "string" ? encoding : "utf8"
+		);
+		if (this[ABORTED]) {
+			/* c8 ignore next */
+			cb?.();
+			return false;
+		}
+		if ((this[UNZIP] === void 0 || this.brotli === void 0 && this[UNZIP] === false) && chunk) {
+			if (this[BUFFER]) {
+				chunk = Buffer.concat([this[BUFFER], chunk]);
+				this[BUFFER] = void 0;
+			}
+			if (chunk.length < ZIP_HEADER_LEN) {
+				this[BUFFER] = chunk;
+				/* c8 ignore next */
+				cb?.();
+				return true;
+			}
+			for (let i = 0; this[UNZIP] === void 0 && i < gzipHeader.length; i++) if (chunk[i] !== gzipHeader[i]) this[UNZIP] = false;
+			let isZstd = false;
+			if (this[UNZIP] === false && this.zstd !== false) {
+				isZstd = true;
+				for (let i = 0; i < zstdHeader.length; i++) if (chunk[i] !== zstdHeader[i]) {
+					isZstd = false;
+					break;
+				}
+			}
+			const maybeBrotli = this.brotli === void 0 && !isZstd;
+			if (this[UNZIP] === false && maybeBrotli) if (chunk.length < 512) if (this[ENDED$1]) this.brotli = true;
+			else {
+				this[BUFFER] = chunk;
+				/* c8 ignore next */
+				cb?.();
+				return true;
+			}
+			else try {
+				new Header(chunk.subarray(0, 512));
+				this.brotli = false;
+			} catch (_) {
+				this.brotli = true;
+			}
+			if (this[UNZIP] === void 0 || this[UNZIP] === false && (this.brotli || isZstd)) {
+				const ended = this[ENDED$1];
+				this[ENDED$1] = 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[CONSUMECHUNK]();
+				});
+				this[WRITING] = true;
+				const ret = !!this[UNZIP][ended ? "end" : "write"](chunk);
+				this[WRITING] = false;
+				cb?.();
+				return ret;
+			}
+		}
+		this[WRITING] = true;
+		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"));
+		/* c8 ignore next */
+		cb?.();
+		return ret;
+	}
+	[BUFFERCONCAT](c) {
+		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]) {
+			this[EMITTEDEND] = true;
+			const entry = this[WRITEENTRY];
+			if (entry && entry.blockRemain) {
+				const have = this[BUFFER] ? this[BUFFER].length : 0;
+				this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
+				if (this[BUFFER]) entry.write(this[BUFFER]);
+				entry.end();
+			}
+			this[EMIT](DONE);
+		}
+	}
+	[CONSUMECHUNK](chunk) {
+		if (this[CONSUMING] && chunk) this[BUFFERCONCAT](chunk);
+		else if (!chunk && !this[BUFFER]) this[MAYBEEND]();
+		else if (chunk) {
+			this[CONSUMING] = true;
+			if (this[BUFFER]) {
+				this[BUFFERCONCAT](chunk);
+				const c = this[BUFFER];
+				this[BUFFER] = void 0;
+				this[CONSUMECHUNKSUB](c);
+			} else this[CONSUMECHUNKSUB](chunk);
+			while (this[BUFFER] && this[BUFFER]?.length >= 512 && !this[ABORTED] && !this[SAW_EOF]) {
+				const c = this[BUFFER];
+				this[BUFFER] = void 0;
+				this[CONSUMECHUNKSUB](c);
+			}
+			this[CONSUMING] = false;
+		}
+		if (!this[BUFFER] || this[ENDED$1]) this[MAYBEEND]();
+	}
+	[CONSUMECHUNKSUB](chunk) {
+		let position = 0;
+		const length = chunk.length;
+		while (position + 512 <= length && !this[ABORTED] && !this[SAW_EOF]) switch (this[STATE]) {
+			case "begin":
+			case "header":
+				this[CONSUMEHEADER](chunk, position);
+				position += 512;
+				break;
+			case "ignore":
+			case "body":
+				position += this[CONSUMEBODY](chunk, position);
+				break;
+			case "meta":
+				position += this[CONSUMEMETA](chunk, position);
+				break;
+			default: throw new Error("invalid state: " + this[STATE]);
+		}
+		if (position < length) if (this[BUFFER]) this[BUFFER] = Buffer.concat([chunk.subarray(position), this[BUFFER]]);
+		else this[BUFFER] = chunk.subarray(position);
+	}
+	end(chunk, encoding, cb) {
+		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);
+		if (cb) this.once("finish", cb);
+		if (!this[ABORTED]) if (this[UNZIP]) {
+			/* c8 ignore start */
+			if (chunk) this[UNZIP].write(chunk);
+			/* c8 ignore stop */
+			this[UNZIP].end();
+		} else {
+			this[ENDED$1] = true;
+			if (this.brotli === void 0 || this.zstd === void 0) chunk = chunk || Buffer.alloc(0);
+			if (chunk) this.write(chunk);
+			this[MAYBEEND]();
+		}
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/strip-trailing-slashes.js
+var stripTrailingSlashes = (str) => {
+	let i = str.length - 1;
+	let slashesStart = -1;
+	while (i > -1 && str.charAt(i) === "/") {
+		slashesStart = i;
+		i--;
+	}
+	return slashesStart === -1 ? str : str.slice(0, slashesStart);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/list.js
+var onReadEntryFunction = (opt) => {
+	const onReadEntry = opt.onReadEntry;
+	opt.onReadEntry = onReadEntry ? (e) => {
+		onReadEntry(e);
+		e.resume();
+	} : (e) => e.resume();
+};
+var filesFilter = (opt, files) => {
+	const map = new Map(files.map((f) => [stripTrailingSlashes(f), true]));
+	const filter = opt.filter;
+	const mapHas = (file, r = "") => {
+		const root = r || parse(file).root || ".";
+		let ret;
+		if (file === root) ret = false;
+		else {
+			const m = map.get(file);
+			if (m !== void 0) ret = m;
+			else ret = mapHas(dirname$1(file), root);
+		}
+		map.set(file, ret);
+		return ret;
+	};
+	opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripTrailingSlashes(file)) : (file) => mapHas(stripTrailingSlashes(file));
+};
+var listFileSync = (opt) => {
+	const p = new Parser(opt);
+	const file = opt.file;
+	let fd;
+	try {
+		fd = fs.openSync(file, "r");
+		const stat = fs.fstatSync(fd);
+		const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+		if (stat.size < readSize) {
+			const buf = Buffer.allocUnsafe(stat.size);
+			fs.readSync(fd, buf, 0, stat.size, 0);
+			p.end(buf);
+		} else {
+			let pos = 0;
+			const buf = Buffer.allocUnsafe(readSize);
+			while (pos < stat.size) {
+				const bytesRead = fs.readSync(fd, buf, 0, readSize, pos);
+				pos += bytesRead;
+				p.write(buf.subarray(0, bytesRead));
+			}
+			p.end();
+		}
+	} finally {
+		if (typeof fd === "number") try {
+			fs.closeSync(fd);
+		} catch (er) {}
+	}
+};
+var listFile = (opt, _files) => {
+	const parse = new Parser(opt);
+	const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+	const file = opt.file;
+	return new Promise((resolve, reject) => {
+		parse.on("error", reject);
+		parse.on("end", resolve);
+		fs.stat(file, (er, stat) => {
+			if (er) reject(er);
+			else {
+				const stream = new ReadStream(file, {
+					readSize,
+					size: stat.size
+				});
+				stream.on("error", reject);
+				stream.pipe(parse);
+			}
+		});
+	});
+};
+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/strip-absolute-path.js
+var { isAbsolute, parse: parse$1 } = win32;
+var stripAbsolutePath = (path) => {
+	let r = "";
+	let parsed = parse$1(path);
+	while (isAbsolute(path) || parsed.root) {
+		const root = path.charAt(0) === "/" && path.slice(0, 4) !== "//?/" ? "/" : parsed.root;
+		path = path.slice(root.length);
+		r += root;
+		parsed = parse$1(path);
+	}
+	return [r, path];
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/winchars.js
+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 encode = (s) => raw.reduce((s, c) => s.split(c).join(toWin.get(c)), s);
+//#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";
+/* c8 ignore start */
+var { O_CREAT, O_TRUNC, O_WRONLY } = fs$2.constants;
+var UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || fs$2.constants.UV_FS_O_FILEMAP || 0;
+/* c8 ignore stop */
+var fMapEnabled = isWindows$2 && !!UV_FS_O_FILEMAP;
+var fMapLimit = 512 * 1024;
+var fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
+var getWriteFlag = !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w";
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/cwd-error.js
+var CwdError = class extends Error {
+	path;
+	code;
+	syscall = "chdir";
+	constructor(path, code) {
+		super(`${code}: Cannot cd into '${path}'`);
+		this.path = path;
+		this.code = code;
+	}
+	get name() {
+		return "CwdError";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/symlink-error.js
+var SymlinkError = class extends Error {
+	path;
+	symlink;
+	syscall = "symlink";
+	code = "TAR_SYMLINK_ERROR";
+	constructor(symlink, path) {
+		super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link");
+		this.symlink = symlink;
+		this.path = path;
+	}
+	get name() {
+		return "SymlinkError";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/mkdir.js
+var checkCwd = (dir, cb) => {
+	fs.stat(dir, (er, st) => {
+		if (er || !st.isDirectory()) er = new CwdError(dir, er?.code || "ENOTDIR");
+		cb(er);
+	});
+};
+/**
+* Wrapper around fs/promises.mkdir for tar's needs.
+*
+* The main purpose is to avoid creating directories if we know that
+* they already exist (and track which ones exist for this purpose),
+* and prevent entries from being extracted into symlinked folders,
+* if `preservePaths` is not set.
+*/
+var mkdir = (dir, opt, cb) => {
+	dir = normalizeWindowsPath(dir);
+	/* c8 ignore next */
+	const umask = opt.umask ?? 18;
+	const mode = opt.mode | 448;
+	const needChmod = (mode & umask) !== 0;
+	const uid = opt.uid;
+	const gid = opt.gid;
+	const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
+	const preserve = opt.preserve;
+	const unlink = opt.unlink;
+	const cwd = normalizeWindowsPath(opt.cwd);
+	const done = (er, created) => {
+		if (er) cb(er);
+		else if (created && doChown) chownr(created, uid, gid, (er) => done(er));
+		else if (needChmod) fs.chmod(dir, mode, cb);
+		else cb();
+	};
+	if (dir === cwd) return checkCwd(dir, done);
+	if (preserve) return fs$1.mkdir(dir, {
+		mode,
+		recursive: true
+	}).then((made) => done(null, made ?? void 0), done);
+	mkdir_(cwd, normalizeWindowsPath(path.relative(cwd, dir)).split("/"), mode, unlink, cwd, void 0, done);
+};
+var mkdir_ = (base, parts, mode, unlink, cwd, created, cb) => {
+	if (!parts.length) return cb(null, created);
+	const p = parts.shift();
+	const part = normalizeWindowsPath(path.resolve(base + "/" + p));
+	fs.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+};
+var onmkdir = (part, parts, mode, unlink, cwd, created, cb) => (er) => {
+	if (er) fs.lstat(part, (statEr, st) => {
+		if (statEr) {
+			statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
+			cb(statEr);
+		} else if (st.isDirectory()) mkdir_(part, parts, mode, unlink, cwd, created, cb);
+		else if (unlink) fs.unlink(part, (er) => {
+			if (er) return cb(er);
+			fs.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+		});
+		else if (st.isSymbolicLink()) return cb(new SymlinkError(part, part + "/" + parts.join("/")));
+		else cb(er);
+	});
+	else {
+		created = created || part;
+		mkdir_(part, parts, mode, unlink, cwd, created, cb);
+	}
+};
+var checkCwdSync = (dir) => {
+	let ok = false;
+	let code = void 0;
+	try {
+		ok = fs.statSync(dir).isDirectory();
+	} catch (er) {
+		code = er?.code;
+	} finally {
+		if (!ok) throw new CwdError(dir, code ?? "ENOTDIR");
+	}
+};
+var mkdirSync = (dir, opt) => {
+	dir = normalizeWindowsPath(dir);
+	/* c8 ignore next */
+	const umask = opt.umask ?? 18;
+	const mode = opt.mode | 448;
+	const needChmod = (mode & umask) !== 0;
+	const uid = opt.uid;
+	const gid = opt.gid;
+	const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
+	const preserve = opt.preserve;
+	const unlink = opt.unlink;
+	const cwd = normalizeWindowsPath(opt.cwd);
+	const done = (created) => {
+		if (created && doChown) chownrSync(created, uid, gid);
+		if (needChmod) fs.chmodSync(dir, mode);
+	};
+	if (dir === cwd) {
+		checkCwdSync(cwd);
+		return done();
+	}
+	if (preserve) return done(fs.mkdirSync(dir, {
+		mode,
+		recursive: true
+	}) ?? void 0);
+	const parts = normalizeWindowsPath(path.relative(cwd, dir)).split("/");
+	let created = void 0;
+	for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) {
+		part = normalizeWindowsPath(path.resolve(part));
+		try {
+			fs.mkdirSync(part, mode);
+			created = created || part;
+		} catch (er) {
+			const st = fs.lstatSync(part);
+			if (st.isDirectory()) continue;
+			else if (unlink) {
+				fs.unlinkSync(part);
+				fs.mkdirSync(part, mode);
+				created = created || part;
+				continue;
+			} else if (st.isSymbolicLink()) return new SymlinkError(part, part + "/" + parts.join("/"));
+		}
+	}
+	return done(created);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/normalize-unicode.js
+var normalizeCache = Object.create(null);
+var MAX = 1e4;
+var cache = /* @__PURE__ */ new Set();
+var normalizeUnicode = (s) => {
+	if (!cache.has(s)) normalizeCache[s] = s.normalize("NFD");
+	else cache.delete(s);
+	cache.add(s);
+	const ret = normalizeCache[s];
+	let i = cache.size - MAX;
+	if (i > MAX / 10) for (const s of cache) {
+		cache.delete(s);
+		delete normalizeCache[s];
+		if (--i <= 0) break;
+	}
+	return ret;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/path-reservations.js
+var isWindows$1 = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32";
+var getDirs = (path) => {
+	return path.split("/").slice(0, -1).reduce((set, path) => {
+		const s = set[set.length - 1];
+		if (s !== void 0) path = join(s, path);
+		set.push(path || "/");
+		return set;
+	}, []);
+};
+var PathReservations = class {
+	#queues = /* @__PURE__ */ new Map();
+	#reservations = /* @__PURE__ */ new Map();
+	#running = /* @__PURE__ */ new Set();
+	reserve(paths, fn) {
+		paths = isWindows$1 ? ["win32 parallelization disabled"] : paths.map((p) => {
+			return stripTrailingSlashes(join(normalizeUnicode(p))).toLowerCase();
+		});
+		const dirs = new Set(paths.map((path) => getDirs(path)).reduce((a, b) => a.concat(b)));
+		this.#reservations.set(fn, {
+			dirs,
+			paths
+		});
+		for (const p of paths) {
+			const q = this.#queues.get(p);
+			if (!q) this.#queues.set(p, [fn]);
+			else q.push(fn);
+		}
+		for (const dir of dirs) {
+			const q = this.#queues.get(dir);
+			if (!q) this.#queues.set(dir, [new Set([fn])]);
+			else {
+				const l = q[q.length - 1];
+				if (l instanceof Set) l.add(fn);
+				else q.push(new Set([fn]));
+			}
+		}
+		return this.#run(fn);
+	}
+	#getQueues(fn) {
+		const res = this.#reservations.get(fn);
+		/* c8 ignore start */
+		if (!res) throw new Error("function does not have any path reservations");
+		/* c8 ignore stop */
+		return {
+			paths: res.paths.map((path) => this.#queues.get(path)),
+			dirs: [...res.dirs].map((path) => this.#queues.get(path))
+		};
+	}
+	check(fn) {
+		const { paths, dirs } = this.#getQueues(fn);
+		return paths.every((q) => q && q[0] === fn) && dirs.every((q) => q && q[0] instanceof Set && q[0].has(fn));
+	}
+	#run(fn) {
+		if (this.#running.has(fn) || !this.check(fn)) return false;
+		this.#running.add(fn);
+		fn(() => this.#clear(fn));
+		return true;
+	}
+	#clear(fn) {
+		if (!this.#running.has(fn)) return false;
+		const res = this.#reservations.get(fn);
+		/* c8 ignore start */
+		if (!res) throw new Error("invalid reservation");
+		/* c8 ignore stop */
+		const { paths, dirs } = res;
+		const next = /* @__PURE__ */ new Set();
+		for (const path of paths) {
+			const q = this.#queues.get(path);
+			/* c8 ignore start */
+			if (!q || q?.[0] !== fn) continue;
+			/* c8 ignore stop */
+			const q0 = q[1];
+			if (!q0) {
+				this.#queues.delete(path);
+				continue;
+			}
+			q.shift();
+			if (typeof q0 === "function") next.add(q0);
+			else for (const f of q0) next.add(f);
+		}
+		for (const dir of dirs) {
+			const q = this.#queues.get(dir);
+			const q0 = q?.[0];
+			/* c8 ignore next - type safety only */
+			if (!q || !(q0 instanceof Set)) continue;
+			if (q0.size === 1 && q.length === 1) {
+				this.#queues.delete(dir);
+				continue;
+			} else if (q0.size === 1) {
+				q.shift();
+				const n = q[0];
+				if (typeof n === "function") next.add(n);
+			} else q0.delete(fn);
+		}
+		this.#running.delete(fn);
+		next.forEach((fn) => this.#run(fn));
+		return true;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/unpack.js
+var ONENTRY = Symbol("onEntry");
+var CHECKFS = Symbol("checkFs");
+var CHECKFS2 = Symbol("checkFs2");
+var ISREUSABLE = Symbol("isReusable");
+var MAKEFS = Symbol("makeFs");
+var FILE = Symbol("file");
+var DIRECTORY = Symbol("directory");
+var LINK = Symbol("link");
+var SYMLINK = Symbol("symlink");
+var HARDLINK = Symbol("hardlink");
+var UNSUPPORTED = Symbol("unsupported");
+var CHECKPATH = Symbol("checkPath");
+var MKDIR = Symbol("mkdir");
+var ONERROR = Symbol("onError");
+var PENDING = Symbol("pending");
+var PEND = Symbol("pend");
+var UNPEND = Symbol("unpend");
+var ENDED = Symbol("ended");
+var MAYBECLOSE = Symbol("maybeClose");
+var SKIP = Symbol("skip");
+var DOCHOWN = Symbol("doChown");
+var UID = Symbol("uid");
+var GID = Symbol("gid");
+var CHECKED_CWD = Symbol("checkedCwd");
+var isWindows = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32";
+var DEFAULT_MAX_DEPTH = 1024;
+/* c8 ignore start */
+var unlinkFile = (path, cb) => {
+	if (!isWindows) return fs.unlink(path, cb);
+	const name = path + ".DELETE." + randomBytes(16).toString("hex");
+	fs.rename(path, name, (er) => {
+		if (er) return cb(er);
+		fs.unlink(name, cb);
+	});
+};
+/* c8 ignore stop */
+/* c8 ignore start */
+var unlinkFileSync = (path) => {
+	if (!isWindows) return fs.unlinkSync(path);
+	const name = path + ".DELETE." + randomBytes(16).toString("hex");
+	fs.renameSync(path, name);
+	fs.unlinkSync(name);
+};
+/* c8 ignore stop */
+var uint32 = (a, b, c) => a !== void 0 && a === a >>> 0 ? a : b !== void 0 && b === b >>> 0 ? b : c;
+var Unpack = class extends Parser {
+	[ENDED] = false;
+	[CHECKED_CWD] = false;
+	[PENDING] = 0;
+	reservations = new PathReservations();
+	transform;
+	writable = true;
+	readable = false;
+	uid;
+	gid;
+	setOwner;
+	preserveOwner;
+	processGid;
+	processUid;
+	maxDepth;
+	forceChown;
+	win32;
+	newer;
+	keep;
+	noMtime;
+	preservePaths;
+	unlink;
+	cwd;
+	strip;
+	processUmask;
+	umask;
+	dmode;
+	fmode;
+	chmod;
+	constructor(opt = {}) {
+		opt.ondone = () => {
+			this[ENDED] = true;
+			this[MAYBECLOSE]();
+		};
+		super(opt);
+		this.transform = opt.transform;
+		this.chmod = !!opt.chmod;
+		if (typeof opt.uid === "number" || typeof opt.gid === "number") {
+			if (typeof opt.uid !== "number" || typeof opt.gid !== "number") throw new TypeError("cannot set owner without number uid and gid");
+			if (opt.preserveOwner) throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
+			this.uid = opt.uid;
+			this.gid = opt.gid;
+			this.setOwner = true;
+		} else {
+			this.uid = void 0;
+			this.gid = void 0;
+			this.setOwner = false;
+		}
+		if (opt.preserveOwner === void 0 && typeof opt.uid !== "number") this.preserveOwner = !!(process.getuid && process.getuid() === 0);
+		else this.preserveOwner = !!opt.preserveOwner;
+		this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0;
+		this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0;
+		this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH;
+		this.forceChown = opt.forceChown === true;
+		this.win32 = !!opt.win32 || isWindows;
+		this.newer = !!opt.newer;
+		this.keep = !!opt.keep;
+		this.noMtime = !!opt.noMtime;
+		this.preservePaths = !!opt.preservePaths;
+		this.unlink = !!opt.unlink;
+		this.cwd = normalizeWindowsPath(path.resolve(opt.cwd || process.cwd()));
+		this.strip = Number(opt.strip) || 0;
+		this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : process.umask();
+		this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask;
+		this.dmode = opt.dmode || 511 & ~this.umask;
+		this.fmode = opt.fmode || 438 & ~this.umask;
+		this.on("entry", (entry) => this[ONENTRY](entry));
+	}
+	warn(code, msg, data = {}) {
+		if (code === "TAR_BAD_ARCHIVE" || code === "TAR_ABORT") data.recoverable = false;
+		return super.warn(code, msg, data);
+	}
+	[MAYBECLOSE]() {
+		if (this[ENDED] && this[PENDING] === 0) {
+			this.emit("prefinish");
+			this.emit("finish");
+			this.emit("end");
+		}
+	}
+	[CHECKPATH](entry) {
+		const p = normalizeWindowsPath(entry.path);
+		const parts = p.split("/");
+		if (this.strip) {
+			if (parts.length < this.strip) return false;
+			if (entry.type === "Link") {
+				const linkparts = normalizeWindowsPath(String(entry.linkpath)).split("/");
+				if (linkparts.length >= this.strip) entry.linkpath = linkparts.slice(this.strip).join("/");
+				else return false;
+			}
+			parts.splice(0, this.strip);
+			entry.path = parts.join("/");
+		}
+		if (isFinite(this.maxDepth) && parts.length > this.maxDepth) {
+			this.warn("TAR_ENTRY_ERROR", "path excessively deep", {
+				entry,
+				path: p,
+				depth: parts.length,
+				maxDepth: this.maxDepth
+			});
+			return false;
+		}
+		if (!this.preservePaths) {
+			if (parts.includes("..") || isWindows && /^[a-z]:\.\.$/i.test(parts[0] ?? "")) {
+				this.warn("TAR_ENTRY_ERROR", `path contains '..'`, {
+					entry,
+					path: p
+				});
+				return false;
+			}
+			const [root, stripped] = stripAbsolutePath(p);
+			if (root) {
+				entry.path = String(stripped);
+				this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute path`, {
+					entry,
+					path: p
+				});
+			}
+		}
+		if (path.isAbsolute(entry.path)) entry.absolute = normalizeWindowsPath(path.resolve(entry.path));
+		else entry.absolute = normalizeWindowsPath(path.resolve(this.cwd, entry.path));
+		/* c8 ignore start - defense in depth */
+		if (!this.preservePaths && typeof entry.absolute === "string" && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) {
+			this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
+				entry,
+				path: normalizeWindowsPath(entry.path),
+				resolvedPath: entry.absolute,
+				cwd: this.cwd
+			});
+			return false;
+		}
+		/* c8 ignore stop */
+		if (entry.absolute === this.cwd && entry.type !== "Directory" && entry.type !== "GNUDumpDir") return false;
+		if (this.win32) {
+			const { root: aRoot } = path.win32.parse(String(entry.absolute));
+			entry.absolute = aRoot + encode(String(entry.absolute).slice(aRoot.length));
+			const { root: pRoot } = path.win32.parse(entry.path);
+			entry.path = pRoot + encode(entry.path.slice(pRoot.length));
+		}
+		return true;
+	}
+	[ONENTRY](entry) {
+		if (!this[CHECKPATH](entry)) return entry.resume();
+		assert.equal(typeof entry.absolute, "string");
+		switch (entry.type) {
+			case "Directory":
+			case "GNUDumpDir": if (entry.mode) entry.mode = entry.mode | 448;
+			case "File":
+			case "OldFile":
+			case "ContiguousFile":
+			case "Link":
+			case "SymbolicLink": return this[CHECKFS](entry);
+			default: return this[UNSUPPORTED](entry);
+		}
+	}
+	[ONERROR](er, entry) {
+		if (er.name === "CwdError") this.emit("error", er);
+		else {
+			this.warn("TAR_ENTRY_ERROR", er, { entry });
+			this[UNPEND]();
+			entry.resume();
+		}
+	}
+	[MKDIR](dir, mode, cb) {
+		mkdir(normalizeWindowsPath(dir), {
+			uid: this.uid,
+			gid: this.gid,
+			processUid: this.processUid,
+			processGid: this.processGid,
+			umask: this.processUmask,
+			preserve: this.preservePaths,
+			unlink: this.unlink,
+			cwd: this.cwd,
+			mode
+		}, cb);
+	}
+	[DOCHOWN](entry) {
+		return this.forceChown || this.preserveOwner && (typeof entry.uid === "number" && entry.uid !== this.processUid || typeof entry.gid === "number" && entry.gid !== this.processGid) || typeof this.uid === "number" && this.uid !== this.processUid || typeof this.gid === "number" && this.gid !== this.processGid;
+	}
+	[UID](entry) {
+		return uint32(this.uid, entry.uid, this.processUid);
+	}
+	[GID](entry) {
+		return uint32(this.gid, entry.gid, this.processGid);
+	}
+	[FILE](entry, fullyDone) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
+		const stream = new WriteStream(String(entry.absolute), {
+			flags: getWriteFlag(entry.size),
+			mode,
+			autoClose: false
+		});
+		stream.on("error", (er) => {
+			if (stream.fd) fs.close(stream.fd, () => {});
+			stream.write = () => true;
+			this[ONERROR](er, entry);
+			fullyDone();
+		});
+		let actions = 1;
+		const done = (er) => {
+			if (er) {
+				/* c8 ignore start - we should always have a fd by now */
+				if (stream.fd) fs.close(stream.fd, () => {});
+				/* c8 ignore stop */
+				this[ONERROR](er, entry);
+				fullyDone();
+				return;
+			}
+			if (--actions === 0) {
+				if (stream.fd !== void 0) fs.close(stream.fd, (er) => {
+					if (er) this[ONERROR](er, entry);
+					else this[UNPEND]();
+					fullyDone();
+				});
+			}
+		};
+		stream.on("finish", () => {
+			const abs = String(entry.absolute);
+			const fd = stream.fd;
+			if (typeof fd === "number" && entry.mtime && !this.noMtime) {
+				actions++;
+				const atime = entry.atime || /* @__PURE__ */ new Date();
+				const mtime = entry.mtime;
+				fs.futimes(fd, atime, mtime, (er) => er ? fs.utimes(abs, atime, mtime, (er2) => done(er2 && er)) : done());
+			}
+			if (typeof fd === "number" && this[DOCHOWN](entry)) {
+				actions++;
+				const uid = this[UID](entry);
+				const gid = this[GID](entry);
+				if (typeof uid === "number" && typeof gid === "number") fs.fchown(fd, uid, gid, (er) => er ? fs.chown(abs, uid, gid, (er2) => done(er2 && er)) : done());
+			}
+			done();
+		});
+		const tx = this.transform ? this.transform(entry) || entry : entry;
+		if (tx !== entry) {
+			tx.on("error", (er) => {
+				this[ONERROR](er, entry);
+				fullyDone();
+			});
+			entry.pipe(tx);
+		}
+		tx.pipe(stream);
+	}
+	[DIRECTORY](entry, fullyDone) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
+		this[MKDIR](String(entry.absolute), mode, (er) => {
+			if (er) {
+				this[ONERROR](er, entry);
+				fullyDone();
+				return;
+			}
+			let actions = 1;
+			const done = () => {
+				if (--actions === 0) {
+					fullyDone();
+					this[UNPEND]();
+					entry.resume();
+				}
+			};
+			if (entry.mtime && !this.noMtime) {
+				actions++;
+				fs.utimes(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done);
+			}
+			if (this[DOCHOWN](entry)) {
+				actions++;
+				fs.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
+			}
+			done();
+		});
+	}
+	[UNSUPPORTED](entry) {
+		entry.unsupported = true;
+		this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${entry.type}`, { entry });
+		entry.resume();
+	}
+	[SYMLINK](entry, done) {
+		this[LINK](entry, String(entry.linkpath), "symlink", done);
+	}
+	[HARDLINK](entry, done) {
+		const linkpath = normalizeWindowsPath(path.resolve(this.cwd, String(entry.linkpath)));
+		this[LINK](entry, linkpath, "link", done);
+	}
+	[PEND]() {
+		this[PENDING]++;
+	}
+	[UNPEND]() {
+		this[PENDING]--;
+		this[MAYBECLOSE]();
+	}
+	[SKIP](entry) {
+		this[UNPEND]();
+		entry.resume();
+	}
+	[ISREUSABLE](entry, st) {
+		return entry.type === "File" && !this.unlink && st.isFile() && st.nlink <= 1 && !isWindows;
+	}
+	[CHECKFS](entry) {
+		this[PEND]();
+		const paths = [entry.path];
+		if (entry.linkpath) paths.push(entry.linkpath);
+		this.reservations.reserve(paths, (done) => this[CHECKFS2](entry, done));
+	}
+	[CHECKFS2](entry, fullyDone) {
+		const done = (er) => {
+			fullyDone(er);
+		};
+		const checkCwd = () => {
+			this[MKDIR](this.cwd, this.dmode, (er) => {
+				if (er) {
+					this[ONERROR](er, entry);
+					done();
+					return;
+				}
+				this[CHECKED_CWD] = true;
+				start();
+			});
+		};
+		const start = () => {
+			if (entry.absolute !== this.cwd) {
+				const parent = normalizeWindowsPath(path.dirname(String(entry.absolute)));
+				if (parent !== this.cwd) return this[MKDIR](parent, this.dmode, (er) => {
+					if (er) {
+						this[ONERROR](er, entry);
+						done();
+						return;
+					}
+					afterMakeParent();
+				});
+			}
+			afterMakeParent();
+		};
+		const afterMakeParent = () => {
+			fs.lstat(String(entry.absolute), (lstatEr, st) => {
+				if (st && (this.keep || this.newer && st.mtime > (entry.mtime ?? st.mtime))) {
+					this[SKIP](entry);
+					done();
+					return;
+				}
+				if (lstatEr || this[ISREUSABLE](entry, st)) return this[MAKEFS](null, entry, done);
+				if (st.isDirectory()) {
+					if (entry.type === "Directory") {
+						const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode;
+						const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done);
+						if (!needChmod) return afterChmod();
+						return fs.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
+					}
+					if (entry.absolute !== this.cwd) return fs.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+				}
+				if (entry.absolute === this.cwd) return this[MAKEFS](null, entry, done);
+				unlinkFile(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+			});
+		};
+		if (this[CHECKED_CWD]) start();
+		else checkCwd();
+	}
+	[MAKEFS](er, entry, done) {
+		if (er) {
+			this[ONERROR](er, entry);
+			done();
+			return;
+		}
+		switch (entry.type) {
+			case "File":
+			case "OldFile":
+			case "ContiguousFile": return this[FILE](entry, done);
+			case "Link": return this[HARDLINK](entry, done);
+			case "SymbolicLink": return this[SYMLINK](entry, done);
+			case "Directory":
+			case "GNUDumpDir": return this[DIRECTORY](entry, done);
+		}
+	}
+	[LINK](entry, linkpath, link, done) {
+		fs[link](linkpath, String(entry.absolute), (er) => {
+			if (er) this[ONERROR](er, entry);
+			else {
+				this[UNPEND]();
+				entry.resume();
+			}
+			done();
+		});
+	}
+};
+var callSync = (fn) => {
+	try {
+		return [null, fn()];
+	} catch (er) {
+		return [er, null];
+	}
+};
+var UnpackSync = class extends Unpack {
+	sync = true;
+	[MAKEFS](er, entry) {
+		return super[MAKEFS](er, entry, () => {});
+	}
+	[CHECKFS](entry) {
+		if (!this[CHECKED_CWD]) {
+			const er = this[MKDIR](this.cwd, this.dmode);
+			if (er) return this[ONERROR](er, entry);
+			this[CHECKED_CWD] = true;
+		}
+		if (entry.absolute !== this.cwd) {
+			const parent = normalizeWindowsPath(path.dirname(String(entry.absolute)));
+			if (parent !== this.cwd) {
+				const mkParent = this[MKDIR](parent, this.dmode);
+				if (mkParent) return this[ONERROR](mkParent, entry);
+			}
+		}
+		const [lstatEr, st] = callSync(() => fs.lstatSync(String(entry.absolute)));
+		if (st && (this.keep || this.newer && st.mtime > (entry.mtime ?? st.mtime))) return this[SKIP](entry);
+		if (lstatEr || this[ISREUSABLE](entry, st)) return this[MAKEFS](null, entry);
+		if (st.isDirectory()) {
+			if (entry.type === "Directory") {
+				const [er] = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode ? callSync(() => {
+					fs.chmodSync(String(entry.absolute), Number(entry.mode));
+				}) : [];
+				return this[MAKEFS](er, entry);
+			}
+			const [er] = callSync(() => fs.rmdirSync(String(entry.absolute)));
+			this[MAKEFS](er, entry);
+		}
+		const [er] = entry.absolute === this.cwd ? [] : callSync(() => unlinkFileSync(String(entry.absolute)));
+		this[MAKEFS](er, entry);
+	}
+	[FILE](entry, done) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
+		const oner = (er) => {
+			let closeError;
+			try {
+				fs.closeSync(fd);
+			} catch (e) {
+				closeError = e;
+			}
+			if (er || closeError) this[ONERROR](er || closeError, entry);
+			done();
+		};
+		let fd;
+		try {
+			fd = fs.openSync(String(entry.absolute), getWriteFlag(entry.size), mode);
+		} catch (er) {
+			return oner(er);
+		}
+		/* c8 ignore stop */
+		const tx = this.transform ? this.transform(entry) || entry : entry;
+		if (tx !== entry) {
+			tx.on("error", (er) => this[ONERROR](er, entry));
+			entry.pipe(tx);
+		}
+		tx.on("data", (chunk) => {
+			try {
+				fs.writeSync(fd, chunk, 0, chunk.length);
+			} catch (er) {
+				oner(er);
+			}
+		});
+		tx.on("end", () => {
+			let er = null;
+			if (entry.mtime && !this.noMtime) {
+				const atime = entry.atime || /* @__PURE__ */ new Date();
+				const mtime = entry.mtime;
+				try {
+					fs.futimesSync(fd, atime, mtime);
+				} catch (futimeser) {
+					try {
+						fs.utimesSync(String(entry.absolute), atime, mtime);
+					} catch (utimeser) {
+						er = futimeser;
+					}
+				}
+			}
+			if (this[DOCHOWN](entry)) {
+				const uid = this[UID](entry);
+				const gid = this[GID](entry);
+				try {
+					fs.fchownSync(fd, Number(uid), Number(gid));
+				} catch (fchowner) {
+					try {
+						fs.chownSync(String(entry.absolute), Number(uid), Number(gid));
+					} catch (chowner) {
+						er = er || fchowner;
+					}
+				}
+			}
+			oner(er);
+		});
+	}
+	[DIRECTORY](entry, done) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
+		const er = this[MKDIR](String(entry.absolute), mode);
+		if (er) {
+			this[ONERROR](er, entry);
+			done();
+			return;
+		}
+		if (entry.mtime && !this.noMtime) try {
+			fs.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime);
+		} catch (er) {}
+		if (this[DOCHOWN](entry)) try {
+			fs.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
+		} catch (er) {}
+		done();
+		entry.resume();
+	}
+	[MKDIR](dir, mode) {
+		try {
+			return mkdirSync(normalizeWindowsPath(dir), {
+				uid: this.uid,
+				gid: this.gid,
+				processUid: this.processUid,
+				processGid: this.processGid,
+				umask: this.processUmask,
+				preserve: this.preservePaths,
+				unlink: this.unlink,
+				cwd: this.cwd,
+				mode
+			});
+		} catch (er) {
+			return er;
+		}
+	}
+	[LINK](entry, linkpath, link, done) {
+		const ls = `${link}Sync`;
+		try {
+			fs[ls](linkpath, String(entry.absolute));
+			done();
+			entry.resume();
+		} catch (er) {
+			return this[ONERROR](er, entry);
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.1/node_modules/tar/dist/esm/extract.js
+var extractFileSync = (opt) => {
+	const u = new UnpackSync(opt);
+	const file = opt.file;
+	const stat = fs.statSync(file);
+	new ReadStreamSync(file, {
+		readSize: opt.maxReadSize || 16 * 1024 * 1024,
+		size: stat.size
+	}).pipe(u);
+};
+var extractFile = (opt, _) => {
+	const u = new Unpack(opt);
+	const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+	const file = opt.file;
+	return new Promise((resolve, reject) => {
+		u.on("error", reject);
+		u.on("close", resolve);
+		fs.stat(file, (er, stat) => {
+			if (er) reject(er);
+			else {
+				const stream = new ReadStream(file, {
+					readSize,
+					size: stat.size
+				});
+				stream.on("error", reject);
+				stream.pipe(u);
+			}
+		});
+	});
+};
+var extract = makeCommand(extractFileSync, extractFile, (opt) => new UnpackSync(opt), (opt) => new Unpack(opt), (opt, files) => {
+	if (files?.length) filesFilter(opt, files);
+});
+//#endregion
+export { extract as t };