create-book 11.0.1 → 11.0.3

package/dist/esm-BlS2QDIo.js

@@ -0,0 +1,5039 @@
+import path, { dirname, parse, resolve } from "path";
+import fs from "node:fs";
+import fs$1, { mkdir, mkdirSync, stat, statSync as statSync$1 } from "fs";
+import EE, { EventEmitter } from "events";
+import * as realZlib$1 from "zlib";
+import realZlib from "zlib";
+import assert from "assert";
+import path$1, { basename, join, posix as posix$1, win32 } from "node:path";
+import me from "node:stream";
+import { Buffer as Buffer$1 } from "buffer";
+import assert$1 from "node:assert";
+import { EventEmitter as EventEmitter$1 } from "node:events";
+import { randomBytes } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+//#region ../../node_modules/.pnpm/minipass@7.1.2/node_modules/minipass/dist/esm/index.js
+const proc = typeof process === "object" && process ? process : {
+	stdout: null,
+	stderr: null
+};
+/**
+* Return true if the argument is a Minipass stream, Node stream, or something
+* else that Minipass can interact with.
+*/
+const isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof me || isReadable(s) || isWritable(s));
+/**
+* Return true if the argument is a valid {@link Minipass.Readable}
+*/
+const isReadable = (s) => !!s && typeof s === "object" && s instanceof EventEmitter$1 && typeof s.pipe === "function" && s.pipe !== me.Writable.prototype.pipe;
+/**
+* Return true if the argument is a valid {@link Minipass.Writable}
+*/
+const isWritable = (s) => !!s && typeof s === "object" && s instanceof EventEmitter$1 && typeof s.write === "function" && typeof s.end === "function";
+const EOF$1 = Symbol("EOF");
+const MAYBE_EMIT_END = Symbol("maybeEmitEnd");
+const EMITTED_END = Symbol("emittedEnd");
+const EMITTING_END = Symbol("emittingEnd");
+const EMITTED_ERROR = Symbol("emittedError");
+const CLOSED = Symbol("closed");
+const READ$1 = Symbol("read");
+const FLUSH = Symbol("flush");
+const FLUSHCHUNK = Symbol("flushChunk");
+const ENCODING = Symbol("encoding");
+const DECODER = Symbol("decoder");
+const FLOWING = Symbol("flowing");
+const PAUSED = Symbol("paused");
+const RESUME = Symbol("resume");
+const BUFFER$1 = Symbol("buffer");
+const PIPES = Symbol("pipes");
+const BUFFERLENGTH = Symbol("bufferLength");
+const BUFFERPUSH = Symbol("bufferPush");
+const BUFFERSHIFT = Symbol("bufferShift");
+const OBJECTMODE = Symbol("objectMode");
+const DESTROYED = Symbol("destroyed");
+const ERROR = Symbol("error");
+const EMITDATA = Symbol("emitData");
+const EMITEND = Symbol("emitEnd");
+const EMITEND2 = Symbol("emitEnd2");
+const ASYNC = Symbol("async");
+const ABORT = Symbol("abort");
+const ABORTED$1 = Symbol("aborted");
+const SIGNAL = Symbol("signal");
+const DATALISTENERS = Symbol("dataListeners");
+const DISCARDED = Symbol("discarded");
+const defer = (fn) => Promise.resolve().then(fn);
+const nodefer = (fn) => fn();
+const isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
+const isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
+const isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+/**
+* Internal class representing a pipe to a destination stream.
+*
+* @internal
+*/
+var Pipe = class {
+	src;
+	dest;
+	opts;
+	ondrain;
+	constructor(src, dest, opts) {
+		this.src = src;
+		this.dest = dest;
+		this.opts = opts;
+		this.ondrain = () => src[RESUME]();
+		this.dest.on("drain", this.ondrain);
+	}
+	unpipe() {
+		this.dest.removeListener("drain", this.ondrain);
+	}
+	/* c8 ignore start */
+	proxyErrors(_er) {}
+	/* c8 ignore stop */
+	end() {
+		this.unpipe();
+		if (this.opts.end) this.dest.end();
+	}
+};
+/**
+* Internal class representing a pipe to a destination stream where
+* errors are proxied.
+*
+* @internal
+*/
+var PipeProxyErrors = class extends Pipe {
+	unpipe() {
+		this.src.removeListener("error", this.proxyErrors);
+		super.unpipe();
+	}
+	constructor(src, dest, opts) {
+		super(src, dest, opts);
+		this.proxyErrors = (er) => dest.emit("error", er);
+		src.on("error", this.proxyErrors);
+	}
+};
+const isObjectModeOptions = (o) => !!o.objectMode;
+const isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
+/**
+* Main export, the Minipass class
+*
+* `RType` is the type of data emitted, defaults to Buffer
+*
+* `WType` is the type of data to be written, if RType is buffer or string,
+* then any {@link Minipass.ContiguousData} is allowed.
+*
+* `Events` is the set of event handler signatures that this object
+* will emit, see {@link Minipass.Events}
+*/
+var Minipass = class extends EventEmitter$1 {
+	[FLOWING] = false;
+	[PAUSED] = false;
+	[PIPES] = [];
+	[BUFFER$1] = [];
+	[OBJECTMODE];
+	[ENCODING];
+	[ASYNC];
+	[DECODER];
+	[EOF$1] = false;
+	[EMITTED_END] = false;
+	[EMITTING_END] = false;
+	[CLOSED] = false;
+	[EMITTED_ERROR] = null;
+	[BUFFERLENGTH] = 0;
+	[DESTROYED] = false;
+	[SIGNAL];
+	[ABORTED$1] = false;
+	[DATALISTENERS] = 0;
+	[DISCARDED] = false;
+	/**
+	* true if the stream can be written
+	*/
+	writable = true;
+	/**
+	* true if the stream can be read
+	*/
+	readable = true;
+	/**
+	* If `RType` is Buffer, then options do not need to be provided.
+	* Otherwise, an options object must be provided to specify either
+	* {@link Minipass.SharedOptions.objectMode} or
+	* {@link Minipass.SharedOptions.encoding}, as appropriate.
+	*/
+	constructor(...args) {
+		const options = args[0] || {};
+		super();
+		if (options.objectMode && typeof options.encoding === "string") throw new TypeError("Encoding and objectMode may not be used together");
+		if (isObjectModeOptions(options)) {
+			this[OBJECTMODE] = true;
+			this[ENCODING] = null;
+		} else if (isEncodingOptions(options)) {
+			this[ENCODING] = options.encoding;
+			this[OBJECTMODE] = false;
+		} else {
+			this[OBJECTMODE] = false;
+			this[ENCODING] = null;
+		}
+		this[ASYNC] = !!options.async;
+		this[DECODER] = this[ENCODING] ? new StringDecoder(this[ENCODING]) : null;
+		if (options && options.debugExposeBuffer === true) Object.defineProperty(this, "buffer", { get: () => this[BUFFER$1] });
+		if (options && options.debugExposePipes === true) Object.defineProperty(this, "pipes", { get: () => this[PIPES] });
+		const { signal } = options;
+		if (signal) {
+			this[SIGNAL] = signal;
+			if (signal.aborted) this[ABORT]();
+			else signal.addEventListener("abort", () => this[ABORT]());
+		}
+	}
+	/**
+	* The amount of data stored in the buffer waiting to be read.
+	*
+	* For Buffer strings, this will be the total byte length.
+	* For string encoding streams, this will be the string character length,
+	* according to JavaScript's `string.length` logic.
+	* For objectMode streams, this is a count of the items waiting to be
+	* emitted.
+	*/
+	get bufferLength() {
+		return this[BUFFERLENGTH];
+	}
+	/**
+	* The `BufferEncoding` currently in use, or `null`
+	*/
+	get encoding() {
+		return this[ENCODING];
+	}
+	/**
+	* @deprecated - This is a read only property
+	*/
+	set encoding(_enc) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	/**
+	* @deprecated - Encoding may only be set at instantiation time
+	*/
+	setEncoding(_enc) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	/**
+	* True if this is an objectMode stream
+	*/
+	get objectMode() {
+		return this[OBJECTMODE];
+	}
+	/**
+	* @deprecated - This is a read-only property
+	*/
+	set objectMode(_om) {
+		throw new Error("objectMode must be set at instantiation time");
+	}
+	/**
+	* true if this is an async stream
+	*/
+	get ["async"]() {
+		return this[ASYNC];
+	}
+	/**
+	* Set to true to make this stream async.
+	*
+	* Once set, it cannot be unset, as this would potentially cause incorrect
+	* behavior.  Ie, a sync stream can be made async, but an async stream
+	* cannot be safely made sync.
+	*/
+	set ["async"](a) {
+		this[ASYNC] = this[ASYNC] || !!a;
+	}
+	[ABORT]() {
+		this[ABORTED$1] = true;
+		this.emit("abort", this[SIGNAL]?.reason);
+		this.destroy(this[SIGNAL]?.reason);
+	}
+	/**
+	* True if the stream has been aborted.
+	*/
+	get aborted() {
+		return this[ABORTED$1];
+	}
+	/**
+	* No-op setter. Stream aborted status is set via the AbortSignal provided
+	* in the constructor options.
+	*/
+	set aborted(_) {}
+	write(chunk, encoding, cb) {
+		if (this[ABORTED$1]) return false;
+		if (this[EOF$1]) throw new Error("write after end");
+		if (this[DESTROYED]) {
+			this.emit("error", Object.assign(/* @__PURE__ */ new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
+			return true;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = "utf8";
+		}
+		if (!encoding) encoding = "utf8";
+		const fn = this[ASYNC] ? defer : nodefer;
+		if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+			if (isArrayBufferView(chunk)) chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+			else if (isArrayBufferLike(chunk)) chunk = Buffer.from(chunk);
+			else if (typeof chunk !== "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+		}
+		if (this[OBJECTMODE]) {
+			/* c8 ignore start */
+			if (this[FLOWING] && this[BUFFERLENGTH] !== 0) this[FLUSH](true);
+			/* c8 ignore stop */
+			if (this[FLOWING]) this.emit("data", chunk);
+			else this[BUFFERPUSH](chunk);
+			if (this[BUFFERLENGTH] !== 0) this.emit("readable");
+			if (cb) fn(cb);
+			return this[FLOWING];
+		}
+		if (!chunk.length) {
+			if (this[BUFFERLENGTH] !== 0) this.emit("readable");
+			if (cb) fn(cb);
+			return this[FLOWING];
+		}
+		if (typeof chunk === "string" && !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) chunk = Buffer.from(chunk, encoding);
+		if (Buffer.isBuffer(chunk) && this[ENCODING]) chunk = this[DECODER].write(chunk);
+		if (this[FLOWING] && this[BUFFERLENGTH] !== 0) this[FLUSH](true);
+		if (this[FLOWING]) this.emit("data", chunk);
+		else this[BUFFERPUSH](chunk);
+		if (this[BUFFERLENGTH] !== 0) this.emit("readable");
+		if (cb) fn(cb);
+		return this[FLOWING];
+	}
+	/**
+	* Low-level explicit read method.
+	*
+	* In objectMode, the argument is ignored, and one item is returned if
+	* available.
+	*
+	* `n` is the number of bytes (or in the case of encoding streams,
+	* characters) to consume. If `n` is not provided, then the entire buffer
+	* is returned, or `null` is returned if no data is available.
+	*
+	* If `n` is greater that the amount of data in the internal buffer,
+	* then `null` is returned.
+	*/
+	read(n) {
+		if (this[DESTROYED]) return null;
+		this[DISCARDED] = false;
+		if (this[BUFFERLENGTH] === 0 || n === 0 || n && n > this[BUFFERLENGTH]) {
+			this[MAYBE_EMIT_END]();
+			return null;
+		}
+		if (this[OBJECTMODE]) n = null;
+		if (this[BUFFER$1].length > 1 && !this[OBJECTMODE]) this[BUFFER$1] = [this[ENCODING] ? this[BUFFER$1].join("") : Buffer.concat(this[BUFFER$1], this[BUFFERLENGTH])];
+		const ret = this[READ$1](n || null, this[BUFFER$1][0]);
+		this[MAYBE_EMIT_END]();
+		return ret;
+	}
+	[READ$1](n, chunk) {
+		if (this[OBJECTMODE]) this[BUFFERSHIFT]();
+		else {
+			const c = chunk;
+			if (n === c.length || n === null) this[BUFFERSHIFT]();
+			else if (typeof c === "string") {
+				this[BUFFER$1][0] = c.slice(n);
+				chunk = c.slice(0, n);
+				this[BUFFERLENGTH] -= n;
+			} else {
+				this[BUFFER$1][0] = c.subarray(n);
+				chunk = c.subarray(0, n);
+				this[BUFFERLENGTH] -= n;
+			}
+		}
+		this.emit("data", chunk);
+		if (!this[BUFFER$1].length && !this[EOF$1]) this.emit("drain");
+		return chunk;
+	}
+	end(chunk, encoding, cb) {
+		if (typeof chunk === "function") {
+			cb = chunk;
+			chunk = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = "utf8";
+		}
+		if (chunk !== void 0) this.write(chunk, encoding);
+		if (cb) this.once("end", cb);
+		this[EOF$1] = true;
+		this.writable = false;
+		if (this[FLOWING] || !this[PAUSED]) this[MAYBE_EMIT_END]();
+		return this;
+	}
+	[RESUME]() {
+		if (this[DESTROYED]) return;
+		if (!this[DATALISTENERS] && !this[PIPES].length) this[DISCARDED] = true;
+		this[PAUSED] = false;
+		this[FLOWING] = true;
+		this.emit("resume");
+		if (this[BUFFER$1].length) this[FLUSH]();
+		else if (this[EOF$1]) this[MAYBE_EMIT_END]();
+		else this.emit("drain");
+	}
+	/**
+	* Resume the stream if it is currently in a paused state
+	*
+	* If called when there are no pipe destinations or `data` event listeners,
+	* this will place the stream in a "discarded" state, where all data will
+	* be thrown away. The discarded state is removed if a pipe destination or
+	* data handler is added, if pause() is called, or if any synchronous or
+	* asynchronous iteration is started.
+	*/
+	resume() {
+		return this[RESUME]();
+	}
+	/**
+	* Pause the stream
+	*/
+	pause() {
+		this[FLOWING] = false;
+		this[PAUSED] = true;
+		this[DISCARDED] = false;
+	}
+	/**
+	* true if the stream has been forcibly destroyed
+	*/
+	get destroyed() {
+		return this[DESTROYED];
+	}
+	/**
+	* true if the stream is currently in a flowing state, meaning that
+	* any writes will be immediately emitted.
+	*/
+	get flowing() {
+		return this[FLOWING];
+	}
+	/**
+	* true if the stream is currently in a paused state
+	*/
+	get paused() {
+		return this[PAUSED];
+	}
+	[BUFFERPUSH](chunk) {
+		if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1;
+		else this[BUFFERLENGTH] += chunk.length;
+		this[BUFFER$1].push(chunk);
+	}
+	[BUFFERSHIFT]() {
+		if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1;
+		else this[BUFFERLENGTH] -= this[BUFFER$1][0].length;
+		return this[BUFFER$1].shift();
+	}
+	[FLUSH](noDrain = false) {
+		do		;
+while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER$1].length);
+		if (!noDrain && !this[BUFFER$1].length && !this[EOF$1]) this.emit("drain");
+	}
+	[FLUSHCHUNK](chunk) {
+		this.emit("data", chunk);
+		return this[FLOWING];
+	}
+	/**
+	* Pipe all data emitted by this stream into the destination provided.
+	*
+	* Triggers the flow of data.
+	*/
+	pipe(dest, opts) {
+		if (this[DESTROYED]) return dest;
+		this[DISCARDED] = false;
+		const ended = this[EMITTED_END];
+		opts = opts || {};
+		if (dest === proc.stdout || dest === proc.stderr) opts.end = false;
+		else opts.end = opts.end !== false;
+		opts.proxyErrors = !!opts.proxyErrors;
+		if (ended) {
+			if (opts.end) dest.end();
+		} else {
+			this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
+			if (this[ASYNC]) defer(() => this[RESUME]());
+			else this[RESUME]();
+		}
+		return dest;
+	}
+	/**
+	* Fully unhook a piped destination stream.
+	*
+	* If the destination stream was the only consumer of this stream (ie,
+	* there are no other piped destinations or `'data'` event listeners)
+	* then the flow of data will stop until there is another consumer or
+	* {@link Minipass#resume} is explicitly called.
+	*/
+	unpipe(dest) {
+		const p = this[PIPES].find((p) => p.dest === dest);
+		if (p) {
+			if (this[PIPES].length === 1) {
+				if (this[FLOWING] && this[DATALISTENERS] === 0) this[FLOWING] = false;
+				this[PIPES] = [];
+			} else this[PIPES].splice(this[PIPES].indexOf(p), 1);
+			p.unpipe();
+		}
+	}
+	/**
+	* Alias for {@link Minipass#on}
+	*/
+	addListener(ev, handler) {
+		return this.on(ev, handler);
+	}
+	/**
+	* Mostly identical to `EventEmitter.on`, with the following
+	* behavior differences to prevent data loss and unnecessary hangs:
+	*
+	* - Adding a 'data' event handler will trigger the flow of data
+	*
+	* - Adding a 'readable' event handler when there is data waiting to be read
+	*   will cause 'readable' to be emitted immediately.
+	*
+	* - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+	*   already passed will cause the event to be emitted immediately and all
+	*   handlers removed.
+	*
+	* - Adding an 'error' event handler after an error has been emitted will
+	*   cause the event to be re-emitted immediately with the error previously
+	*   raised.
+	*/
+	on(ev, handler) {
+		const ret = super.on(ev, handler);
+		if (ev === "data") {
+			this[DISCARDED] = false;
+			this[DATALISTENERS]++;
+			if (!this[PIPES].length && !this[FLOWING]) this[RESUME]();
+		} else if (ev === "readable" && this[BUFFERLENGTH] !== 0) super.emit("readable");
+		else if (isEndish(ev) && this[EMITTED_END]) {
+			super.emit(ev);
+			this.removeAllListeners(ev);
+		} else if (ev === "error" && this[EMITTED_ERROR]) {
+			const h = handler;
+			if (this[ASYNC]) defer(() => h.call(this, this[EMITTED_ERROR]));
+			else h.call(this, this[EMITTED_ERROR]);
+		}
+		return ret;
+	}
+	/**
+	* Alias for {@link Minipass#off}
+	*/
+	removeListener(ev, handler) {
+		return this.off(ev, handler);
+	}
+	/**
+	* Mostly identical to `EventEmitter.off`
+	*
+	* If a 'data' event handler is removed, and it was the last consumer
+	* (ie, there are no pipe destinations or other 'data' event listeners),
+	* then the flow of data will stop until there is another consumer or
+	* {@link Minipass#resume} is explicitly called.
+	*/
+	off(ev, handler) {
+		const ret = super.off(ev, handler);
+		if (ev === "data") {
+			this[DATALISTENERS] = this.listeners("data").length;
+			if (this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length) this[FLOWING] = false;
+		}
+		return ret;
+	}
+	/**
+	* Mostly identical to `EventEmitter.removeAllListeners`
+	*
+	* If all 'data' event handlers are removed, and they were the last consumer
+	* (ie, there are no pipe destinations), then the flow of data will stop
+	* until there is another consumer or {@link Minipass#resume} is explicitly
+	* called.
+	*/
+	removeAllListeners(ev) {
+		const ret = super.removeAllListeners(ev);
+		if (ev === "data" || ev === void 0) {
+			this[DATALISTENERS] = 0;
+			if (!this[DISCARDED] && !this[PIPES].length) this[FLOWING] = false;
+		}
+		return ret;
+	}
+	/**
+	* true if the 'end' event has been emitted
+	*/
+	get emittedEnd() {
+		return this[EMITTED_END];
+	}
+	[MAYBE_EMIT_END]() {
+		if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER$1].length === 0 && this[EOF$1]) {
+			this[EMITTING_END] = true;
+			this.emit("end");
+			this.emit("prefinish");
+			this.emit("finish");
+			if (this[CLOSED]) this.emit("close");
+			this[EMITTING_END] = false;
+		}
+	}
+	/**
+	* Mostly identical to `EventEmitter.emit`, with the following
+	* behavior differences to prevent data loss and unnecessary hangs:
+	*
+	* If the stream has been destroyed, and the event is something other
+	* than 'close' or 'error', then `false` is returned and no handlers
+	* are called.
+	*
+	* If the event is 'end', and has already been emitted, then the event
+	* is ignored. If the stream is in a paused or non-flowing state, then
+	* the event will be deferred until data flow resumes. If the stream is
+	* async, then handlers will be called on the next tick rather than
+	* immediately.
+	*
+	* If the event is 'close', and 'end' has not yet been emitted, then
+	* the event will be deferred until after 'end' is emitted.
+	*
+	* If the event is 'error', and an AbortSignal was provided for the stream,
+	* and there are no listeners, then the event is ignored, matching the
+	* behavior of node core streams in the presense of an AbortSignal.
+	*
+	* If the event is 'finish' or 'prefinish', then all listeners will be
+	* removed after emitting the event, to prevent double-firing.
+	*/
+	emit(ev, ...args) {
+		const data = args[0];
+		if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) return false;
+		else if (ev === "data") return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data)), true) : this[EMITDATA](data);
+		else if (ev === "end") return this[EMITEND]();
+		else if (ev === "close") {
+			this[CLOSED] = true;
+			if (!this[EMITTED_END] && !this[DESTROYED]) return false;
+			const ret = super.emit("close");
+			this.removeAllListeners("close");
+			return ret;
+		} else if (ev === "error") {
+			this[EMITTED_ERROR] = data;
+			super.emit(ERROR, data);
+			const ret = !this[SIGNAL] || this.listeners("error").length ? super.emit("error", data) : false;
+			this[MAYBE_EMIT_END]();
+			return ret;
+		} else if (ev === "resume") {
+			const ret = super.emit("resume");
+			this[MAYBE_EMIT_END]();
+			return ret;
+		} else if (ev === "finish" || ev === "prefinish") {
+			const ret = super.emit(ev);
+			this.removeAllListeners(ev);
+			return ret;
+		}
+		const ret = super.emit(ev, ...args);
+		this[MAYBE_EMIT_END]();
+		return ret;
+	}
+	[EMITDATA](data) {
+		for (const p of this[PIPES]) if (p.dest.write(data) === false) this.pause();
+		const ret = this[DISCARDED] ? false : super.emit("data", data);
+		this[MAYBE_EMIT_END]();
+		return ret;
+	}
+	[EMITEND]() {
+		if (this[EMITTED_END]) return false;
+		this[EMITTED_END] = true;
+		this.readable = false;
+		return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2]();
+	}
+	[EMITEND2]() {
+		if (this[DECODER]) {
+			const data = this[DECODER].end();
+			if (data) {
+				for (const p of this[PIPES]) p.dest.write(data);
+				if (!this[DISCARDED]) super.emit("data", data);
+			}
+		}
+		for (const p of this[PIPES]) p.end();
+		const ret = super.emit("end");
+		this.removeAllListeners("end");
+		return ret;
+	}
+	/**
+	* Return a Promise that resolves to an array of all emitted data once
+	* the stream ends.
+	*/
+	async collect() {
+		const buf = Object.assign([], { dataLength: 0 });
+		if (!this[OBJECTMODE]) buf.dataLength = 0;
+		const p = this.promise();
+		this.on("data", (c) => {
+			buf.push(c);
+			if (!this[OBJECTMODE]) buf.dataLength += c.length;
+		});
+		await p;
+		return buf;
+	}
+	/**
+	* Return a Promise that resolves to the concatenation of all emitted data
+	* once the stream ends.
+	*
+	* Not allowed on objectMode streams.
+	*/
+	async concat() {
+		if (this[OBJECTMODE]) throw new Error("cannot concat in objectMode");
+		const buf = await this.collect();
+		return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
+	}
+	/**
+	* Return a void Promise that resolves once the stream ends.
+	*/
+	async promise() {
+		return new Promise((resolve, reject) => {
+			this.on(DESTROYED, () => reject(/* @__PURE__ */ new Error("stream destroyed")));
+			this.on("error", (er) => reject(er));
+			this.on("end", () => resolve());
+		});
+	}
+	/**
+	* Asynchronous `for await of` iteration.
+	*
+	* This will continue emitting all chunks until the stream terminates.
+	*/
+	[Symbol.asyncIterator]() {
+		this[DISCARDED] = false;
+		let stopped = false;
+		const stop = async () => {
+			this.pause();
+			stopped = true;
+			return {
+				value: void 0,
+				done: true
+			};
+		};
+		const next = () => {
+			if (stopped) return stop();
+			const res = this.read();
+			if (res !== null) return Promise.resolve({
+				done: false,
+				value: res
+			});
+			if (this[EOF$1]) return stop();
+			let resolve;
+			let reject;
+			const onerr = (er) => {
+				this.off("data", ondata);
+				this.off("end", onend);
+				this.off(DESTROYED, ondestroy);
+				stop();
+				reject(er);
+			};
+			const ondata = (value) => {
+				this.off("error", onerr);
+				this.off("end", onend);
+				this.off(DESTROYED, ondestroy);
+				this.pause();
+				resolve({
+					value,
+					done: !!this[EOF$1]
+				});
+			};
+			const onend = () => {
+				this.off("error", onerr);
+				this.off("data", ondata);
+				this.off(DESTROYED, ondestroy);
+				stop();
+				resolve({
+					done: true,
+					value: void 0
+				});
+			};
+			const ondestroy = () => onerr(/* @__PURE__ */ new Error("stream destroyed"));
+			return new Promise((res, rej) => {
+				reject = rej;
+				resolve = res;
+				this.once(DESTROYED, ondestroy);
+				this.once("error", onerr);
+				this.once("end", onend);
+				this.once("data", ondata);
+			});
+		};
+		return {
+			next,
+			throw: stop,
+			return: stop,
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+	/**
+	* Synchronous `for of` iteration.
+	*
+	* The iteration will terminate when the internal buffer runs out, even
+	* if the stream has not yet terminated.
+	*/
+	[Symbol.iterator]() {
+		this[DISCARDED] = false;
+		let stopped = false;
+		const stop = () => {
+			this.pause();
+			this.off(ERROR, stop);
+			this.off(DESTROYED, stop);
+			this.off("end", stop);
+			stopped = true;
+			return {
+				done: true,
+				value: void 0
+			};
+		};
+		const next = () => {
+			if (stopped) return stop();
+			const value = this.read();
+			return value === null ? stop() : {
+				done: false,
+				value
+			};
+		};
+		this.once("end", stop);
+		this.once(ERROR, stop);
+		this.once(DESTROYED, stop);
+		return {
+			next,
+			throw: stop,
+			return: stop,
+			[Symbol.iterator]() {
+				return this;
+			}
+		};
+	}
+	/**
+	* Destroy a stream, preventing it from being used for any further purpose.
+	*
+	* If the stream has a `close()` method, then it will be called on
+	* destruction.
+	*
+	* After destruction, any attempt to write data, read data, or emit most
+	* events will be ignored.
+	*
+	* If an error argument is provided, then it will be emitted in an
+	* 'error' event.
+	*/
+	destroy(er) {
+		if (this[DESTROYED]) {
+			if (er) this.emit("error", er);
+			else this.emit(DESTROYED);
+			return this;
+		}
+		this[DESTROYED] = true;
+		this[DISCARDED] = true;
+		this[BUFFER$1].length = 0;
+		this[BUFFERLENGTH] = 0;
+		const wc = this;
+		if (typeof wc.close === "function" && !this[CLOSED]) wc.close();
+		if (er) this.emit("error", er);
+		else this.emit(DESTROYED);
+		return this;
+	}
+	/**
+	* Alias for {@link isStream}
+	*
+	* Former export location, maintained for backwards compatibility.
+	*
+	* @deprecated
+	*/
+	static get isStream() {
+		return isStream;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@isaacs+fs-minipass@4.0.1/node_modules/@isaacs/fs-minipass/dist/esm/index.js
+const writev = fs$1.writev;
+const _autoClose = Symbol("_autoClose");
+const _close = Symbol("_close");
+const _ended = Symbol("_ended");
+const _fd = Symbol("_fd");
+const _finished = Symbol("_finished");
+const _flags = Symbol("_flags");
+const _flush = Symbol("_flush");
+const _handleChunk = Symbol("_handleChunk");
+const _makeBuf = Symbol("_makeBuf");
+const _mode = Symbol("_mode");
+const _needDrain = Symbol("_needDrain");
+const _onerror = Symbol("_onerror");
+const _onopen = Symbol("_onopen");
+const _onread = Symbol("_onread");
+const _onwrite = Symbol("_onwrite");
+const _open = Symbol("_open");
+const _path = Symbol("_path");
+const _pos = Symbol("_pos");
+const _queue = Symbol("_queue");
+const _read = Symbol("_read");
+const _readSize = Symbol("_readSize");
+const _reading = Symbol("_reading");
+const _remain = Symbol("_remain");
+const _size = Symbol("_size");
+const _write = Symbol("_write");
+const _writing = Symbol("_writing");
+const _defaultFlag = Symbol("_defaultFlag");
+const _errored = Symbol("_errored");
+var ReadStream = class extends Minipass {
+	[_errored] = false;
+	[_fd];
+	[_path];
+	[_readSize];
+	[_reading] = false;
+	[_size];
+	[_remain];
+	[_autoClose];
+	constructor(path, opt) {
+		opt = opt || {};
+		super(opt);
+		this.readable = true;
+		this.writable = false;
+		if (typeof path !== "string") throw new TypeError("path must be a string");
+		this[_errored] = false;
+		this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0;
+		this[_path] = path;
+		this[_readSize] = opt.readSize || 16 * 1024 * 1024;
+		this[_reading] = false;
+		this[_size] = typeof opt.size === "number" ? opt.size : Infinity;
+		this[_remain] = this[_size];
+		this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true;
+		if (typeof this[_fd] === "number") this[_read]();
+		else this[_open]();
+	}
+	get fd() {
+		return this[_fd];
+	}
+	get path() {
+		return this[_path];
+	}
+	write() {
+		throw new TypeError("this is a readable stream");
+	}
+	end() {
+		throw new TypeError("this is a readable stream");
+	}
+	[_open]() {
+		fs$1.open(this[_path], "r", (er, fd) => this[_onopen](er, fd));
+	}
+	[_onopen](er, fd) {
+		if (er) this[_onerror](er);
+		else {
+			this[_fd] = fd;
+			this.emit("open", fd);
+			this[_read]();
+		}
+	}
+	[_makeBuf]() {
+		return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]));
+	}
+	[_read]() {
+		if (!this[_reading]) {
+			this[_reading] = true;
+			const buf = this[_makeBuf]();
+			/* c8 ignore start */
+			if (buf.length === 0) return process.nextTick(() => this[_onread](null, 0, buf));
+			/* c8 ignore stop */
+			fs$1.read(this[_fd], buf, 0, buf.length, null, (er, br, b) => this[_onread](er, br, b));
+		}
+	}
+	[_onread](er, br, buf) {
+		this[_reading] = false;
+		if (er) this[_onerror](er);
+		else if (this[_handleChunk](br, buf)) this[_read]();
+	}
+	[_close]() {
+		if (this[_autoClose] && typeof this[_fd] === "number") {
+			const fd = this[_fd];
+			this[_fd] = void 0;
+			fs$1.close(fd, (er) => er ? this.emit("error", er) : this.emit("close"));
+		}
+	}
+	[_onerror](er) {
+		this[_reading] = true;
+		this[_close]();
+		this.emit("error", er);
+	}
+	[_handleChunk](br, buf) {
+		let ret = false;
+		this[_remain] -= br;
+		if (br > 0) ret = super.write(br < buf.length ? buf.subarray(0, br) : buf);
+		if (br === 0 || this[_remain] <= 0) {
+			ret = false;
+			this[_close]();
+			super.end();
+		}
+		return ret;
+	}
+	emit(ev, ...args) {
+		switch (ev) {
+			case "prefinish":
+			case "finish": return false;
+			case "drain":
+				if (typeof this[_fd] === "number") this[_read]();
+				return false;
+			case "error":
+				if (this[_errored]) return false;
+				this[_errored] = true;
+				return super.emit(ev, ...args);
+			default: return super.emit(ev, ...args);
+		}
+	}
+};
+var ReadStreamSync = class extends ReadStream {
+	[_open]() {
+		let threw = true;
+		try {
+			this[_onopen](null, fs$1.openSync(this[_path], "r"));
+			threw = false;
+		} finally {
+			if (threw) this[_close]();
+		}
+	}
+	[_read]() {
+		let threw = true;
+		try {
+			if (!this[_reading]) {
+				this[_reading] = true;
+				do {
+					const buf = this[_makeBuf]();
+					/* c8 ignore start */
+					const br = buf.length === 0 ? 0 : fs$1.readSync(this[_fd], buf, 0, buf.length, null);
+					/* c8 ignore stop */
+					if (!this[_handleChunk](br, buf)) break;
+				} while (true);
+				this[_reading] = false;
+			}
+			threw = false;
+		} finally {
+			if (threw) this[_close]();
+		}
+	}
+	[_close]() {
+		if (this[_autoClose] && typeof this[_fd] === "number") {
+			const fd = this[_fd];
+			this[_fd] = void 0;
+			fs$1.closeSync(fd);
+			this.emit("close");
+		}
+	}
+};
+var WriteStream = class extends EE {
+	readable = false;
+	writable = true;
+	[_errored] = false;
+	[_writing] = false;
+	[_ended] = false;
+	[_queue] = [];
+	[_needDrain] = false;
+	[_path];
+	[_mode];
+	[_autoClose];
+	[_fd];
+	[_defaultFlag];
+	[_flags];
+	[_finished] = false;
+	[_pos];
+	constructor(path, opt) {
+		opt = opt || {};
+		super(opt);
+		this[_path] = path;
+		this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0;
+		this[_mode] = opt.mode === void 0 ? 438 : opt.mode;
+		this[_pos] = typeof opt.start === "number" ? opt.start : void 0;
+		this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true;
+		const defaultFlag = this[_pos] !== void 0 ? "r+" : "w";
+		this[_defaultFlag] = opt.flags === void 0;
+		this[_flags] = opt.flags === void 0 ? defaultFlag : opt.flags;
+		if (this[_fd] === void 0) this[_open]();
+	}
+	emit(ev, ...args) {
+		if (ev === "error") {
+			if (this[_errored]) return false;
+			this[_errored] = true;
+		}
+		return super.emit(ev, ...args);
+	}
+	get fd() {
+		return this[_fd];
+	}
+	get path() {
+		return this[_path];
+	}
+	[_onerror](er) {
+		this[_close]();
+		this[_writing] = true;
+		this.emit("error", er);
+	}
+	[_open]() {
+		fs$1.open(this[_path], this[_flags], this[_mode], (er, fd) => this[_onopen](er, fd));
+	}
+	[_onopen](er, fd) {
+		if (this[_defaultFlag] && this[_flags] === "r+" && er && er.code === "ENOENT") {
+			this[_flags] = "w";
+			this[_open]();
+		} else if (er) this[_onerror](er);
+		else {
+			this[_fd] = fd;
+			this.emit("open", fd);
+			if (!this[_writing]) this[_flush]();
+		}
+	}
+	end(buf, enc) {
+		if (buf) this.write(buf, enc);
+		this[_ended] = true;
+		if (!this[_writing] && !this[_queue].length && typeof this[_fd] === "number") this[_onwrite](null, 0);
+		return this;
+	}
+	write(buf, enc) {
+		if (typeof buf === "string") buf = Buffer.from(buf, enc);
+		if (this[_ended]) {
+			this.emit("error", /* @__PURE__ */ new Error("write() after end()"));
+			return false;
+		}
+		if (this[_fd] === void 0 || this[_writing] || this[_queue].length) {
+			this[_queue].push(buf);
+			this[_needDrain] = true;
+			return false;
+		}
+		this[_writing] = true;
+		this[_write](buf);
+		return true;
+	}
+	[_write](buf) {
+		fs$1.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw));
+	}
+	[_onwrite](er, bw) {
+		if (er) this[_onerror](er);
+		else {
+			if (this[_pos] !== void 0 && typeof bw === "number") this[_pos] += bw;
+			if (this[_queue].length) this[_flush]();
+			else {
+				this[_writing] = false;
+				if (this[_ended] && !this[_finished]) {
+					this[_finished] = true;
+					this[_close]();
+					this.emit("finish");
+				} else if (this[_needDrain]) {
+					this[_needDrain] = false;
+					this.emit("drain");
+				}
+			}
+		}
+	}
+	[_flush]() {
+		if (this[_queue].length === 0) {
+			if (this[_ended]) this[_onwrite](null, 0);
+		} else if (this[_queue].length === 1) this[_write](this[_queue].pop());
+		else {
+			const iovec = this[_queue];
+			this[_queue] = [];
+			writev(this[_fd], iovec, this[_pos], (er, bw) => this[_onwrite](er, bw));
+		}
+	}
+	[_close]() {
+		if (this[_autoClose] && typeof this[_fd] === "number") {
+			const fd = this[_fd];
+			this[_fd] = void 0;
+			fs$1.close(fd, (er) => er ? this.emit("error", er) : this.emit("close"));
+		}
+	}
+};
+var WriteStreamSync = class extends WriteStream {
+	[_open]() {
+		let fd;
+		if (this[_defaultFlag] && this[_flags] === "r+") try {
+			fd = fs$1.openSync(this[_path], this[_flags], this[_mode]);
+		} catch (er) {
+			if (er?.code === "ENOENT") {
+				this[_flags] = "w";
+				return this[_open]();
+			} else throw er;
+		}
+		else fd = fs$1.openSync(this[_path], this[_flags], this[_mode]);
+		this[_onopen](null, fd);
+	}
+	[_close]() {
+		if (this[_autoClose] && typeof this[_fd] === "number") {
+			const fd = this[_fd];
+			this[_fd] = void 0;
+			fs$1.closeSync(fd);
+			this.emit("close");
+		}
+	}
+	[_write](buf) {
+		let threw = true;
+		try {
+			this[_onwrite](null, fs$1.writeSync(this[_fd], buf, 0, buf.length, this[_pos]));
+			threw = false;
+		} finally {
+			if (threw) try {
+				this[_close]();
+			} catch {}
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/options.js
+const argmap = /* @__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"]
+]);
+const isSyncFile = (o) => !!o.sync && !!o.file;
+const isAsyncFile = (o) => !o.sync && !!o.file;
+const isSyncNoFile = (o) => !!o.sync && !o.file;
+const isAsyncNoFile = (o) => !o.sync && !o.file;
+const isFile = (o) => !!o.file;
+const dealiasKey = (k) => {
+	const d = argmap.get(k);
+	if (d) return d;
+	return k;
+};
+const dealias = (opt = {}) => {
+	if (!opt) return {};
+	const result = {};
+	for (const [key, v] of Object.entries(opt)) {
+		const k = dealiasKey(key);
+		result[k] = v;
+	}
+	if (result.chmod === void 0 && result.noChmod === false) result.chmod = true;
+	delete result.noChmod;
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/make-command.js
+const makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => {
+	return Object.assign((opt_ = [], entries, cb) => {
+		if (Array.isArray(opt_)) {
+			entries = opt_;
+			opt_ = {};
+		}
+		if (typeof entries === "function") {
+			cb = entries;
+			entries = void 0;
+		}
+		if (!entries) entries = [];
+		else entries = Array.from(entries);
+		const opt = dealias(opt_);
+		validate?.(opt, entries);
+		if (isSyncFile(opt)) {
+			if (typeof cb === "function") throw new TypeError("callback not supported for sync tar functions");
+			return syncFile(opt, entries);
+		} else if (isAsyncFile(opt)) {
+			const p = asyncFile(opt, entries);
+			const c = cb ? cb : void 0;
+			return c ? p.then(() => c(), c) : p;
+		} else if (isSyncNoFile(opt)) {
+			if (typeof cb === "function") throw new TypeError("callback not supported for sync tar functions");
+			return syncNoFile(opt, entries);
+		} else if (isAsyncNoFile(opt)) {
+			if (typeof cb === "function") throw new TypeError("callback only supported with file option");
+			return asyncNoFile(opt, entries);
+		} else throw new Error("impossible options??");
+		/* c8 ignore stop */
+	}, {
+		syncFile,
+		asyncFile,
+		syncNoFile,
+		asyncNoFile,
+		validate
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/minizlib@3.0.2/node_modules/minizlib/dist/esm/constants.js
+/* c8 ignore start */
+const realZlibConstants = realZlib.constants || { ZLIB_VERNUM: 4736 };
+/* c8 ignore stop */
+const constants = 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: Infinity,
+	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
+}, realZlibConstants));
+//#endregion
+//#region ../../node_modules/.pnpm/minizlib@3.0.2/node_modules/minizlib/dist/esm/index.js
+const OriginalBufferConcat = Buffer$1.concat;
+const desc = Object.getOwnPropertyDescriptor(Buffer$1, "concat");
+const noop$1 = (args) => args;
+const passthroughBufferConcat = desc?.writable === true || desc?.set !== void 0 ? (makeNoOp) => {
+	Buffer$1.concat = makeNoOp ? noop$1 : OriginalBufferConcat;
+} : (_) => {};
+const _superWrite = Symbol("_superWrite");
+var ZlibError = class extends Error {
+	code;
+	errno;
+	constructor(err) {
+		super("zlib: " + err.message);
+		this.code = err.code;
+		this.errno = err.errno;
+		/* c8 ignore next */
+		if (!this.code) this.code = "ZLIB_ERROR";
+		this.message = "zlib: " + err.message;
+		Error.captureStackTrace(this, this.constructor);
+	}
+	get name() {
+		return "ZlibError";
+	}
+};
+const _flushFlag = Symbol("flushFlag");
+var ZlibBase = class extends Minipass {
+	#sawError = false;
+	#ended = false;
+	#flushFlag;
+	#finishFlushFlag;
+	#fullFlushFlag;
+	#handle;
+	#onError;
+	get sawError() {
+		return this.#sawError;
+	}
+	get handle() {
+		return this.#handle;
+	}
+	/* c8 ignore start */
+	get flushFlag() {
+		return this.#flushFlag;
+	}
+	/* c8 ignore stop */
+	constructor(opts, mode) {
+		if (!opts || typeof opts !== "object") throw new TypeError("invalid options for ZlibBase constructor");
+		super(opts);
+		/* c8 ignore start */
+		this.#flushFlag = opts.flush ?? 0;
+		this.#finishFlushFlag = opts.finishFlush ?? 0;
+		this.#fullFlushFlag = opts.fullFlushFlag ?? 0;
+		/* c8 ignore stop */
+		try {
+			this.#handle = new realZlib$1[mode](opts);
+		} catch (er) {
+			throw new ZlibError(er);
+		}
+		this.#onError = (err) => {
+			if (this.#sawError) return;
+			this.#sawError = true;
+			this.close();
+			this.emit("error", err);
+		};
+		this.#handle?.on("error", (er) => this.#onError(new ZlibError(er)));
+		this.once("end", () => this.close);
+	}
+	close() {
+		if (this.#handle) {
+			this.#handle.close();
+			this.#handle = void 0;
+			this.emit("close");
+		}
+	}
+	reset() {
+		if (!this.#sawError) {
+			assert(this.#handle, "zlib binding closed");
+			return this.#handle.reset?.();
+		}
+	}
+	flush(flushFlag) {
+		if (this.ended) return;
+		if (typeof flushFlag !== "number") flushFlag = this.#fullFlushFlag;
+		this.write(Object.assign(Buffer$1.alloc(0), { [_flushFlag]: flushFlag }));
+	}
+	end(chunk, encoding, cb) {
+		/* c8 ignore start */
+		if (typeof chunk === "function") {
+			cb = chunk;
+			encoding = void 0;
+			chunk = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		/* c8 ignore stop */
+		if (chunk) if (encoding) this.write(chunk, encoding);
+		else this.write(chunk);
+		this.flush(this.#finishFlushFlag);
+		this.#ended = true;
+		return super.end(cb);
+	}
+	get ended() {
+		return this.#ended;
+	}
+	[_superWrite](data) {
+		return super.write(data);
+	}
+	write(chunk, encoding, cb) {
+		if (typeof encoding === "function") cb = encoding, encoding = "utf8";
+		if (typeof chunk === "string") chunk = Buffer$1.from(chunk, encoding);
+		if (this.#sawError) return;
+		assert(this.#handle, "zlib binding closed");
+		const nativeHandle = this.#handle._handle;
+		const originalNativeClose = nativeHandle.close;
+		nativeHandle.close = () => {};
+		const originalClose = this.#handle.close;
+		this.#handle.close = () => {};
+		passthroughBufferConcat(true);
+		let result = void 0;
+		try {
+			const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : this.#flushFlag;
+			result = this.#handle._processChunk(chunk, flushFlag);
+			passthroughBufferConcat(false);
+		} catch (err) {
+			passthroughBufferConcat(false);
+			this.#onError(new ZlibError(err));
+		} finally {
+			if (this.#handle) {
+				this.#handle._handle = nativeHandle;
+				nativeHandle.close = originalNativeClose;
+				this.#handle.close = originalClose;
+				this.#handle.removeAllListeners("error");
+			}
+		}
+		if (this.#handle) this.#handle.on("error", (er) => this.#onError(new ZlibError(er)));
+		let writeReturn;
+		if (result) if (Array.isArray(result) && result.length > 0) {
+			const r = result[0];
+			writeReturn = this[_superWrite](Buffer$1.from(r));
+			for (let i = 1; i < result.length; i++) writeReturn = this[_superWrite](result[i]);
+		} else writeReturn = this[_superWrite](Buffer$1.from(result));
+		if (cb) cb();
+		return writeReturn;
+	}
+};
+var Zlib = class extends ZlibBase {
+	#level;
+	#strategy;
+	constructor(opts, mode) {
+		opts = opts || {};
+		opts.flush = opts.flush || constants.Z_NO_FLUSH;
+		opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
+		opts.fullFlushFlag = constants.Z_FULL_FLUSH;
+		super(opts, mode);
+		this.#level = opts.level;
+		this.#strategy = opts.strategy;
+	}
+	params(level, strategy) {
+		if (this.sawError) return;
+		if (!this.handle) throw new Error("cannot switch params when binding is closed");
+		/* c8 ignore start */
+		if (!this.handle.params) throw new Error("not supported in this implementation");
+		/* c8 ignore stop */
+		if (this.#level !== level || this.#strategy !== strategy) {
+			this.flush(constants.Z_SYNC_FLUSH);
+			assert(this.handle, "zlib binding closed");
+			const origFlush = this.handle.flush;
+			this.handle.flush = (flushFlag, cb) => {
+				/* c8 ignore start */
+				if (typeof flushFlag === "function") {
+					cb = flushFlag;
+					flushFlag = this.flushFlag;
+				}
+				/* c8 ignore stop */
+				this.flush(flushFlag);
+				cb?.();
+			};
+			try {
+				this.handle.params(level, strategy);
+			} finally {
+				this.handle.flush = origFlush;
+			}
+			/* c8 ignore start */
+			if (this.handle) {
+				this.#level = level;
+				this.#strategy = strategy;
+			}
+		}
+	}
+};
+var Gzip = class extends Zlib {
+	#portable;
+	constructor(opts) {
+		super(opts, "Gzip");
+		this.#portable = opts && !!opts.portable;
+	}
+	[_superWrite](data) {
+		if (!this.#portable) return super[_superWrite](data);
+		this.#portable = false;
+		data[9] = 255;
+		return super[_superWrite](data);
+	}
+};
+var Unzip = class extends Zlib {
+	constructor(opts) {
+		super(opts, "Unzip");
+	}
+};
+var Brotli = class extends ZlibBase {
+	constructor(opts, mode) {
+		opts = opts || {};
+		opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
+		opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
+		opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
+		super(opts, mode);
+	}
+};
+var BrotliCompress = class extends Brotli {
+	constructor(opts) {
+		super(opts, "BrotliCompress");
+	}
+};
+var BrotliDecompress = class extends Brotli {
+	constructor(opts) {
+		super(opts, "BrotliDecompress");
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/yallist@5.0.0/node_modules/yallist/dist/esm/index.js
+var Yallist = class Yallist {
+	tail;
+	head;
+	length = 0;
+	static create(list = []) {
+		return new Yallist(list);
+	}
+	constructor(list = []) {
+		for (const item of list) this.push(item);
+	}
+	*[Symbol.iterator]() {
+		for (let walker = this.head; walker; walker = walker.next) yield walker.value;
+	}
+	removeNode(node) {
+		if (node.list !== this) throw new Error("removing node which does not belong to this list");
+		const next = node.next;
+		const prev = node.prev;
+		if (next) next.prev = prev;
+		if (prev) prev.next = next;
+		if (node === this.head) this.head = next;
+		if (node === this.tail) this.tail = prev;
+		this.length--;
+		node.next = void 0;
+		node.prev = void 0;
+		node.list = void 0;
+		return next;
+	}
+	unshiftNode(node) {
+		if (node === this.head) return;
+		if (node.list) node.list.removeNode(node);
+		const head = this.head;
+		node.list = this;
+		node.next = head;
+		if (head) head.prev = node;
+		this.head = node;
+		if (!this.tail) this.tail = node;
+		this.length++;
+	}
+	pushNode(node) {
+		if (node === this.tail) return;
+		if (node.list) node.list.removeNode(node);
+		const tail = this.tail;
+		node.list = this;
+		node.prev = tail;
+		if (tail) tail.next = node;
+		this.tail = node;
+		if (!this.head) this.head = node;
+		this.length++;
+	}
+	push(...args) {
+		for (let i = 0, l = args.length; i < l; i++) push(this, args[i]);
+		return this.length;
+	}
+	unshift(...args) {
+		for (var i = 0, l = args.length; i < l; i++) unshift(this, args[i]);
+		return this.length;
+	}
+	pop() {
+		if (!this.tail) return;
+		const res = this.tail.value;
+		const t = this.tail;
+		this.tail = this.tail.prev;
+		if (this.tail) this.tail.next = void 0;
+		else this.head = void 0;
+		t.list = void 0;
+		this.length--;
+		return res;
+	}
+	shift() {
+		if (!this.head) return;
+		const res = this.head.value;
+		const h = this.head;
+		this.head = this.head.next;
+		if (this.head) this.head.prev = void 0;
+		else this.tail = void 0;
+		h.list = void 0;
+		this.length--;
+		return res;
+	}
+	forEach(fn, thisp) {
+		thisp = thisp || this;
+		for (let walker = this.head, i = 0; !!walker; i++) {
+			fn.call(thisp, walker.value, i, this);
+			walker = walker.next;
+		}
+	}
+	forEachReverse(fn, thisp) {
+		thisp = thisp || this;
+		for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
+			fn.call(thisp, walker.value, i, this);
+			walker = walker.prev;
+		}
+	}
+	get(n) {
+		let i = 0;
+		let walker = this.head;
+		for (; !!walker && i < n; i++) walker = walker.next;
+		if (i === n && !!walker) return walker.value;
+	}
+	getReverse(n) {
+		let i = 0;
+		let walker = this.tail;
+		for (; !!walker && i < n; i++) walker = walker.prev;
+		if (i === n && !!walker) return walker.value;
+	}
+	map(fn, thisp) {
+		thisp = thisp || this;
+		const res = new Yallist();
+		for (let walker = this.head; !!walker;) {
+			res.push(fn.call(thisp, walker.value, this));
+			walker = walker.next;
+		}
+		return res;
+	}
+	mapReverse(fn, thisp) {
+		thisp = thisp || this;
+		var res = new Yallist();
+		for (let walker = this.tail; !!walker;) {
+			res.push(fn.call(thisp, walker.value, this));
+			walker = walker.prev;
+		}
+		return res;
+	}
+	reduce(fn, initial) {
+		let acc;
+		let walker = this.head;
+		if (arguments.length > 1) acc = initial;
+		else if (this.head) {
+			walker = this.head.next;
+			acc = this.head.value;
+		} else throw new TypeError("Reduce of empty list with no initial value");
+		for (var i = 0; !!walker; i++) {
+			acc = fn(acc, walker.value, i);
+			walker = walker.next;
+		}
+		return acc;
+	}
+	reduceReverse(fn, initial) {
+		let acc;
+		let walker = this.tail;
+		if (arguments.length > 1) acc = initial;
+		else if (this.tail) {
+			walker = this.tail.prev;
+			acc = this.tail.value;
+		} else throw new TypeError("Reduce of empty list with no initial value");
+		for (let i = this.length - 1; !!walker; i--) {
+			acc = fn(acc, walker.value, i);
+			walker = walker.prev;
+		}
+		return acc;
+	}
+	toArray() {
+		const arr = new Array(this.length);
+		for (let i = 0, walker = this.head; !!walker; i++) {
+			arr[i] = walker.value;
+			walker = walker.next;
+		}
+		return arr;
+	}
+	toArrayReverse() {
+		const arr = new Array(this.length);
+		for (let i = 0, walker = this.tail; !!walker; i++) {
+			arr[i] = walker.value;
+			walker = walker.prev;
+		}
+		return arr;
+	}
+	slice(from = 0, to = this.length) {
+		if (to < 0) to += this.length;
+		if (from < 0) from += this.length;
+		const ret = new Yallist();
+		if (to < from || to < 0) return ret;
+		if (from < 0) from = 0;
+		if (to > this.length) to = this.length;
+		let walker = this.head;
+		let i = 0;
+		for (i = 0; !!walker && i < from; i++) walker = walker.next;
+		for (; !!walker && i < to; i++, walker = walker.next) ret.push(walker.value);
+		return ret;
+	}
+	sliceReverse(from = 0, to = this.length) {
+		if (to < 0) to += this.length;
+		if (from < 0) from += this.length;
+		const ret = new Yallist();
+		if (to < from || to < 0) return ret;
+		if (from < 0) from = 0;
+		if (to > this.length) to = this.length;
+		let i = this.length;
+		let walker = this.tail;
+		for (; !!walker && i > to; i--) walker = walker.prev;
+		for (; !!walker && i > from; i--, walker = walker.prev) ret.push(walker.value);
+		return ret;
+	}
+	splice(start, deleteCount = 0, ...nodes) {
+		if (start > this.length) start = this.length - 1;
+		if (start < 0) start = this.length + start;
+		let walker = this.head;
+		for (let i = 0; !!walker && i < start; i++) walker = walker.next;
+		const ret = [];
+		for (let i = 0; !!walker && i < deleteCount; i++) {
+			ret.push(walker.value);
+			walker = this.removeNode(walker);
+		}
+		if (!walker) walker = this.tail;
+		else if (walker !== this.tail) walker = walker.prev;
+		for (const v of nodes) walker = insertAfter(this, walker, v);
+		return ret;
+	}
+	reverse() {
+		const head = this.head;
+		const tail = this.tail;
+		for (let walker = head; !!walker; walker = walker.prev) {
+			const p = walker.prev;
+			walker.prev = walker.next;
+			walker.next = p;
+		}
+		this.head = tail;
+		this.tail = head;
+		return this;
+	}
+};
+function insertAfter(self, node, value) {
+	const inserted = new Node(value, node, node ? node.next : self.head, self);
+	if (inserted.next === void 0) self.tail = inserted;
+	if (inserted.prev === void 0) self.head = inserted;
+	self.length++;
+	return inserted;
+}
+function push(self, item) {
+	self.tail = new Node(item, self.tail, void 0, self);
+	if (!self.head) self.head = self.tail;
+	self.length++;
+}
+function unshift(self, item) {
+	self.head = new Node(item, void 0, self.head, self);
+	if (!self.tail) self.tail = self.head;
+	self.length++;
+}
+var Node = class {
+	list;
+	next;
+	prev;
+	value;
+	constructor(value, prev, next, list) {
+		this.list = list;
+		this.value = value;
+		if (prev) {
+			prev.next = this;
+			this.prev = prev;
+		} else this.prev = void 0;
+		if (next) {
+			next.prev = this;
+			this.next = next;
+		} else this.next = void 0;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/large-numbers.js
+const encode$1 = (num, buf) => {
+	if (!Number.isSafeInteger(num)) throw Error("cannot encode number outside of javascript safe integer range");
+	else if (num < 0) encodeNegative(num, buf);
+	else encodePositive(num, buf);
+	return buf;
+};
+const encodePositive = (num, buf) => {
+	buf[0] = 128;
+	for (var i = buf.length; i > 1; i--) {
+		buf[i - 1] = num & 255;
+		num = Math.floor(num / 256);
+	}
+};
+const encodeNegative = (num, buf) => {
+	buf[0] = 255;
+	var flipped = false;
+	num = num * -1;
+	for (var i = buf.length; i > 1; i--) {
+		var byte = num & 255;
+		num = Math.floor(num / 256);
+		if (flipped) buf[i - 1] = onesComp(byte);
+		else if (byte === 0) buf[i - 1] = 0;
+		else {
+			flipped = true;
+			buf[i - 1] = twosComp(byte);
+		}
+	}
+};
+const parse$2 = (buf) => {
+	const pre = buf[0];
+	const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
+	if (value === null) throw Error("invalid base256 encoding");
+	if (!Number.isSafeInteger(value)) throw Error("parsed number outside of javascript safe integer range");
+	return value;
+};
+const twos = (buf) => {
+	var len = buf.length;
+	var sum = 0;
+	var flipped = false;
+	for (var i = len - 1; i > -1; i--) {
+		var byte = Number(buf[i]);
+		var f;
+		if (flipped) f = onesComp(byte);
+		else if (byte === 0) f = byte;
+		else {
+			flipped = true;
+			f = twosComp(byte);
+		}
+		if (f !== 0) sum -= f * Math.pow(256, len - i - 1);
+	}
+	return sum;
+};
+const pos = (buf) => {
+	var len = buf.length;
+	var sum = 0;
+	for (var i = len - 1; i > -1; i--) {
+		var byte = Number(buf[i]);
+		if (byte !== 0) sum += byte * Math.pow(256, len - i - 1);
+	}
+	return sum;
+};
+const onesComp = (byte) => (255 ^ byte) & 255;
+const twosComp = (byte) => (255 ^ byte) + 1 & 255;
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/types.js
+const isCode = (c) => name.has(c);
+const name = /* @__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"]
+]);
+const code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/header.js
+var Header = class {
+	cksumValid = false;
+	needPax = false;
+	nullBlock = false;
+	block;
+	path;
+	mode;
+	uid;
+	gid;
+	size;
+	cksum;
+	#type = "Unsupported";
+	linkpath;
+	uname;
+	gname;
+	devmaj = 0;
+	devmin = 0;
+	atime;
+	ctime;
+	mtime;
+	charset;
+	comment;
+	constructor(data, off = 0, ex, gex) {
+		if (Buffer.isBuffer(data)) this.decode(data, off || 0, ex, gex);
+		else if (data) this.#slurp(data);
+	}
+	decode(buf, off, ex, gex) {
+		if (!off) off = 0;
+		if (!buf || !(buf.length >= off + 512)) throw new Error("need 512 bytes for header");
+		this.path = decString(buf, off, 100);
+		this.mode = decNumber(buf, off + 100, 8);
+		this.uid = decNumber(buf, off + 108, 8);
+		this.gid = decNumber(buf, off + 116, 8);
+		this.size = decNumber(buf, off + 124, 12);
+		this.mtime = decDate(buf, off + 136, 12);
+		this.cksum = decNumber(buf, off + 148, 12);
+		if (gex) this.#slurp(gex, true);
+		if (ex) this.#slurp(ex);
+		const t = decString(buf, off + 156, 1);
+		if (isCode(t)) this.#type = t || "0";
+		if (this.#type === "0" && this.path.slice(-1) === "/") this.#type = "5";
+		if (this.#type === "5") this.size = 0;
+		this.linkpath = decString(buf, off + 157, 100);
+		if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
+			this.uname = decString(buf, off + 265, 32);
+			this.gname = decString(buf, off + 297, 32);
+			/* c8 ignore start */
+			this.devmaj = decNumber(buf, off + 329, 8) ?? 0;
+			this.devmin = decNumber(buf, off + 337, 8) ?? 0;
+			/* c8 ignore stop */
+			if (buf[off + 475] !== 0) {
+				const prefix = decString(buf, off + 345, 155);
+				this.path = prefix + "/" + this.path;
+			} else {
+				const prefix = decString(buf, off + 345, 130);
+				if (prefix) this.path = prefix + "/" + this.path;
+				this.atime = decDate(buf, off + 476, 12);
+				this.ctime = decDate(buf, off + 488, 12);
+			}
+		}
+		let sum = 256;
+		for (let i = off; i < off + 148; i++) sum += buf[i];
+		for (let i = off + 156; i < off + 512; i++) sum += buf[i];
+		this.cksumValid = sum === this.cksum;
+		if (this.cksum === void 0 && sum === 256) this.nullBlock = true;
+	}
+	#slurp(ex, gex = false) {
+		Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+			return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global");
+		})));
+	}
+	encode(buf, off = 0) {
+		if (!buf) buf = this.block = Buffer.alloc(512);
+		if (this.#type === "Unsupported") this.#type = "0";
+		if (!(buf.length >= off + 512)) throw new Error("need 512 bytes for header");
+		const prefixSize = this.ctime || this.atime ? 130 : 155;
+		const split = splitPrefix(this.path || "", prefixSize);
+		const path = split[0];
+		const prefix = split[1];
+		this.needPax = !!split[2];
+		this.needPax = encString(buf, off, 100, path) || this.needPax;
+		this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
+		this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
+		this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
+		this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
+		this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
+		buf[off + 156] = this.#type.charCodeAt(0);
+		this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax;
+		buf.write("ustar\x0000", off + 257, 8);
+		this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax;
+		this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax;
+		this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
+		this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
+		this.needPax = encString(buf, off + 345, prefixSize, prefix) || this.needPax;
+		if (buf[off + 475] !== 0) this.needPax = encString(buf, off + 345, 155, prefix) || this.needPax;
+		else {
+			this.needPax = encString(buf, off + 345, 130, prefix) || this.needPax;
+			this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax;
+			this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax;
+		}
+		let sum = 256;
+		for (let i = off; i < off + 148; i++) sum += buf[i];
+		for (let i = off + 156; i < off + 512; i++) sum += buf[i];
+		this.cksum = sum;
+		encNumber(buf, off + 148, 8, this.cksum);
+		this.cksumValid = true;
+		return this.needPax;
+	}
+	get type() {
+		return this.#type === "Unsupported" ? this.#type : name.get(this.#type);
+	}
+	get typeKey() {
+		return this.#type;
+	}
+	set type(type) {
+		const c = String(code.get(type));
+		if (isCode(c) || c === "Unsupported") this.#type = c;
+		else if (isCode(type)) this.#type = type;
+		else throw new TypeError("invalid entry type: " + type);
+	}
+};
+const splitPrefix = (p, prefixSize) => {
+	const pathSize = 100;
+	let pp = p;
+	let prefix = "";
+	let ret = void 0;
+	const root = posix$1.parse(p).root || ".";
+	if (Buffer.byteLength(pp) < pathSize) ret = [
+		pp,
+		prefix,
+		false
+	];
+	else {
+		prefix = posix$1.dirname(pp);
+		pp = posix$1.basename(pp);
+		do
+			if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix) <= prefixSize) ret = [
+				pp,
+				prefix,
+				false
+			];
+			else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix) <= prefixSize) ret = [
+				pp.slice(0, pathSize - 1),
+				prefix,
+				true
+			];
+			else {
+				pp = posix$1.join(posix$1.basename(prefix), pp);
+				prefix = posix$1.dirname(prefix);
+			}
+		while (prefix !== root && ret === void 0);
+		if (!ret) ret = [
+			p.slice(0, pathSize - 1),
+			"",
+			true
+		];
+	}
+	return ret;
+};
+const decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
+const decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
+const numToDate = (num) => num === void 0 ? void 0 : /* @__PURE__ */ new Date(num * 1e3);
+const decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse$2(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
+const nanUndef = (value) => isNaN(value) ? void 0 : value;
+const decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
+const MAXNUM = {
+	12: 8589934591,
+	8: 2097151
+};
+const encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode$1(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
+const encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
+const octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
+const padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
+const encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
+const NULLS = new Array(156).join("\0");
+const encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/pax.js
+var Pax = class Pax {
+	atime;
+	mtime;
+	ctime;
+	charset;
+	comment;
+	gid;
+	uid;
+	gname;
+	uname;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	path;
+	size;
+	mode;
+	global;
+	constructor(obj, global = false) {
+		this.atime = obj.atime;
+		this.charset = obj.charset;
+		this.comment = obj.comment;
+		this.ctime = obj.ctime;
+		this.dev = obj.dev;
+		this.gid = obj.gid;
+		this.global = global;
+		this.gname = obj.gname;
+		this.ino = obj.ino;
+		this.linkpath = obj.linkpath;
+		this.mtime = obj.mtime;
+		this.nlink = obj.nlink;
+		this.path = obj.path;
+		this.size = obj.size;
+		this.uid = obj.uid;
+		this.uname = obj.uname;
+	}
+	encode() {
+		const body = this.encodeBody();
+		if (body === "") return Buffer.allocUnsafe(0);
+		const bodyLen = Buffer.byteLength(body);
+		const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+		const buf = Buffer.allocUnsafe(bufLen);
+		for (let i = 0; i < 512; i++) buf[i] = 0;
+		new Header({
+			/* c8 ignore start */
+			path: ("PaxHeader/" + basename(this.path ?? "")).slice(0, 99),
+			/* c8 ignore stop */
+			mode: this.mode || 420,
+			uid: this.uid,
+			gid: this.gid,
+			size: bodyLen,
+			mtime: this.mtime,
+			type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
+			linkpath: "",
+			uname: this.uname || "",
+			gname: this.gname || "",
+			devmaj: 0,
+			devmin: 0,
+			atime: this.atime,
+			ctime: this.ctime
+		}).encode(buf);
+		buf.write(body, 512, bodyLen, "utf8");
+		for (let i = bodyLen + 512; i < buf.length; i++) buf[i] = 0;
+		return buf;
+	}
+	encodeBody() {
+		return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
+	}
+	encodeField(field) {
+		if (this[field] === void 0) return "";
+		const r = this[field];
+		const v = r instanceof Date ? r.getTime() / 1e3 : r;
+		const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
+		const byteLen = Buffer.byteLength(s);
+		let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
+		if (byteLen + digits >= Math.pow(10, digits)) digits += 1;
+		return digits + byteLen + s;
+	}
+	static parse(str, ex, g = false) {
+		return new Pax(merge(parseKV(str), ex), g);
+	}
+};
+const merge = (a, b) => b ? Object.assign({}, b, a) : a;
+const parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, Object.create(null));
+const parseKVLine = (set, line) => {
+	const n = parseInt(line, 10);
+	if (n !== Buffer.byteLength(line) + 1) return set;
+	line = line.slice((n + " ").length);
+	const kv = line.split("=");
+	const r = kv.shift();
+	if (!r) return set;
+	const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1");
+	const v = kv.join("=");
+	set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? /* @__PURE__ */ new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v;
+	return set;
+};
+const normalizeWindowsPath = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/");
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/read-entry.js
+var ReadEntry = class extends Minipass {
+	extended;
+	globalExtended;
+	header;
+	startBlockSize;
+	blockRemain;
+	remain;
+	type;
+	meta = false;
+	ignore = false;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	size = 0;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	invalid = false;
+	absolute;
+	unsupported = false;
+	constructor(header, ex, gex) {
+		super({});
+		this.pause();
+		this.extended = ex;
+		this.globalExtended = gex;
+		this.header = header;
+		/* c8 ignore start */
+		this.remain = header.size ?? 0;
+		/* c8 ignore stop */
+		this.startBlockSize = 512 * Math.ceil(this.remain / 512);
+		this.blockRemain = this.startBlockSize;
+		this.type = header.type;
+		switch (this.type) {
+			case "File":
+			case "OldFile":
+			case "Link":
+			case "SymbolicLink":
+			case "CharacterDevice":
+			case "BlockDevice":
+			case "Directory":
+			case "FIFO":
+			case "ContiguousFile":
+			case "GNUDumpDir": break;
+			case "NextFileHasLongLinkpath":
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath":
+			case "GlobalExtendedHeader":
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this.meta = true;
+				break;
+			default: this.ignore = true;
+		}
+		/* c8 ignore start */
+		if (!header.path) throw new Error("no path provided for tar.ReadEntry");
+		/* c8 ignore stop */
+		this.path = normalizeWindowsPath(header.path);
+		this.mode = header.mode;
+		if (this.mode) this.mode = this.mode & 4095;
+		this.uid = header.uid;
+		this.gid = header.gid;
+		this.uname = header.uname;
+		this.gname = header.gname;
+		this.size = this.remain;
+		this.mtime = header.mtime;
+		this.atime = header.atime;
+		this.ctime = header.ctime;
+		/* c8 ignore start */
+		this.linkpath = header.linkpath ? normalizeWindowsPath(header.linkpath) : void 0;
+		/* c8 ignore stop */
+		this.uname = header.uname;
+		this.gname = header.gname;
+		if (ex) this.#slurp(ex);
+		if (gex) this.#slurp(gex, true);
+	}
+	write(data) {
+		const writeLen = data.length;
+		if (writeLen > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		const r = this.remain;
+		const br = this.blockRemain;
+		this.remain = Math.max(0, r - writeLen);
+		this.blockRemain = Math.max(0, br - writeLen);
+		if (this.ignore) return true;
+		if (r >= writeLen) return super.write(data);
+		return super.write(data.subarray(0, r));
+	}
+	#slurp(ex, gex = false) {
+		if (ex.path) ex.path = normalizeWindowsPath(ex.path);
+		if (ex.linkpath) ex.linkpath = normalizeWindowsPath(ex.linkpath);
+		Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+			return !(v === null || v === void 0 || k === "path" && gex);
+		})));
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/warn-method.js
+const warnMethod = (self, code, message, data = {}) => {
+	if (self.file) data.file = self.file;
+	if (self.cwd) data.cwd = self.cwd;
+	data.code = message instanceof Error && message.code || code;
+	data.tarCode = code;
+	if (!self.strict && data.recoverable !== false) {
+		if (message instanceof Error) {
+			data = Object.assign(message, data);
+			message = message.message;
+		}
+		self.emit("warn", code, message, data);
+	} else if (message instanceof Error) self.emit("error", Object.assign(message, data));
+	else self.emit("error", Object.assign(/* @__PURE__ */ new Error(`${code}: ${message}`), data));
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/parse.js
+const maxMetaEntrySize = 1024 * 1024;
+const gzipHeader = Buffer.from([31, 139]);
+const STATE = Symbol("state");
+const WRITEENTRY = Symbol("writeEntry");
+const READENTRY = Symbol("readEntry");
+const NEXTENTRY = Symbol("nextEntry");
+const PROCESSENTRY = Symbol("processEntry");
+const EX = Symbol("extendedHeader");
+const GEX = Symbol("globalExtendedHeader");
+const META = Symbol("meta");
+const EMITMETA = Symbol("emitMeta");
+const BUFFER = Symbol("buffer");
+const QUEUE$1 = Symbol("queue");
+const ENDED$2 = Symbol("ended");
+const EMITTEDEND = Symbol("emittedEnd");
+const EMIT = Symbol("emit");
+const UNZIP = Symbol("unzip");
+const CONSUMECHUNK = Symbol("consumeChunk");
+const CONSUMECHUNKSUB = Symbol("consumeChunkSub");
+const CONSUMEBODY = Symbol("consumeBody");
+const CONSUMEMETA = Symbol("consumeMeta");
+const CONSUMEHEADER = Symbol("consumeHeader");
+const CONSUMING = Symbol("consuming");
+const BUFFERCONCAT = Symbol("bufferConcat");
+const MAYBEEND = Symbol("maybeEnd");
+const WRITING = Symbol("writing");
+const ABORTED = Symbol("aborted");
+const DONE = Symbol("onDone");
+const SAW_VALID_ENTRY = Symbol("sawValidEntry");
+const SAW_NULL_BLOCK = Symbol("sawNullBlock");
+const SAW_EOF = Symbol("sawEOF");
+const CLOSESTREAM = Symbol("closeStream");
+const noop = () => true;
+var Parser = class extends EventEmitter {
+	file;
+	strict;
+	maxMetaEntrySize;
+	filter;
+	brotli;
+	writable = true;
+	readable = false;
+	[QUEUE$1] = new Yallist();
+	[BUFFER];
+	[READENTRY];
+	[WRITEENTRY];
+	[STATE] = "begin";
+	[META] = "";
+	[EX];
+	[GEX];
+	[ENDED$2] = false;
+	[UNZIP];
+	[ABORTED] = false;
+	[SAW_VALID_ENTRY];
+	[SAW_NULL_BLOCK] = false;
+	[SAW_EOF] = false;
+	[WRITING] = false;
+	[CONSUMING] = false;
+	[EMITTEDEND] = false;
+	constructor(opt = {}) {
+		super();
+		this.file = opt.file || "";
+		this.on(DONE, () => {
+			if (this[STATE] === "begin" || this[SAW_VALID_ENTRY] === false) this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format");
+		});
+		if (opt.ondone) this.on(DONE, opt.ondone);
+		else this.on(DONE, () => {
+			this.emit("prefinish");
+			this.emit("finish");
+			this.emit("end");
+		});
+		this.strict = !!opt.strict;
+		this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
+		this.filter = typeof opt.filter === "function" ? opt.filter : noop;
+		const isTBR = opt.file && (opt.file.endsWith(".tar.br") || opt.file.endsWith(".tbr"));
+		this.brotli = !opt.gzip && opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false;
+		this.on("end", () => this[CLOSESTREAM]());
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		if (typeof opt.onReadEntry === "function") this.on("entry", opt.onReadEntry);
+	}
+	warn(code, message, data = {}) {
+		warnMethod(this, code, message, data);
+	}
+	[CONSUMEHEADER](chunk, position) {
+		if (this[SAW_VALID_ENTRY] === void 0) this[SAW_VALID_ENTRY] = false;
+		let header;
+		try {
+			header = new Header(chunk, position, this[EX], this[GEX]);
+		} catch (er) {
+			return this.warn("TAR_ENTRY_INVALID", er);
+		}
+		if (header.nullBlock) if (this[SAW_NULL_BLOCK]) {
+			this[SAW_EOF] = true;
+			if (this[STATE] === "begin") this[STATE] = "header";
+			this[EMIT]("eof");
+		} else {
+			this[SAW_NULL_BLOCK] = true;
+			this[EMIT]("nullBlock");
+		}
+		else {
+			this[SAW_NULL_BLOCK] = false;
+			if (!header.cksumValid) this.warn("TAR_ENTRY_INVALID", "checksum failure", { header });
+			else if (!header.path) this.warn("TAR_ENTRY_INVALID", "path is required", { header });
+			else {
+				const type = header.type;
+				if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath required", { header });
+				else if (!/^(Symbolic)?Link$/.test(type) && !/^(Global)?ExtendedHeader$/.test(type) && header.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", { header });
+				else {
+					const entry = this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]);
+					if (!this[SAW_VALID_ENTRY]) if (entry.remain) {
+						const onend = () => {
+							if (!entry.invalid) this[SAW_VALID_ENTRY] = true;
+						};
+						entry.on("end", onend);
+					} else this[SAW_VALID_ENTRY] = true;
+					if (entry.meta) {
+						if (entry.size > this.maxMetaEntrySize) {
+							entry.ignore = true;
+							this[EMIT]("ignoredEntry", entry);
+							this[STATE] = "ignore";
+							entry.resume();
+						} else if (entry.size > 0) {
+							this[META] = "";
+							entry.on("data", (c) => this[META] += c);
+							this[STATE] = "meta";
+						}
+					} else {
+						this[EX] = void 0;
+						entry.ignore = entry.ignore || !this.filter(entry.path, entry);
+						if (entry.ignore) {
+							this[EMIT]("ignoredEntry", entry);
+							this[STATE] = entry.remain ? "ignore" : "header";
+							entry.resume();
+						} else {
+							if (entry.remain) this[STATE] = "body";
+							else {
+								this[STATE] = "header";
+								entry.end();
+							}
+							if (!this[READENTRY]) {
+								this[QUEUE$1].push(entry);
+								this[NEXTENTRY]();
+							} else this[QUEUE$1].push(entry);
+						}
+					}
+				}
+			}
+		}
+	}
+	[CLOSESTREAM]() {
+		queueMicrotask(() => this.emit("close"));
+	}
+	[PROCESSENTRY](entry) {
+		let go = true;
+		if (!entry) {
+			this[READENTRY] = void 0;
+			go = false;
+		} else if (Array.isArray(entry)) {
+			const [ev, ...args] = entry;
+			this.emit(ev, ...args);
+		} else {
+			this[READENTRY] = entry;
+			this.emit("entry", entry);
+			if (!entry.emittedEnd) {
+				entry.on("end", () => this[NEXTENTRY]());
+				go = false;
+			}
+		}
+		return go;
+	}
+	[NEXTENTRY]() {
+		do		;
+while (this[PROCESSENTRY](this[QUEUE$1].shift()));
+		if (!this[QUEUE$1].length) {
+			const re = this[READENTRY];
+			if (!re || re.flowing || re.size === re.remain) {
+				if (!this[WRITING]) this.emit("drain");
+			} else re.once("drain", () => this.emit("drain"));
+		}
+	}
+	[CONSUMEBODY](chunk, position) {
+		const entry = this[WRITEENTRY];
+		/* c8 ignore start */
+		if (!entry) throw new Error("attempt to consume body without entry??");
+		const br = entry.blockRemain ?? 0;
+		/* c8 ignore stop */
+		const c = br >= chunk.length && position === 0 ? chunk : chunk.subarray(position, position + br);
+		entry.write(c);
+		if (!entry.blockRemain) {
+			this[STATE] = "header";
+			this[WRITEENTRY] = void 0;
+			entry.end();
+		}
+		return c.length;
+	}
+	[CONSUMEMETA](chunk, position) {
+		const entry = this[WRITEENTRY];
+		const ret = this[CONSUMEBODY](chunk, position);
+		if (!this[WRITEENTRY] && entry) this[EMITMETA](entry);
+		return ret;
+	}
+	[EMIT](ev, data, extra) {
+		if (!this[QUEUE$1].length && !this[READENTRY]) this.emit(ev, data, extra);
+		else this[QUEUE$1].push([
+			ev,
+			data,
+			extra
+		]);
+	}
+	[EMITMETA](entry) {
+		this[EMIT]("meta", this[META]);
+		switch (entry.type) {
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this[EX] = Pax.parse(this[META], this[EX], false);
+				break;
+			case "GlobalExtendedHeader":
+				this[GEX] = Pax.parse(this[META], this[GEX], true);
+				break;
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath": {
+				const ex = this[EX] ?? Object.create(null);
+				this[EX] = ex;
+				ex.path = this[META].replace(/\0.*/, "");
+				break;
+			}
+			case "NextFileHasLongLinkpath": {
+				const ex = this[EX] || Object.create(null);
+				this[EX] = ex;
+				ex.linkpath = this[META].replace(/\0.*/, "");
+				break;
+			}
+			/* c8 ignore start */
+			default: throw new Error("unknown meta: " + entry.type);
+		}
+	}
+	abort(error) {
+		this[ABORTED] = true;
+		this.emit("abort", error);
+		this.warn("TAR_ABORT", error, { recoverable: false });
+	}
+	write(chunk, encoding, cb) {
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(
+			chunk,
+			/* c8 ignore next */
+			typeof encoding === "string" ? encoding : "utf8"
+		);
+		if (this[ABORTED]) {
+			/* c8 ignore next */
+			cb?.();
+			return false;
+		}
+		if ((this[UNZIP] === void 0 || this.brotli === void 0 && this[UNZIP] === false) && chunk) {
+			if (this[BUFFER]) {
+				chunk = Buffer.concat([this[BUFFER], chunk]);
+				this[BUFFER] = void 0;
+			}
+			if (chunk.length < gzipHeader.length) {
+				this[BUFFER] = chunk;
+				/* c8 ignore next */
+				cb?.();
+				return true;
+			}
+			for (let i = 0; this[UNZIP] === void 0 && i < gzipHeader.length; i++) if (chunk[i] !== gzipHeader[i]) this[UNZIP] = false;
+			const maybeBrotli = this.brotli === void 0;
+			if (this[UNZIP] === false && maybeBrotli) if (chunk.length < 512) if (this[ENDED$2]) this.brotli = true;
+			else {
+				this[BUFFER] = chunk;
+				/* c8 ignore next */
+				cb?.();
+				return true;
+			}
+			else try {
+				new Header(chunk.subarray(0, 512));
+				this.brotli = false;
+			} catch (_) {
+				this.brotli = true;
+			}
+			if (this[UNZIP] === void 0 || this[UNZIP] === false && this.brotli) {
+				const ended = this[ENDED$2];
+				this[ENDED$2] = false;
+				this[UNZIP] = this[UNZIP] === void 0 ? new Unzip({}) : new BrotliDecompress({});
+				this[UNZIP].on("data", (chunk) => this[CONSUMECHUNK](chunk));
+				this[UNZIP].on("error", (er) => this.abort(er));
+				this[UNZIP].on("end", () => {
+					this[ENDED$2] = true;
+					this[CONSUMECHUNK]();
+				});
+				this[WRITING] = true;
+				const ret = !!this[UNZIP][ended ? "end" : "write"](chunk);
+				this[WRITING] = false;
+				cb?.();
+				return ret;
+			}
+		}
+		this[WRITING] = true;
+		if (this[UNZIP]) this[UNZIP].write(chunk);
+		else this[CONSUMECHUNK](chunk);
+		this[WRITING] = false;
+		const ret = this[QUEUE$1].length ? false : this[READENTRY] ? this[READENTRY].flowing : true;
+		if (!ret && !this[QUEUE$1].length) this[READENTRY]?.once("drain", () => this.emit("drain"));
+		/* c8 ignore next */
+		cb?.();
+		return ret;
+	}
+	[BUFFERCONCAT](c) {
+		if (c && !this[ABORTED]) this[BUFFER] = this[BUFFER] ? Buffer.concat([this[BUFFER], c]) : c;
+	}
+	[MAYBEEND]() {
+		if (this[ENDED$2] && !this[EMITTEDEND] && !this[ABORTED] && !this[CONSUMING]) {
+			this[EMITTEDEND] = true;
+			const entry = this[WRITEENTRY];
+			if (entry && entry.blockRemain) {
+				const have = this[BUFFER] ? this[BUFFER].length : 0;
+				this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
+				if (this[BUFFER]) entry.write(this[BUFFER]);
+				entry.end();
+			}
+			this[EMIT](DONE);
+		}
+	}
+	[CONSUMECHUNK](chunk) {
+		if (this[CONSUMING] && chunk) this[BUFFERCONCAT](chunk);
+		else if (!chunk && !this[BUFFER]) this[MAYBEEND]();
+		else if (chunk) {
+			this[CONSUMING] = true;
+			if (this[BUFFER]) {
+				this[BUFFERCONCAT](chunk);
+				const c = this[BUFFER];
+				this[BUFFER] = void 0;
+				this[CONSUMECHUNKSUB](c);
+			} else this[CONSUMECHUNKSUB](chunk);
+			while (this[BUFFER] && this[BUFFER]?.length >= 512 && !this[ABORTED] && !this[SAW_EOF]) {
+				const c = this[BUFFER];
+				this[BUFFER] = void 0;
+				this[CONSUMECHUNKSUB](c);
+			}
+			this[CONSUMING] = false;
+		}
+		if (!this[BUFFER] || this[ENDED$2]) this[MAYBEEND]();
+	}
+	[CONSUMECHUNKSUB](chunk) {
+		let position = 0;
+		const length = chunk.length;
+		while (position + 512 <= length && !this[ABORTED] && !this[SAW_EOF]) switch (this[STATE]) {
+			case "begin":
+			case "header":
+				this[CONSUMEHEADER](chunk, position);
+				position += 512;
+				break;
+			case "ignore":
+			case "body":
+				position += this[CONSUMEBODY](chunk, position);
+				break;
+			case "meta":
+				position += this[CONSUMEMETA](chunk, position);
+				break;
+			/* c8 ignore start */
+			default: throw new Error("invalid state: " + this[STATE]);
+		}
+		if (position < length) if (this[BUFFER]) this[BUFFER] = Buffer.concat([chunk.subarray(position), this[BUFFER]]);
+		else this[BUFFER] = chunk.subarray(position);
+	}
+	end(chunk, encoding, cb) {
+		if (typeof chunk === "function") {
+			cb = chunk;
+			encoding = void 0;
+			chunk = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, encoding);
+		if (cb) this.once("finish", cb);
+		if (!this[ABORTED]) if (this[UNZIP]) {
+			/* c8 ignore start */
+			if (chunk) this[UNZIP].write(chunk);
+			/* c8 ignore stop */
+			this[UNZIP].end();
+		} else {
+			this[ENDED$2] = true;
+			if (this.brotli === void 0) chunk = chunk || Buffer.alloc(0);
+			if (chunk) this.write(chunk);
+			this[MAYBEEND]();
+		}
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/strip-trailing-slashes.js
+const stripTrailingSlashes = (str) => {
+	let i = str.length - 1;
+	let slashesStart = -1;
+	while (i > -1 && str.charAt(i) === "/") {
+		slashesStart = i;
+		i--;
+	}
+	return slashesStart === -1 ? str : str.slice(0, slashesStart);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/list.js
+const onReadEntryFunction = (opt) => {
+	const onReadEntry = opt.onReadEntry;
+	opt.onReadEntry = onReadEntry ? (e) => {
+		onReadEntry(e);
+		e.resume();
+	} : (e) => e.resume();
+};
+const filesFilter = (opt, files) => {
+	const map = new Map(files.map((f) => [stripTrailingSlashes(f), true]));
+	const filter = opt.filter;
+	const mapHas = (file, r = "") => {
+		const root = r || parse(file).root || ".";
+		let ret;
+		if (file === root) ret = false;
+		else {
+			const m = map.get(file);
+			if (m !== void 0) ret = m;
+			else ret = mapHas(dirname(file), root);
+		}
+		map.set(file, ret);
+		return ret;
+	};
+	opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripTrailingSlashes(file)) : (file) => mapHas(stripTrailingSlashes(file));
+};
+const listFileSync = (opt) => {
+	const p = new Parser(opt);
+	const file = opt.file;
+	let fd;
+	try {
+		const stat = fs.statSync(file);
+		const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+		if (stat.size < readSize) p.end(fs.readFileSync(file));
+		else {
+			let pos = 0;
+			const buf = Buffer.allocUnsafe(readSize);
+			fd = fs.openSync(file, "r");
+			while (pos < stat.size) {
+				const bytesRead = fs.readSync(fd, buf, 0, readSize, pos);
+				pos += bytesRead;
+				p.write(buf.subarray(0, bytesRead));
+			}
+			p.end();
+		}
+	} finally {
+		if (typeof fd === "number") try {
+			fs.closeSync(fd);
+		} catch (er) {}
+	}
+};
+const listFile = (opt, _files) => {
+	const parse = new Parser(opt);
+	const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+	const file = opt.file;
+	return new Promise((resolve, reject) => {
+		parse.on("error", reject);
+		parse.on("end", resolve);
+		fs.stat(file, (er, stat) => {
+			if (er) reject(er);
+			else {
+				const stream = new ReadStream(file, {
+					readSize,
+					size: stat.size
+				});
+				stream.on("error", reject);
+				stream.pipe(parse);
+			}
+		});
+	});
+};
+const list = makeCommand(listFileSync, listFile, (opt) => new Parser(opt), (opt) => new Parser(opt), (opt, files) => {
+	if (files?.length) filesFilter(opt, files);
+	if (!opt.noResume) onReadEntryFunction(opt);
+});
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/mode-fix.js
+const modeFix = (mode, isDir, portable) => {
+	mode &= 4095;
+	if (portable) mode = (mode | 384) & -19;
+	if (isDir) {
+		if (mode & 256) mode |= 64;
+		if (mode & 32) mode |= 8;
+		if (mode & 4) mode |= 1;
+	}
+	return mode;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/strip-absolute-path.js
+const { isAbsolute, parse: parse$1 } = win32;
+const stripAbsolutePath = (path) => {
+	let r = "";
+	let parsed = parse$1(path);
+	while (isAbsolute(path) || parsed.root) {
+		const root = path.charAt(0) === "/" && path.slice(0, 4) !== "//?/" ? "/" : parsed.root;
+		path = path.slice(root.length);
+		r += root;
+		parsed = parse$1(path);
+	}
+	return [r, path];
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/winchars.js
+const raw = [
+	"|",
+	"<",
+	">",
+	"?",
+	":"
+];
+const win = raw.map((char) => String.fromCharCode(61440 + char.charCodeAt(0)));
+const toWin = new Map(raw.map((char, i) => [char, win[i]]));
+const toRaw = new Map(win.map((char, i) => [char, raw[i]]));
+const encode = (s) => raw.reduce((s, c) => s.split(c).join(toWin.get(c)), s);
+const decode = (s) => win.reduce((s, c) => s.split(c).join(toRaw.get(c)), s);
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/write-entry.js
+const prefixPath = (path, prefix) => {
+	if (!prefix) return normalizeWindowsPath(path);
+	path = normalizeWindowsPath(path).replace(/^\.(\/|$)/, "");
+	return stripTrailingSlashes(prefix) + "/" + path;
+};
+const maxReadSize = 16 * 1024 * 1024;
+const PROCESS$1 = Symbol("process");
+const FILE$1 = Symbol("file");
+const DIRECTORY$1 = Symbol("directory");
+const SYMLINK$1 = Symbol("symlink");
+const HARDLINK$1 = Symbol("hardlink");
+const HEADER = Symbol("header");
+const READ = Symbol("read");
+const LSTAT = Symbol("lstat");
+const ONLSTAT = Symbol("onlstat");
+const ONREAD = Symbol("onread");
+const ONREADLINK = Symbol("onreadlink");
+const OPENFILE = Symbol("openfile");
+const ONOPENFILE = Symbol("onopenfile");
+const CLOSE = Symbol("close");
+const MODE = Symbol("mode");
+const AWAITDRAIN = Symbol("awaitDrain");
+const ONDRAIN$1 = Symbol("ondrain");
+const PREFIX = Symbol("prefix");
+var WriteEntry = class extends Minipass {
+	path;
+	portable;
+	myuid = process.getuid && process.getuid() || 0;
+	myuser = process.env.USER || "";
+	maxReadSize;
+	linkCache;
+	statCache;
+	preservePaths;
+	cwd;
+	strict;
+	mtime;
+	noPax;
+	noMtime;
+	prefix;
+	fd;
+	blockLen = 0;
+	blockRemain = 0;
+	buf;
+	pos = 0;
+	remain = 0;
+	length = 0;
+	offset = 0;
+	win32;
+	absolute;
+	header;
+	type;
+	linkpath;
+	stat;
+	onWriteEntry;
+	#hadError = false;
+	constructor(p, opt_ = {}) {
+		const opt = dealias(opt_);
+		super();
+		this.path = normalizeWindowsPath(p);
+		this.portable = !!opt.portable;
+		this.maxReadSize = opt.maxReadSize || maxReadSize;
+		this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
+		this.statCache = opt.statCache || /* @__PURE__ */ new Map();
+		this.preservePaths = !!opt.preservePaths;
+		this.cwd = normalizeWindowsPath(opt.cwd || process.cwd());
+		this.strict = !!opt.strict;
+		this.noPax = !!opt.noPax;
+		this.noMtime = !!opt.noMtime;
+		this.mtime = opt.mtime;
+		this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : void 0;
+		this.onWriteEntry = opt.onWriteEntry;
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		let pathWarn = false;
+		if (!this.preservePaths) {
+			const [root, stripped] = stripAbsolutePath(this.path);
+			if (root && typeof stripped === "string") {
+				this.path = stripped;
+				pathWarn = root;
+			}
+		}
+		this.win32 = !!opt.win32 || process.platform === "win32";
+		if (this.win32) {
+			this.path = decode(this.path.replace(/\\/g, "/"));
+			p = p.replace(/\\/g, "/");
+		}
+		this.absolute = normalizeWindowsPath(opt.absolute || path.resolve(this.cwd, p));
+		if (this.path === "") this.path = "./";
+		if (pathWarn) this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
+			entry: this,
+			path: pathWarn + this.path
+		});
+		const cs = this.statCache.get(this.absolute);
+		if (cs) this[ONLSTAT](cs);
+		else this[LSTAT]();
+	}
+	warn(code, message, data = {}) {
+		return warnMethod(this, code, message, data);
+	}
+	emit(ev, ...data) {
+		if (ev === "error") this.#hadError = true;
+		return super.emit(ev, ...data);
+	}
+	[LSTAT]() {
+		fs$1.lstat(this.absolute, (er, stat) => {
+			if (er) return this.emit("error", er);
+			this[ONLSTAT](stat);
+		});
+	}
+	[ONLSTAT](stat) {
+		this.statCache.set(this.absolute, stat);
+		this.stat = stat;
+		if (!stat.isFile()) stat.size = 0;
+		this.type = getType(stat);
+		this.emit("stat", stat);
+		this[PROCESS$1]();
+	}
+	[PROCESS$1]() {
+		switch (this.type) {
+			case "File": return this[FILE$1]();
+			case "Directory": return this[DIRECTORY$1]();
+			case "SymbolicLink": return this[SYMLINK$1]();
+			default: return this.end();
+		}
+	}
+	[MODE](mode) {
+		return modeFix(mode, this.type === "Directory", this.portable);
+	}
+	[PREFIX](path) {
+		return prefixPath(path, this.prefix);
+	}
+	[HEADER]() {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot write header before stat");
+		/* c8 ignore stop */
+		if (this.type === "Directory" && this.portable) this.noMtime = true;
+		this.onWriteEntry?.(this);
+		this.header = new Header({
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			mode: this[MODE](this.stat.mode),
+			uid: this.portable ? void 0 : this.stat.uid,
+			gid: this.portable ? void 0 : this.stat.gid,
+			size: this.stat.size,
+			mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime,
+			/* c8 ignore next */
+			type: this.type === "Unsupported" ? void 0 : this.type,
+			uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : "",
+			atime: this.portable ? void 0 : this.stat.atime,
+			ctime: this.portable ? void 0 : this.stat.ctime
+		});
+		if (this.header.encode() && !this.noPax) super.write(new Pax({
+			atime: this.portable ? void 0 : this.header.atime,
+			ctime: this.portable ? void 0 : this.header.ctime,
+			gid: this.portable ? void 0 : this.header.gid,
+			mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime,
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			size: this.header.size,
+			uid: this.portable ? void 0 : this.header.uid,
+			uname: this.portable ? void 0 : this.header.uname,
+			dev: this.portable ? void 0 : this.stat.dev,
+			ino: this.portable ? void 0 : this.stat.ino,
+			nlink: this.portable ? void 0 : this.stat.nlink
+		}).encode());
+		const block = this.header?.block;
+		/* c8 ignore start */
+		if (!block) throw new Error("failed to encode header");
+		/* c8 ignore stop */
+		super.write(block);
+	}
+	[DIRECTORY$1]() {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot create directory entry without stat");
+		/* c8 ignore stop */
+		if (this.path.slice(-1) !== "/") this.path += "/";
+		this.stat.size = 0;
+		this[HEADER]();
+		this.end();
+	}
+	[SYMLINK$1]() {
+		fs$1.readlink(this.absolute, (er, linkpath) => {
+			if (er) return this.emit("error", er);
+			this[ONREADLINK](linkpath);
+		});
+	}
+	[ONREADLINK](linkpath) {
+		this.linkpath = normalizeWindowsPath(linkpath);
+		this[HEADER]();
+		this.end();
+	}
+	[HARDLINK$1](linkpath) {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot create link entry without stat");
+		/* c8 ignore stop */
+		this.type = "Link";
+		this.linkpath = normalizeWindowsPath(path.relative(this.cwd, linkpath));
+		this.stat.size = 0;
+		this[HEADER]();
+		this.end();
+	}
+	[FILE$1]() {
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("cannot create file entry without stat");
+		/* c8 ignore stop */
+		if (this.stat.nlink > 1) {
+			const linkKey = `${this.stat.dev}:${this.stat.ino}`;
+			const linkpath = this.linkCache.get(linkKey);
+			if (linkpath?.indexOf(this.cwd) === 0) return this[HARDLINK$1](linkpath);
+			this.linkCache.set(linkKey, this.absolute);
+		}
+		this[HEADER]();
+		if (this.stat.size === 0) return this.end();
+		this[OPENFILE]();
+	}
+	[OPENFILE]() {
+		fs$1.open(this.absolute, "r", (er, fd) => {
+			if (er) return this.emit("error", er);
+			this[ONOPENFILE](fd);
+		});
+	}
+	[ONOPENFILE](fd) {
+		this.fd = fd;
+		if (this.#hadError) return this[CLOSE]();
+		/* c8 ignore start */
+		if (!this.stat) throw new Error("should stat before calling onopenfile");
+		/* c8 ignore start */
+		this.blockLen = 512 * Math.ceil(this.stat.size / 512);
+		this.blockRemain = this.blockLen;
+		const bufLen = Math.min(this.blockLen, this.maxReadSize);
+		this.buf = Buffer.allocUnsafe(bufLen);
+		this.offset = 0;
+		this.pos = 0;
+		this.remain = this.stat.size;
+		this.length = this.buf.length;
+		this[READ]();
+	}
+	[READ]() {
+		const { fd, buf, offset, length, pos } = this;
+		if (fd === void 0 || buf === void 0) throw new Error("cannot read file without first opening");
+		fs$1.read(fd, buf, offset, length, pos, (er, bytesRead) => {
+			if (er) return this[CLOSE](() => this.emit("error", er));
+			this[ONREAD](bytesRead);
+		});
+	}
+	/* c8 ignore start */
+	[CLOSE](cb = () => {}) {
+		/* c8 ignore stop */
+		if (this.fd !== void 0) fs$1.close(this.fd, cb);
+	}
+	[ONREAD](bytesRead) {
+		if (bytesRead <= 0 && this.remain > 0) {
+			const er = Object.assign(/* @__PURE__ */ new Error("encountered unexpected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[CLOSE](() => this.emit("error", er));
+		}
+		if (bytesRead > this.remain) {
+			const er = Object.assign(/* @__PURE__ */ new Error("did not encounter expected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[CLOSE](() => this.emit("error", er));
+		}
+		/* c8 ignore start */
+		if (!this.buf) throw new Error("should have created buffer prior to reading");
+		/* c8 ignore stop */
+		if (bytesRead === this.remain) for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) {
+			this.buf[i + this.offset] = 0;
+			bytesRead++;
+			this.remain++;
+		}
+		const chunk = this.offset === 0 && bytesRead === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + bytesRead);
+		if (!this.write(chunk)) this[AWAITDRAIN](() => this[ONDRAIN$1]());
+		else this[ONDRAIN$1]();
+	}
+	[AWAITDRAIN](cb) {
+		this.once("drain", cb);
+	}
+	write(chunk, encoding, cb) {
+		/* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
+		/* c8 ignore stop */
+		if (this.blockRemain < chunk.length) {
+			const er = Object.assign(/* @__PURE__ */ new Error("writing more data than expected"), { path: this.absolute });
+			return this.emit("error", er);
+		}
+		this.remain -= chunk.length;
+		this.blockRemain -= chunk.length;
+		this.pos += chunk.length;
+		this.offset += chunk.length;
+		return super.write(chunk, null, cb);
+	}
+	[ONDRAIN$1]() {
+		if (!this.remain) {
+			if (this.blockRemain) super.write(Buffer.alloc(this.blockRemain));
+			return this[CLOSE]((er) => er ? this.emit("error", er) : this.end());
+		}
+		/* c8 ignore start */
+		if (!this.buf) throw new Error("buffer lost somehow in ONDRAIN");
+		/* c8 ignore stop */
+		if (this.offset >= this.length) {
+			this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
+			this.offset = 0;
+		}
+		this.length = this.buf.length - this.offset;
+		this[READ]();
+	}
+};
+var WriteEntrySync = class extends WriteEntry {
+	sync = true;
+	[LSTAT]() {
+		this[ONLSTAT](fs$1.lstatSync(this.absolute));
+	}
+	[SYMLINK$1]() {
+		this[ONREADLINK](fs$1.readlinkSync(this.absolute));
+	}
+	[OPENFILE]() {
+		this[ONOPENFILE](fs$1.openSync(this.absolute, "r"));
+	}
+	[READ]() {
+		let threw = true;
+		try {
+			const { fd, buf, offset, length, pos } = this;
+			/* c8 ignore start */
+			if (fd === void 0 || buf === void 0) throw new Error("fd and buf must be set in READ method");
+			/* c8 ignore stop */
+			const bytesRead = fs$1.readSync(fd, buf, offset, length, pos);
+			this[ONREAD](bytesRead);
+			threw = false;
+		} finally {
+			if (threw) try {
+				this[CLOSE](() => {});
+			} catch (er) {}
+		}
+	}
+	[AWAITDRAIN](cb) {
+		cb();
+	}
+	/* c8 ignore start */
+	[CLOSE](cb = () => {}) {
+		/* c8 ignore stop */
+		if (this.fd !== void 0) fs$1.closeSync(this.fd);
+		cb();
+	}
+};
+var WriteEntryTar = class extends Minipass {
+	blockLen = 0;
+	blockRemain = 0;
+	buf = 0;
+	pos = 0;
+	remain = 0;
+	length = 0;
+	preservePaths;
+	portable;
+	strict;
+	noPax;
+	noMtime;
+	readEntry;
+	type;
+	prefix;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	header;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	size;
+	onWriteEntry;
+	warn(code, message, data = {}) {
+		return warnMethod(this, code, message, data);
+	}
+	constructor(readEntry, opt_ = {}) {
+		const opt = dealias(opt_);
+		super();
+		this.preservePaths = !!opt.preservePaths;
+		this.portable = !!opt.portable;
+		this.strict = !!opt.strict;
+		this.noPax = !!opt.noPax;
+		this.noMtime = !!opt.noMtime;
+		this.onWriteEntry = opt.onWriteEntry;
+		this.readEntry = readEntry;
+		const { type } = readEntry;
+		/* c8 ignore start */
+		if (type === "Unsupported") throw new Error("writing entry that should be ignored");
+		/* c8 ignore stop */
+		this.type = type;
+		if (this.type === "Directory" && this.portable) this.noMtime = true;
+		this.prefix = opt.prefix;
+		this.path = normalizeWindowsPath(readEntry.path);
+		this.mode = readEntry.mode !== void 0 ? this[MODE](readEntry.mode) : void 0;
+		this.uid = this.portable ? void 0 : readEntry.uid;
+		this.gid = this.portable ? void 0 : readEntry.gid;
+		this.uname = this.portable ? void 0 : readEntry.uname;
+		this.gname = this.portable ? void 0 : readEntry.gname;
+		this.size = readEntry.size;
+		this.mtime = this.noMtime ? void 0 : opt.mtime || readEntry.mtime;
+		this.atime = this.portable ? void 0 : readEntry.atime;
+		this.ctime = this.portable ? void 0 : readEntry.ctime;
+		this.linkpath = readEntry.linkpath !== void 0 ? normalizeWindowsPath(readEntry.linkpath) : void 0;
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		let pathWarn = false;
+		if (!this.preservePaths) {
+			const [root, stripped] = stripAbsolutePath(this.path);
+			if (root && typeof stripped === "string") {
+				this.path = stripped;
+				pathWarn = root;
+			}
+		}
+		this.remain = readEntry.size;
+		this.blockRemain = readEntry.startBlockSize;
+		this.onWriteEntry?.(this);
+		this.header = new Header({
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			mode: this.mode,
+			uid: this.portable ? void 0 : this.uid,
+			gid: this.portable ? void 0 : this.gid,
+			size: this.size,
+			mtime: this.noMtime ? void 0 : this.mtime,
+			type: this.type,
+			uname: this.portable ? void 0 : this.uname,
+			atime: this.portable ? void 0 : this.atime,
+			ctime: this.portable ? void 0 : this.ctime
+		});
+		if (pathWarn) this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
+			entry: this,
+			path: pathWarn + this.path
+		});
+		if (this.header.encode() && !this.noPax) super.write(new Pax({
+			atime: this.portable ? void 0 : this.atime,
+			ctime: this.portable ? void 0 : this.ctime,
+			gid: this.portable ? void 0 : this.gid,
+			mtime: this.noMtime ? void 0 : this.mtime,
+			path: this[PREFIX](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+			size: this.size,
+			uid: this.portable ? void 0 : this.uid,
+			uname: this.portable ? void 0 : this.uname,
+			dev: this.portable ? void 0 : this.readEntry.dev,
+			ino: this.portable ? void 0 : this.readEntry.ino,
+			nlink: this.portable ? void 0 : this.readEntry.nlink
+		}).encode());
+		const b = this.header?.block;
+		/* c8 ignore start */
+		if (!b) throw new Error("failed to encode header");
+		/* c8 ignore stop */
+		super.write(b);
+		readEntry.pipe(this);
+	}
+	[PREFIX](path) {
+		return prefixPath(path, this.prefix);
+	}
+	[MODE](mode) {
+		return modeFix(mode, this.type === "Directory", this.portable);
+	}
+	write(chunk, encoding, cb) {
+		/* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
+		/* c8 ignore stop */
+		const writeLen = chunk.length;
+		if (writeLen > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		this.blockRemain -= writeLen;
+		return super.write(chunk, cb);
+	}
+	end(chunk, encoding, cb) {
+		if (this.blockRemain) super.write(Buffer.alloc(this.blockRemain));
+		/* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+		if (typeof chunk === "function") {
+			cb = chunk;
+			encoding = void 0;
+			chunk = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (typeof chunk === "string") chunk = Buffer.from(chunk, encoding ?? "utf8");
+		if (cb) this.once("finish", cb);
+		chunk ? super.end(chunk, cb) : super.end(cb);
+		/* c8 ignore stop */
+		return this;
+	}
+};
+const getType = (stat) => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/pack.js
+var PackJob = class {
+	path;
+	absolute;
+	entry;
+	stat;
+	readdir;
+	pending = false;
+	ignore = false;
+	piped = false;
+	constructor(path, absolute) {
+		this.path = path || "./";
+		this.absolute = absolute;
+	}
+};
+const EOF = Buffer.alloc(1024);
+const ONSTAT = Symbol("onStat");
+const ENDED$1 = Symbol("ended");
+const QUEUE = Symbol("queue");
+const CURRENT = Symbol("current");
+const PROCESS = Symbol("process");
+const PROCESSING = Symbol("processing");
+const PROCESSJOB = Symbol("processJob");
+const JOBS = Symbol("jobs");
+const JOBDONE = Symbol("jobDone");
+const ADDFSENTRY = Symbol("addFSEntry");
+const ADDTARENTRY = Symbol("addTarEntry");
+const STAT = Symbol("stat");
+const READDIR = Symbol("readdir");
+const ONREADDIR = Symbol("onreaddir");
+const PIPE = Symbol("pipe");
+const ENTRY = Symbol("entry");
+const ENTRYOPT = Symbol("entryOpt");
+const WRITEENTRYCLASS = Symbol("writeEntryClass");
+const WRITE = Symbol("write");
+const ONDRAIN = Symbol("ondrain");
+var Pack = class extends Minipass {
+	opt;
+	cwd;
+	maxReadSize;
+	preservePaths;
+	strict;
+	noPax;
+	prefix;
+	linkCache;
+	statCache;
+	file;
+	portable;
+	zip;
+	readdirCache;
+	noDirRecurse;
+	follow;
+	noMtime;
+	mtime;
+	filter;
+	jobs;
+	[WRITEENTRYCLASS];
+	onWriteEntry;
+	[QUEUE];
+	[JOBS] = 0;
+	[PROCESSING] = false;
+	[ENDED$1] = false;
+	constructor(opt = {}) {
+		super();
+		this.opt = opt;
+		this.file = opt.file || "";
+		this.cwd = opt.cwd || process.cwd();
+		this.maxReadSize = opt.maxReadSize;
+		this.preservePaths = !!opt.preservePaths;
+		this.strict = !!opt.strict;
+		this.noPax = !!opt.noPax;
+		this.prefix = normalizeWindowsPath(opt.prefix || "");
+		this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
+		this.statCache = opt.statCache || /* @__PURE__ */ new Map();
+		this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map();
+		this.onWriteEntry = opt.onWriteEntry;
+		this[WRITEENTRYCLASS] = WriteEntry;
+		if (typeof opt.onwarn === "function") this.on("warn", opt.onwarn);
+		this.portable = !!opt.portable;
+		if (opt.gzip || opt.brotli) {
+			if (opt.gzip && opt.brotli) throw new TypeError("gzip and brotli are mutually exclusive");
+			if (opt.gzip) {
+				if (typeof opt.gzip !== "object") opt.gzip = {};
+				if (this.portable) opt.gzip.portable = true;
+				this.zip = new Gzip(opt.gzip);
+			}
+			if (opt.brotli) {
+				if (typeof opt.brotli !== "object") opt.brotli = {};
+				this.zip = new BrotliCompress(opt.brotli);
+			}
+			/* c8 ignore next */
+			if (!this.zip) throw new Error("impossible");
+			const zip = this.zip;
+			zip.on("data", (chunk) => super.write(chunk));
+			zip.on("end", () => super.end());
+			zip.on("drain", () => this[ONDRAIN]());
+			this.on("resume", () => zip.resume());
+		} else this.on("drain", this[ONDRAIN]);
+		this.noDirRecurse = !!opt.noDirRecurse;
+		this.follow = !!opt.follow;
+		this.noMtime = !!opt.noMtime;
+		if (opt.mtime) this.mtime = opt.mtime;
+		this.filter = typeof opt.filter === "function" ? opt.filter : () => true;
+		this[QUEUE] = new Yallist();
+		this[JOBS] = 0;
+		this.jobs = Number(opt.jobs) || 4;
+		this[PROCESSING] = false;
+		this[ENDED$1] = false;
+	}
+	[WRITE](chunk) {
+		return super.write(chunk);
+	}
+	add(path) {
+		this.write(path);
+		return this;
+	}
+	end(path, encoding, cb) {
+		/* c8 ignore start */
+		if (typeof path === "function") {
+			cb = path;
+			path = void 0;
+		}
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		/* c8 ignore stop */
+		if (path) this.add(path);
+		this[ENDED$1] = true;
+		this[PROCESS]();
+		/* c8 ignore next */
+		if (cb) cb();
+		return this;
+	}
+	write(path) {
+		if (this[ENDED$1]) throw new Error("write after end");
+		if (path instanceof ReadEntry) this[ADDTARENTRY](path);
+		else this[ADDFSENTRY](path);
+		return this.flowing;
+	}
+	[ADDTARENTRY](p) {
+		const absolute = normalizeWindowsPath(path.resolve(this.cwd, p.path));
+		if (!this.filter(p.path, p)) p.resume();
+		else {
+			const job = new PackJob(p.path, absolute);
+			job.entry = new WriteEntryTar(p, this[ENTRYOPT](job));
+			job.entry.on("end", () => this[JOBDONE](job));
+			this[JOBS] += 1;
+			this[QUEUE].push(job);
+		}
+		this[PROCESS]();
+	}
+	[ADDFSENTRY](p) {
+		const absolute = normalizeWindowsPath(path.resolve(this.cwd, p));
+		this[QUEUE].push(new PackJob(p, absolute));
+		this[PROCESS]();
+	}
+	[STAT](job) {
+		job.pending = true;
+		this[JOBS] += 1;
+		fs$1[this.follow ? "stat" : "lstat"](job.absolute, (er, stat) => {
+			job.pending = false;
+			this[JOBS] -= 1;
+			if (er) this.emit("error", er);
+			else this[ONSTAT](job, stat);
+		});
+	}
+	[ONSTAT](job, stat) {
+		this.statCache.set(job.absolute, stat);
+		job.stat = stat;
+		if (!this.filter(job.path, stat)) job.ignore = true;
+		this[PROCESS]();
+	}
+	[READDIR](job) {
+		job.pending = true;
+		this[JOBS] += 1;
+		fs$1.readdir(job.absolute, (er, entries) => {
+			job.pending = false;
+			this[JOBS] -= 1;
+			if (er) return this.emit("error", er);
+			this[ONREADDIR](job, entries);
+		});
+	}
+	[ONREADDIR](job, entries) {
+		this.readdirCache.set(job.absolute, entries);
+		job.readdir = entries;
+		this[PROCESS]();
+	}
+	[PROCESS]() {
+		if (this[PROCESSING]) return;
+		this[PROCESSING] = true;
+		for (let w = this[QUEUE].head; !!w && this[JOBS] < this.jobs; w = w.next) {
+			this[PROCESSJOB](w.value);
+			if (w.value.ignore) {
+				const p = w.next;
+				this[QUEUE].removeNode(w);
+				w.next = p;
+			}
+		}
+		this[PROCESSING] = false;
+		if (this[ENDED$1] && !this[QUEUE].length && this[JOBS] === 0) if (this.zip) this.zip.end(EOF);
+		else {
+			super.write(EOF);
+			super.end();
+		}
+	}
+	get [CURRENT]() {
+		return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value;
+	}
+	[JOBDONE](_job) {
+		this[QUEUE].shift();
+		this[JOBS] -= 1;
+		this[PROCESS]();
+	}
+	[PROCESSJOB](job) {
+		if (job.pending) return;
+		if (job.entry) {
+			if (job === this[CURRENT] && !job.piped) this[PIPE](job);
+			return;
+		}
+		if (!job.stat) {
+			const sc = this.statCache.get(job.absolute);
+			if (sc) this[ONSTAT](job, sc);
+			else this[STAT](job);
+		}
+		if (!job.stat) return;
+		if (job.ignore) return;
+		if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) {
+			const rc = this.readdirCache.get(job.absolute);
+			if (rc) this[ONREADDIR](job, rc);
+			else this[READDIR](job);
+			if (!job.readdir) return;
+		}
+		job.entry = this[ENTRY](job);
+		if (!job.entry) {
+			job.ignore = true;
+			return;
+		}
+		if (job === this[CURRENT] && !job.piped) this[PIPE](job);
+	}
+	[ENTRYOPT](job) {
+		return {
+			onwarn: (code, msg, data) => this.warn(code, msg, data),
+			noPax: this.noPax,
+			cwd: this.cwd,
+			absolute: job.absolute,
+			preservePaths: this.preservePaths,
+			maxReadSize: this.maxReadSize,
+			strict: this.strict,
+			portable: this.portable,
+			linkCache: this.linkCache,
+			statCache: this.statCache,
+			noMtime: this.noMtime,
+			mtime: this.mtime,
+			prefix: this.prefix,
+			onWriteEntry: this.onWriteEntry
+		};
+	}
+	[ENTRY](job) {
+		this[JOBS] += 1;
+		try {
+			return new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job)).on("end", () => this[JOBDONE](job)).on("error", (er) => this.emit("error", er));
+		} catch (er) {
+			this.emit("error", er);
+		}
+	}
+	[ONDRAIN]() {
+		if (this[CURRENT] && this[CURRENT].entry) this[CURRENT].entry.resume();
+	}
+	[PIPE](job) {
+		job.piped = true;
+		if (job.readdir) job.readdir.forEach((entry) => {
+			const p = job.path;
+			const base = p === "./" ? "" : p.replace(/\/*$/, "/");
+			this[ADDFSENTRY](base + entry);
+		});
+		const source = job.entry;
+		const zip = this.zip;
+		/* c8 ignore start */
+		if (!source) throw new Error("cannot pipe without source");
+		/* c8 ignore stop */
+		if (zip) source.on("data", (chunk) => {
+			if (!zip.write(chunk)) source.pause();
+		});
+		else source.on("data", (chunk) => {
+			if (!super.write(chunk)) source.pause();
+		});
+	}
+	pause() {
+		if (this.zip) this.zip.pause();
+		return super.pause();
+	}
+	warn(code, message, data = {}) {
+		warnMethod(this, code, message, data);
+	}
+};
+var PackSync = class extends Pack {
+	sync = true;
+	constructor(opt) {
+		super(opt);
+		this[WRITEENTRYCLASS] = WriteEntrySync;
+	}
+	pause() {}
+	resume() {}
+	[STAT](job) {
+		const stat = this.follow ? "statSync" : "lstatSync";
+		this[ONSTAT](job, fs$1[stat](job.absolute));
+	}
+	[READDIR](job) {
+		this[ONREADDIR](job, fs$1.readdirSync(job.absolute));
+	}
+	[PIPE](job) {
+		const source = job.entry;
+		const zip = this.zip;
+		if (job.readdir) job.readdir.forEach((entry) => {
+			const p = job.path;
+			const base = p === "./" ? "" : p.replace(/\/*$/, "/");
+			this[ADDFSENTRY](base + entry);
+		});
+		/* c8 ignore start */
+		if (!source) throw new Error("Cannot pipe without source");
+		/* c8 ignore stop */
+		if (zip) source.on("data", (chunk) => {
+			zip.write(chunk);
+		});
+		else source.on("data", (chunk) => {
+			super[WRITE](chunk);
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/create.js
+const createFileSync = (opt, files) => {
+	const p = new PackSync(opt);
+	const stream = new WriteStreamSync(opt.file, { mode: opt.mode || 438 });
+	p.pipe(stream);
+	addFilesSync$1(p, files);
+};
+const createFile = (opt, files) => {
+	const p = new Pack(opt);
+	const stream = new WriteStream(opt.file, { mode: opt.mode || 438 });
+	p.pipe(stream);
+	const promise = new Promise((res, rej) => {
+		stream.on("error", rej);
+		stream.on("close", res);
+		p.on("error", rej);
+	});
+	addFilesAsync$1(p, files);
+	return promise;
+};
+const addFilesSync$1 = (p, files) => {
+	files.forEach((file) => {
+		if (file.charAt(0) === "@") list({
+			file: path$1.resolve(p.cwd, file.slice(1)),
+			sync: true,
+			noResume: true,
+			onReadEntry: (entry) => p.add(entry)
+		});
+		else p.add(file);
+	});
+	p.end();
+};
+const addFilesAsync$1 = async (p, files) => {
+	for (let i = 0; i < files.length; i++) {
+		const file = String(files[i]);
+		if (file.charAt(0) === "@") await list({
+			file: path$1.resolve(String(p.cwd), file.slice(1)),
+			noResume: true,
+			onReadEntry: (entry) => {
+				p.add(entry);
+			}
+		});
+		else p.add(file);
+	}
+	p.end();
+};
+const createSync = (opt, files) => {
+	const p = new PackSync(opt);
+	addFilesSync$1(p, files);
+	return p;
+};
+const createAsync = (opt, files) => {
+	const p = new Pack(opt);
+	addFilesAsync$1(p, files);
+	return p;
+};
+makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => {
+	if (!files?.length) throw new TypeError("no paths specified to add to archive");
+});
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/get-write-flag.js
+const isWindows$2 = (process.env.__FAKE_PLATFORM__ || process.platform) === "win32";
+/* c8 ignore start */
+const { O_CREAT, O_TRUNC, O_WRONLY } = fs$1.constants;
+const UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || fs$1.constants.UV_FS_O_FILEMAP || 0;
+/* c8 ignore stop */
+const fMapEnabled = isWindows$2 && !!UV_FS_O_FILEMAP;
+const fMapLimit = 512 * 1024;
+const fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
+const getWriteFlag = !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w";
+//#endregion
+//#region ../../node_modules/.pnpm/chownr@3.0.0/node_modules/chownr/dist/esm/index.js
+const lchownSync = (path, uid, gid) => {
+	try {
+		return fs.lchownSync(path, uid, gid);
+	} catch (er) {
+		if (er?.code !== "ENOENT") throw er;
+	}
+};
+const chown = (cpath, uid, gid, cb) => {
+	fs.lchown(cpath, uid, gid, (er) => {
+		cb(er && er?.code !== "ENOENT" ? er : null);
+	});
+};
+const chownrKid = (p, child, uid, gid, cb) => {
+	if (child.isDirectory()) chownr(path$1.resolve(p, child.name), uid, gid, (er) => {
+		if (er) return cb(er);
+		chown(path$1.resolve(p, child.name), uid, gid, cb);
+	});
+	else chown(path$1.resolve(p, child.name), uid, gid, cb);
+};
+const chownr = (p, uid, gid, cb) => {
+	fs.readdir(p, { withFileTypes: true }, (er, children) => {
+		if (er) {
+			if (er.code === "ENOENT") return cb();
+			else if (er.code !== "ENOTDIR" && er.code !== "ENOTSUP") return cb(er);
+		}
+		if (er || !children.length) return chown(p, uid, gid, cb);
+		let len = children.length;
+		let errState = null;
+		const then = (er) => {
+			/* c8 ignore start */
+			if (errState) return;
+			/* c8 ignore stop */
+			if (er) return cb(errState = er);
+			if (--len === 0) return chown(p, uid, gid, cb);
+		};
+		for (const child of children) chownrKid(p, child, uid, gid, then);
+	});
+};
+const chownrKidSync = (p, child, uid, gid) => {
+	if (child.isDirectory()) chownrSync(path$1.resolve(p, child.name), uid, gid);
+	lchownSync(path$1.resolve(p, child.name), uid, gid);
+};
+const chownrSync = (p, uid, gid) => {
+	let children;
+	try {
+		children = fs.readdirSync(p, { withFileTypes: true });
+	} catch (er) {
+		const e = er;
+		if (e?.code === "ENOENT") return;
+		else if (e?.code === "ENOTDIR" || e?.code === "ENOTSUP") return lchownSync(p, uid, gid);
+		else throw e;
+	}
+	for (const child of children) chownrKidSync(p, child, uid, gid);
+	return lchownSync(p, uid, gid);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/opts-arg.js
+const optsArg = (opts) => {
+	if (!opts) opts = { mode: 511 };
+	else if (typeof opts === "object") opts = {
+		mode: 511,
+		...opts
+	};
+	else if (typeof opts === "number") opts = { mode: opts };
+	else if (typeof opts === "string") opts = { mode: parseInt(opts, 8) };
+	else throw new TypeError("invalid options argument");
+	const resolved = opts;
+	const optsFs = opts.fs || {};
+	opts.mkdir = opts.mkdir || optsFs.mkdir || mkdir;
+	opts.mkdirAsync = opts.mkdirAsync ? opts.mkdirAsync : async (path, options) => {
+		return new Promise((res, rej) => resolved.mkdir(path, options, (er, made) => er ? rej(er) : res(made)));
+	};
+	opts.stat = opts.stat || optsFs.stat || stat;
+	opts.statAsync = opts.statAsync ? opts.statAsync : async (path) => new Promise((res, rej) => resolved.stat(path, (err, stats) => err ? rej(err) : res(stats)));
+	opts.statSync = opts.statSync || optsFs.statSync || statSync$1;
+	opts.mkdirSync = opts.mkdirSync || optsFs.mkdirSync || mkdirSync;
+	return resolved;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/mkdirp-manual.js
+const mkdirpManualSync = (path, options, made) => {
+	const parent = dirname(path);
+	const opts = {
+		...optsArg(options),
+		recursive: false
+	};
+	if (parent === path) try {
+		return opts.mkdirSync(path, opts);
+	} catch (er) {
+		const fer = er;
+		if (fer && fer.code !== "EISDIR") throw er;
+		return;
+	}
+	try {
+		opts.mkdirSync(path, opts);
+		return made || path;
+	} catch (er) {
+		const fer = er;
+		if (fer && fer.code === "ENOENT") return mkdirpManualSync(path, opts, mkdirpManualSync(parent, opts, made));
+		if (fer && fer.code !== "EEXIST" && fer && fer.code !== "EROFS") throw er;
+		try {
+			if (!opts.statSync(path).isDirectory()) throw er;
+		} catch (_) {
+			throw er;
+		}
+	}
+};
+const mkdirpManual = Object.assign(async (path, options, made) => {
+	const opts = optsArg(options);
+	opts.recursive = false;
+	const parent = dirname(path);
+	if (parent === path) return opts.mkdirAsync(path, opts).catch((er) => {
+		const fer = er;
+		if (fer && fer.code !== "EISDIR") throw er;
+	});
+	return opts.mkdirAsync(path, opts).then(() => made || path, async (er) => {
+		const fer = er;
+		if (fer && fer.code === "ENOENT") return mkdirpManual(parent, opts).then((made) => mkdirpManual(path, opts, made));
+		if (fer && fer.code !== "EEXIST" && fer.code !== "EROFS") throw er;
+		return opts.statAsync(path).then((st) => {
+			if (st.isDirectory()) return made;
+			else throw er;
+		}, () => {
+			throw er;
+		});
+	});
+}, { sync: mkdirpManualSync });
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/find-made.js
+const findMade = async (opts, parent, path) => {
+	if (path === parent) return;
+	return opts.statAsync(parent).then((st) => st.isDirectory() ? path : void 0, (er) => {
+		const fer = er;
+		return fer && fer.code === "ENOENT" ? findMade(opts, dirname(parent), parent) : void 0;
+	});
+};
+const findMadeSync = (opts, parent, path) => {
+	if (path === parent) return;
+	try {
+		return opts.statSync(parent).isDirectory() ? path : void 0;
+	} catch (er) {
+		const fer = er;
+		return fer && fer.code === "ENOENT" ? findMadeSync(opts, dirname(parent), parent) : void 0;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/mkdirp-native.js
+const mkdirpNativeSync = (path, options) => {
+	const opts = optsArg(options);
+	opts.recursive = true;
+	if (dirname(path) === path) return opts.mkdirSync(path, opts);
+	const made = findMadeSync(opts, path);
+	try {
+		opts.mkdirSync(path, opts);
+		return made;
+	} catch (er) {
+		const fer = er;
+		if (fer && fer.code === "ENOENT") return mkdirpManualSync(path, opts);
+		else throw er;
+	}
+};
+const mkdirpNative = Object.assign(async (path, options) => {
+	const opts = {
+		...optsArg(options),
+		recursive: true
+	};
+	if (dirname(path) === path) return await opts.mkdirAsync(path, opts);
+	return findMade(opts, path).then((made) => opts.mkdirAsync(path, opts).then((m) => made || m).catch((er) => {
+		const fer = er;
+		if (fer && fer.code === "ENOENT") return mkdirpManual(path, opts);
+		else throw er;
+	}));
+}, { sync: mkdirpNativeSync });
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/path-arg.js
+const platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform;
+const pathArg = (path) => {
+	if (/\0/.test(path)) throw Object.assign(/* @__PURE__ */ new TypeError("path must be a string without null bytes"), {
+		path,
+		code: "ERR_INVALID_ARG_VALUE"
+	});
+	path = resolve(path);
+	if (platform === "win32") {
+		const badWinChars = /[*|"<>?:]/;
+		const { root } = parse(path);
+		if (badWinChars.test(path.substring(root.length))) throw Object.assign(/* @__PURE__ */ new Error("Illegal characters in path."), {
+			path,
+			code: "EINVAL"
+		});
+	}
+	return path;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/use-native.js
+const versArr = (process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version).replace(/^v/, "").split(".");
+const hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12;
+const useNativeSync = !hasNative ? () => false : (opts) => optsArg(opts).mkdirSync === mkdirSync;
+const useNative = Object.assign(!hasNative ? () => false : (opts) => optsArg(opts).mkdir === mkdir, { sync: useNativeSync });
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@3.0.1/node_modules/mkdirp/dist/mjs/index.js
+/* c8 ignore stop */
+const mkdirpSync = (path, opts) => {
+	path = pathArg(path);
+	const resolved = optsArg(opts);
+	return useNativeSync(resolved) ? mkdirpNativeSync(path, resolved) : mkdirpManualSync(path, resolved);
+};
+const mkdirp = Object.assign(async (path, opts) => {
+	path = pathArg(path);
+	const resolved = optsArg(opts);
+	return useNative(resolved) ? mkdirpNative(path, resolved) : mkdirpManual(path, resolved);
+}, {
+	mkdirpSync,
+	mkdirpNative,
+	mkdirpNativeSync,
+	mkdirpManual,
+	mkdirpManualSync,
+	sync: mkdirpSync,
+	native: mkdirpNative,
+	nativeSync: mkdirpNativeSync,
+	manual: mkdirpManual,
+	manualSync: mkdirpManualSync,
+	useNative,
+	useNativeSync
+});
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/cwd-error.js
+var CwdError = class extends Error {
+	path;
+	code;
+	syscall = "chdir";
+	constructor(path, code) {
+		super(`${code}: Cannot cd into '${path}'`);
+		this.path = path;
+		this.code = code;
+	}
+	get name() {
+		return "CwdError";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/symlink-error.js
+var SymlinkError = class extends Error {
+	path;
+	symlink;
+	syscall = "symlink";
+	code = "TAR_SYMLINK_ERROR";
+	constructor(symlink, path) {
+		super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link");
+		this.symlink = symlink;
+		this.path = path;
+	}
+	get name() {
+		return "SymlinkError";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/mkdir.js
+const cGet = (cache, key) => cache.get(normalizeWindowsPath(key));
+const cSet = (cache, key, val) => cache.set(normalizeWindowsPath(key), val);
+const checkCwd = (dir, cb) => {
+	fs$1.stat(dir, (er, st) => {
+		if (er || !st.isDirectory()) er = new CwdError(dir, er?.code || "ENOTDIR");
+		cb(er);
+	});
+};
+/**
+* Wrapper around mkdirp for tar's needs.
+*
+* The main purpose is to avoid creating directories if we know that
+* they already exist (and track which ones exist for this purpose),
+* and prevent entries from being extracted into symlinked folders,
+* if `preservePaths` is not set.
+*/
+const mkdir$1 = (dir, opt, cb) => {
+	dir = normalizeWindowsPath(dir);
+	/* c8 ignore next */
+	const umask = opt.umask ?? 18;
+	const mode = opt.mode | 448;
+	const needChmod = (mode & umask) !== 0;
+	const uid = opt.uid;
+	const gid = opt.gid;
+	const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
+	const preserve = opt.preserve;
+	const unlink = opt.unlink;
+	const cache = opt.cache;
+	const cwd = normalizeWindowsPath(opt.cwd);
+	const done = (er, created) => {
+		if (er) cb(er);
+		else {
+			cSet(cache, dir, true);
+			if (created && doChown) chownr(created, uid, gid, (er) => done(er));
+			else if (needChmod) fs$1.chmod(dir, mode, cb);
+			else cb();
+		}
+	};
+	if (cache && cGet(cache, dir) === true) return done();
+	if (dir === cwd) return checkCwd(dir, done);
+	if (preserve) return mkdirp(dir, { mode }).then((made) => done(null, made ?? void 0), done);
+	mkdir_(cwd, normalizeWindowsPath(path$1.relative(cwd, dir)).split("/"), mode, cache, unlink, cwd, void 0, done);
+};
+const mkdir_ = (base, parts, mode, cache, unlink, cwd, created, cb) => {
+	if (!parts.length) return cb(null, created);
+	const p = parts.shift();
+	const part = normalizeWindowsPath(path$1.resolve(base + "/" + p));
+	if (cGet(cache, part)) return mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
+	fs$1.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb));
+};
+const onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => (er) => {
+	if (er) fs$1.lstat(part, (statEr, st) => {
+		if (statEr) {
+			statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
+			cb(statEr);
+		} else if (st.isDirectory()) mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
+		else if (unlink) fs$1.unlink(part, (er) => {
+			if (er) return cb(er);
+			fs$1.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb));
+		});
+		else if (st.isSymbolicLink()) return cb(new SymlinkError(part, part + "/" + parts.join("/")));
+		else cb(er);
+	});
+	else {
+		created = created || part;
+		mkdir_(part, parts, mode, cache, unlink, cwd, created, cb);
+	}
+};
+const checkCwdSync = (dir) => {
+	let ok = false;
+	let code = void 0;
+	try {
+		ok = fs$1.statSync(dir).isDirectory();
+	} catch (er) {
+		code = er?.code;
+	} finally {
+		if (!ok) throw new CwdError(dir, code ?? "ENOTDIR");
+	}
+};
+const mkdirSync$1 = (dir, opt) => {
+	dir = normalizeWindowsPath(dir);
+	/* c8 ignore next */
+	const umask = opt.umask ?? 18;
+	const mode = opt.mode | 448;
+	const needChmod = (mode & umask) !== 0;
+	const uid = opt.uid;
+	const gid = opt.gid;
+	const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
+	const preserve = opt.preserve;
+	const unlink = opt.unlink;
+	const cache = opt.cache;
+	const cwd = normalizeWindowsPath(opt.cwd);
+	const done = (created) => {
+		cSet(cache, dir, true);
+		if (created && doChown) chownrSync(created, uid, gid);
+		if (needChmod) fs$1.chmodSync(dir, mode);
+	};
+	if (cache && cGet(cache, dir) === true) return done();
+	if (dir === cwd) {
+		checkCwdSync(cwd);
+		return done();
+	}
+	if (preserve) return done(mkdirpSync(dir, mode) ?? void 0);
+	const parts = normalizeWindowsPath(path$1.relative(cwd, dir)).split("/");
+	let created = void 0;
+	for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) {
+		part = normalizeWindowsPath(path$1.resolve(part));
+		if (cGet(cache, part)) continue;
+		try {
+			fs$1.mkdirSync(part, mode);
+			created = created || part;
+			cSet(cache, part, true);
+		} catch (er) {
+			const st = fs$1.lstatSync(part);
+			if (st.isDirectory()) {
+				cSet(cache, part, true);
+				continue;
+			} else if (unlink) {
+				fs$1.unlinkSync(part);
+				fs$1.mkdirSync(part, mode);
+				created = created || part;
+				cSet(cache, part, true);
+				continue;
+			} else if (st.isSymbolicLink()) return new SymlinkError(part, part + "/" + parts.join("/"));
+		}
+	}
+	return done(created);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/normalize-unicode.js
+const normalizeCache = Object.create(null);
+const { hasOwnProperty } = Object.prototype;
+const normalizeUnicode = (s) => {
+	if (!hasOwnProperty.call(normalizeCache, s)) normalizeCache[s] = s.normalize("NFD");
+	return normalizeCache[s];
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/path-reservations.js
+const isWindows$1 = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32";
+const getDirs = (path) => {
+	return path.split("/").slice(0, -1).reduce((set, path) => {
+		const s = set[set.length - 1];
+		if (s !== void 0) path = join(s, path);
+		set.push(path || "/");
+		return set;
+	}, []);
+};
+var PathReservations = class {
+	#queues = /* @__PURE__ */ new Map();
+	#reservations = /* @__PURE__ */ new Map();
+	#running = /* @__PURE__ */ new Set();
+	reserve(paths, fn) {
+		paths = isWindows$1 ? ["win32 parallelization disabled"] : paths.map((p) => {
+			return stripTrailingSlashes(join(normalizeUnicode(p))).toLowerCase();
+		});
+		const dirs = new Set(paths.map((path) => getDirs(path)).reduce((a, b) => a.concat(b)));
+		this.#reservations.set(fn, {
+			dirs,
+			paths
+		});
+		for (const p of paths) {
+			const q = this.#queues.get(p);
+			if (!q) this.#queues.set(p, [fn]);
+			else q.push(fn);
+		}
+		for (const dir of dirs) {
+			const q = this.#queues.get(dir);
+			if (!q) this.#queues.set(dir, [/* @__PURE__ */ new Set([fn])]);
+			else {
+				const l = q[q.length - 1];
+				if (l instanceof Set) l.add(fn);
+				else q.push(/* @__PURE__ */ new Set([fn]));
+			}
+		}
+		return this.#run(fn);
+	}
+	#getQueues(fn) {
+		const res = this.#reservations.get(fn);
+		/* c8 ignore start */
+		if (!res) throw new Error("function does not have any path reservations");
+		/* c8 ignore stop */
+		return {
+			paths: res.paths.map((path) => this.#queues.get(path)),
+			dirs: [...res.dirs].map((path) => this.#queues.get(path))
+		};
+	}
+	check(fn) {
+		const { paths, dirs } = this.#getQueues(fn);
+		return paths.every((q) => q && q[0] === fn) && dirs.every((q) => q && q[0] instanceof Set && q[0].has(fn));
+	}
+	#run(fn) {
+		if (this.#running.has(fn) || !this.check(fn)) return false;
+		this.#running.add(fn);
+		fn(() => this.#clear(fn));
+		return true;
+	}
+	#clear(fn) {
+		if (!this.#running.has(fn)) return false;
+		const res = this.#reservations.get(fn);
+		/* c8 ignore start */
+		if (!res) throw new Error("invalid reservation");
+		/* c8 ignore stop */
+		const { paths, dirs } = res;
+		const next = /* @__PURE__ */ new Set();
+		for (const path of paths) {
+			const q = this.#queues.get(path);
+			/* c8 ignore start */
+			if (!q || q?.[0] !== fn) continue;
+			/* c8 ignore stop */
+			const q0 = q[1];
+			if (!q0) {
+				this.#queues.delete(path);
+				continue;
+			}
+			q.shift();
+			if (typeof q0 === "function") next.add(q0);
+			else for (const f of q0) next.add(f);
+		}
+		for (const dir of dirs) {
+			const q = this.#queues.get(dir);
+			const q0 = q?.[0];
+			/* c8 ignore next - type safety only */
+			if (!q || !(q0 instanceof Set)) continue;
+			if (q0.size === 1 && q.length === 1) {
+				this.#queues.delete(dir);
+				continue;
+			} else if (q0.size === 1) {
+				q.shift();
+				const n = q[0];
+				if (typeof n === "function") next.add(n);
+			} else q0.delete(fn);
+		}
+		this.#running.delete(fn);
+		next.forEach((fn) => this.#run(fn));
+		return true;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/unpack.js
+const ONENTRY = Symbol("onEntry");
+const CHECKFS = Symbol("checkFs");
+const CHECKFS2 = Symbol("checkFs2");
+const PRUNECACHE = Symbol("pruneCache");
+const ISREUSABLE = Symbol("isReusable");
+const MAKEFS = Symbol("makeFs");
+const FILE = Symbol("file");
+const DIRECTORY = Symbol("directory");
+const LINK = Symbol("link");
+const SYMLINK = Symbol("symlink");
+const HARDLINK = Symbol("hardlink");
+const UNSUPPORTED = Symbol("unsupported");
+const CHECKPATH = Symbol("checkPath");
+const MKDIR = Symbol("mkdir");
+const ONERROR = Symbol("onError");
+const PENDING = Symbol("pending");
+const PEND = Symbol("pend");
+const UNPEND = Symbol("unpend");
+const ENDED = Symbol("ended");
+const MAYBECLOSE = Symbol("maybeClose");
+const SKIP = Symbol("skip");
+const DOCHOWN = Symbol("doChown");
+const UID = Symbol("uid");
+const GID = Symbol("gid");
+const CHECKED_CWD = Symbol("checkedCwd");
+const isWindows = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32";
+const DEFAULT_MAX_DEPTH = 1024;
+/* c8 ignore start */
+const unlinkFile = (path, cb) => {
+	if (!isWindows) return fs.unlink(path, cb);
+	const name = path + ".DELETE." + randomBytes(16).toString("hex");
+	fs.rename(path, name, (er) => {
+		if (er) return cb(er);
+		fs.unlink(name, cb);
+	});
+};
+/* c8 ignore stop */
+/* c8 ignore start */
+const unlinkFileSync = (path) => {
+	if (!isWindows) return fs.unlinkSync(path);
+	const name = path + ".DELETE." + randomBytes(16).toString("hex");
+	fs.renameSync(path, name);
+	fs.unlinkSync(name);
+};
+/* c8 ignore stop */
+const uint32 = (a, b, c) => a !== void 0 && a === a >>> 0 ? a : b !== void 0 && b === b >>> 0 ? b : c;
+const cacheKeyNormalize = (path) => stripTrailingSlashes(normalizeWindowsPath(normalizeUnicode(path))).toLowerCase();
+const pruneCache = (cache, abs) => {
+	abs = cacheKeyNormalize(abs);
+	for (const path of cache.keys()) {
+		const pnorm = cacheKeyNormalize(path);
+		if (pnorm === abs || pnorm.indexOf(abs + "/") === 0) cache.delete(path);
+	}
+};
+const dropCache = (cache) => {
+	for (const key of cache.keys()) cache.delete(key);
+};
+var Unpack = class extends Parser {
+	[ENDED] = false;
+	[CHECKED_CWD] = false;
+	[PENDING] = 0;
+	reservations = new PathReservations();
+	transform;
+	writable = true;
+	readable = false;
+	dirCache;
+	uid;
+	gid;
+	setOwner;
+	preserveOwner;
+	processGid;
+	processUid;
+	maxDepth;
+	forceChown;
+	win32;
+	newer;
+	keep;
+	noMtime;
+	preservePaths;
+	unlink;
+	cwd;
+	strip;
+	processUmask;
+	umask;
+	dmode;
+	fmode;
+	chmod;
+	constructor(opt = {}) {
+		opt.ondone = () => {
+			this[ENDED] = true;
+			this[MAYBECLOSE]();
+		};
+		super(opt);
+		this.transform = opt.transform;
+		this.dirCache = opt.dirCache || /* @__PURE__ */ new Map();
+		this.chmod = !!opt.chmod;
+		if (typeof opt.uid === "number" || typeof opt.gid === "number") {
+			if (typeof opt.uid !== "number" || typeof opt.gid !== "number") throw new TypeError("cannot set owner without number uid and gid");
+			if (opt.preserveOwner) throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
+			this.uid = opt.uid;
+			this.gid = opt.gid;
+			this.setOwner = true;
+		} else {
+			this.uid = void 0;
+			this.gid = void 0;
+			this.setOwner = false;
+		}
+		if (opt.preserveOwner === void 0 && typeof opt.uid !== "number") this.preserveOwner = !!(process.getuid && process.getuid() === 0);
+		else this.preserveOwner = !!opt.preserveOwner;
+		this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0;
+		this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0;
+		this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH;
+		this.forceChown = opt.forceChown === true;
+		this.win32 = !!opt.win32 || isWindows;
+		this.newer = !!opt.newer;
+		this.keep = !!opt.keep;
+		this.noMtime = !!opt.noMtime;
+		this.preservePaths = !!opt.preservePaths;
+		this.unlink = !!opt.unlink;
+		this.cwd = normalizeWindowsPath(path$1.resolve(opt.cwd || process.cwd()));
+		this.strip = Number(opt.strip) || 0;
+		this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : process.umask();
+		this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask;
+		this.dmode = opt.dmode || 511 & ~this.umask;
+		this.fmode = opt.fmode || 438 & ~this.umask;
+		this.on("entry", (entry) => this[ONENTRY](entry));
+	}
+	warn(code, msg, data = {}) {
+		if (code === "TAR_BAD_ARCHIVE" || code === "TAR_ABORT") data.recoverable = false;
+		return super.warn(code, msg, data);
+	}
+	[MAYBECLOSE]() {
+		if (this[ENDED] && this[PENDING] === 0) {
+			this.emit("prefinish");
+			this.emit("finish");
+			this.emit("end");
+		}
+	}
+	[CHECKPATH](entry) {
+		const p = normalizeWindowsPath(entry.path);
+		const parts = p.split("/");
+		if (this.strip) {
+			if (parts.length < this.strip) return false;
+			if (entry.type === "Link") {
+				const linkparts = normalizeWindowsPath(String(entry.linkpath)).split("/");
+				if (linkparts.length >= this.strip) entry.linkpath = linkparts.slice(this.strip).join("/");
+				else return false;
+			}
+			parts.splice(0, this.strip);
+			entry.path = parts.join("/");
+		}
+		if (isFinite(this.maxDepth) && parts.length > this.maxDepth) {
+			this.warn("TAR_ENTRY_ERROR", "path excessively deep", {
+				entry,
+				path: p,
+				depth: parts.length,
+				maxDepth: this.maxDepth
+			});
+			return false;
+		}
+		if (!this.preservePaths) {
+			if (parts.includes("..") || isWindows && /^[a-z]:\.\.$/i.test(parts[0] ?? "")) {
+				this.warn("TAR_ENTRY_ERROR", `path contains '..'`, {
+					entry,
+					path: p
+				});
+				return false;
+			}
+			const [root, stripped] = stripAbsolutePath(p);
+			if (root) {
+				entry.path = String(stripped);
+				this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute path`, {
+					entry,
+					path: p
+				});
+			}
+		}
+		if (path$1.isAbsolute(entry.path)) entry.absolute = normalizeWindowsPath(path$1.resolve(entry.path));
+		else entry.absolute = normalizeWindowsPath(path$1.resolve(this.cwd, entry.path));
+		/* c8 ignore start - defense in depth */
+		if (!this.preservePaths && typeof entry.absolute === "string" && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) {
+			this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
+				entry,
+				path: normalizeWindowsPath(entry.path),
+				resolvedPath: entry.absolute,
+				cwd: this.cwd
+			});
+			return false;
+		}
+		/* c8 ignore stop */
+		if (entry.absolute === this.cwd && entry.type !== "Directory" && entry.type !== "GNUDumpDir") return false;
+		if (this.win32) {
+			const { root: aRoot } = path$1.win32.parse(String(entry.absolute));
+			entry.absolute = aRoot + encode(String(entry.absolute).slice(aRoot.length));
+			const { root: pRoot } = path$1.win32.parse(entry.path);
+			entry.path = pRoot + encode(entry.path.slice(pRoot.length));
+		}
+		return true;
+	}
+	[ONENTRY](entry) {
+		if (!this[CHECKPATH](entry)) return entry.resume();
+		assert$1.equal(typeof entry.absolute, "string");
+		switch (entry.type) {
+			case "Directory":
+			case "GNUDumpDir": if (entry.mode) entry.mode = entry.mode | 448;
+			case "File":
+			case "OldFile":
+			case "ContiguousFile":
+			case "Link":
+			case "SymbolicLink": return this[CHECKFS](entry);
+			default: return this[UNSUPPORTED](entry);
+		}
+	}
+	[ONERROR](er, entry) {
+		if (er.name === "CwdError") this.emit("error", er);
+		else {
+			this.warn("TAR_ENTRY_ERROR", er, { entry });
+			this[UNPEND]();
+			entry.resume();
+		}
+	}
+	[MKDIR](dir, mode, cb) {
+		mkdir$1(normalizeWindowsPath(dir), {
+			uid: this.uid,
+			gid: this.gid,
+			processUid: this.processUid,
+			processGid: this.processGid,
+			umask: this.processUmask,
+			preserve: this.preservePaths,
+			unlink: this.unlink,
+			cache: this.dirCache,
+			cwd: this.cwd,
+			mode
+		}, cb);
+	}
+	[DOCHOWN](entry) {
+		return this.forceChown || this.preserveOwner && (typeof entry.uid === "number" && entry.uid !== this.processUid || typeof entry.gid === "number" && entry.gid !== this.processGid) || typeof this.uid === "number" && this.uid !== this.processUid || typeof this.gid === "number" && this.gid !== this.processGid;
+	}
+	[UID](entry) {
+		return uint32(this.uid, entry.uid, this.processUid);
+	}
+	[GID](entry) {
+		return uint32(this.gid, entry.gid, this.processGid);
+	}
+	[FILE](entry, fullyDone) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
+		const stream = new WriteStream(String(entry.absolute), {
+			flags: getWriteFlag(entry.size),
+			mode,
+			autoClose: false
+		});
+		stream.on("error", (er) => {
+			if (stream.fd) fs.close(stream.fd, () => {});
+			stream.write = () => true;
+			this[ONERROR](er, entry);
+			fullyDone();
+		});
+		let actions = 1;
+		const done = (er) => {
+			if (er) {
+				/* c8 ignore start - we should always have a fd by now */
+				if (stream.fd) fs.close(stream.fd, () => {});
+				/* c8 ignore stop */
+				this[ONERROR](er, entry);
+				fullyDone();
+				return;
+			}
+			if (--actions === 0) {
+				if (stream.fd !== void 0) fs.close(stream.fd, (er) => {
+					if (er) this[ONERROR](er, entry);
+					else this[UNPEND]();
+					fullyDone();
+				});
+			}
+		};
+		stream.on("finish", () => {
+			const abs = String(entry.absolute);
+			const fd = stream.fd;
+			if (typeof fd === "number" && entry.mtime && !this.noMtime) {
+				actions++;
+				const atime = entry.atime || /* @__PURE__ */ new Date();
+				const mtime = entry.mtime;
+				fs.futimes(fd, atime, mtime, (er) => er ? fs.utimes(abs, atime, mtime, (er2) => done(er2 && er)) : done());
+			}
+			if (typeof fd === "number" && this[DOCHOWN](entry)) {
+				actions++;
+				const uid = this[UID](entry);
+				const gid = this[GID](entry);
+				if (typeof uid === "number" && typeof gid === "number") fs.fchown(fd, uid, gid, (er) => er ? fs.chown(abs, uid, gid, (er2) => done(er2 && er)) : done());
+			}
+			done();
+		});
+		const tx = this.transform ? this.transform(entry) || entry : entry;
+		if (tx !== entry) {
+			tx.on("error", (er) => {
+				this[ONERROR](er, entry);
+				fullyDone();
+			});
+			entry.pipe(tx);
+		}
+		tx.pipe(stream);
+	}
+	[DIRECTORY](entry, fullyDone) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
+		this[MKDIR](String(entry.absolute), mode, (er) => {
+			if (er) {
+				this[ONERROR](er, entry);
+				fullyDone();
+				return;
+			}
+			let actions = 1;
+			const done = () => {
+				if (--actions === 0) {
+					fullyDone();
+					this[UNPEND]();
+					entry.resume();
+				}
+			};
+			if (entry.mtime && !this.noMtime) {
+				actions++;
+				fs.utimes(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done);
+			}
+			if (this[DOCHOWN](entry)) {
+				actions++;
+				fs.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
+			}
+			done();
+		});
+	}
+	[UNSUPPORTED](entry) {
+		entry.unsupported = true;
+		this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${entry.type}`, { entry });
+		entry.resume();
+	}
+	[SYMLINK](entry, done) {
+		this[LINK](entry, String(entry.linkpath), "symlink", done);
+	}
+	[HARDLINK](entry, done) {
+		const linkpath = normalizeWindowsPath(path$1.resolve(this.cwd, String(entry.linkpath)));
+		this[LINK](entry, linkpath, "link", done);
+	}
+	[PEND]() {
+		this[PENDING]++;
+	}
+	[UNPEND]() {
+		this[PENDING]--;
+		this[MAYBECLOSE]();
+	}
+	[SKIP](entry) {
+		this[UNPEND]();
+		entry.resume();
+	}
+	[ISREUSABLE](entry, st) {
+		return entry.type === "File" && !this.unlink && st.isFile() && st.nlink <= 1 && !isWindows;
+	}
+	[CHECKFS](entry) {
+		this[PEND]();
+		const paths = [entry.path];
+		if (entry.linkpath) paths.push(entry.linkpath);
+		this.reservations.reserve(paths, (done) => this[CHECKFS2](entry, done));
+	}
+	[PRUNECACHE](entry) {
+		if (entry.type === "SymbolicLink") dropCache(this.dirCache);
+		else if (entry.type !== "Directory") pruneCache(this.dirCache, String(entry.absolute));
+	}
+	[CHECKFS2](entry, fullyDone) {
+		this[PRUNECACHE](entry);
+		const done = (er) => {
+			this[PRUNECACHE](entry);
+			fullyDone(er);
+		};
+		const checkCwd = () => {
+			this[MKDIR](this.cwd, this.dmode, (er) => {
+				if (er) {
+					this[ONERROR](er, entry);
+					done();
+					return;
+				}
+				this[CHECKED_CWD] = true;
+				start();
+			});
+		};
+		const start = () => {
+			if (entry.absolute !== this.cwd) {
+				const parent = normalizeWindowsPath(path$1.dirname(String(entry.absolute)));
+				if (parent !== this.cwd) return this[MKDIR](parent, this.dmode, (er) => {
+					if (er) {
+						this[ONERROR](er, entry);
+						done();
+						return;
+					}
+					afterMakeParent();
+				});
+			}
+			afterMakeParent();
+		};
+		const afterMakeParent = () => {
+			fs.lstat(String(entry.absolute), (lstatEr, st) => {
+				if (st && (this.keep || this.newer && st.mtime > (entry.mtime ?? st.mtime))) {
+					this[SKIP](entry);
+					done();
+					return;
+				}
+				if (lstatEr || this[ISREUSABLE](entry, st)) return this[MAKEFS](null, entry, done);
+				if (st.isDirectory()) {
+					if (entry.type === "Directory") {
+						const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode;
+						const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done);
+						if (!needChmod) return afterChmod();
+						return fs.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
+					}
+					if (entry.absolute !== this.cwd) return fs.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+				}
+				if (entry.absolute === this.cwd) return this[MAKEFS](null, entry, done);
+				unlinkFile(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+			});
+		};
+		if (this[CHECKED_CWD]) start();
+		else checkCwd();
+	}
+	[MAKEFS](er, entry, done) {
+		if (er) {
+			this[ONERROR](er, entry);
+			done();
+			return;
+		}
+		switch (entry.type) {
+			case "File":
+			case "OldFile":
+			case "ContiguousFile": return this[FILE](entry, done);
+			case "Link": return this[HARDLINK](entry, done);
+			case "SymbolicLink": return this[SYMLINK](entry, done);
+			case "Directory":
+			case "GNUDumpDir": return this[DIRECTORY](entry, done);
+		}
+	}
+	[LINK](entry, linkpath, link, done) {
+		fs[link](linkpath, String(entry.absolute), (er) => {
+			if (er) this[ONERROR](er, entry);
+			else {
+				this[UNPEND]();
+				entry.resume();
+			}
+			done();
+		});
+	}
+};
+const callSync = (fn) => {
+	try {
+		return [null, fn()];
+	} catch (er) {
+		return [er, null];
+	}
+};
+var UnpackSync = class extends Unpack {
+	sync = true;
+	[MAKEFS](er, entry) {
+		return super[MAKEFS](er, entry, () => {});
+	}
+	[CHECKFS](entry) {
+		this[PRUNECACHE](entry);
+		if (!this[CHECKED_CWD]) {
+			const er = this[MKDIR](this.cwd, this.dmode);
+			if (er) return this[ONERROR](er, entry);
+			this[CHECKED_CWD] = true;
+		}
+		if (entry.absolute !== this.cwd) {
+			const parent = normalizeWindowsPath(path$1.dirname(String(entry.absolute)));
+			if (parent !== this.cwd) {
+				const mkParent = this[MKDIR](parent, this.dmode);
+				if (mkParent) return this[ONERROR](mkParent, entry);
+			}
+		}
+		const [lstatEr, st] = callSync(() => fs.lstatSync(String(entry.absolute)));
+		if (st && (this.keep || this.newer && st.mtime > (entry.mtime ?? st.mtime))) return this[SKIP](entry);
+		if (lstatEr || this[ISREUSABLE](entry, st)) return this[MAKEFS](null, entry);
+		if (st.isDirectory()) {
+			if (entry.type === "Directory") {
+				const [er] = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode ? callSync(() => {
+					fs.chmodSync(String(entry.absolute), Number(entry.mode));
+				}) : [];
+				return this[MAKEFS](er, entry);
+			}
+			const [er] = callSync(() => fs.rmdirSync(String(entry.absolute)));
+			this[MAKEFS](er, entry);
+		}
+		const [er] = entry.absolute === this.cwd ? [] : callSync(() => unlinkFileSync(String(entry.absolute)));
+		this[MAKEFS](er, entry);
+	}
+	[FILE](entry, done) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
+		const oner = (er) => {
+			let closeError;
+			try {
+				fs.closeSync(fd);
+			} catch (e) {
+				closeError = e;
+			}
+			if (er || closeError) this[ONERROR](er || closeError, entry);
+			done();
+		};
+		let fd;
+		try {
+			fd = fs.openSync(String(entry.absolute), getWriteFlag(entry.size), mode);
+		} catch (er) {
+			return oner(er);
+		}
+		const tx = this.transform ? this.transform(entry) || entry : entry;
+		if (tx !== entry) {
+			tx.on("error", (er) => this[ONERROR](er, entry));
+			entry.pipe(tx);
+		}
+		tx.on("data", (chunk) => {
+			try {
+				fs.writeSync(fd, chunk, 0, chunk.length);
+			} catch (er) {
+				oner(er);
+			}
+		});
+		tx.on("end", () => {
+			let er = null;
+			if (entry.mtime && !this.noMtime) {
+				const atime = entry.atime || /* @__PURE__ */ new Date();
+				const mtime = entry.mtime;
+				try {
+					fs.futimesSync(fd, atime, mtime);
+				} catch (futimeser) {
+					try {
+						fs.utimesSync(String(entry.absolute), atime, mtime);
+					} catch (utimeser) {
+						er = futimeser;
+					}
+				}
+			}
+			if (this[DOCHOWN](entry)) {
+				const uid = this[UID](entry);
+				const gid = this[GID](entry);
+				try {
+					fs.fchownSync(fd, Number(uid), Number(gid));
+				} catch (fchowner) {
+					try {
+						fs.chownSync(String(entry.absolute), Number(uid), Number(gid));
+					} catch (chowner) {
+						er = er || fchowner;
+					}
+				}
+			}
+			oner(er);
+		});
+	}
+	[DIRECTORY](entry, done) {
+		const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
+		const er = this[MKDIR](String(entry.absolute), mode);
+		if (er) {
+			this[ONERROR](er, entry);
+			done();
+			return;
+		}
+		if (entry.mtime && !this.noMtime) try {
+			fs.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime);
+		} catch (er) {}
+		if (this[DOCHOWN](entry)) try {
+			fs.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
+		} catch (er) {}
+		done();
+		entry.resume();
+	}
+	[MKDIR](dir, mode) {
+		try {
+			return mkdirSync$1(normalizeWindowsPath(dir), {
+				uid: this.uid,
+				gid: this.gid,
+				processUid: this.processUid,
+				processGid: this.processGid,
+				umask: this.processUmask,
+				preserve: this.preservePaths,
+				unlink: this.unlink,
+				cache: this.dirCache,
+				cwd: this.cwd,
+				mode
+			});
+		} catch (er) {
+			return er;
+		}
+	}
+	[LINK](entry, linkpath, link, done) {
+		const ls = `${link}Sync`;
+		try {
+			fs[ls](linkpath, String(entry.absolute));
+			done();
+			entry.resume();
+		} catch (er) {
+			return this[ONERROR](er, entry);
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/extract.js
+const extractFileSync = (opt) => {
+	const u = new UnpackSync(opt);
+	const file = opt.file;
+	const stat = fs.statSync(file);
+	new ReadStreamSync(file, {
+		readSize: opt.maxReadSize || 16 * 1024 * 1024,
+		size: stat.size
+	}).pipe(u);
+};
+const extractFile = (opt, _) => {
+	const u = new Unpack(opt);
+	const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+	const file = opt.file;
+	return new Promise((resolve, reject) => {
+		u.on("error", reject);
+		u.on("close", resolve);
+		fs.stat(file, (er, stat) => {
+			if (er) reject(er);
+			else {
+				const stream = new ReadStream(file, {
+					readSize,
+					size: stat.size
+				});
+				stream.on("error", reject);
+				stream.pipe(u);
+			}
+		});
+	});
+};
+const extract = makeCommand(extractFileSync, extractFile, (opt) => new UnpackSync(opt), (opt) => new Unpack(opt), (opt, files) => {
+	if (files?.length) filesFilter(opt, files);
+});
+//#endregion
+//#region ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/replace.js
+const replaceSync = (opt, files) => {
+	const p = new PackSync(opt);
+	let threw = true;
+	let fd;
+	let position;
+	try {
+		try {
+			fd = fs.openSync(opt.file, "r+");
+		} catch (er) {
+			if (er?.code === "ENOENT") fd = fs.openSync(opt.file, "w+");
+			else throw er;
+		}
+		const st = fs.fstatSync(fd);
+		const headBuf = Buffer.alloc(512);
+		POSITION: for (position = 0; position < st.size; position += 512) {
+			for (let bufPos = 0, bytes = 0; bufPos < 512; bufPos += bytes) {
+				bytes = fs.readSync(fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos);
+				if (position === 0 && headBuf[0] === 31 && headBuf[1] === 139) throw new Error("cannot append to compressed archives");
+				if (!bytes) break POSITION;
+			}
+			const h = new Header(headBuf);
+			if (!h.cksumValid) break;
+			const entryBlockSize = 512 * Math.ceil((h.size || 0) / 512);
+			if (position + entryBlockSize + 512 > st.size) break;
+			position += entryBlockSize;
+			if (opt.mtimeCache && h.mtime) opt.mtimeCache.set(String(h.path), h.mtime);
+		}
+		threw = false;
+		streamSync(opt, p, position, fd, files);
+	} finally {
+		if (threw) try {
+			fs.closeSync(fd);
+		} catch (er) {}
+	}
+};
+const streamSync = (opt, p, position, fd, files) => {
+	const stream = new WriteStreamSync(opt.file, {
+		fd,
+		start: position
+	});
+	p.pipe(stream);
+	addFilesSync(p, files);
+};
+const replaceAsync = (opt, files) => {
+	files = Array.from(files);
+	const p = new Pack(opt);
+	const getPos = (fd, size, cb_) => {
+		const cb = (er, pos) => {
+			if (er) fs.close(fd, (_) => cb_(er));
+			else cb_(null, pos);
+		};
+		let position = 0;
+		if (size === 0) return cb(null, 0);
+		let bufPos = 0;
+		const headBuf = Buffer.alloc(512);
+		const onread = (er, bytes) => {
+			if (er || typeof bytes === "undefined") return cb(er);
+			bufPos += bytes;
+			if (bufPos < 512 && bytes) return fs.read(fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos, onread);
+			if (position === 0 && headBuf[0] === 31 && headBuf[1] === 139) return cb(/* @__PURE__ */ new Error("cannot append to compressed archives"));
+			if (bufPos < 512) return cb(null, position);
+			const h = new Header(headBuf);
+			if (!h.cksumValid) return cb(null, position);
+			/* c8 ignore next */
+			const entryBlockSize = 512 * Math.ceil((h.size ?? 0) / 512);
+			if (position + entryBlockSize + 512 > size) return cb(null, position);
+			position += entryBlockSize + 512;
+			if (position >= size) return cb(null, position);
+			if (opt.mtimeCache && h.mtime) opt.mtimeCache.set(String(h.path), h.mtime);
+			bufPos = 0;
+			fs.read(fd, headBuf, 0, 512, position, onread);
+		};
+		fs.read(fd, headBuf, 0, 512, position, onread);
+	};
+	return new Promise((resolve, reject) => {
+		p.on("error", reject);
+		let flag = "r+";
+		const onopen = (er, fd) => {
+			if (er && er.code === "ENOENT" && flag === "r+") {
+				flag = "w+";
+				return fs.open(opt.file, flag, onopen);
+			}
+			if (er || !fd) return reject(er);
+			fs.fstat(fd, (er, st) => {
+				if (er) return fs.close(fd, () => reject(er));
+				getPos(fd, st.size, (er, position) => {
+					if (er) return reject(er);
+					const stream = new WriteStream(opt.file, {
+						fd,
+						start: position
+					});
+					p.pipe(stream);
+					stream.on("error", reject);
+					stream.on("close", resolve);
+					addFilesAsync(p, files);
+				});
+			});
+		};
+		fs.open(opt.file, flag, onopen);
+	});
+};
+const addFilesSync = (p, files) => {
+	files.forEach((file) => {
+		if (file.charAt(0) === "@") list({
+			file: path$1.resolve(p.cwd, file.slice(1)),
+			sync: true,
+			noResume: true,
+			onReadEntry: (entry) => p.add(entry)
+		});
+		else p.add(file);
+	});
+	p.end();
+};
+const addFilesAsync = async (p, files) => {
+	for (let i = 0; i < files.length; i++) {
+		const file = String(files[i]);
+		if (file.charAt(0) === "@") await list({
+			file: path$1.resolve(String(p.cwd), file.slice(1)),
+			noResume: true,
+			onReadEntry: (entry) => p.add(entry)
+		});
+		else p.add(file);
+	}
+	p.end();
+};
+const replace = makeCommand(
+	replaceSync,
+	replaceAsync,
+	/* c8 ignore start */
+	() => {
+		throw new TypeError("file is required");
+	},
+	() => {
+		throw new TypeError("file is required");
+	},
+	/* c8 ignore stop */
+	(opt, entries) => {
+		if (!isFile(opt)) throw new TypeError("file is required");
+		if (opt.gzip || opt.brotli || opt.file.endsWith(".br") || opt.file.endsWith(".tbr")) throw new TypeError("cannot append to compressed archives");
+		if (!entries?.length) throw new TypeError("no paths specified to add/replace");
+	}
+);
+makeCommand(replace.syncFile, replace.asyncFile, replace.syncNoFile, replace.asyncNoFile, (opt, entries = []) => {
+	replace.validate?.(opt, entries);
+	mtimeFilter(opt);
+});
+const mtimeFilter = (opt) => {
+	const filter = opt.filter;
+	if (!opt.mtimeCache) opt.mtimeCache = /* @__PURE__ */ new Map();
+	opt.filter = filter ? (path, stat) => filter(path, stat) && !((opt.mtimeCache?.get(path) ?? stat.mtime ?? 0) > (stat.mtime ?? 0)) : (path, stat) => !((opt.mtimeCache?.get(path) ?? stat.mtime ?? 0) > (stat.mtime ?? 0));
+};
+//#endregion
+export { extract };
+
+//# sourceMappingURL=esm-BlS2QDIo.js.map