@nebulahome/package-sdk 1.0.0 → 1.1.0

package/dist/chunks/node-pack.js

@@ -0,0 +1,3455 @@
+import { t as PackageConfigError } from "./node-problems.js";
+import { C as url, S as union, _ as date, a as isRecord, b as strictObject, c as packageServiceNameSchema, d as semverRangeSchema, f as semverSchema, g as array, h as _enum, l as packageIdSchema, m as ZodISODateTime, o as PACKAGE_CATEGORIES, p as iconIdSchema, r as RELEASE_PATHS, s as packageRequiresSchema, t as githubEnvironment, v as int, w as _isoDateTime, x as string } from "./node-config.js";
+import ro, { readFile, readdir, writeFile } from "node:fs/promises";
+import path, { basename, join, posix, win32 } from "node:path";
+import { Buffer as Buffer$1 } from "buffer";
+import ar, { dirname, parse } from "path";
+import I from "fs";
+import { createHash, randomBytes } from "node:crypto";
+import Qr, { EventEmitter } from "events";
+import { EventEmitter as EventEmitter$1 } from "node:events";
+import Cs from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import Br from "node:fs";
+import zi from "assert";
+import * as Ps from "zlib";
+import en from "zlib";
+import co from "node:assert";
+//#region ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/iso.js
+function datetime(params) {
+	return _isoDateTime(ZodISODateTime, params);
+}
+//#endregion
+//#region ../contracts/dist/timestamp.js
+/**
+* The one way a moment in time is validated at a boundary.
+*
+* Every timestamp in the platform is a `Date` in memory and an ISO 8601 string on the wire,
+* because JSON has no date type. A schema written as `z.date()` therefore accepts a value built
+* in this process and rejects the identical value after a round trip through the bus - which
+* would mean two schemas for every shape that carries a time, one per side of the boundary, and
+* two places to forget a field.
+*
+* This accepts both forms and always produces a `Date`.
+*/
+/**
+* A moment in time, given either as a `Date` or as an ISO 8601 string with a zone.
+*
+* Deliberately not `z.coerce.date()`. That runs `new Date(value)` on whatever it is handed, and
+* `new Date(null)` is a valid date at the Unix epoch - so a report that omitted its timestamp
+* would arrive dated 1 January 1970 instead of being rejected, and the entity would appear to
+* have last changed fifty years ago.
+*/
+const timestampSchema = union([date(), datetime({ offset: true }).transform((value) => new Date(value))]);
+/** One archive: where it is, how large, and its digest. */
+const packageArtifactSchema = strictObject({
+	/** An HTTPS address: a GitHub release asset. */
+	url: url({ protocol: /^https$/ }).max(1024),
+	/** The SHA-256 of the archive, in hexadecimal. */
+	sha256: string().regex(/^[0-9a-f]{64}$/, "Must be a SHA-256 in lower-case hexadecimal"),
+	size: int().min(1).max(536870912)
+});
+/** One release of a package. */
+const packageReleaseSchema = strictObject({
+	version: semverSchema,
+	/** The platform versions it works with, as its manifest says. */
+	platform: semverRangeSchema,
+	/** The SDK versions it was written against. */
+	sdk: semverRangeSchema,
+	/** What it needs besides itself, as its manifest says, so the store can say it before. */
+	requires: packageRequiresSchema,
+	/** The services it provides. */
+	provides: array(packageServiceNameSchema).max(16).default([]),
+	artifact: packageArtifactSchema,
+	publishedAt: timestampSchema,
+	/** Where what changed is written: the release's page. */
+	changelogUrl: url().max(1024).optional()
+});
+/** One package, as the index lists it. */
+const packageIndexEntrySchema = strictObject({
+	id: packageIdSchema,
+	name: string().min(1).max(64),
+	description: string().min(1).max(512),
+	/** Its repository on GitHub, `owner/name`. */
+	repository: string().regex(/^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/),
+	category: _enum(PACKAGE_CATEGORIES),
+	icon: iconIdSchema.optional(),
+	/** Every release, newest first. */
+	versions: array(packageReleaseSchema).min(1).max(256)
+});
+strictObject({
+	/** When it was made. */
+	generatedAt: timestampSchema,
+	packages: array(packageIndexEntrySchema).max(4096)
+}).refine((index) => new Set(index.packages.map((each) => each.id)).size === index.packages.length, { message: "Each package is listed once" });
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.22/node_modules/tar/dist/esm/index.min.js
+var zr = Object.defineProperty;
+var Ur = (s, t) => {
+	for (var e in t) zr(s, e, {
+		get: t[e],
+		enumerable: !0
+	});
+};
+var Ds = typeof process == "object" && process ? process : {
+	stdout: null,
+	stderr: null
+};
+var Wr = (s) => !!s && typeof s == "object" && (s instanceof A || s instanceof Cs || Gr(s) || Zr(s));
+var Gr = (s) => !!s && typeof s == "object" && s instanceof EventEmitter$1 && typeof s.pipe == "function" && s.pipe !== Cs.Writable.prototype.pipe;
+var Zr = (s) => !!s && typeof s == "object" && s instanceof EventEmitter$1 && typeof s.write == "function" && typeof s.end == "function";
+var Q = Symbol("EOF");
+var J = Symbol("maybeEmitEnd");
+var nt = Symbol("emittedEnd");
+var De = Symbol("emittingEnd");
+var qt = Symbol("emittedError");
+var Ne = Symbol("closed");
+var Ns = Symbol("read");
+var Ae = Symbol("flush");
+var As = Symbol("flushChunk");
+var z = Symbol("encoding");
+var Mt = Symbol("decoder");
+var g = Symbol("flowing");
+var Qt = Symbol("paused");
+var Bt = Symbol("resume");
+var b = Symbol("buffer");
+var N = Symbol("pipes");
+var _ = Symbol("bufferLength");
+var bi = Symbol("bufferPush");
+var Ie = Symbol("bufferShift");
+var L = Symbol("objectMode");
+var S = Symbol("destroyed");
+var _i = Symbol("error");
+var Oi = Symbol("emitData");
+var Is = Symbol("emitEnd");
+var Ti = Symbol("emitEnd2");
+var Z = Symbol("async");
+var xi = Symbol("abort");
+var Ce = Symbol("aborted");
+var Jt = Symbol("signal");
+var Rt = Symbol("dataListeners");
+var C = Symbol("discarded");
+var jt = (s) => Promise.resolve().then(s);
+var Yr = (s) => s();
+var Kr = (s) => s === "end" || s === "finish" || s === "prefinish";
+var Vr = (s) => s instanceof ArrayBuffer || !!s && typeof s == "object" && s.constructor && s.constructor.name === "ArrayBuffer" && s.byteLength >= 0;
+var $r = (s) => !Buffer.isBuffer(s) && ArrayBuffer.isView(s);
+var Fe = class {
+	src;
+	dest;
+	opts;
+	ondrain;
+	constructor(t, e, i) {
+		this.src = t, this.dest = e, this.opts = i, this.ondrain = () => t[Bt](), this.dest.on("drain", this.ondrain);
+	}
+	unpipe() {
+		this.dest.removeListener("drain", this.ondrain);
+	}
+	proxyErrors(t) {}
+	end() {
+		this.unpipe(), this.opts.end && this.dest.end();
+	}
+};
+var Li = class extends Fe {
+	unpipe() {
+		this.src.removeListener("error", this.proxyErrors), super.unpipe();
+	}
+	constructor(t, e, i) {
+		super(t, e, i), this.proxyErrors = (r) => this.dest.emit("error", r), t.on("error", this.proxyErrors);
+	}
+};
+var Xr = (s) => !!s.objectMode;
+var qr = (s) => !s.objectMode && !!s.encoding && s.encoding !== "buffer";
+var A = class extends EventEmitter$1 {
+	[g] = !1;
+	[Qt] = !1;
+	[N] = [];
+	[b] = [];
+	[L];
+	[z];
+	[Z];
+	[Mt];
+	[Q] = !1;
+	[nt] = !1;
+	[De] = !1;
+	[Ne] = !1;
+	[qt] = null;
+	[_] = 0;
+	[S] = !1;
+	[Jt];
+	[Ce] = !1;
+	[Rt] = 0;
+	[C] = !1;
+	writable = !0;
+	readable = !0;
+	constructor(...t) {
+		let e = t[0] || {};
+		if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
+		Xr(e) ? (this[L] = !0, this[z] = null) : qr(e) ? (this[z] = e.encoding, this[L] = !1) : (this[L] = !1, this[z] = null), this[Z] = !!e.async, this[Mt] = this[z] ? new StringDecoder(this[z]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[b] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[N] });
+		let { signal: i } = e;
+		i && (this[Jt] = i, i.aborted ? this[xi]() : i.addEventListener("abort", () => this[xi]()));
+	}
+	get bufferLength() {
+		return this[_];
+	}
+	get encoding() {
+		return this[z];
+	}
+	set encoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	setEncoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	get objectMode() {
+		return this[L];
+	}
+	set objectMode(t) {
+		throw new Error("objectMode must be set at instantiation time");
+	}
+	get async() {
+		return this[Z];
+	}
+	set async(t) {
+		this[Z] = this[Z] || !!t;
+	}
+	[xi]() {
+		this[Ce] = !0, this.emit("abort", this[Jt]?.reason), this.destroy(this[Jt]?.reason);
+	}
+	get aborted() {
+		return this[Ce];
+	}
+	set aborted(t) {}
+	write(t, e, i) {
+		if (this[Ce]) return !1;
+		if (this[Q]) throw new Error("write after end");
+		if (this[S]) return this.emit("error", Object.assign(/* @__PURE__ */ new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+		typeof e == "function" && (i = e, e = "utf8"), e || (e = "utf8");
+		let r = this[Z] ? jt : Yr;
+		if (!this[L] && !Buffer.isBuffer(t)) {
+			if ($r(t)) t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+			else if (Vr(t)) t = Buffer.from(t);
+			else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+		}
+		return this[L] ? (this[g] && this[_] !== 0 && this[Ae](!0), this[g] ? this.emit("data", t) : this[bi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : t.length ? (typeof t == "string" && (e !== this[z] || this[Mt]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[z] && (t = this[Mt].write(t)), this[g] && this[_] !== 0 && this[Ae](!0), this[g] ? this.emit("data", t) : this[bi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : (this[_] !== 0 && this.emit("readable"), i && r(i), this[g]);
+	}
+	read(t) {
+		if (this[S]) return null;
+		if (this[C] = !1, this[_] === 0 || t === 0 || t && t > this[_]) return this[J](), null;
+		this[L] && (t = null), this[b].length > 1 && !this[L] && (this[b] = [this[z] ? this[b].join("") : Buffer.concat(this[b], this[_])]);
+		let e = this[Ns](t || null, this[b][0]);
+		return this[J](), e;
+	}
+	[Ns](t, e) {
+		if (this[L]) this[Ie]();
+		else {
+			let i = e;
+			t === i.length || t === null ? this[Ie]() : typeof i == "string" ? (this[b][0] = i.slice(t), e = i.slice(0, t), this[_] -= t) : (this[b][0] = i.subarray(t), e = i.subarray(0, t), this[_] -= t);
+		}
+		return this.emit("data", e), !this[b].length && !this[Q] && this.emit("drain"), e;
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, t = void 0), typeof e == "function" && (i = e, e = "utf8"), t !== void 0 && this.write(t, e), i && this.once("end", i), this[Q] = !0, this.writable = !1, (this[g] || !this[Qt]) && this[J](), this;
+	}
+	[Bt]() {
+		this[S] || (!this[Rt] && !this[N].length && (this[C] = !0), this[Qt] = !1, this[g] = !0, this.emit("resume"), this[b].length ? this[Ae]() : this[Q] ? this[J]() : this.emit("drain"));
+	}
+	resume() {
+		return this[Bt]();
+	}
+	pause() {
+		this[g] = !1, this[Qt] = !0, this[C] = !1;
+	}
+	get destroyed() {
+		return this[S];
+	}
+	get flowing() {
+		return this[g];
+	}
+	get paused() {
+		return this[Qt];
+	}
+	[bi](t) {
+		this[L] ? this[_] += 1 : this[_] += t.length, this[b].push(t);
+	}
+	[Ie]() {
+		return this[L] ? this[_] -= 1 : this[_] -= this[b][0].length, this[b].shift();
+	}
+	[Ae](t = !1) {
+		do		;
+while (this[As](this[Ie]()) && this[b].length);
+		!t && !this[b].length && !this[Q] && this.emit("drain");
+	}
+	[As](t) {
+		return this.emit("data", t), this[g];
+	}
+	pipe(t, e) {
+		if (this[S]) return t;
+		this[C] = !1;
+		let i = this[nt];
+		return e = e || {}, t === Ds.stdout || t === Ds.stderr ? e.end = !1 : e.end = e.end !== !1, e.proxyErrors = !!e.proxyErrors, i ? e.end && t.end() : (this[N].push(e.proxyErrors ? new Li(this, t, e) : new Fe(this, t, e)), this[Z] ? jt(() => this[Bt]()) : this[Bt]()), t;
+	}
+	unpipe(t) {
+		let e = this[N].find((i) => i.dest === t);
+		e && (this[N].length === 1 ? (this[g] && this[Rt] === 0 && (this[g] = !1), this[N] = []) : this[N].splice(this[N].indexOf(e), 1), e.unpipe());
+	}
+	addListener(t, e) {
+		return this.on(t, e);
+	}
+	on(t, e) {
+		let i = super.on(t, e);
+		if (t === "data") this[C] = !1, this[Rt]++, !this[N].length && !this[g] && this[Bt]();
+		else if (t === "readable" && this[_] !== 0) super.emit("readable");
+		else if (Kr(t) && this[nt]) super.emit(t), this.removeAllListeners(t);
+		else if (t === "error" && this[qt]) {
+			let r = e;
+			this[Z] ? jt(() => r.call(this, this[qt])) : r.call(this, this[qt]);
+		}
+		return i;
+	}
+	removeListener(t, e) {
+		return this.off(t, e);
+	}
+	off(t, e) {
+		let i = super.off(t, e);
+		return t === "data" && (this[Rt] = this.listeners("data").length, this[Rt] === 0 && !this[C] && !this[N].length && (this[g] = !1)), i;
+	}
+	removeAllListeners(t) {
+		let e = super.removeAllListeners(t);
+		return (t === "data" || t === void 0) && (this[Rt] = 0, !this[C] && !this[N].length && (this[g] = !1)), e;
+	}
+	get emittedEnd() {
+		return this[nt];
+	}
+	[J]() {
+		!this[De] && !this[nt] && !this[S] && this[b].length === 0 && this[Q] && (this[De] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[Ne] && this.emit("close"), this[De] = !1);
+	}
+	emit(t, ...e) {
+		let i = e[0];
+		if (t !== "error" && t !== "close" && t !== S && this[S]) return !1;
+		if (t === "data") return !this[L] && !i ? !1 : this[Z] ? (jt(() => this[Oi](i)), !0) : this[Oi](i);
+		if (t === "end") return this[Is]();
+		if (t === "close") {
+			if (this[Ne] = !0, !this[nt] && !this[S]) return !1;
+			let n = super.emit("close");
+			return this.removeAllListeners("close"), n;
+		} else if (t === "error") {
+			this[qt] = i, super.emit(_i, i);
+			let n = !this[Jt] || this.listeners("error").length ? super.emit("error", i) : !1;
+			return this[J](), n;
+		} else if (t === "resume") {
+			let n = super.emit("resume");
+			return this[J](), n;
+		} else if (t === "finish" || t === "prefinish") {
+			let n = super.emit(t);
+			return this.removeAllListeners(t), n;
+		}
+		let r = super.emit(t, ...e);
+		return this[J](), r;
+	}
+	[Oi](t) {
+		for (let i of this[N]) i.dest.write(t) === !1 && this.pause();
+		let e = this[C] ? !1 : super.emit("data", t);
+		return this[J](), e;
+	}
+	[Is]() {
+		return this[nt] ? !1 : (this[nt] = !0, this.readable = !1, this[Z] ? (jt(() => this[Ti]()), !0) : this[Ti]());
+	}
+	[Ti]() {
+		if (this[Mt]) {
+			let e = this[Mt].end();
+			if (e) {
+				for (let i of this[N]) i.dest.write(e);
+				this[C] || super.emit("data", e);
+			}
+		}
+		for (let e of this[N]) e.end();
+		let t = super.emit("end");
+		return this.removeAllListeners("end"), t;
+	}
+	async collect() {
+		let t = Object.assign([], { dataLength: 0 });
+		this[L] || (t.dataLength = 0);
+		let e = this.promise();
+		return this.on("data", (i) => {
+			t.push(i), this[L] || (t.dataLength += i.length);
+		}), await e, t;
+	}
+	async concat() {
+		if (this[L]) throw new Error("cannot concat in objectMode");
+		let t = await this.collect();
+		return this[z] ? t.join("") : Buffer.concat(t, t.dataLength);
+	}
+	async promise() {
+		return new Promise((t, e) => {
+			this.on(S, () => e(/* @__PURE__ */ new Error("stream destroyed"))), this.on("error", (i) => e(i)), this.on("end", () => t());
+		});
+	}
+	[Symbol.asyncIterator]() {
+		this[C] = !1;
+		let t = !1, e = async () => (this.pause(), t = !0, {
+			value: void 0,
+			done: !0
+		});
+		return {
+			next: () => {
+				if (t) return e();
+				let r = this.read();
+				if (r !== null) return Promise.resolve({
+					done: !1,
+					value: r
+				});
+				if (this[Q]) return e();
+				let n, o, h = (d) => {
+					this.off("data", a), this.off("end", l), this.off(S, c), e(), o(d);
+				}, a = (d) => {
+					this.off("error", h), this.off("end", l), this.off(S, c), this.pause(), n({
+						value: d,
+						done: !!this[Q]
+					});
+				}, l = () => {
+					this.off("error", h), this.off("data", a), this.off(S, c), e(), n({
+						done: !0,
+						value: void 0
+					});
+				}, c = () => h(/* @__PURE__ */ new Error("stream destroyed"));
+				return new Promise((d, y) => {
+					o = y, n = d, this.once(S, c), this.once("error", h), this.once("end", l), this.once("data", a);
+				});
+			},
+			throw: e,
+			return: e,
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			[Symbol.asyncDispose]: async () => {}
+		};
+	}
+	[Symbol.iterator]() {
+		this[C] = !1;
+		let t = !1, e = () => (this.pause(), this.off(_i, e), this.off(S, e), this.off("end", e), t = !0, {
+			done: !0,
+			value: void 0
+		}), i = () => {
+			if (t) return e();
+			let r = this.read();
+			return r === null ? e() : {
+				done: !1,
+				value: r
+			};
+		};
+		return this.once("end", e), this.once(_i, e), this.once(S, e), {
+			next: i,
+			throw: e,
+			return: e,
+			[Symbol.iterator]() {
+				return this;
+			},
+			[Symbol.dispose]: () => {}
+		};
+	}
+	destroy(t) {
+		if (this[S]) return t ? this.emit("error", t) : this.emit(S), this;
+		this[S] = !0, this[C] = !0, this[b].length = 0, this[_] = 0;
+		let e = this;
+		return typeof e.close == "function" && !this[Ne] && e.close(), t ? this.emit("error", t) : this.emit(S), this;
+	}
+	static get isStream() {
+		return Wr;
+	}
+};
+var Jr = I.writev;
+var ht = Symbol("_autoClose");
+var H = Symbol("_close");
+var te = Symbol("_ended");
+var m = Symbol("_fd");
+var Ni = Symbol("_finished");
+var tt = Symbol("_flags");
+var Ai = Symbol("_flush");
+var ki = Symbol("_handleChunk");
+var vi = Symbol("_makeBuf");
+var ie = Symbol("_mode");
+var ke = Symbol("_needDrain");
+var Ut = Symbol("_onerror");
+var Ht = Symbol("_onopen");
+var Ii = Symbol("_onread");
+var Pt = Symbol("_onwrite");
+var at = Symbol("_open");
+var U = Symbol("_path");
+var ot = Symbol("_pos");
+var Y = Symbol("_queue");
+var zt = Symbol("_read");
+var Ci = Symbol("_readSize");
+var j = Symbol("_reading");
+var ee = Symbol("_remain");
+var Fi = Symbol("_size");
+var ve = Symbol("_write");
+var gt = Symbol("_writing");
+var Me = Symbol("_defaultFlag");
+var bt = Symbol("_errored");
+var _t = class extends A {
+	[bt] = !1;
+	[m];
+	[U];
+	[Ci];
+	[j] = !1;
+	[Fi];
+	[ee];
+	[ht];
+	constructor(t, e) {
+		if (e = e || {}, super(e), this.readable = !0, this.writable = !1, typeof t != "string") throw new TypeError("path must be a string");
+		this[bt] = !1, this[m] = typeof e.fd == "number" ? e.fd : void 0, this[U] = t, this[Ci] = e.readSize || 16777216, this[j] = !1, this[Fi] = typeof e.size == "number" ? e.size : 1 / 0, this[ee] = this[Fi], this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : !0, typeof this[m] == "number" ? this[zt]() : this[at]();
+	}
+	get fd() {
+		return this[m];
+	}
+	get path() {
+		return this[U];
+	}
+	write() {
+		throw new TypeError("this is a readable stream");
+	}
+	end() {
+		throw new TypeError("this is a readable stream");
+	}
+	[at]() {
+		I.open(this[U], "r", (t, e) => this[Ht](t, e));
+	}
+	[Ht](t, e) {
+		t ? this[Ut](t) : (this[m] = e, this.emit("open", e), this[zt]());
+	}
+	[vi]() {
+		return Buffer.allocUnsafe(Math.min(this[Ci], this[ee]));
+	}
+	[zt]() {
+		if (!this[j]) {
+			this[j] = !0;
+			let t = this[vi]();
+			if (t.length === 0) return process.nextTick(() => this[Ii](null, 0, t));
+			I.read(this[m], t, 0, t.length, null, (e, i, r) => this[Ii](e, i, r));
+		}
+	}
+	[Ii](t, e, i) {
+		this[j] = !1, t ? this[Ut](t) : this[ki](e, i) && this[zt]();
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
+		}
+	}
+	[Ut](t) {
+		this[j] = !0, this[H](), this.emit("error", t);
+	}
+	[ki](t, e) {
+		let i = !1;
+		return this[ee] -= t, t > 0 && (i = super.write(t < e.length ? e.subarray(0, t) : e)), (t === 0 || this[ee] <= 0) && (i = !1, this[H](), super.end()), i;
+	}
+	emit(t, ...e) {
+		switch (t) {
+			case "prefinish":
+			case "finish": return !1;
+			case "drain": return typeof this[m] == "number" && this[zt](), !1;
+			case "error": return this[bt] ? !1 : (this[bt] = !0, super.emit(t, ...e));
+			default: return super.emit(t, ...e);
+		}
+	}
+};
+var Be = class extends _t {
+	[at]() {
+		let t = !0;
+		try {
+			this[Ht](null, I.openSync(this[U], "r")), t = !1;
+		} finally {
+			t && this[H]();
+		}
+	}
+	[zt]() {
+		let t = !0;
+		try {
+			if (!this[j]) {
+				this[j] = !0;
+				do {
+					let e = this[vi](), i = e.length === 0 ? 0 : I.readSync(this[m], e, 0, e.length, null);
+					if (!this[ki](i, e)) break;
+				} while (!0);
+				this[j] = !1;
+			}
+			t = !1;
+		} finally {
+			t && this[H]();
+		}
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.closeSync(t), this.emit("close");
+		}
+	}
+};
+var et = class extends Qr {
+	readable = !1;
+	writable = !0;
+	[bt] = !1;
+	[gt] = !1;
+	[te] = !1;
+	[Y] = [];
+	[ke] = !1;
+	[U];
+	[ie];
+	[ht];
+	[m];
+	[Me];
+	[tt];
+	[Ni] = !1;
+	[ot];
+	constructor(t, e) {
+		e = e || {}, super(e), this[U] = t, this[m] = typeof e.fd == "number" ? e.fd : void 0, this[ie] = e.mode === void 0 ? 438 : e.mode, this[ot] = typeof e.start == "number" ? e.start : void 0, this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : !0;
+		let i = this[ot] !== void 0 ? "r+" : "w";
+		this[Me] = e.flags === void 0, this[tt] = e.flags === void 0 ? i : e.flags, this[m] === void 0 && this[at]();
+	}
+	emit(t, ...e) {
+		if (t === "error") {
+			if (this[bt]) return !1;
+			this[bt] = !0;
+		}
+		return super.emit(t, ...e);
+	}
+	get fd() {
+		return this[m];
+	}
+	get path() {
+		return this[U];
+	}
+	[Ut](t) {
+		this[H](), this[gt] = !0, this.emit("error", t);
+	}
+	[at]() {
+		I.open(this[U], this[tt], this[ie], (t, e) => this[Ht](t, e));
+	}
+	[Ht](t, e) {
+		this[Me] && this[tt] === "r+" && t && t.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t ? this[Ut](t) : (this[m] = e, this.emit("open", e), this[gt] || this[Ai]());
+	}
+	end(t, e) {
+		return t && this.write(t, e), this[te] = !0, !this[gt] && !this[Y].length && typeof this[m] == "number" && this[Pt](null, 0), this;
+	}
+	write(t, e) {
+		return typeof t == "string" && (t = Buffer.from(t, e)), this[te] ? (this.emit("error", /* @__PURE__ */ new Error("write() after end()")), !1) : this[m] === void 0 || this[gt] || this[Y].length ? (this[Y].push(t), this[ke] = !0, !1) : (this[gt] = !0, this[ve](t), !0);
+	}
+	[ve](t) {
+		I.write(this[m], t, 0, t.length, this[ot], (e, i) => this[Pt](e, i));
+	}
+	[Pt](t, e) {
+		t ? this[Ut](t) : (this[ot] !== void 0 && typeof e == "number" && (this[ot] += e), this[Y].length ? this[Ai]() : (this[gt] = !1, this[te] && !this[Ni] ? (this[Ni] = !0, this[H](), this.emit("finish")) : this[ke] && (this[ke] = !1, this.emit("drain"))));
+	}
+	[Ai]() {
+		if (this[Y].length === 0) this[te] && this[Pt](null, 0);
+		else if (this[Y].length === 1) this[ve](this[Y].pop());
+		else {
+			let t = this[Y];
+			this[Y] = [], Jr(this[m], t, this[ot], (e, i) => this[Pt](e, i));
+		}
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
+		}
+	}
+};
+var Wt = class extends et {
+	[at]() {
+		let t;
+		if (this[Me] && this[tt] === "r+") try {
+			t = I.openSync(this[U], this[tt], this[ie]);
+		} catch (e) {
+			if (e?.code === "ENOENT") return this[tt] = "w", this[at]();
+			throw e;
+		}
+		else t = I.openSync(this[U], this[tt], this[ie]);
+		this[Ht](null, t);
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.closeSync(t), this.emit("close");
+		}
+	}
+	[ve](t) {
+		let e = !0;
+		try {
+			this[Pt](null, I.writeSync(this[m], t, 0, t.length, this[ot])), e = !1;
+		} finally {
+			if (e) try {
+				this[H]();
+			} catch {}
+		}
+	}
+};
+var jr = /* @__PURE__ */ 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 Fs = (s) => !!s.sync && !!s.file;
+var ks = (s) => !s.sync && !!s.file;
+var vs = (s) => !!s.sync && !s.file;
+var Ms = (s) => !s.sync && !s.file;
+var Bs = (s) => !!s.file;
+var tn = (s) => {
+	return jr.get(s) || s;
+};
+var se = (s = {}) => {
+	if (!s) return {};
+	let t = {};
+	for (let [e, i] of Object.entries(s)) {
+		let r = tn(e);
+		t[r] = i;
+	}
+	return t.chmod === void 0 && t.noChmod === !1 && (t.chmod = !0), delete t.noChmod, t;
+};
+var K = (s, t, e, i, r) => Object.assign((n = [], o, h) => {
+	Array.isArray(n) && (o = n, n = {}), typeof o == "function" && (h = o, o = void 0), o = o ? Array.from(o) : [];
+	let a = se(n);
+	if (r?.(a, o), Fs(a)) {
+		if (typeof h == "function") throw new TypeError("callback not supported for sync tar functions");
+		return s(a, o);
+	} else if (ks(a)) {
+		let l = t(a, o);
+		return h ? l.then(() => h(), h) : l;
+	} else if (vs(a)) {
+		if (typeof h == "function") throw new TypeError("callback not supported for sync tar functions");
+		return e(a, o);
+	} else if (Ms(a)) {
+		if (typeof h == "function") throw new TypeError("callback only supported with file option");
+		return i(a, o);
+	}
+	throw new Error("impossible options??");
+}, {
+	syncFile: s,
+	asyncFile: t,
+	syncNoFile: e,
+	asyncNoFile: i,
+	validate: r
+});
+var sn = en.constants || { ZLIB_VERNUM: 4736 };
+var M = Object.freeze(Object.assign(Object.create(null), {
+	Z_NO_FLUSH: 0,
+	Z_PARTIAL_FLUSH: 1,
+	Z_SYNC_FLUSH: 2,
+	Z_FULL_FLUSH: 3,
+	Z_FINISH: 4,
+	Z_BLOCK: 5,
+	Z_OK: 0,
+	Z_STREAM_END: 1,
+	Z_NEED_DICT: 2,
+	Z_ERRNO: -1,
+	Z_STREAM_ERROR: -2,
+	Z_DATA_ERROR: -3,
+	Z_MEM_ERROR: -4,
+	Z_BUF_ERROR: -5,
+	Z_VERSION_ERROR: -6,
+	Z_NO_COMPRESSION: 0,
+	Z_BEST_SPEED: 1,
+	Z_BEST_COMPRESSION: 9,
+	Z_DEFAULT_COMPRESSION: -1,
+	Z_FILTERED: 1,
+	Z_HUFFMAN_ONLY: 2,
+	Z_RLE: 3,
+	Z_FIXED: 4,
+	Z_DEFAULT_STRATEGY: 0,
+	DEFLATE: 1,
+	INFLATE: 2,
+	GZIP: 3,
+	GUNZIP: 4,
+	DEFLATERAW: 5,
+	INFLATERAW: 6,
+	UNZIP: 7,
+	BROTLI_DECODE: 8,
+	BROTLI_ENCODE: 9,
+	Z_MIN_WINDOWBITS: 8,
+	Z_MAX_WINDOWBITS: 15,
+	Z_DEFAULT_WINDOWBITS: 15,
+	Z_MIN_CHUNK: 64,
+	Z_MAX_CHUNK: 1 / 0,
+	Z_DEFAULT_CHUNK: 16384,
+	Z_MIN_MEMLEVEL: 1,
+	Z_MAX_MEMLEVEL: 9,
+	Z_DEFAULT_MEMLEVEL: 8,
+	Z_MIN_LEVEL: -1,
+	Z_MAX_LEVEL: 9,
+	Z_DEFAULT_LEVEL: -1,
+	BROTLI_OPERATION_PROCESS: 0,
+	BROTLI_OPERATION_FLUSH: 1,
+	BROTLI_OPERATION_FINISH: 2,
+	BROTLI_OPERATION_EMIT_METADATA: 3,
+	BROTLI_MODE_GENERIC: 0,
+	BROTLI_MODE_TEXT: 1,
+	BROTLI_MODE_FONT: 2,
+	BROTLI_DEFAULT_MODE: 0,
+	BROTLI_MIN_QUALITY: 0,
+	BROTLI_MAX_QUALITY: 11,
+	BROTLI_DEFAULT_QUALITY: 11,
+	BROTLI_MIN_WINDOW_BITS: 10,
+	BROTLI_MAX_WINDOW_BITS: 24,
+	BROTLI_LARGE_MAX_WINDOW_BITS: 30,
+	BROTLI_DEFAULT_WINDOW: 22,
+	BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+	BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+	BROTLI_PARAM_MODE: 0,
+	BROTLI_PARAM_QUALITY: 1,
+	BROTLI_PARAM_LGWIN: 2,
+	BROTLI_PARAM_LGBLOCK: 3,
+	BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
+	BROTLI_PARAM_SIZE_HINT: 5,
+	BROTLI_PARAM_LARGE_WINDOW: 6,
+	BROTLI_PARAM_NPOSTFIX: 7,
+	BROTLI_PARAM_NDIRECT: 8,
+	BROTLI_DECODER_RESULT_ERROR: 0,
+	BROTLI_DECODER_RESULT_SUCCESS: 1,
+	BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
+	BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
+	BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
+	BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
+	BROTLI_DECODER_NO_ERROR: 0,
+	BROTLI_DECODER_SUCCESS: 1,
+	BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
+	BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
+	BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
+	BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
+	BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
+	BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
+	BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
+	BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
+	BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
+	BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
+	BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
+	BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
+	BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
+	BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
+	BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
+	BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
+	BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
+	BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
+	BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
+	BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
+	BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
+	BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
+	BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
+	BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
+	BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
+	BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
+	BROTLI_DECODER_ERROR_UNREACHABLE: -31
+}, sn));
+var rn = Buffer$1.concat;
+var zs = Object.getOwnPropertyDescriptor(Buffer$1, "concat");
+var nn = (s) => s;
+var Bi = zs?.writable === !0 || zs?.set !== void 0 ? (s) => {
+	Buffer$1.concat = s ? nn : rn;
+} : (s) => {};
+var Tt = Symbol("_superWrite");
+var Gt = class extends Error {
+	code;
+	errno;
+	constructor(t, e) {
+		super("zlib: " + t.message, { cause: t }), this.code = t.code, this.errno = t.errno, this.code || (this.code = "ZLIB_ERROR"), this.message = "zlib: " + t.message, Error.captureStackTrace(this, e ?? this.constructor);
+	}
+	get name() {
+		return "ZlibError";
+	}
+};
+var Pi = Symbol("flushFlag");
+var re = class extends A {
+	#t = !1;
+	#i = !1;
+	#s;
+	#n;
+	#r;
+	#e;
+	#o;
+	get sawError() {
+		return this.#t;
+	}
+	get handle() {
+		return this.#e;
+	}
+	get flushFlag() {
+		return this.#s;
+	}
+	constructor(t, e) {
+		if (!t || typeof t != "object") throw new TypeError("invalid options for ZlibBase constructor");
+		if (super(t), this.#s = t.flush ?? 0, this.#n = t.finishFlush ?? 0, this.#r = t.fullFlushFlag ?? 0, typeof Ps[e] != "function") throw new TypeError("Compression method not supported: " + e);
+		try {
+			this.#e = new Ps[e](t);
+		} catch (i) {
+			throw new Gt(i, this.constructor);
+		}
+		this.#o = (i) => {
+			this.#t || (this.#t = !0, this.close(), this.emit("error", i));
+		}, this.#e?.on("error", (i) => this.#o(new Gt(i))), this.once("end", () => this.close);
+	}
+	close() {
+		this.#e && (this.#e.close(), this.#e = void 0, this.emit("close"));
+	}
+	reset() {
+		if (!this.#t) return zi(this.#e, "zlib binding closed"), this.#e.reset?.();
+	}
+	flush(t) {
+		this.ended || (typeof t != "number" && (t = this.#r), this.write(Object.assign(Buffer$1.alloc(0), { [Pi]: t })));
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, e = void 0, t = void 0), typeof e == "function" && (i = e, e = void 0), t && (e ? this.write(t, e) : this.write(t)), this.flush(this.#n), this.#i = !0, super.end(i);
+	}
+	get ended() {
+		return this.#i;
+	}
+	[Tt](t) {
+		return super.write(t);
+	}
+	write(t, e, i) {
+		if (typeof e == "function" && (i = e, e = "utf8"), typeof t == "string" && (t = Buffer$1.from(t, e)), this.#t) return;
+		zi(this.#e, "zlib binding closed");
+		let r = this.#e._handle, n = r.close;
+		r.close = () => {};
+		let o = this.#e.close;
+		this.#e.close = () => {}, Bi(!0);
+		let h;
+		try {
+			let l = typeof t[Pi] == "number" ? t[Pi] : this.#s;
+			h = this.#e._processChunk(t, l), Bi(!1);
+		} catch (l) {
+			Bi(!1), this.#o(new Gt(l, this.write));
+		} finally {
+			this.#e && (this.#e._handle = r, r.close = n, this.#e.close = o, this.#e.removeAllListeners("error"));
+		}
+		this.#e && this.#e.on("error", (l) => this.#o(new Gt(l, this.write)));
+		let a;
+		if (h) if (Array.isArray(h) && h.length > 0) {
+			let l = h[0];
+			a = this[Tt](Buffer$1.from(l));
+			for (let c = 1; c < h.length; c++) a = this[Tt](h[c]);
+		} else a = this[Tt](Buffer$1.from(h));
+		return i && i(), a;
+	}
+};
+var Pe = class extends re {
+	#t;
+	#i;
+	constructor(t, e) {
+		t = t || {}, t.flush = t.flush || M.Z_NO_FLUSH, t.finishFlush = t.finishFlush || M.Z_FINISH, t.fullFlushFlag = M.Z_FULL_FLUSH, super(t, e), this.#t = t.level, this.#i = t.strategy;
+	}
+	params(t, e) {
+		if (!this.sawError) {
+			if (!this.handle) throw new Error("cannot switch params when binding is closed");
+			if (!this.handle.params) throw new Error("not supported in this implementation");
+			if (this.#t !== t || this.#i !== e) {
+				this.flush(M.Z_SYNC_FLUSH), zi(this.handle, "zlib binding closed");
+				let i = this.handle.flush;
+				this.handle.flush = (r, n) => {
+					typeof r == "function" && (n = r, r = this.flushFlag), this.flush(r), n?.();
+				};
+				try {
+					this.handle.params(t, e);
+				} finally {
+					this.handle.flush = i;
+				}
+				this.handle && (this.#t = t, this.#i = e);
+			}
+		}
+	}
+};
+var ze = class extends Pe {
+	#t;
+	constructor(t) {
+		super(t, "Gzip"), this.#t = t && !!t.portable;
+	}
+	[Tt](t) {
+		return this.#t ? (this.#t = !1, t[9] = 255, super[Tt](t)) : super[Tt](t);
+	}
+};
+var Ue = class extends Pe {
+	constructor(t) {
+		super(t, "Unzip");
+	}
+};
+var He = class extends re {
+	constructor(t, e) {
+		t = t || {}, t.flush = t.flush || M.BROTLI_OPERATION_PROCESS, t.finishFlush = t.finishFlush || M.BROTLI_OPERATION_FINISH, t.fullFlushFlag = M.BROTLI_OPERATION_FLUSH, super(t, e);
+	}
+};
+var We = class extends He {
+	constructor(t) {
+		super(t, "BrotliCompress");
+	}
+};
+var Ge = class extends He {
+	constructor(t) {
+		super(t, "BrotliDecompress");
+	}
+};
+var Ze = class extends re {
+	constructor(t, e) {
+		t = t || {}, t.flush = t.flush || M.ZSTD_e_continue, t.finishFlush = t.finishFlush || M.ZSTD_e_end, t.fullFlushFlag = M.ZSTD_e_flush, super(t, e);
+	}
+};
+var Ye = class extends Ze {
+	constructor(t) {
+		super(t, "ZstdCompress");
+	}
+};
+var Ke = class extends Ze {
+	constructor(t) {
+		super(t, "ZstdDecompress");
+	}
+};
+var Us = (s, t) => {
+	if (Number.isSafeInteger(s)) s < 0 ? an(s, t) : hn(s, t);
+	else throw Error("cannot encode number outside of javascript safe integer range");
+	return t;
+};
+var hn = (s, t) => {
+	t[0] = 128;
+	for (var e = t.length; e > 1; e--) t[e - 1] = s & 255, s = Math.floor(s / 256);
+};
+var an = (s, t) => {
+	t[0] = 255;
+	var e = !1;
+	s = s * -1;
+	for (var i = t.length; i > 1; i--) {
+		var r = s & 255;
+		s = Math.floor(s / 256), e ? t[i - 1] = Ws(r) : r === 0 ? t[i - 1] = 0 : (e = !0, t[i - 1] = Gs(r));
+	}
+};
+var Hs = (s) => {
+	let t = s[0], e = t === 128 ? cn(s.subarray(1, s.length)) : t === 255 ? ln(s) : null;
+	if (e === null) throw Error("invalid base256 encoding");
+	if (!Number.isSafeInteger(e)) throw Error("parsed number outside of javascript safe integer range");
+	return e;
+};
+var ln = (s) => {
+	for (var t = s.length, e = 0, i = !1, r = t - 1; r > -1; r--) {
+		var n = Number(s[r]), o;
+		i ? o = Ws(n) : n === 0 ? o = n : (i = !0, o = Gs(n)), o !== 0 && (e -= o * Math.pow(256, t - r - 1));
+	}
+	return e;
+};
+var cn = (s) => {
+	for (var t = s.length, e = 0, i = t - 1; i > -1; i--) {
+		var r = Number(s[i]);
+		r !== 0 && (e += r * Math.pow(256, t - i - 1));
+	}
+	return e;
+};
+var Ws = (s) => (255 ^ s) & 255;
+var Gs = (s) => (255 ^ s) + 1 & 255;
+Ur({}, {
+	code: () => Ve,
+	isCode: () => ne,
+	isName: () => dn,
+	name: () => oe,
+	normalFsTypes: () => Ui
+});
+var ne = (s) => oe.has(s);
+var dn = (s) => Ve.has(s);
+var Ui = /* @__PURE__ */ new Set([
+	"0",
+	"",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"D"
+]);
+var oe = /* @__PURE__ */ 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 Ve = new Map(Array.from(oe).map((s) => [s[1], s[0]]));
+var un = (s) => s === void 0 || s < 0 ? void 0 : s;
+var F = class {
+	cksumValid = !1;
+	needPax = !1;
+	nullBlock = !1;
+	block;
+	path;
+	mode;
+	uid;
+	gid;
+	size;
+	cksum;
+	#t = "Unsupported";
+	linkpath;
+	uname;
+	gname;
+	devmaj = 0;
+	devmin = 0;
+	atime;
+	ctime;
+	mtime;
+	charset;
+	comment;
+	constructor(t, e = 0, i, r) {
+		Buffer.isBuffer(t) ? this.decode(t, e || 0, i, r) : t && this.#i(t);
+	}
+	decode(t, e, i, r) {
+		if (e || (e = 0), !t || !(t.length >= e + 512)) throw new Error("need 512 bytes for header");
+		let n = xt(t, e + 156, 1), o = Ui.has(n), h = o ? i : void 0, a = o ? r : void 0;
+		if (this.path = h?.path ?? xt(t, e, 100), this.mode = h?.mode ?? a?.mode ?? lt(t, e + 100, 8), this.uid = h?.uid ?? a?.uid ?? lt(t, e + 108, 8), this.gid = h?.gid ?? a?.gid ?? lt(t, e + 116, 8), this.size = un(h?.size ?? a?.size ?? lt(t, e + 124, 12)), this.mtime = h?.mtime ?? a?.mtime ?? Wi(t, e + 136, 12), this.cksum = lt(t, e + 148, 12), a && this.#i(a, !0), h && this.#i(h), ne(n) && (this.#t = n || "0"), this.#t === "0" && this.path.slice(-1) === "/" && (this.#t = "5"), this.#t === "5" && (this.size = 0), this.linkpath = xt(t, e + 157, 100), t.subarray(e + 257, e + 265).toString() === "ustar\x0000") if (this.uname = h?.uname ?? a?.uname ?? xt(t, e + 265, 32), this.gname = h?.gname ?? a?.gname ?? xt(t, e + 297, 32), this.devmaj = h?.devmaj ?? a?.devmaj ?? lt(t, e + 329, 8) ?? 0, this.devmin = h?.devmin ?? a?.devmin ?? lt(t, e + 337, 8) ?? 0, t[e + 475] !== 0) {
+			let c = xt(t, e + 345, 155);
+			this.path = c + "/" + this.path;
+		} else {
+			let c = xt(t, e + 345, 130);
+			c && (this.path = c + "/" + this.path), this.atime = i?.atime ?? r?.atime ?? Wi(t, e + 476, 12), this.ctime = i?.ctime ?? r?.ctime ?? Wi(t, e + 488, 12);
+		}
+		let l = 256;
+		for (let c = e; c < e + 148; c++) l += t[c];
+		for (let c = e + 156; c < e + 512; c++) l += t[c];
+		this.cksumValid = l === this.cksum, this.cksum === void 0 && l === 256 && (this.nullBlock = !0);
+	}
+	#i(t, e = !1) {
+		Object.assign(this, Object.fromEntries(Object.entries(t).filter(([i, r]) => !(r == null || i === "size" && Number(r) < 0 || i === "path" && e || i === "linkpath" && e || i === "global"))));
+	}
+	encode(t, e = 0) {
+		if (t || (t = this.block = Buffer.alloc(512)), this.#t === "Unsupported" && (this.#t = "0"), !(t.length >= e + 512)) throw new Error("need 512 bytes for header");
+		let i = this.ctime || this.atime ? 130 : 155, r = mn(this.path || "", i), n = r[0], o = r[1];
+		this.needPax = !!r[2], this.needPax = Lt(t, e, 100, n) || this.needPax, this.needPax = ct(t, e + 100, 8, this.mode) || this.needPax, this.needPax = ct(t, e + 108, 8, this.uid) || this.needPax, this.needPax = ct(t, e + 116, 8, this.gid) || this.needPax, this.needPax = ct(t, e + 124, 12, this.size) || this.needPax, this.needPax = Gi(t, e + 136, 12, this.mtime) || this.needPax, t[e + 156] = Number(this.#t.codePointAt(0)), this.needPax = Lt(t, e + 157, 100, this.linkpath) || this.needPax, t.write("ustar\x0000", e + 257, 8), this.needPax = Lt(t, e + 265, 32, this.uname) || this.needPax, this.needPax = Lt(t, e + 297, 32, this.gname) || this.needPax, this.needPax = ct(t, e + 329, 8, this.devmaj) || this.needPax, this.needPax = ct(t, e + 337, 8, this.devmin) || this.needPax, this.needPax = Lt(t, e + 345, i, o) || this.needPax, t[e + 475] !== 0 ? this.needPax = Lt(t, e + 345, 155, o) || this.needPax : (this.needPax = Lt(t, e + 345, 130, o) || this.needPax, this.needPax = Gi(t, e + 476, 12, this.atime) || this.needPax, this.needPax = Gi(t, e + 488, 12, this.ctime) || this.needPax);
+		let h = 256;
+		for (let a = e; a < e + 148; a++) h += t[a];
+		for (let a = e + 156; a < e + 512; a++) h += t[a];
+		return this.cksum = h, ct(t, e + 148, 8, this.cksum), this.cksumValid = !0, this.needPax;
+	}
+	get type() {
+		return this.#t === "Unsupported" ? this.#t : oe.get(this.#t);
+	}
+	get typeKey() {
+		return this.#t;
+	}
+	set type(t) {
+		let e = String(Ve.get(t));
+		if (ne(e) || e === "Unsupported") this.#t = e;
+		else if (ne(t)) this.#t = t;
+		else throw new TypeError("invalid entry type: " + t);
+	}
+};
+var mn = (s, t) => {
+	let i = s, r = "", n, o = posix.parse(s).root || ".";
+	if (Buffer.byteLength(i) < 100) n = [
+		i,
+		r,
+		!1
+	];
+	else {
+		r = posix.dirname(i), i = posix.basename(i);
+		do
+			Buffer.byteLength(i) <= 100 && Buffer.byteLength(r) <= t ? n = [
+				i,
+				r,
+				!1
+			] : Buffer.byteLength(i) > 100 && Buffer.byteLength(r) <= t ? n = [
+				i.slice(0, 99),
+				r,
+				!0
+			] : (i = posix.join(posix.basename(r), i), r = posix.dirname(r));
+		while (r !== o && n === void 0);
+		n || (n = [
+			s.slice(0, 99),
+			"",
+			!0
+		]);
+	}
+	return n;
+};
+var xt = (s, t, e) => s.subarray(t, t + e).toString("utf8").replace(/\0.*/, "");
+var Wi = (s, t, e) => pn(lt(s, t, e));
+var pn = (s) => s === void 0 ? void 0 : /* @__PURE__ */ new Date(s * 1e3);
+var lt = (s, t, e) => Number(s[t]) & 128 ? Hs(s.subarray(t, t + e)) : wn(s, t, e);
+var En = (s) => isNaN(s) ? void 0 : s;
+var wn = (s, t, e) => En(parseInt(s.subarray(t, t + e).toString("utf8").replace(/\0.*$/, "").trim(), 8));
+var Sn = {
+	12: 8589934591,
+	8: 2097151
+};
+var ct = (s, t, e, i) => i === void 0 ? !1 : i > Sn[e] || i < 0 ? (Us(i, s.subarray(t, t + e)), !0) : (yn(s, t, e, i), !1);
+var yn = (s, t, e, i) => s.write(Rn(i, e), t, e, "ascii");
+var Rn = (s, t) => gn(Math.floor(s).toString(8), t);
+var gn = (s, t) => (s.length === t - 1 ? s : new Array(t - s.length - 1).join("0") + s + " ") + "\0";
+var Gi = (s, t, e, i) => i === void 0 ? !1 : ct(s, t, e, i.getTime() / 1e3);
+var bn = new Array(156).join("\0");
+var Lt = (s, t, e, i) => i === void 0 ? !1 : (s.write(i + bn, t, e, "utf8"), i.length !== Buffer.byteLength(i) || i.length > e);
+var ft = class s {
+	atime;
+	mtime;
+	ctime;
+	charset;
+	comment;
+	gid;
+	uid;
+	gname;
+	uname;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	path;
+	size;
+	mode;
+	global;
+	constructor(t, e = !1) {
+		this.atime = t.atime, this.charset = t.charset, this.comment = t.comment, this.ctime = t.ctime, this.dev = t.dev, this.gid = t.gid, this.global = e, this.gname = t.gname, this.ino = t.ino, this.linkpath = t.linkpath, this.mtime = t.mtime, this.nlink = t.nlink, this.path = t.path, this.size = t.size, this.uid = t.uid, this.uname = t.uname;
+	}
+	encode() {
+		let t = this.encodeBody();
+		if (t === "") return Buffer.allocUnsafe(0);
+		let e = Buffer.byteLength(t), i = 512 * Math.ceil(1 + e / 512), r = Buffer.allocUnsafe(i);
+		for (let n = 0; n < 512; n++) r[n] = 0;
+		new F({
+			path: ("PaxHeader/" + basename(this.path ?? "")).slice(0, 99),
+			mode: this.mode || 420,
+			uid: this.uid,
+			gid: this.gid,
+			size: e,
+			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(r), r.write(t, 512, e, "utf8");
+		for (let n = e + 512; n < r.length; n++) r[n] = 0;
+		return r;
+	}
+	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(t) {
+		if (this[t] === void 0) return "";
+		let e = this[t], i = e instanceof Date ? e.getTime() / 1e3 : e, r = " " + (t === "dev" || t === "ino" || t === "nlink" ? "SCHILY." : "") + t + "=" + i + `
+`, n = Buffer.byteLength(r), o = Math.floor(Math.log(n) / Math.log(10)) + 1;
+		return n + o >= Math.pow(10, o) && (o += 1), o + n + r;
+	}
+	static parse(t, e, i = !1) {
+		return new s(On(Tn(t), e), i);
+	}
+};
+var On = (s, t) => t ? Object.assign({}, t, s) : s;
+var Tn = (s) => s.replace(/\n$/, "").split(`
+`).reduce(xn, Object.create(null));
+var xn = (s, t) => {
+	let e = parseInt(t, 10);
+	if (e !== Buffer.byteLength(t) + 1) return s;
+	t = t.slice((e + " ").length);
+	let i = t.split("="), r = i.shift();
+	if (!r) return s;
+	let n = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1"), o = i.join("=").replace(/\0.*/, "");
+	switch (n) {
+		case "path":
+		case "linkpath":
+		case "type":
+		case "charset":
+		case "comment":
+		case "gname":
+		case "uname":
+			s[n] = o;
+			break;
+		case "ctime":
+		case "atime":
+		case "mtime":
+			s[n] = /* @__PURE__ */ new Date(Number(o) * 1e3);
+			break;
+		case "size":
+			let h = +o;
+			h >= 0 && (s[n] = h);
+			break;
+		case "gid":
+		case "uid":
+		case "dev":
+		case "ino":
+		case "nlink":
+		case "mode": s[n] = +o;
+	}
+	return s;
+};
+var f = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) !== "win32" ? (s) => String(s) : (s) => String(s).replaceAll(/\\/g, "/");
+var $e = class extends A {
+	extended;
+	globalExtended;
+	header;
+	startBlockSize;
+	blockRemain;
+	remain;
+	type;
+	meta = !1;
+	ignore = !1;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	size = 0;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	invalid = !1;
+	absolute;
+	unsupported = !1;
+	constructor(t, e, i) {
+		switch (super({}), this.pause(), this.extended = e, this.globalExtended = i, this.header = t, this.remain = t.size ?? 0, this.startBlockSize = 512 * Math.ceil(this.remain / 512), this.blockRemain = this.startBlockSize, this.type = t.type, 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 = !0;
+				break;
+			default: this.ignore = !0;
+		}
+		if (!t.path) throw new Error("no path provided for tar.ReadEntry");
+		this.path = f(t.path), this.mode = t.mode, this.mode && (this.mode = this.mode & 4095), this.uid = t.uid, this.gid = t.gid, this.uname = t.uname, this.gname = t.gname, this.size = this.remain, this.mtime = t.mtime, this.atime = t.atime, this.ctime = t.ctime, this.linkpath = t.linkpath ? f(t.linkpath) : void 0, this.uname = t.uname, this.gname = t.gname, e && this.#t(e), i && this.#t(i, !0);
+	}
+	write(t) {
+		let e = t.length;
+		if (e > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		let i = this.remain, r = this.blockRemain;
+		return this.remain = Math.max(0, i - e), this.blockRemain = Math.max(0, r - e), this.ignore ? !0 : i >= e ? super.write(t) : super.write(t.subarray(0, i));
+	}
+	#t(t, e = !1) {
+		t.path && (t.path = f(t.path)), t.linkpath && (t.linkpath = f(t.linkpath)), Object.assign(this, Object.fromEntries(Object.entries(t).filter(([i, r]) => !(r == null || i === "path" && e))));
+	}
+};
+var Dt = (s, t, e, i = {}) => {
+	s.file && (i.file = s.file), s.cwd && (i.cwd = s.cwd), i.code = e instanceof Error && e.code || t, i.tarCode = t, !s.strict && i.recoverable !== !1 ? (e instanceof Error && (i = Object.assign(e, i), e = e.message), s.emit("warn", t, e, i)) : e instanceof Error ? s.emit("error", Object.assign(e, i)) : s.emit("error", Object.assign(/* @__PURE__ */ new Error(`${t}: ${e}`), i));
+};
+var Nn = 1048576;
+var Xi = Buffer.from([31, 139]);
+var qi = Buffer.from([
+	40,
+	181,
+	47,
+	253
+]);
+var An = Math.max(Xi.length, qi.length);
+var B = Symbol("state");
+var Nt = Symbol("writeEntry");
+var it = Symbol("readEntry");
+var Zi = Symbol("nextEntry");
+var Zs = Symbol("processEntry");
+var V = Symbol("extendedHeader");
+var he = Symbol("globalExtendedHeader");
+var dt = Symbol("meta");
+var Ys = Symbol("emitMeta");
+var p = Symbol("buffer");
+var st = Symbol("queue");
+var ut = Symbol("ended");
+var Yi = Symbol("emittedEnd");
+var At = Symbol("emit");
+var w = Symbol("unzip");
+var Xe = Symbol("consumeChunk");
+var qe = Symbol("consumeChunkSub");
+var Ki = Symbol("consumeBody");
+var Ks = Symbol("consumeMeta");
+var Vs = Symbol("consumeHeader");
+var ae = Symbol("consuming");
+var Vi = Symbol("bufferConcat");
+var Qe = Symbol("maybeEnd");
+var Yt = Symbol("writing");
+var $ = Symbol("aborted");
+var Je = Symbol("onDone");
+var It = Symbol("sawValidEntry");
+var je = Symbol("sawNullBlock");
+var ti = Symbol("sawEOF");
+var $s = Symbol("closeStream");
+var In = 1e3;
+var le = Symbol("compressedBytesRead");
+var $i = Symbol("decompressedBytesRead");
+var Xs = Symbol("checkDecompressionRatio");
+var Cn = () => !0;
+var rt = class extends EventEmitter {
+	file;
+	strict;
+	maxMetaEntrySize;
+	filter;
+	brotli;
+	zstd;
+	maxDecompressionRatio;
+	writable = !0;
+	readable = !1;
+	[st] = [];
+	[p];
+	[it];
+	[Nt];
+	[B] = "begin";
+	[dt] = "";
+	[V];
+	[he];
+	[ut] = !1;
+	[w];
+	[$] = !1;
+	[It];
+	[je] = !1;
+	[ti] = !1;
+	[Yt] = !1;
+	[ae] = !1;
+	[Yi] = !1;
+	[le] = 0;
+	[$i] = 0;
+	constructor(t = {}) {
+		super(), this.file = t.file || "", this.on(Je, () => {
+			(this[B] === "begin" || this[It] === !1) && this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format");
+		}), t.ondone ? this.on(Je, t.ondone) : this.on(Je, () => {
+			this.emit("prefinish"), this.emit("finish"), this.emit("end");
+		}), this.strict = !!t.strict, this.maxDecompressionRatio = typeof t.maxDecompressionRatio == "number" ? t.maxDecompressionRatio : In, this.maxMetaEntrySize = t.maxMetaEntrySize || Nn, this.filter = typeof t.filter == "function" ? t.filter : Cn;
+		let e = t.file && (t.file.endsWith(".tar.br") || t.file.endsWith(".tbr"));
+		this.brotli = !(t.gzip || t.zstd) && t.brotli !== void 0 ? t.brotli : e ? void 0 : !1;
+		let i = t.file && (t.file.endsWith(".tar.zst") || t.file.endsWith(".tzst"));
+		this.zstd = !(t.gzip || t.brotli) && t.zstd !== void 0 ? t.zstd : i ? !0 : void 0, this.on("end", () => this[$s]()), typeof t.onwarn == "function" && this.on("warn", t.onwarn), typeof t.onReadEntry == "function" && this.on("entry", t.onReadEntry);
+	}
+	warn(t, e, i = {}) {
+		Dt(this, t, e, i);
+	}
+	[Vs](t, e) {
+		this[It] === void 0 && (this[It] = !1);
+		let i;
+		try {
+			i = new F(t, e, this[V], this[he]);
+		} catch (r) {
+			return this.warn("TAR_ENTRY_INVALID", r);
+		}
+		if (i.nullBlock) this[je] ? (this[ti] = !0, this[B] === "begin" && (this[B] = "header"), this[At]("eof")) : (this[je] = !0, this[At]("nullBlock"));
+		else if (this[je] = !1, !i.cksumValid) this.warn("TAR_ENTRY_INVALID", "checksum failure", { header: i });
+		else if (!i.path) this.warn("TAR_ENTRY_INVALID", "path is required", { header: i });
+		else {
+			let r = i.type;
+			if (/^(Symbolic)?Link$/.test(r) && !i.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath required", { header: i });
+			else if (!/^(Symbolic)?Link$/.test(r) && !/^(Global)?ExtendedHeader$/.test(r) && i.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", { header: i });
+			else {
+				let n = this[Nt] = new $e(i, this[V], this[he]);
+				if (!this[It]) if (n.remain) {
+					let o = () => {
+						n.invalid || (this[It] = !0);
+					};
+					n.on("end", o);
+				} else this[It] = !0;
+				n.meta ? n.size > this.maxMetaEntrySize ? (n.ignore = !0, this[At]("ignoredEntry", n), this[B] = "ignore", n.resume()) : n.size > 0 && (this[dt] = "", n.on("data", (o) => this[dt] += o), this[B] = "meta") : (this[V] = void 0, n.ignore = n.ignore || !this.filter(n.path, n), n.ignore ? (this[At]("ignoredEntry", n), this[B] = n.remain ? "ignore" : "header", n.resume()) : (n.remain ? this[B] = "body" : (this[B] = "header", n.end()), this[it] ? this[st].push(n) : (this[st].push(n), this[Zi]())));
+			}
+		}
+	}
+	[$s]() {
+		queueMicrotask(() => this.emit("close"));
+	}
+	[Zs](t) {
+		let e = !0;
+		if (!t) this[it] = void 0, e = !1;
+		else if (Array.isArray(t)) {
+			let [i, ...r] = t;
+			this.emit(i, ...r);
+		} else this[it] = t, this.emit("entry", t), t.emittedEnd || (t.on("end", () => this[Zi]()), e = !1);
+		return e;
+	}
+	[Zi]() {
+		do		;
+while (this[Zs](this[st].shift()));
+		if (this[st].length === 0) {
+			let t = this[it];
+			!t || t.flowing || t.size === t.remain ? this[Yt] || this.emit("drain") : t.once("drain", () => this.emit("drain"));
+		}
+	}
+	[Ki](t, e) {
+		let i = this[Nt];
+		if (!i) throw new Error("attempt to consume body without entry??");
+		let r = i.blockRemain ?? 0, n = r >= t.length && e === 0 ? t : t.subarray(e, e + r);
+		return i.write(n), i.blockRemain || (this[B] = "header", this[Nt] = void 0, i.end()), n.length;
+	}
+	[Ks](t, e) {
+		let i = this[Nt], r = this[Ki](t, e);
+		return !this[Nt] && i && this[Ys](i), r;
+	}
+	[At](t, e, i) {
+		this[st].length === 0 && !this[it] ? this.emit(t, e, i) : this[st].push([
+			t,
+			e,
+			i
+		]);
+	}
+	[Ys](t) {
+		switch (this[At]("meta", this[dt]), t.type) {
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this[V] = ft.parse(this[dt], this[V], !1);
+				break;
+			case "GlobalExtendedHeader":
+				this[he] = ft.parse(this[dt], this[he], !0);
+				break;
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath": {
+				let e = this[V] ?? Object.create(null);
+				this[V] = e, e.path = this[dt].replace(/\0.*/, "");
+				break;
+			}
+			case "NextFileHasLongLinkpath": {
+				let e = this[V] || Object.create(null);
+				this[V] = e, e.linkpath = this[dt].replace(/\0.*/, "");
+				break;
+			}
+			default: throw new Error("unknown meta: " + t.type);
+		}
+	}
+	abort(t) {
+		if (!this[$]) {
+			if (this[w]) {
+				let e = this[w];
+				e.write = () => !0, e.end = () => e, e.emit = () => !1, e.destroy?.();
+			}
+			this[$] = !0, this.emit("abort", t), this.warn("TAR_ABORT", t, { recoverable: !1 });
+		}
+	}
+	[Xs](t) {
+		this[$i] += t.length;
+		let e = this[$i] / this[le];
+		return e > this.maxDecompressionRatio ? (this.abort(/* @__PURE__ */ new Error(`max decompression ratio exceeded: ${e.toFixed(2)} > ${this.maxDecompressionRatio}`)), !1) : !0;
+	}
+	write(t, e, i) {
+		if (typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, typeof e == "string" ? e : "utf8")), this[$]) return i?.(), !1;
+		if ((this[w] === void 0 || this.brotli === void 0 && this[w] === !1) && t) {
+			if (this[p] && (t = Buffer.concat([this[p], t]), this[p] = void 0), t.length < An) return this[p] = t, i?.(), !0;
+			for (let a = 0; this[w] === void 0 && a < Xi.length; a++) t[a] !== Xi[a] && (this[w] = !1);
+			let o = !1;
+			if (this[w] === !1 && this.zstd !== !1) {
+				o = !0;
+				for (let a = 0; a < qi.length; a++) if (t[a] !== qi[a]) {
+					o = !1;
+					break;
+				}
+			}
+			let h = this.brotli === void 0 && !o;
+			if (this[w] === !1 && h) if (t.length < 512) if (this[ut]) this.brotli = !0;
+			else return this[p] = t, i?.(), !0;
+			else try {
+				new F(t.subarray(0, 512)), this.brotli = !1;
+			} catch {
+				this.brotli = !0;
+			}
+			if (this[w] === void 0 || this[w] === !1 && (this.brotli || o)) {
+				let a = this[ut];
+				this[ut] = !1, this[w] = this[w] === void 0 ? new Ue({}) : o ? new Ke({}) : new Ge({}), this[w].on("data", (c) => {
+					this[Xs](c) && this[Xe](c);
+				}), this[w].on("error", (c) => {
+					this[$] || this.abort(c);
+				}), this[w].on("end", () => {
+					this[ut] = !0, this[Xe]();
+				}), this[Yt] = !0, this[le] += t.length;
+				let l = !!this[w][a ? "end" : "write"](t);
+				return this[Yt] = !1, i?.(), l;
+			}
+		}
+		this[Yt] = !0, this[w] ? (this[le] += t.length, this[w].write(t)) : this[Xe](t), this[Yt] = !1;
+		let n = this[st].length > 0 ? !1 : this[it] ? this[it].flowing : !0;
+		return !n && this[st].length === 0 && this[it]?.once("drain", () => this.emit("drain")), i?.(), n;
+	}
+	[Vi](t) {
+		t && !this[$] && (this[p] = this[p] ? Buffer.concat([this[p], t]) : t);
+	}
+	[Qe]() {
+		if (this[ut] && !this[Yi] && !this[$] && !this[ae]) {
+			this[Yi] = !0;
+			let t = this[Nt];
+			if (t?.blockRemain) {
+				let e = this[p] ? this[p].length : 0;
+				this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${t.blockRemain} more bytes, only ${e} available)`, { entry: t }), this[p] && t.write(this[p]), t.end();
+			}
+			this[At](Je);
+		}
+	}
+	[Xe](t) {
+		if (this[ae] && t) this[Vi](t);
+		else if (!t && !this[p]) this[Qe]();
+		else if (t) {
+			if (this[ae] = !0, this[p]) {
+				this[Vi](t);
+				let e = this[p];
+				this[p] = void 0, this[qe](e);
+			} else this[qe](t);
+			for (; this[p] && this[p]?.length >= 512 && !this[$] && !this[ti];) {
+				let e = this[p];
+				this[p] = void 0, this[qe](e);
+			}
+			this[ae] = !1;
+		}
+		(!this[p] || this[ut]) && this[Qe]();
+	}
+	[qe](t) {
+		let e = 0, i = t.length;
+		for (; e + 512 <= i && !this[$] && !this[ti];) switch (this[B]) {
+			case "begin":
+			case "header":
+				this[Vs](t, e), e += 512;
+				break;
+			case "ignore":
+			case "body":
+				e += this[Ki](t, e);
+				break;
+			case "meta":
+				e += this[Ks](t, e);
+				break;
+			default: throw new Error("invalid state: " + this[B]);
+		}
+		e < i && (this[p] = this[p] ? Buffer.concat([t.subarray(e), this[p]]) : t.subarray(e));
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, e = void 0, t = void 0), typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, e)), i && this.once("finish", i), this[$] || (this[w] ? (t && (this[le] += t.length, this[w].write(t)), this[w].end()) : (this[ut] = !0, (this.brotli === void 0 || this.zstd === void 0) && (t = t || Buffer.alloc(0)), t && this.write(t), this[Qe]())), this;
+	}
+};
+var mt = (s) => {
+	let t = s.length - 1, e = -1;
+	for (; t > -1 && s.charAt(t) === "/";) e = t, t--;
+	return e === -1 ? s : s.slice(0, e);
+};
+var vn = (s) => {
+	let t = s.onReadEntry;
+	s.onReadEntry = t ? (e) => {
+		t(e), e.resume();
+	} : (e) => e.resume();
+};
+var Qi = (s, t) => {
+	let e = new Map(t.map((o) => [mt(o), !0])), i = s.filter, r = 100, n = (o, h = "", a = 0) => {
+		if (a >= r) return e.set(o, !1), !1;
+		let l = h || parse(o).root || ".", c;
+		if (o === l) c = !1;
+		else {
+			let d = e.get(o);
+			c = d !== void 0 ? d : n(dirname(o), l, a + 1);
+		}
+		return e.set(o, c), c;
+	};
+	s.filter = i ? (o, h) => i(o, h) && n(mt(o)) : (o) => n(mt(o));
+};
+var Mn = (s) => {
+	let t = new rt(s), e = s.file, i;
+	try {
+		i = Br.openSync(e, "r");
+		let r = Br.fstatSync(i), n = s.maxReadSize || 16777216;
+		if (r.size < n) {
+			let o = Buffer.allocUnsafe(r.size), h = Br.readSync(i, o, 0, r.size, 0);
+			t.end(h === o.byteLength ? o : o.subarray(0, h));
+		} else {
+			let o = 0, h = Buffer.allocUnsafe(n);
+			for (; o < r.size;) {
+				let a = Br.readSync(i, h, 0, n, o);
+				if (a === 0) break;
+				o += a, t.write(h.subarray(0, a));
+			}
+			t.end();
+		}
+	} finally {
+		if (typeof i == "number") try {
+			Br.closeSync(i);
+		} catch {}
+	}
+};
+var Bn = (s, t) => {
+	let e = new rt(s), i = s.maxReadSize || 16777216, r = s.file;
+	return new Promise((o, h) => {
+		e.on("error", h), e.on("end", o), Br.stat(r, (a, l) => {
+			if (a) h(a);
+			else {
+				let c = new _t(r, {
+					readSize: i,
+					size: l.size
+				});
+				c.on("error", h), c.pipe(e);
+			}
+		});
+	});
+};
+var Ct = K(Mn, Bn, (s) => new rt(s), (s) => new rt(s), (s, t) => {
+	t?.length && Qi(s, t), s.noResume || vn(s);
+});
+var Ji = (s, t, e) => (s &= 4095, e && (s = (s | 384) & -19), t && (s & 256 && (s |= 64), s & 32 && (s |= 8), s & 4 && (s |= 1)), s);
+var { isAbsolute: zn, parse: qs } = win32, ce = (s) => {
+	let t = "", e = qs(s);
+	for (; zn(s) || e.root;) {
+		let i = s.charAt(0) === "/" && s.slice(0, 4) !== "//?/" ? "/" : e.root;
+		s = s.slice(i.length), t += i, e = qs(s);
+	}
+	return [t, s];
+};
+var ei = [
+	"|",
+	"<",
+	">",
+	"?",
+	":"
+];
+var ji = ei.map((s) => String.fromCodePoint(61440 + Number(s.codePointAt(0))));
+var Un = new Map(ei.map((s, t) => [s, ji[t]]));
+var Hn = new Map(ji.map((s, t) => [s, ei[t]]));
+var ts = (s) => ei.reduce((t, e) => t.split(e).join(Un.get(e)), s);
+var Qs = (s) => ji.reduce((t, e) => t.split(e).join(Hn.get(e)), s);
+var rr = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(s);
+var Wn = 16777216;
+var tr = Symbol("process");
+var er = Symbol("file");
+var ir = Symbol("directory");
+var is = Symbol("symlink");
+var sr = Symbol("hardlink");
+var fe = Symbol("header");
+var ii = Symbol("read");
+var ss = Symbol("lstat");
+var si = Symbol("onlstat");
+var rs = Symbol("onread");
+var ns = Symbol("onreadlink");
+var os = Symbol("openfile");
+var hs = Symbol("onopenfile");
+var pt = Symbol("close");
+var ri = Symbol("mode");
+var as = Symbol("awaitDrain");
+var es = Symbol("ondrain");
+var q = Symbol("prefix");
+var de = class extends A {
+	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;
+	#t = !1;
+	constructor(t, e = {}) {
+		let i = se(e);
+		super(), this.path = f(t), this.portable = !!i.portable, this.maxReadSize = i.maxReadSize || Wn, this.linkCache = i.linkCache || /* @__PURE__ */ new Map(), this.statCache = i.statCache || /* @__PURE__ */ new Map(), this.preservePaths = !!i.preservePaths, this.cwd = f(i.cwd || process.cwd()), this.strict = !!i.strict, this.noPax = !!i.noPax, this.noMtime = !!i.noMtime, this.mtime = i.mtime, this.prefix = i.prefix ? f(i.prefix) : void 0, this.onWriteEntry = i.onWriteEntry, typeof i.onwarn == "function" && this.on("warn", i.onwarn);
+		let r = !1;
+		if (!this.preservePaths) {
+			let [o, h] = ce(this.path);
+			o && typeof h == "string" && (this.path = h, r = o);
+		}
+		this.win32 = !!i.win32 || process.platform === "win32", this.win32 && (this.path = Qs(this.path.replaceAll(/\\/g, "/")), t = t.replaceAll(/\\/g, "/")), this.absolute = f(i.absolute || ar.resolve(this.cwd, t)), this.path === "" && (this.path = "./"), r && this.warn("TAR_ENTRY_INFO", `stripping ${r} from absolute path`, {
+			entry: this,
+			path: r + this.path
+		});
+		let n = this.statCache.get(this.absolute);
+		n ? this[si](n) : this[ss]();
+	}
+	warn(t, e, i = {}) {
+		return Dt(this, t, e, i);
+	}
+	emit(t, ...e) {
+		return t === "error" && (this.#t = !0), super.emit(t, ...e);
+	}
+	[ss]() {
+		I.lstat(this.absolute, (t, e) => {
+			if (t) return this.emit("error", t);
+			this[si](e);
+		});
+	}
+	[si](t) {
+		this.statCache.set(this.absolute, t), this.stat = t, t.isFile() || (t.size = 0), this.type = Gn(t), this.emit("stat", t), this[tr]();
+	}
+	[tr]() {
+		switch (this.type) {
+			case "File": return this[er]();
+			case "Directory": return this[ir]();
+			case "SymbolicLink": return this[is]();
+			default: return this.end();
+		}
+	}
+	[ri](t) {
+		return Ji(t, this.type === "Directory", this.portable);
+	}
+	[q](t) {
+		return rr(t, this.prefix);
+	}
+	[fe]() {
+		if (!this.stat) throw new Error("cannot write header before stat");
+		this.type === "Directory" && this.portable && (this.noMtime = !0), this.onWriteEntry?.(this), this.header = new F({
+			path: this[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](this.linkpath) : this.linkpath,
+			mode: this[ri](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
+		}), this.header.encode() && !this.noPax && super.write(new ft({
+			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[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](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());
+		let t = this.header?.block;
+		if (!t) throw new Error("failed to encode header");
+		super.write(t);
+	}
+	[ir]() {
+		if (!this.stat) throw new Error("cannot create directory entry without stat");
+		this.path.slice(-1) !== "/" && (this.path += "/"), this.stat.size = 0, this[fe](), this.end();
+	}
+	[is]() {
+		I.readlink(this.absolute, (t, e) => {
+			if (t) return this.emit("error", t);
+			this[ns](e);
+		});
+	}
+	[ns](t) {
+		this.linkpath = f(t), this[fe](), this.end();
+	}
+	[sr](t) {
+		if (!this.stat) throw new Error("cannot create link entry without stat");
+		this.type = "Link", this.linkpath = f(ar.relative(this.cwd, t)), this.stat.size = 0, this[fe](), this.end();
+	}
+	[er]() {
+		if (!this.stat) throw new Error("cannot create file entry without stat");
+		if (this.stat.nlink > 1) {
+			let t = `${this.stat.dev}:${this.stat.ino}`, e = this.linkCache.get(t);
+			if (e?.indexOf(this.cwd) === 0) return this[sr](e);
+			this.linkCache.set(t, this.absolute);
+		}
+		if (this[fe](), this.stat.size === 0) return this.end();
+		this[os]();
+	}
+	[os]() {
+		I.open(this.absolute, "r", (t, e) => {
+			if (t) return this.emit("error", t);
+			this[hs](e);
+		});
+	}
+	[hs](t) {
+		if (this.fd = t, this.#t) return this[pt]();
+		if (!this.stat) throw new Error("should stat before calling onopenfile");
+		this.blockLen = 512 * Math.ceil(this.stat.size / 512), this.blockRemain = this.blockLen;
+		let e = Math.min(this.blockLen, this.maxReadSize);
+		this.buf = Buffer.allocUnsafe(e), this.offset = 0, this.pos = 0, this.remain = this.stat.size, this.length = this.buf.length, this[ii]();
+	}
+	[ii]() {
+		let { fd: t, buf: e, offset: i, length: r, pos: n } = this;
+		if (t === void 0 || e === void 0) throw new Error("cannot read file without first opening");
+		I.read(t, e, i, r, n, (o, h) => {
+			if (o) return this[pt](() => this.emit("error", o));
+			this[rs](h);
+		});
+	}
+	[pt](t = () => {}) {
+		this.fd !== void 0 && I.close(this.fd, t);
+	}
+	[rs](t) {
+		if (t <= 0 && this.remain > 0) {
+			let r = Object.assign(/* @__PURE__ */ new Error("encountered unexpected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[pt](() => this.emit("error", r));
+		}
+		if (t > this.remain) {
+			let r = Object.assign(/* @__PURE__ */ new Error("did not encounter expected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[pt](() => this.emit("error", r));
+		}
+		if (!this.buf) throw new Error("should have created buffer prior to reading");
+		if (t === this.remain) for (let r = t; r < this.length && t < this.blockRemain; r++) this.buf[r + this.offset] = 0, t++, this.remain++;
+		let e = this.offset === 0 && t === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + t);
+		this.write(e) ? this[es]() : this[as](() => this[es]());
+	}
+	[as](t) {
+		this.once("drain", t);
+	}
+	write(t, e, i) {
+		if (typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, typeof e == "string" ? e : "utf8")), this.blockRemain < t.length) {
+			let r = Object.assign(/* @__PURE__ */ new Error("writing more data than expected"), { path: this.absolute });
+			return this.emit("error", r);
+		}
+		return this.remain -= t.length, this.blockRemain -= t.length, this.pos += t.length, this.offset += t.length, super.write(t, null, i);
+	}
+	[es]() {
+		if (!this.remain) return this.blockRemain && super.write(Buffer.alloc(this.blockRemain)), this[pt]((t) => t ? this.emit("error", t) : this.end());
+		if (!this.buf) throw new Error("buffer lost somehow in ONDRAIN");
+		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[ii]();
+	}
+};
+var ni = class extends de {
+	sync = !0;
+	[ss]() {
+		this[si](I.lstatSync(this.absolute));
+	}
+	[is]() {
+		this[ns](I.readlinkSync(this.absolute));
+	}
+	[os]() {
+		this[hs](I.openSync(this.absolute, "r"));
+	}
+	[ii]() {
+		let t = !0;
+		try {
+			let { fd: e, buf: i, offset: r, length: n, pos: o } = this;
+			if (e === void 0 || i === void 0) throw new Error("fd and buf must be set in READ method");
+			let h = I.readSync(e, i, r, n, o);
+			this[rs](h), t = !1;
+		} finally {
+			if (t) try {
+				this[pt](() => {});
+			} catch {}
+		}
+	}
+	[as](t) {
+		t();
+	}
+	[pt](t = () => {}) {
+		this.fd !== void 0 && I.closeSync(this.fd), t();
+	}
+};
+var oi = class extends A {
+	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(t, e, i = {}) {
+		return Dt(this, t, e, i);
+	}
+	constructor(t, e = {}) {
+		let i = se(e);
+		super(), this.preservePaths = !!i.preservePaths, this.portable = !!i.portable, this.strict = !!i.strict, this.noPax = !!i.noPax, this.noMtime = !!i.noMtime, this.onWriteEntry = i.onWriteEntry, this.readEntry = t;
+		let { type: r } = t;
+		if (r === "Unsupported") throw new Error("writing entry that should be ignored");
+		this.type = r, this.type === "Directory" && this.portable && (this.noMtime = !0), this.prefix = i.prefix, this.path = f(t.path), this.mode = t.mode !== void 0 ? this[ri](t.mode) : void 0, this.uid = this.portable ? void 0 : t.uid, this.gid = this.portable ? void 0 : t.gid, this.uname = this.portable ? void 0 : t.uname, this.gname = this.portable ? void 0 : t.gname, this.size = t.size, this.mtime = this.noMtime ? void 0 : i.mtime || t.mtime, this.atime = this.portable ? void 0 : t.atime, this.ctime = this.portable ? void 0 : t.ctime, this.linkpath = t.linkpath !== void 0 ? f(t.linkpath) : void 0, typeof i.onwarn == "function" && this.on("warn", i.onwarn);
+		let n = !1;
+		if (!this.preservePaths) {
+			let [h, a] = ce(this.path);
+			h && typeof a == "string" && (this.path = a, n = h);
+		}
+		this.remain = t.size, this.blockRemain = t.startBlockSize, this.onWriteEntry?.(this), this.header = new F({
+			path: this[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](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
+		}), n && this.warn("TAR_ENTRY_INFO", `stripping ${n} from absolute path`, {
+			entry: this,
+			path: n + this.path
+		}), this.header.encode() && !this.noPax && super.write(new ft({
+			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[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](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());
+		let o = this.header?.block;
+		if (!o) throw new Error("failed to encode header");
+		super.write(o), t.pipe(this);
+	}
+	[q](t) {
+		return rr(t, this.prefix);
+	}
+	[ri](t) {
+		return Ji(t, this.type === "Directory", this.portable);
+	}
+	write(t, e, i) {
+		typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, typeof e == "string" ? e : "utf8"));
+		let r = t.length;
+		if (r > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		return this.blockRemain -= r, super.write(t, i);
+	}
+	end(t, e, i) {
+		return this.blockRemain && super.write(Buffer.alloc(this.blockRemain)), typeof t == "function" && (i = t, e = void 0, t = void 0), typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, e ?? "utf8")), i && this.once("finish", i), t ? super.end(t, i) : super.end(i), this;
+	}
+};
+var Gn = (s) => s.isFile() ? "File" : s.isDirectory() ? "Directory" : s.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
+var hi = class s {
+	tail;
+	head;
+	length = 0;
+	static create(t = []) {
+		return new s(t);
+	}
+	constructor(t = []) {
+		for (let e of t) this.push(e);
+	}
+	*[Symbol.iterator]() {
+		for (let t = this.head; t; t = t.next) yield t.value;
+	}
+	removeNode(t) {
+		if (t.list !== this) throw new Error("removing node which does not belong to this list");
+		let e = t.next, i = t.prev;
+		return e && (e.prev = i), i && (i.next = e), t === this.head && (this.head = e), t === this.tail && (this.tail = i), this.length--, t.next = void 0, t.prev = void 0, t.list = void 0, e;
+	}
+	unshiftNode(t) {
+		if (t === this.head) return;
+		t.list && t.list.removeNode(t);
+		let e = this.head;
+		t.list = this, t.next = e, e && (e.prev = t), this.head = t, this.tail || (this.tail = t), this.length++;
+	}
+	pushNode(t) {
+		if (t === this.tail) return;
+		t.list && t.list.removeNode(t);
+		let e = this.tail;
+		t.list = this, t.prev = e, e && (e.next = t), this.tail = t, this.head || (this.head = t), this.length++;
+	}
+	push(...t) {
+		for (let e = 0, i = t.length; e < i; e++) Yn(this, t[e]);
+		return this.length;
+	}
+	unshift(...t) {
+		for (var e = 0, i = t.length; e < i; e++) Kn(this, t[e]);
+		return this.length;
+	}
+	pop() {
+		if (!this.tail) return;
+		let t = this.tail.value, e = this.tail;
+		return this.tail = this.tail.prev, this.tail ? this.tail.next = void 0 : this.head = void 0, e.list = void 0, this.length--, t;
+	}
+	shift() {
+		if (!this.head) return;
+		let t = this.head.value, e = this.head;
+		return this.head = this.head.next, this.head ? this.head.prev = void 0 : this.tail = void 0, e.list = void 0, this.length--, t;
+	}
+	forEach(t, e) {
+		e = e || this;
+		for (let i = this.head, r = 0; i; r++) t.call(e, i.value, r, this), i = i.next;
+	}
+	forEachReverse(t, e) {
+		e = e || this;
+		for (let i = this.tail, r = this.length - 1; i; r--) t.call(e, i.value, r, this), i = i.prev;
+	}
+	get(t) {
+		let e = 0, i = this.head;
+		for (; i && e < t; e++) i = i.next;
+		if (e === t && i) return i.value;
+	}
+	getReverse(t) {
+		let e = 0, i = this.tail;
+		for (; i && e < t; e++) i = i.prev;
+		if (e === t && i) return i.value;
+	}
+	map(t, e) {
+		e = e || this;
+		let i = new s();
+		for (let r = this.head; r;) i.push(t.call(e, r.value, this)), r = r.next;
+		return i;
+	}
+	mapReverse(t, e) {
+		e = e || this;
+		var i = new s();
+		for (let r = this.tail; r;) i.push(t.call(e, r.value, this)), r = r.prev;
+		return i;
+	}
+	reduce(t, e) {
+		let i, r = this.head;
+		if (arguments.length > 1) i = e;
+		else if (this.head) r = this.head.next, i = this.head.value;
+		else throw new TypeError("Reduce of empty list with no initial value");
+		for (var n = 0; r; n++) i = t(i, r.value, n), r = r.next;
+		return i;
+	}
+	reduceReverse(t, e) {
+		let i, r = this.tail;
+		if (arguments.length > 1) i = e;
+		else if (this.tail) r = this.tail.prev, i = this.tail.value;
+		else throw new TypeError("Reduce of empty list with no initial value");
+		for (let n = this.length - 1; r; n--) i = t(i, r.value, n), r = r.prev;
+		return i;
+	}
+	toArray() {
+		let t = new Array(this.length);
+		for (let e = 0, i = this.head; i; e++) t[e] = i.value, i = i.next;
+		return t;
+	}
+	toArrayReverse() {
+		let t = new Array(this.length);
+		for (let e = 0, i = this.tail; i; e++) t[e] = i.value, i = i.prev;
+		return t;
+	}
+	slice(t = 0, e = this.length) {
+		e < 0 && (e += this.length), t < 0 && (t += this.length);
+		let i = new s();
+		if (e < t || e < 0) return i;
+		t < 0 && (t = 0), e > this.length && (e = this.length);
+		let r = this.head, n = 0;
+		for (n = 0; r && n < t; n++) r = r.next;
+		for (; r && n < e; n++, r = r.next) i.push(r.value);
+		return i;
+	}
+	sliceReverse(t = 0, e = this.length) {
+		e < 0 && (e += this.length), t < 0 && (t += this.length);
+		let i = new s();
+		if (e < t || e < 0) return i;
+		t < 0 && (t = 0), e > this.length && (e = this.length);
+		let r = this.length, n = this.tail;
+		for (; n && r > e; r--) n = n.prev;
+		for (; n && r > t; r--, n = n.prev) i.push(n.value);
+		return i;
+	}
+	splice(t, e = 0, ...i) {
+		t > this.length && (t = this.length - 1), t < 0 && (t = this.length + t);
+		let r = this.head;
+		for (let o = 0; r && o < t; o++) r = r.next;
+		let n = [];
+		for (let o = 0; r && o < e; o++) n.push(r.value), r = this.removeNode(r);
+		r ? r !== this.tail && (r = r.prev) : r = this.tail;
+		for (let o of i) r = Zn(this, r, o);
+		return n;
+	}
+	reverse() {
+		let t = this.head, e = this.tail;
+		for (let i = t; i; i = i.prev) {
+			let r = i.prev;
+			i.prev = i.next, i.next = r;
+		}
+		return this.head = e, this.tail = t, this;
+	}
+};
+function Zn(s, t, e) {
+	let n = new ue(e, t, t ? t.next : s.head, s);
+	return n.next === void 0 && (s.tail = n), n.prev === void 0 && (s.head = n), s.length++, n;
+}
+function Yn(s, t) {
+	s.tail = new ue(t, s.tail, void 0, s), s.head || (s.head = s.tail), s.length++;
+}
+function Kn(s, t) {
+	s.head = new ue(t, void 0, s.head, s), s.tail || (s.tail = s.head), s.length++;
+}
+var ue = class {
+	list;
+	next;
+	prev;
+	value;
+	constructor(t, e, i, r) {
+		this.list = r, this.value = t, e ? (e.next = this, this.prev = e) : this.prev = void 0, i ? (i.prev = this, this.next = i) : this.next = void 0;
+	}
+};
+var pi = class {
+	path;
+	absolute;
+	entry;
+	stat;
+	readdir;
+	pending = !1;
+	pendingLink = !1;
+	ignore = !1;
+	piped = !1;
+	constructor(t, e) {
+		this.path = t || "./", this.absolute = e;
+	}
+};
+var nr = Buffer.alloc(1024);
+var li = Symbol("onStat");
+var me = Symbol("ended");
+var W = Symbol("queue");
+var pe = Symbol("pendingLinks");
+var Et = Symbol("current");
+var Ft = Symbol("process");
+var Ee = Symbol("processing");
+var ai = Symbol("processJob");
+var G = Symbol("jobs");
+var ls = Symbol("jobDone");
+var ci = Symbol("addFSEntry");
+var or = Symbol("addTarEntry");
+var ds = Symbol("stat");
+var us = Symbol("readdir");
+var fi = Symbol("onreaddir");
+var di = Symbol("pipe");
+var hr = Symbol("entry");
+var cs = Symbol("entryOpt");
+var ui = Symbol("writeEntryClass");
+var lr = Symbol("write");
+var fs = Symbol("ondrain");
+var wt = class extends A {
+	sync = !1;
+	opt;
+	cwd;
+	maxReadSize;
+	preservePaths;
+	strict;
+	noPax;
+	prefix;
+	linkCache;
+	statCache;
+	file;
+	portable;
+	zip;
+	readdirCache;
+	noDirRecurse;
+	follow;
+	noMtime;
+	mtime;
+	filter;
+	jobs;
+	[ui];
+	onWriteEntry;
+	[W];
+	[pe] = /* @__PURE__ */ new Map();
+	[G] = 0;
+	[Ee] = !1;
+	[me] = !1;
+	constructor(t = {}) {
+		if (super(), this.opt = t, this.file = t.file || "", this.cwd = t.cwd || process.cwd(), this.maxReadSize = t.maxReadSize, this.preservePaths = !!t.preservePaths, this.strict = !!t.strict, this.noPax = !!t.noPax, this.prefix = f(t.prefix || ""), this.linkCache = t.linkCache || /* @__PURE__ */ new Map(), this.statCache = t.statCache || /* @__PURE__ */ new Map(), this.readdirCache = t.readdirCache || /* @__PURE__ */ new Map(), this.onWriteEntry = t.onWriteEntry, this[ui] = de, typeof t.onwarn == "function" && this.on("warn", t.onwarn), this.portable = !!t.portable, t.gzip || t.brotli || t.zstd) {
+			if ((t.gzip ? 1 : 0) + (t.brotli ? 1 : 0) + (t.zstd ? 1 : 0) > 1) throw new TypeError("gzip, brotli, zstd are mutually exclusive");
+			if (t.gzip && (typeof t.gzip != "object" && (t.gzip = {}), this.portable && (t.gzip.portable = !0), this.zip = new ze(t.gzip)), t.brotli && (typeof t.brotli != "object" && (t.brotli = {}), this.zip = new We(t.brotli)), t.zstd && (typeof t.zstd != "object" && (t.zstd = {}), this.zip = new Ye(t.zstd)), !this.zip) throw new Error("impossible");
+			let e = this.zip;
+			e.on("data", (i) => super.write(i)), e.on("end", () => super.end()), e.on("drain", () => this[fs]()), this.on("resume", () => e.resume());
+		} else this.on("drain", this[fs]);
+		this.noDirRecurse = !!t.noDirRecurse, this.follow = !!t.follow, this.noMtime = !!t.noMtime, t.mtime && (this.mtime = t.mtime), this.filter = typeof t.filter == "function" ? t.filter : () => !0, this[W] = new hi(), this[G] = 0, this.jobs = Number(t.jobs) || 4, this[Ee] = !1, this[me] = !1;
+	}
+	[lr](t) {
+		return super.write(t);
+	}
+	add(t) {
+		return this.write(t), this;
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, t = void 0), typeof e == "function" && (i = e, e = void 0), t && this.add(t), this[me] = !0, this[Ft](), i && i(), this;
+	}
+	write(t) {
+		if (this[me]) throw new Error("write after end");
+		return typeof t == "string" ? this[ci](t) : this[or](t), this.flowing;
+	}
+	[or](t) {
+		let e = f(ar.resolve(this.cwd, t.path));
+		if (!this.filter(t.path, t)) t.resume();
+		else {
+			let i = new pi(t.path, e);
+			i.entry = new oi(t, this[cs](i)), i.entry.on("end", () => this[ls](i)), this[G] += 1, this[W].push(i);
+		}
+		this[Ft]();
+	}
+	[ci](t) {
+		let e = f(ar.resolve(this.cwd, t));
+		this[W].push(new pi(t, e)), this[Ft]();
+	}
+	[ds](t) {
+		t.pending = !0, this[G] += 1;
+		let e = this.follow ? "stat" : "lstat";
+		I[e](t.absolute, (i, r) => {
+			t.pending = !1, this[G] -= 1, i ? this.emit("error", i) : this[li](t, r);
+		});
+	}
+	[li](t, e) {
+		if (this.statCache.set(t.absolute, e), t.stat = e, !this.filter(t.path, e)) t.ignore = !0;
+		else if (e.isFile() && e.nlink > 1 && !this.linkCache.get(`${e.dev}:${e.ino}`) && !this.sync) if (t === this[Et]) this[ai](t);
+		else {
+			let i = `${e.dev}:${e.ino}`, r = this[pe].get(i);
+			r ? r.push(t) : this[pe].set(i, [t]), t.pendingLink = !0, t.pending = !0;
+		}
+		this[Ft]();
+	}
+	[us](t) {
+		t.pending = !0, this[G] += 1, I.readdir(t.absolute, (e, i) => {
+			if (t.pending = !1, this[G] -= 1, e) return this.emit("error", e);
+			this[fi](t, i);
+		});
+	}
+	[fi](t, e) {
+		this.readdirCache.set(t.absolute, e), t.readdir = e, this[Ft]();
+	}
+	[Ft]() {
+		if (!this[Ee]) {
+			this[Ee] = !0;
+			for (let t = this[W].head; t && this[G] < this.jobs; t = t.next) if (this[ai](t.value), t.value.ignore) {
+				let e = t.next;
+				this[W].removeNode(t), t.next = e;
+			}
+			this[Ee] = !1, this[me] && this[W].length === 0 && this[G] === 0 && (this.zip ? this.zip.end(nr) : (super.write(nr), super.end()));
+		}
+	}
+	get [Et]() {
+		return this[W] && this[W].head && this[W].head.value;
+	}
+	[ls](t) {
+		this[W].shift(), this[G] -= 1;
+		let { stat: e } = t;
+		if (e && e.isFile() && e.nlink > 1) {
+			let i = `${e.dev}:${e.ino}`, r = this[pe].get(i);
+			if (r) {
+				this[pe].delete(i);
+				for (let n of r) n.pending = !1, this[ai](n);
+			}
+		}
+		this[Ft]();
+	}
+	[ai](t) {
+		if (t.pending && t.pendingLink && t === this[Et] && (t.pending = !1, t.pendingLink = !1), !t.pending) {
+			if (t.entry) {
+				t === this[Et] && !t.piped && this[di](t);
+				return;
+			}
+			if (!t.stat) {
+				let e = this.statCache.get(t.absolute);
+				e ? this[li](t, e) : this[ds](t);
+			}
+			if (t.stat && !t.ignore) {
+				if (!this.noDirRecurse && t.stat.isDirectory() && !t.readdir) {
+					let e = this.readdirCache.get(t.absolute);
+					if (e ? this[fi](t, e) : this[us](t), !t.readdir) return;
+				}
+				if (t.entry = this[hr](t), !t.entry) {
+					t.ignore = !0;
+					return;
+				}
+				t === this[Et] && !t.piped && this[di](t);
+			}
+		}
+	}
+	[cs](t) {
+		return {
+			onwarn: (e, i, r) => this.warn(e, i, r),
+			noPax: this.noPax,
+			cwd: this.cwd,
+			absolute: t.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
+		};
+	}
+	[hr](t) {
+		this[G] += 1;
+		try {
+			return new this[ui](t.path, this[cs](t)).on("end", () => this[ls](t)).on("error", (i) => this.emit("error", i));
+		} catch (e) {
+			this.emit("error", e);
+		}
+	}
+	[fs]() {
+		this[Et] && this[Et].entry && this[Et].entry.resume();
+	}
+	[di](t) {
+		t.piped = !0, t.readdir && t.readdir.forEach((r) => {
+			let n = t.path, o = n === "./" ? "" : n.replace(/\/*$/, "/");
+			this[ci](o + r);
+		});
+		let e = t.entry, i = this.zip;
+		if (!e) throw new Error("cannot pipe without source");
+		i ? e.on("data", (r) => {
+			i.write(r) || e.pause();
+		}) : e.on("data", (r) => {
+			super.write(r) || e.pause();
+		});
+	}
+	pause() {
+		return this.zip && this.zip.pause(), super.pause();
+	}
+	warn(t, e, i = {}) {
+		Dt(this, t, e, i);
+	}
+};
+var kt = class extends wt {
+	sync = !0;
+	constructor(t) {
+		super(t), this[ui] = ni;
+	}
+	pause() {}
+	resume() {}
+	[ds](t) {
+		let e = this.follow ? "statSync" : "lstatSync";
+		this[li](t, I[e](t.absolute));
+	}
+	[us](t) {
+		this[fi](t, I.readdirSync(t.absolute));
+	}
+	[di](t) {
+		let e = t.entry, i = this.zip;
+		if (t.readdir && t.readdir.forEach((r) => {
+			let n = t.path, o = n === "./" ? "" : n.replace(/\/*$/, "/");
+			this[ci](o + r);
+		}), !e) throw new Error("Cannot pipe without source");
+		i ? e.on("data", (r) => {
+			i.write(r);
+		}) : e.on("data", (r) => {
+			super[lr](r);
+		});
+	}
+};
+var Vn = (s, t) => {
+	let e = new kt(s), i = new Wt(s.file, { mode: s.mode || 438 });
+	e.pipe(i), fr(e, t);
+};
+var $n = (s, t) => {
+	let e = new wt(s), i = new et(s.file, { mode: s.mode || 438 });
+	e.pipe(i);
+	let r = new Promise((n, o) => {
+		i.on("error", o), i.on("close", n), e.on("error", o);
+	});
+	return dr(e, t).catch((n) => e.emit("error", n)), r;
+};
+var fr = (s, t) => {
+	t.forEach((e) => {
+		e.charAt(0) === "@" ? Ct({
+			file: path.resolve(s.cwd, e.slice(1)),
+			sync: !0,
+			noResume: !0,
+			onReadEntry: (i) => s.add(i)
+		}) : s.add(e);
+	}), s.end();
+};
+var dr = async (s, t) => {
+	for (let e of t) e.charAt(0) === "@" ? await Ct({
+		file: path.resolve(String(s.cwd), e.slice(1)),
+		noResume: !0,
+		onReadEntry: (i) => {
+			s.add(i);
+		}
+	}) : s.add(e);
+	s.end();
+};
+var Xn = (s, t) => {
+	let e = new kt(s);
+	return fr(e, t), e;
+};
+var qn = (s, t) => {
+	let e = new wt(s);
+	return dr(e, t).catch((i) => e.emit("error", i)), e;
+};
+var Qn = K(Vn, $n, Xn, qn, (s, t) => {
+	if (!t?.length) throw new TypeError("no paths specified to add to archive");
+});
+var Er = (process.env.__FAKE_PLATFORM__ || process.platform) === "win32", { O_CREAT: wr, O_NOFOLLOW: ur, O_TRUNC: Sr, O_WRONLY: yr } = I.constants, Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || I.constants.UV_FS_O_FILEMAP || 0, jn = Er && !!Rr, to = 524288, eo = Rr | Sr | wr | yr, mr = !Er && typeof ur == "number" ? ur | Sr | wr | yr : null, ms = mr !== null ? () => mr : jn ? (s) => s < to ? eo : "w" : () => "w";
+var ps = (s, t, e) => {
+	try {
+		return Br.lchownSync(s, t, e);
+	} catch (i) {
+		if (i?.code !== "ENOENT") throw i;
+	}
+};
+var Ei = (s, t, e, i) => {
+	Br.lchown(s, t, e, (r) => {
+		i(r && r?.code !== "ENOENT" ? r : null);
+	});
+};
+var io = (s, t, e, i, r) => {
+	if (t.isDirectory()) Es(path.resolve(s, t.name), e, i, (n) => {
+		if (n) return r(n);
+		Ei(path.resolve(s, t.name), e, i, r);
+	});
+	else Ei(path.resolve(s, t.name), e, i, r);
+};
+var Es = (s, t, e, i) => {
+	Br.readdir(s, { withFileTypes: !0 }, (r, n) => {
+		if (r) {
+			if (r.code === "ENOENT") return i();
+			if (r.code !== "ENOTDIR" && r.code !== "ENOTSUP") return i(r);
+		}
+		if (r || !n.length) return Ei(s, t, e, i);
+		let o = n.length, h = null, a = (l) => {
+			if (!h) {
+				if (l) return i(h = l);
+				if (--o === 0) return Ei(s, t, e, i);
+			}
+		};
+		for (let l of n) io(s, l, t, e, a);
+	});
+};
+var so = (s, t, e, i) => {
+	t.isDirectory() && ws(path.resolve(s, t.name), e, i), ps(path.resolve(s, t.name), e, i);
+};
+var ws = (s, t, e) => {
+	let i;
+	try {
+		i = Br.readdirSync(s, { withFileTypes: !0 });
+	} catch (r) {
+		let n = r;
+		if (n?.code === "ENOENT") return;
+		if (n?.code === "ENOTDIR" || n?.code === "ENOTSUP") return ps(s, t, e);
+		throw n;
+	}
+	for (let r of i) so(s, r, t, e);
+	return ps(s, t, e);
+};
+var Se = class extends Error {
+	path;
+	code;
+	syscall = "chdir";
+	constructor(t, e) {
+		super(`${e}: Cannot cd into '${t}'`), this.path = t, this.code = e;
+	}
+	get name() {
+		return "CwdError";
+	}
+};
+var St = class extends Error {
+	path;
+	symlink;
+	syscall = "symlink";
+	code = "TAR_SYMLINK_ERROR";
+	constructor(t, e) {
+		super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"), this.symlink = t, this.path = e;
+	}
+	get name() {
+		return "SymlinkError";
+	}
+};
+var no = (s, t) => {
+	Br.stat(s, (e, i) => {
+		(e || !i.isDirectory()) && (e = new Se(s, e?.code || "ENOTDIR")), t(e);
+	});
+};
+var gr = (s, t, e) => {
+	s = f(s);
+	let i = t.umask ?? 18, r = t.mode | 448, n = (r & i) !== 0, o = t.uid, h = t.gid, a = typeof o == "number" && typeof h == "number" && (o !== t.processUid || h !== t.processGid), l = t.preserve, c = t.unlink, d = f(t.cwd), y = (E, x) => {
+		E ? e(E) : x && a ? Es(x, o, h, (Le) => y(Le)) : n ? Br.chmod(s, r, e) : e();
+	};
+	if (s === d) return no(s, y);
+	if (l) return ro.mkdir(s, {
+		mode: r,
+		recursive: !0
+	}).then((E) => y(null, E ?? void 0), y);
+	Ss(d, f(path.relative(d, s)).split("/"), r, c, d, void 0, y);
+};
+var Ss = (s, t, e, i, r, n, o) => {
+	if (t.length === 0) return o(null, n);
+	let h = t.shift(), a = f(path.resolve(s + "/" + h));
+	Br.mkdir(a, e, br(a, t, e, i, r, n, o));
+};
+var br = (s, t, e, i, r, n, o) => (h) => {
+	h ? Br.lstat(s, (a, l) => {
+		if (a) a.path = a.path && f(a.path), o(a);
+		else if (l.isDirectory()) Ss(s, t, e, i, r, n, o);
+		else if (i) Br.unlink(s, (c) => {
+			if (c) return o(c);
+			Br.mkdir(s, e, br(s, t, e, i, r, n, o));
+		});
+		else {
+			if (l.isSymbolicLink()) return o(new St(s, s + "/" + t.join("/")));
+			o(h);
+		}
+	}) : (n = n || s, Ss(s, t, e, i, r, n, o));
+};
+var oo = (s) => {
+	let t = !1, e;
+	try {
+		t = Br.statSync(s).isDirectory();
+	} catch (i) {
+		e = i?.code;
+	} finally {
+		if (!t) throw new Se(s, e ?? "ENOTDIR");
+	}
+};
+var _r = (s, t) => {
+	s = f(s);
+	let e = t.umask ?? 18, i = t.mode | 448, r = (i & e) !== 0, n = t.uid, o = t.gid, h = typeof n == "number" && typeof o == "number" && (n !== t.processUid || o !== t.processGid), a = t.preserve, l = t.unlink, c = f(t.cwd), d = (E) => {
+		E && h && ws(E, n, o), r && Br.chmodSync(s, i);
+	};
+	if (s === c) return oo(c), d();
+	if (a) return d(Br.mkdirSync(s, {
+		mode: i,
+		recursive: !0
+	}) ?? void 0);
+	let T = f(path.relative(c, s)).split("/"), D;
+	for (let E = T.shift(), x = c; E && (x += "/" + E); E = T.shift()) {
+		x = f(path.resolve(x));
+		try {
+			Br.mkdirSync(x, i), D = D || x;
+		} catch {
+			let Le = Br.lstatSync(x);
+			if (Le.isDirectory()) continue;
+			if (l) {
+				Br.unlinkSync(x), Br.mkdirSync(x, i), D = D || x;
+				continue;
+			} else if (Le.isSymbolicLink()) return new St(x, x + "/" + T.join("/"));
+		}
+	}
+	return d(D);
+};
+var ys = Object.create(null);
+var Or = 1e4;
+var Vt = /* @__PURE__ */ new Set();
+var Tr = (s) => {
+	Vt.has(s) ? Vt.delete(s) : ys[s] = s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"), Vt.add(s);
+	let t = ys[s], e = Vt.size - Or;
+	if (e > Or / 10) {
+		for (let i of Vt) if (Vt.delete(i), delete ys[i], --e <= 0) break;
+	}
+	return t;
+};
+var ao = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32";
+var lo = (s) => s.split("/").slice(0, -1).reduce((e, i) => {
+	let r = e.at(-1);
+	return r !== void 0 && (i = join(r, i)), e.push(i || "/"), e;
+}, []);
+var yi = class {
+	#t = /* @__PURE__ */ new Map();
+	#i = /* @__PURE__ */ new Map();
+	#s = /* @__PURE__ */ new Set();
+	reserve(t, e) {
+		t = ao ? ["win32 parallelization disabled"] : t.map((r) => mt(join(Tr(r))));
+		let i = new Set(t.map((r) => lo(r)).reduce((r, n) => r.concat(n)));
+		this.#i.set(e, {
+			dirs: i,
+			paths: t
+		});
+		for (let r of t) {
+			let n = this.#t.get(r);
+			n ? n.push(e) : this.#t.set(r, [e]);
+		}
+		for (let r of i) {
+			let n = this.#t.get(r);
+			if (!n) this.#t.set(r, [/* @__PURE__ */ new Set([e])]);
+			else {
+				let o = n.at(-1);
+				o instanceof Set ? o.add(e) : n.push(/* @__PURE__ */ new Set([e]));
+			}
+		}
+		return this.#r(e);
+	}
+	#n(t) {
+		let e = this.#i.get(t);
+		if (!e) throw new Error("function does not have any path reservations");
+		return {
+			paths: e.paths.map((i) => this.#t.get(i)),
+			dirs: [...e.dirs].map((i) => this.#t.get(i))
+		};
+	}
+	check(t) {
+		let { paths: e, dirs: i } = this.#n(t);
+		return e.every((r) => r && r[0] === t) && i.every((r) => r && r[0] instanceof Set && r[0].has(t));
+	}
+	#r(t) {
+		return this.#s.has(t) || !this.check(t) ? !1 : (this.#s.add(t), t(() => this.#e(t)), !0);
+	}
+	#e(t) {
+		if (!this.#s.has(t)) return !1;
+		let e = this.#i.get(t);
+		if (!e) throw new Error("invalid reservation");
+		let { paths: i, dirs: r } = e, n = /* @__PURE__ */ new Set();
+		for (let o of i) {
+			let h = this.#t.get(o);
+			if (!h || h?.[0] !== t) continue;
+			let a = h[1];
+			if (!a) {
+				this.#t.delete(o);
+				continue;
+			}
+			if (h.shift(), typeof a == "function") n.add(a);
+			else for (let l of a) n.add(l);
+		}
+		for (let o of r) {
+			let h = this.#t.get(o), a = h?.[0];
+			if (!(!h || !(a instanceof Set))) if (a.size === 1 && h.length === 1) {
+				this.#t.delete(o);
+				continue;
+			} else if (a.size === 1) {
+				h.shift();
+				let l = h[0];
+				typeof l == "function" && n.add(l);
+			} else a.delete(t);
+		}
+		return this.#s.delete(t), n.forEach((o) => this.#r(o)), !0;
+	}
+};
+var Lr = () => process.umask();
+var Dr = Symbol("onEntry");
+var _s = Symbol("checkFs");
+var Nr = Symbol("checkFs2");
+var Os = Symbol("isReusable");
+var P = Symbol("makeFs");
+var Ts = Symbol("file");
+var xs = Symbol("directory");
+var gi = Symbol("link");
+var Ar = Symbol("symlink");
+var Ir = Symbol("hardlink");
+var Re = Symbol("ensureNoSymlink");
+var Cr = Symbol("unsupported");
+var Fr = Symbol("checkPath");
+var Rs = Symbol("stripAbsolutePath");
+var yt = Symbol("mkdir");
+var O = Symbol("onError");
+var Ri = Symbol("pending");
+var kr = Symbol("pend");
+var $t = Symbol("unpend");
+var gs = Symbol("ended");
+var bs = Symbol("maybeClose");
+var Ls = Symbol("skip");
+var ge = Symbol("doChown");
+var be = Symbol("uid");
+var _e = Symbol("gid");
+var Oe = Symbol("checkedCwd");
+var Te = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32";
+var uo = 1024;
+var mo = (s, t) => {
+	if (!Te) return Br.unlink(s, t);
+	let e = s + ".DELETE." + randomBytes(16).toString("hex");
+	Br.rename(s, e, (i) => {
+		if (i) return t(i);
+		Br.unlink(e, t);
+	});
+};
+var po = (s) => {
+	if (!Te) return Br.unlinkSync(s);
+	let t = s + ".DELETE." + randomBytes(16).toString("hex");
+	Br.renameSync(s, t), Br.unlinkSync(t);
+};
+var vr = (s, t, e) => s !== void 0 && s === s >>> 0 ? s : t !== void 0 && t === t >>> 0 ? t : e;
+var Xt = class extends rt {
+	[gs] = !1;
+	[Oe] = !1;
+	[Ri] = 0;
+	reservations = new yi();
+	transform;
+	writable = !0;
+	readable = !1;
+	uid;
+	gid;
+	setOwner;
+	preserveOwner;
+	processGid;
+	processUid;
+	maxDepth;
+	forceChown;
+	win32;
+	newer;
+	keep;
+	noMtime;
+	preservePaths;
+	unlink;
+	cwd;
+	strip;
+	processUmask;
+	umask;
+	dmode;
+	fmode;
+	chmod;
+	constructor(t = {}) {
+		if (t.ondone = () => {
+			this[gs] = !0, this[bs]();
+		}, super(t), this.transform = t.transform, this.chmod = !!t.chmod, typeof t.uid == "number" || typeof t.gid == "number") {
+			if (typeof t.uid != "number" || typeof t.gid != "number") throw new TypeError("cannot set owner without number uid and gid");
+			if (t.preserveOwner) throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
+			this.uid = t.uid, this.gid = t.gid, this.setOwner = !0;
+		} else this.uid = void 0, this.gid = void 0, this.setOwner = !1;
+		this.preserveOwner = t.preserveOwner === void 0 && typeof t.uid != "number" ? process.getuid?.() === 0 : !!t.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 t.maxDepth == "number" ? t.maxDepth : uo, this.forceChown = t.forceChown === !0, this.win32 = !!t.win32 || Te, this.newer = !!t.newer, this.keep = !!t.keep, this.noMtime = !!t.noMtime, this.preservePaths = !!t.preservePaths, this.unlink = !!t.unlink, this.cwd = f(path.resolve(t.cwd || process.cwd())), this.strip = Number(t.strip) || 0, this.processUmask = this.chmod ? typeof t.processUmask == "number" ? t.processUmask : Lr() : 0, this.umask = typeof t.umask == "number" ? t.umask : this.processUmask, this.dmode = t.dmode || 511 & ~this.umask, this.fmode = t.fmode || 438 & ~this.umask, this.on("entry", (e) => this[Dr](e));
+	}
+	warn(t, e, i = {}) {
+		return (t === "TAR_BAD_ARCHIVE" || t === "TAR_ABORT") && (i.recoverable = !1), super.warn(t, e, i);
+	}
+	[bs]() {
+		this[gs] && this[Ri] === 0 && (this.emit("prefinish"), this.emit("finish"), this.emit("end"));
+	}
+	[Rs](t, e) {
+		let i = t[e], { type: r } = t;
+		if (!i || this.preservePaths) return !0;
+		let [n, o] = ce(i), h = o.replaceAll(/\\/g, "/").split("/");
+		if (h.includes("..") || Te && /^[a-z]:\.\.$/i.test(h[0] ?? "")) {
+			if (e === "path" || r === "Link") return this.warn("TAR_ENTRY_ERROR", `${e} contains '..'`, {
+				entry: t,
+				[e]: i
+			}), !1;
+			let a = path.posix.dirname(t.path), l = path.posix.normalize(path.posix.join(a, h.join("/")));
+			if (l.startsWith("../") || l === "..") return this.warn("TAR_ENTRY_ERROR", `${e} escapes extraction directory`, {
+				entry: t,
+				[e]: i
+			}), !1;
+		}
+		return n && (t[e] = String(o), this.warn("TAR_ENTRY_INFO", `stripping ${n} from absolute ${e}`, {
+			entry: t,
+			[e]: i
+		})), !0;
+	}
+	[Fr](t) {
+		let e = f(t.path), i = e.split("/");
+		if (this.strip) {
+			if (i.length < this.strip) return !1;
+			if (t.type === "Link") {
+				let r = f(String(t.linkpath)).split("/");
+				if (r.length >= this.strip) t.linkpath = r.slice(this.strip).join("/");
+				else return !1;
+			}
+			i.splice(0, this.strip), t.path = i.join("/");
+		}
+		if (isFinite(this.maxDepth) && i.length > this.maxDepth) return this.warn("TAR_ENTRY_ERROR", "path excessively deep", {
+			entry: t,
+			path: e,
+			depth: i.length,
+			maxDepth: this.maxDepth
+		}), !1;
+		if (!this[Rs](t, "path") || !this[Rs](t, "linkpath")) return !1;
+		if (t.absolute = path.isAbsolute(t.path) ? f(path.resolve(t.path)) : f(path.resolve(this.cwd, t.path)), !this.preservePaths && typeof t.absolute == "string" && t.absolute.indexOf(this.cwd + "/") !== 0 && t.absolute !== this.cwd) return this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
+			entry: t,
+			path: f(t.path),
+			resolvedPath: t.absolute,
+			cwd: this.cwd
+		}), !1;
+		if (t.absolute === this.cwd && t.type !== "Directory" && t.type !== "GNUDumpDir") return !1;
+		if (this.win32) {
+			let { root: r } = path.win32.parse(String(t.absolute));
+			t.absolute = r + ts(String(t.absolute).slice(r.length));
+			let { root: n } = path.win32.parse(t.path);
+			t.path = n + ts(t.path.slice(n.length));
+		}
+		return !0;
+	}
+	[Dr](t) {
+		if (!this[Fr](t)) return t.resume();
+		switch (co.equal(typeof t.absolute, "string"), t.type) {
+			case "Directory":
+			case "GNUDumpDir": t.mode && (t.mode = t.mode | 448);
+			case "File":
+			case "OldFile":
+			case "ContiguousFile":
+			case "Link":
+			case "SymbolicLink": return this[_s](t);
+			default: return this[Cr](t);
+		}
+	}
+	[O](t, e) {
+		t.name === "CwdError" ? this.emit("error", t) : (this.warn("TAR_ENTRY_ERROR", t, { entry: e }), this[$t](), e.resume());
+	}
+	[yt](t, e, i) {
+		gr(f(t), {
+			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: e
+		}, i);
+	}
+	[ge](t) {
+		return this.forceChown || this.preserveOwner && (typeof t.uid == "number" && t.uid !== this.processUid || typeof t.gid == "number" && t.gid !== this.processGid) || typeof this.uid == "number" && this.uid !== this.processUid || typeof this.gid == "number" && this.gid !== this.processGid;
+	}
+	[be](t) {
+		return vr(this.uid, t.uid, this.processUid);
+	}
+	[_e](t) {
+		return vr(this.gid, t.gid, this.processGid);
+	}
+	[Ts](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.fmode, r = new et(String(t.absolute), {
+			flags: ms(t.size),
+			mode: i,
+			autoClose: !1
+		});
+		r.on("error", (a) => {
+			r.fd && Br.close(r.fd, () => {}), r.write = () => !0, this[O](a, t), e();
+		});
+		let n = 1, o = (a) => {
+			if (a) {
+				r.fd && Br.close(r.fd, () => {}), this[O](a, t), e();
+				return;
+			}
+			--n === 0 && r.fd !== void 0 && Br.close(r.fd, (l) => {
+				l ? this[O](l, t) : this[$t](), e();
+			});
+		};
+		r.on("finish", () => {
+			let a = String(t.absolute), l = r.fd;
+			if (typeof l == "number" && t.mtime && !this.noMtime) {
+				n++;
+				let c = t.atime || /* @__PURE__ */ new Date(), d = t.mtime;
+				Br.futimes(l, c, d, (y) => y ? Br.utimes(a, c, d, (T) => o(T && y)) : o());
+			}
+			if (typeof l == "number" && this[ge](t)) {
+				n++;
+				let c = this[be](t), d = this[_e](t);
+				typeof c == "number" && typeof d == "number" && Br.fchown(l, c, d, (y) => y ? Br.chown(a, c, d, (T) => o(T && y)) : o());
+			}
+			o();
+		});
+		let h = this.transform && this.transform(t) || t;
+		h !== t && (h.on("error", (a) => {
+			this[O](a, t), e();
+		}), t.pipe(h)), h.pipe(r);
+	}
+	[xs](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.dmode;
+		this[yt](String(t.absolute), i, (r) => {
+			if (r) {
+				this[O](r, t), e();
+				return;
+			}
+			let n = 1, o = () => {
+				--n === 0 && (e(), this[$t](), t.resume());
+			};
+			t.mtime && !this.noMtime && (n++, Br.utimes(String(t.absolute), t.atime || /* @__PURE__ */ new Date(), t.mtime, o)), this[ge](t) && (n++, Br.chown(String(t.absolute), Number(this[be](t)), Number(this[_e](t)), o)), o();
+		});
+	}
+	[Cr](t) {
+		t.unsupported = !0, this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${t.type}`, { entry: t }), t.resume();
+	}
+	[Ar](t, e) {
+		let i = f(path.relative(this.cwd, path.resolve(path.dirname(String(t.absolute)), String(t.linkpath)))).split("/");
+		this[Re](t, this.cwd, i, () => this[gi](t, String(t.linkpath), "symlink", e), (r) => {
+			this[O](r, t), e();
+		});
+	}
+	[Ir](t, e) {
+		let i = f(path.resolve(this.cwd, String(t.linkpath))), r = f(String(t.linkpath)).split("/");
+		this[Re](t, this.cwd, r, () => this[gi](t, i, "link", e), (n) => {
+			this[O](n, t), e();
+		});
+	}
+	[Re](t, e, i, r, n) {
+		let o = i.shift();
+		if (this.preservePaths || o === void 0) return r();
+		let h = path.resolve(e, o);
+		Br.lstat(h, (a, l) => {
+			if (a) return r();
+			if (l?.isSymbolicLink()) return n(new St(h, path.resolve(h, i.join("/"))));
+			this[Re](t, h, i, r, n);
+		});
+	}
+	[kr]() {
+		this[Ri]++;
+	}
+	[$t]() {
+		this[Ri]--, this[bs]();
+	}
+	[Ls](t) {
+		this[$t](), t.resume();
+	}
+	[Os](t, e) {
+		return t.type === "File" && !this.unlink && e.isFile() && e.nlink <= 1 && !Te;
+	}
+	[_s](t) {
+		this[kr]();
+		let e = [t.path];
+		t.linkpath && e.push(t.linkpath), this.reservations.reserve(e, (i) => this[Nr](t, i));
+	}
+	[Nr](t, e) {
+		let i = (h) => {
+			e(h);
+		}, r = () => {
+			this[yt](this.cwd, this.dmode, (h) => {
+				if (h) {
+					this[O](h, t), i();
+					return;
+				}
+				this[Oe] = !0, n();
+			});
+		}, n = () => {
+			if (t.absolute !== this.cwd) {
+				let h = f(path.dirname(String(t.absolute)));
+				if (h !== this.cwd) return this[yt](h, this.dmode, (a) => {
+					if (a) {
+						this[O](a, t), i();
+						return;
+					}
+					o();
+				});
+			}
+			o();
+		}, o = () => {
+			Br.lstat(String(t.absolute), (h, a) => {
+				if (a && (this.keep || this.newer && a.mtime > (t.mtime ?? a.mtime))) {
+					this[Ls](t), i();
+					return;
+				}
+				if (h || this[Os](t, a)) return this[P](null, t, i);
+				if (a.isDirectory()) {
+					if (t.type === "Directory") {
+						let l = this.chmod && t.mode && (a.mode & 4095) !== t.mode, c = (d) => this[P](d ?? null, t, i);
+						return l ? Br.chmod(String(t.absolute), Number(t.mode), c) : c();
+					}
+					if (t.absolute !== this.cwd) return Br.rmdir(String(t.absolute), (l) => this[P](l ?? null, t, i));
+				}
+				if (t.absolute === this.cwd) return this[P](null, t, i);
+				mo(String(t.absolute), (l) => this[P](l ?? null, t, i));
+			});
+		};
+		this[Oe] ? n() : r();
+	}
+	[P](t, e, i) {
+		if (t) {
+			this[O](t, e), i();
+			return;
+		}
+		switch (e.type) {
+			case "File":
+			case "OldFile":
+			case "ContiguousFile": return this[Ts](e, i);
+			case "Link": return this[Ir](e, i);
+			case "SymbolicLink": return this[Ar](e, i);
+			case "Directory":
+			case "GNUDumpDir": return this[xs](e, i);
+		}
+	}
+	[gi](t, e, i, r) {
+		Br[i](e, String(t.absolute), (n) => {
+			n ? this[O](n, t) : (this[$t](), t.resume()), r();
+		});
+	}
+};
+var ye = (s) => {
+	try {
+		return [null, s()];
+	} catch (t) {
+		return [t, null];
+	}
+};
+var xe = class extends Xt {
+	sync = !0;
+	[P](t, e) {
+		return super[P](t, e, () => {});
+	}
+	[_s](t) {
+		if (!this[Oe]) {
+			let n = this[yt](this.cwd, this.dmode);
+			if (n) return this[O](n, t);
+			this[Oe] = !0;
+		}
+		if (t.absolute !== this.cwd) {
+			let n = f(path.dirname(String(t.absolute)));
+			if (n !== this.cwd) {
+				let o = this[yt](n, this.dmode);
+				if (o) return this[O](o, t);
+			}
+		}
+		let [e, i] = ye(() => Br.lstatSync(String(t.absolute)));
+		if (i && (this.keep || this.newer && i.mtime > (t.mtime ?? i.mtime))) return this[Ls](t);
+		if (e || this[Os](t, i)) return this[P](null, t);
+		if (i.isDirectory()) {
+			if (t.type === "Directory") {
+				let [h] = this.chmod && t.mode && (i.mode & 4095) !== t.mode ? ye(() => {
+					Br.chmodSync(String(t.absolute), Number(t.mode));
+				}) : [];
+				return this[P](h, t);
+			}
+			let [n] = ye(() => Br.rmdirSync(String(t.absolute)));
+			this[P](n, t);
+		}
+		let [r] = t.absolute === this.cwd ? [] : ye(() => po(String(t.absolute)));
+		this[P](r, t);
+	}
+	[Ts](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.fmode, r = (h) => {
+			let a;
+			try {
+				Br.closeSync(n);
+			} catch (l) {
+				a = l;
+			}
+			(h || a) && this[O](h || a, t), e();
+		}, n;
+		try {
+			n = Br.openSync(String(t.absolute), ms(t.size), i);
+		} catch (h) {
+			return r(h);
+		}
+		let o = this.transform && this.transform(t) || t;
+		o !== t && (o.on("error", (h) => this[O](h, t)), t.pipe(o)), o.on("data", (h) => {
+			try {
+				Br.writeSync(n, h, 0, h.length);
+			} catch (a) {
+				r(a);
+			}
+		}), o.on("end", () => {
+			let h = null;
+			if (t.mtime && !this.noMtime) {
+				let a = t.atime || /* @__PURE__ */ new Date(), l = t.mtime;
+				try {
+					Br.futimesSync(n, a, l);
+				} catch (c) {
+					try {
+						Br.utimesSync(String(t.absolute), a, l);
+					} catch {
+						h = c;
+					}
+				}
+			}
+			if (this[ge](t)) {
+				let a = this[be](t), l = this[_e](t);
+				try {
+					Br.fchownSync(n, Number(a), Number(l));
+				} catch (c) {
+					try {
+						Br.chownSync(String(t.absolute), Number(a), Number(l));
+					} catch {
+						h = h || c;
+					}
+				}
+			}
+			r(h);
+		});
+	}
+	[xs](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.dmode, r = this[yt](String(t.absolute), i);
+		if (r) {
+			this[O](r, t), e();
+			return;
+		}
+		if (t.mtime && !this.noMtime) try {
+			Br.utimesSync(String(t.absolute), t.atime || /* @__PURE__ */ new Date(), t.mtime);
+		} catch {}
+		if (this[ge](t)) try {
+			Br.chownSync(String(t.absolute), Number(this[be](t)), Number(this[_e](t)));
+		} catch {}
+		e(), t.resume();
+	}
+	[yt](t, e) {
+		try {
+			return _r(f(t), {
+				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: e
+			});
+		} catch (i) {
+			return i;
+		}
+	}
+	[Re](t, e, i, r, n) {
+		if (this.preservePaths || i.length === 0) return r();
+		let o = e;
+		for (let h of i) {
+			o = path.resolve(o, h);
+			let [a, l] = ye(() => Br.lstatSync(o));
+			if (a) return r();
+			if (l.isSymbolicLink()) return n(new St(o, path.resolve(e, i.join("/"))));
+		}
+		r();
+	}
+	[gi](t, e, i, r) {
+		let n = `${i}Sync`;
+		try {
+			Br[n](e, String(t.absolute)), r(), t.resume();
+		} catch (o) {
+			return this[O](o, t);
+		}
+	}
+};
+var Eo = (s) => {
+	let t = new xe(s), e = s.file, i = Br.statSync(e);
+	new Be(e, {
+		readSize: s.maxReadSize || 16777216,
+		size: i.size
+	}).pipe(t);
+};
+var wo = (s, t) => {
+	let e = new Xt(s), i = s.maxReadSize || 16777216, r = s.file;
+	return new Promise((o, h) => {
+		e.on("error", h), e.on("close", o), Br.stat(r, (a, l) => {
+			if (a) h(a);
+			else {
+				let c = new _t(r, {
+					readSize: i,
+					size: l.size
+				});
+				c.on("error", h), c.pipe(e);
+			}
+		});
+	});
+};
+K(Eo, wo, (s) => new xe(s), (s) => new Xt(s), (s, t) => {
+	t?.length && Qi(s, t);
+});
+var yo = (s, t) => {
+	let e = new kt(s), i = !0, r, n;
+	try {
+		try {
+			r = Br.openSync(s.file, "r+");
+		} catch (a) {
+			if (a?.code === "ENOENT") r = Br.openSync(s.file, "w+");
+			else throw a;
+		}
+		let o = Br.fstatSync(r), h = Buffer.alloc(512);
+		t: for (n = 0; n < o.size; n += 512) {
+			for (let c = 0, d = 0; c < 512; c += d) {
+				if (d = Br.readSync(r, h, c, h.length - c, n + c), n === 0 && h[0] === 31 && h[1] === 139) throw new Error("cannot append to compressed archives");
+				if (!d) break t;
+			}
+			let a = new F(h);
+			if (!a.cksumValid) break;
+			let l = 512 * Math.ceil((a.size || 0) / 512);
+			if (n + l + 512 > o.size) break;
+			n += l, s.mtimeCache && a.mtime && s.mtimeCache.set(String(a.path), a.mtime);
+		}
+		i = !1, Ro(s, e, n, r, t);
+	} finally {
+		if (i) try {
+			Br.closeSync(r);
+		} catch {}
+	}
+};
+var Ro = (s, t, e, i, r) => {
+	let n = new Wt(s.file, {
+		fd: i,
+		start: e
+	});
+	t.pipe(n), bo(t, r);
+};
+var go = (s, t) => {
+	t = Array.from(t);
+	let e = new wt(s), i = (n, o, h) => {
+		let a = (T, D) => {
+			T ? Br.close(n, (E) => h(T)) : h(null, D);
+		}, l = 0;
+		if (o === 0) return a(null, 0);
+		let c = 0, d = Buffer.alloc(512), y = (T, D) => {
+			if (T || D === void 0) return a(T);
+			if (c += D, c < 512 && D) return Br.read(n, d, c, d.length - c, l + c, y);
+			if (l === 0 && d[0] === 31 && d[1] === 139) return a(/* @__PURE__ */ new Error("cannot append to compressed archives"));
+			if (c < 512) return a(null, l);
+			let E = new F(d);
+			if (!E.cksumValid) return a(null, l);
+			let x = 512 * Math.ceil((E.size ?? 0) / 512);
+			if (l + x + 512 > o || (l += x + 512, l >= o)) return a(null, l);
+			s.mtimeCache && E.mtime && s.mtimeCache.set(String(E.path), E.mtime), c = 0, Br.read(n, d, 0, 512, l, y);
+		};
+		Br.read(n, d, 0, 512, l, y);
+	};
+	return new Promise((n, o) => {
+		e.on("error", o);
+		let h = "r+", a = (l, c) => {
+			if (l && l.code === "ENOENT" && h === "r+") return h = "w+", Br.open(s.file, h, a);
+			if (l || !c) return o(l);
+			Br.fstat(c, (d, y) => {
+				if (d) return Br.close(c, () => o(d));
+				i(c, y.size, (T, D) => {
+					if (T) return o(T);
+					let E = new et(s.file, {
+						fd: c,
+						start: D
+					});
+					e.pipe(E), E.on("error", o), E.on("close", n), _o(e, t);
+				});
+			});
+		};
+		Br.open(s.file, h, a);
+	});
+};
+var bo = (s, t) => {
+	t.forEach((e) => {
+		e.charAt(0) === "@" ? Ct({
+			file: path.resolve(s.cwd, e.slice(1)),
+			sync: !0,
+			noResume: !0,
+			onReadEntry: (i) => s.add(i)
+		}) : s.add(e);
+	}), s.end();
+};
+var _o = async (s, t) => {
+	for (let e of t) e.charAt(0) === "@" ? await Ct({
+		file: path.resolve(String(s.cwd), e.slice(1)),
+		noResume: !0,
+		onReadEntry: (i) => s.add(i)
+	}) : s.add(e);
+	s.end();
+};
+var vt = K(yo, go, () => {
+	throw new TypeError("file is required");
+}, () => {
+	throw new TypeError("file is required");
+}, (s, t) => {
+	if (!Bs(s)) throw new TypeError("file is required");
+	if (s.gzip || s.brotli || s.zstd || s.file.endsWith(".br") || s.file.endsWith(".tbr")) throw new TypeError("cannot append to compressed archives");
+	if (!t?.length) throw new TypeError("no paths specified to add/replace");
+});
+K(vt.syncFile, vt.asyncFile, vt.syncNoFile, vt.asyncNoFile, (s, t = []) => {
+	vt.validate?.(s, t), To(s);
+});
+var To = (s) => {
+	let t = s.filter;
+	s.mtimeCache || (s.mtimeCache = /* @__PURE__ */ new Map()), s.filter = t ? (e, i) => t(e, i) && !((s.mtimeCache?.get(e) ?? i.mtime ?? 0) > (i.mtime ?? 0)) : (e, i) => !((s.mtimeCache?.get(e) ?? i.mtime ?? 0) > (i.mtime ?? 0));
+};
+//#endregion
+//#region src/cli/pack.ts
+/**
+* `nebulahome-package pack`: a built release, packed into the archive an installation downloads,
+* with its entry for the package index (PACKAGES_DOCS.md 8.2, 10).
+*
+* The archive is a gzipped tar of `dist/` at its root - what the packet-manager unpacks - written
+* with the same library the packet-manager reads it with, without links. The index entry is
+* checked against the index's own schema, so a release the index would refuse is refused here.
+* Without an address for the archive - no `--url`, and not on GitHub Actions - only the archive
+* is written: what a platform's local folder takes to try the package before it is released.
+*/
+/**
+* Packs a built release and writes its index entry, both into the package's folder.
+*
+* @param options - Where the package and its release are, and where the archive will be.
+* @returns What was written, with the archive's digest and size.
+* @throws {PackageConfigError} When there is no release, or its index entry does not hold.
+*/
+async function packRelease(options) {
+	const { root, outDir } = options;
+	let manifest;
+	try {
+		manifest = JSON.parse(await readFile(path.join(outDir, RELEASE_PATHS.manifest), "utf8"));
+	} catch {
+		throw new PackageConfigError([`${outDir} holds no release: run nebulahome-package build first`]);
+	}
+	if (!isRecord(manifest) || typeof manifest["id"] !== "string" || typeof manifest["version"] !== "string") throw new PackageConfigError([`${RELEASE_PATHS.manifest} is not a package's manifest`]);
+	const file = `${manifest["id"]}-${manifest["version"]}.tgz`;
+	const archive = path.join(root, file);
+	const github = githubEnvironment();
+	const base = options.urlBase ?? (github === void 0 ? void 0 : `${github.serverUrl}/${github.repository}/releases/download/${github.refName}`);
+	await Qn({
+		gzip: true,
+		cwd: outDir,
+		file: archive,
+		portable: true,
+		follow: false,
+		noMtime: true
+	}, (await readdir(outDir)).sort());
+	const bytes = await readFile(archive);
+	const sha256 = createHash("sha256").update(bytes).digest("hex");
+	if (base === void 0) return {
+		archive,
+		indexEntry: void 0,
+		sha256,
+		size: bytes.length
+	};
+	const release = packageReleaseSchema.safeParse({
+		version: manifest["version"],
+		platform: manifest["platform"],
+		sdk: manifest["sdk"],
+		requires: manifest["requires"],
+		provides: manifest["provides"],
+		artifact: {
+			url: `${base.replace(/\/$/, "")}/${file}`,
+			sha256,
+			size: bytes.length
+		},
+		publishedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+		...github === void 0 || options.urlBase !== void 0 ? {} : { changelogUrl: `${github.serverUrl}/${github.repository}/releases/tag/${github.refName}` }
+	});
+	if (!release.success) throw new PackageConfigError(release.error.issues.map((issue) => `index-entry.json ${issue.path.join(".")}: ${issue.message}`));
+	const indexEntry = path.join(root, "index-entry.json");
+	await writeFile(indexEntry, `${JSON.stringify(release.data, null, 2)}\n`);
+	return {
+		archive,
+		indexEntry,
+		sha256,
+		size: bytes.length
+	};
+}
+//#endregion
+export { packRelease };