scream-code 0.18.6 → 0.18.7

package/dist/{src-C7C9e5Ds.mjs → src-CQwXASmd.mjs}

@@ -3,11 +3,22 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { createHash } from "node:crypto";
-import { mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
-import { createReadStream, existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+import ro, { mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import I from "fs";
+import Qr, { EventEmitter } from "events";
+import js, { dirname, parse } from "path";
+import { Buffer as Buffer$1 } from "buffer";
+import Cs from "node:stream";
+import Kt, { createReadStream, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
+import path, { basename, join, posix, win32 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { EventEmitter as EventEmitter$1 } from "node:events";
+import { StringDecoder } from "node:string_decoder";
+import zi from "assert";
+import * as Ps from "zlib";
+import en from "zlib";
+import co from "node:assert";
 //#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -140,7 +151,7 @@ const relative$1 = function(from, to) {
 	}
 	return [..._from.map(() => ".."), ..._to].join("/");
 };
-const dirname$1 = function(p) {
+const dirname$2 = function(p) {
 	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
 	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
 	return segments.join("/") || (isAbsolute$1(p) ? "/" : ".");
@@ -157,13 +168,13 @@ const basename$1 = function(p, extension) {
 	}
 	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
-const parse = function(p) {
+const parse$1 = function(p) {
 	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
 	const base = basename$1(p);
 	const extension = extname$1(base);
 	return {
 		root,
-		dir: dirname$1(p),
+		dir: dirname$2(p),
 		base,
 		ext: extension,
 		name: base.slice(0, base.length - extension.length)
@@ -487,6 +498,3022 @@ function toSummary(memo) {
 	};
 }
 //#endregion
+//#region ../../node_modules/.pnpm/tar@7.5.22/node_modules/tar/dist/esm/index.min.js
+var zr = Object.defineProperty;
+var Ur = (s, t) => {
+	for (var e in t) zr(s, e, {
+		get: t[e],
+		enumerable: !0
+	});
+};
+var Ds = typeof process == "object" && process ? process : {
+	stdout: null,
+	stderr: null
+}, Wr = (s) => !!s && typeof s == "object" && (s instanceof A || s instanceof Cs || Gr(s) || Zr(s)), Gr = (s) => !!s && typeof s == "object" && s instanceof EventEmitter$1 && typeof s.pipe == "function" && s.pipe !== Cs.Writable.prototype.pipe, Zr = (s) => !!s && typeof s == "object" && s instanceof EventEmitter$1 && typeof s.write == "function" && typeof s.end == "function", Q = Symbol("EOF"), J = Symbol("maybeEmitEnd"), nt = Symbol("emittedEnd"), De = Symbol("emittingEnd"), qt = Symbol("emittedError"), Ne = Symbol("closed"), Ns = Symbol("read"), Ae = Symbol("flush"), As = Symbol("flushChunk"), z = Symbol("encoding"), Mt = Symbol("decoder"), g = Symbol("flowing"), Qt = Symbol("paused"), Bt = Symbol("resume"), b = Symbol("buffer"), N = Symbol("pipes"), _ = Symbol("bufferLength"), bi = Symbol("bufferPush"), Ie = Symbol("bufferShift"), L = Symbol("objectMode"), S = Symbol("destroyed"), _i = Symbol("error"), Oi = Symbol("emitData"), Is = Symbol("emitEnd"), Ti = Symbol("emitEnd2"), Z = Symbol("async"), xi = Symbol("abort"), Ce = Symbol("aborted"), Jt = Symbol("signal"), Rt = Symbol("dataListeners"), C = Symbol("discarded"), jt = (s) => Promise.resolve().then(s), Yr = (s) => s(), Kr = (s) => s === "end" || s === "finish" || s === "prefinish", Vr = (s) => s instanceof ArrayBuffer || !!s && typeof s == "object" && s.constructor && s.constructor.name === "ArrayBuffer" && s.byteLength >= 0, $r = (s) => !Buffer.isBuffer(s) && ArrayBuffer.isView(s), Fe = class {
+	src;
+	dest;
+	opts;
+	ondrain;
+	constructor(t, e, i) {
+		this.src = t, this.dest = e, this.opts = i, this.ondrain = () => t[Bt](), this.dest.on("drain", this.ondrain);
+	}
+	unpipe() {
+		this.dest.removeListener("drain", this.ondrain);
+	}
+	proxyErrors(t) {}
+	end() {
+		this.unpipe(), this.opts.end && this.dest.end();
+	}
+}, Li = class extends Fe {
+	unpipe() {
+		this.src.removeListener("error", this.proxyErrors), super.unpipe();
+	}
+	constructor(t, e, i) {
+		super(t, e, i), this.proxyErrors = (r) => this.dest.emit("error", r), t.on("error", this.proxyErrors);
+	}
+}, Xr = (s) => !!s.objectMode, qr = (s) => !s.objectMode && !!s.encoding && s.encoding !== "buffer", A = class extends EventEmitter$1 {
+	[g] = !1;
+	[Qt] = !1;
+	[N] = [];
+	[b] = [];
+	[L];
+	[z];
+	[Z];
+	[Mt];
+	[Q] = !1;
+	[nt] = !1;
+	[De] = !1;
+	[Ne] = !1;
+	[qt] = null;
+	[_] = 0;
+	[S] = !1;
+	[Jt];
+	[Ce] = !1;
+	[Rt] = 0;
+	[C] = !1;
+	writable = !0;
+	readable = !0;
+	constructor(...t) {
+		let e = t[0] || {};
+		if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
+		Xr(e) ? (this[L] = !0, this[z] = null) : qr(e) ? (this[z] = e.encoding, this[L] = !1) : (this[L] = !1, this[z] = null), this[Z] = !!e.async, this[Mt] = this[z] ? new StringDecoder(this[z]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[b] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[N] });
+		let { signal: i } = e;
+		i && (this[Jt] = i, i.aborted ? this[xi]() : i.addEventListener("abort", () => this[xi]()));
+	}
+	get bufferLength() {
+		return this[_];
+	}
+	get encoding() {
+		return this[z];
+	}
+	set encoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	setEncoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	get objectMode() {
+		return this[L];
+	}
+	set objectMode(t) {
+		throw new Error("objectMode must be set at instantiation time");
+	}
+	get async() {
+		return this[Z];
+	}
+	set async(t) {
+		this[Z] = this[Z] || !!t;
+	}
+	[xi]() {
+		this[Ce] = !0, this.emit("abort", this[Jt]?.reason), this.destroy(this[Jt]?.reason);
+	}
+	get aborted() {
+		return this[Ce];
+	}
+	set aborted(t) {}
+	write(t, e, i) {
+		if (this[Ce]) return !1;
+		if (this[Q]) throw new Error("write after end");
+		if (this[S]) return this.emit("error", Object.assign(/* @__PURE__ */ new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+		typeof e == "function" && (i = e, e = "utf8"), e || (e = "utf8");
+		let r = this[Z] ? jt : Yr;
+		if (!this[L] && !Buffer.isBuffer(t)) {
+			if ($r(t)) t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+			else if (Vr(t)) t = Buffer.from(t);
+			else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+		}
+		return this[L] ? (this[g] && this[_] !== 0 && this[Ae](!0), this[g] ? this.emit("data", t) : this[bi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : t.length ? (typeof t == "string" && !(e === this[z] && !this[Mt]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[z] && (t = this[Mt].write(t)), this[g] && this[_] !== 0 && this[Ae](!0), this[g] ? this.emit("data", t) : this[bi](t), this[_] !== 0 && this.emit("readable"), i && r(i), this[g]) : (this[_] !== 0 && this.emit("readable"), i && r(i), this[g]);
+	}
+	read(t) {
+		if (this[S]) return null;
+		if (this[C] = !1, this[_] === 0 || t === 0 || t && t > this[_]) return this[J](), null;
+		this[L] && (t = null), this[b].length > 1 && !this[L] && (this[b] = [this[z] ? this[b].join("") : Buffer.concat(this[b], this[_])]);
+		let e = this[Ns](t || null, this[b][0]);
+		return this[J](), e;
+	}
+	[Ns](t, e) {
+		if (this[L]) this[Ie]();
+		else {
+			let i = e;
+			t === i.length || t === null ? this[Ie]() : typeof i == "string" ? (this[b][0] = i.slice(t), e = i.slice(0, t), this[_] -= t) : (this[b][0] = i.subarray(t), e = i.subarray(0, t), this[_] -= t);
+		}
+		return this.emit("data", e), !this[b].length && !this[Q] && this.emit("drain"), e;
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, t = void 0), typeof e == "function" && (i = e, e = "utf8"), t !== void 0 && this.write(t, e), i && this.once("end", i), this[Q] = !0, this.writable = !1, (this[g] || !this[Qt]) && this[J](), this;
+	}
+	[Bt]() {
+		this[S] || (!this[Rt] && !this[N].length && (this[C] = !0), this[Qt] = !1, this[g] = !0, this.emit("resume"), this[b].length ? this[Ae]() : this[Q] ? this[J]() : this.emit("drain"));
+	}
+	resume() {
+		return this[Bt]();
+	}
+	pause() {
+		this[g] = !1, this[Qt] = !0, this[C] = !1;
+	}
+	get destroyed() {
+		return this[S];
+	}
+	get flowing() {
+		return this[g];
+	}
+	get paused() {
+		return this[Qt];
+	}
+	[bi](t) {
+		this[L] ? this[_] += 1 : this[_] += t.length, this[b].push(t);
+	}
+	[Ie]() {
+		return this[L] ? this[_] -= 1 : this[_] -= this[b][0].length, this[b].shift();
+	}
+	[Ae](t = !1) {
+		do		;
+while (this[As](this[Ie]()) && this[b].length);
+		!t && !this[b].length && !this[Q] && this.emit("drain");
+	}
+	[As](t) {
+		return this.emit("data", t), this[g];
+	}
+	pipe(t, e) {
+		if (this[S]) return t;
+		this[C] = !1;
+		let i = this[nt];
+		return e = e || {}, t === Ds.stdout || t === Ds.stderr ? e.end = !1 : e.end = e.end !== !1, e.proxyErrors = !!e.proxyErrors, i ? e.end && t.end() : (this[N].push(e.proxyErrors ? new Li(this, t, e) : new Fe(this, t, e)), this[Z] ? jt(() => this[Bt]()) : this[Bt]()), t;
+	}
+	unpipe(t) {
+		let e = this[N].find((i) => i.dest === t);
+		e && (this[N].length === 1 ? (this[g] && this[Rt] === 0 && (this[g] = !1), this[N] = []) : this[N].splice(this[N].indexOf(e), 1), e.unpipe());
+	}
+	addListener(t, e) {
+		return this.on(t, e);
+	}
+	on(t, e) {
+		let i = super.on(t, e);
+		if (t === "data") this[C] = !1, this[Rt]++, !this[N].length && !this[g] && this[Bt]();
+		else if (t === "readable" && this[_] !== 0) super.emit("readable");
+		else if (Kr(t) && this[nt]) super.emit(t), this.removeAllListeners(t);
+		else if (t === "error" && this[qt]) {
+			let r = e;
+			this[Z] ? jt(() => r.call(this, this[qt])) : r.call(this, this[qt]);
+		}
+		return i;
+	}
+	removeListener(t, e) {
+		return this.off(t, e);
+	}
+	off(t, e) {
+		let i = super.off(t, e);
+		return t === "data" && (this[Rt] = this.listeners("data").length, this[Rt] === 0 && !this[C] && !this[N].length && (this[g] = !1)), i;
+	}
+	removeAllListeners(t) {
+		let e = super.removeAllListeners(t);
+		return (t === "data" || t === void 0) && (this[Rt] = 0, !this[C] && !this[N].length && (this[g] = !1)), e;
+	}
+	get emittedEnd() {
+		return this[nt];
+	}
+	[J]() {
+		!this[De] && !this[nt] && !this[S] && this[b].length === 0 && this[Q] && (this[De] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[Ne] && this.emit("close"), this[De] = !1);
+	}
+	emit(t, ...e) {
+		let i = e[0];
+		if (t !== "error" && t !== "close" && t !== S && this[S]) return !1;
+		if (t === "data") return !this[L] && !i ? !1 : this[Z] ? (jt(() => this[Oi](i)), !0) : this[Oi](i);
+		if (t === "end") return this[Is]();
+		if (t === "close") {
+			if (this[Ne] = !0, !this[nt] && !this[S]) return !1;
+			let n = super.emit("close");
+			return this.removeAllListeners("close"), n;
+		} else if (t === "error") {
+			this[qt] = i, super.emit(_i, i);
+			let n = !this[Jt] || this.listeners("error").length ? super.emit("error", i) : !1;
+			return this[J](), n;
+		} else if (t === "resume") {
+			let n = super.emit("resume");
+			return this[J](), n;
+		} else if (t === "finish" || t === "prefinish") {
+			let n = super.emit(t);
+			return this.removeAllListeners(t), n;
+		}
+		let r = super.emit(t, ...e);
+		return this[J](), r;
+	}
+	[Oi](t) {
+		for (let i of this[N]) i.dest.write(t) === !1 && this.pause();
+		let e = this[C] ? !1 : super.emit("data", t);
+		return this[J](), e;
+	}
+	[Is]() {
+		return this[nt] ? !1 : (this[nt] = !0, this.readable = !1, this[Z] ? (jt(() => this[Ti]()), !0) : this[Ti]());
+	}
+	[Ti]() {
+		if (this[Mt]) {
+			let e = this[Mt].end();
+			if (e) {
+				for (let i of this[N]) i.dest.write(e);
+				this[C] || super.emit("data", e);
+			}
+		}
+		for (let e of this[N]) e.end();
+		let t = super.emit("end");
+		return this.removeAllListeners("end"), t;
+	}
+	async collect() {
+		let t = Object.assign([], { dataLength: 0 });
+		this[L] || (t.dataLength = 0);
+		let e = this.promise();
+		return this.on("data", (i) => {
+			t.push(i), this[L] || (t.dataLength += i.length);
+		}), await e, t;
+	}
+	async concat() {
+		if (this[L]) throw new Error("cannot concat in objectMode");
+		let t = await this.collect();
+		return this[z] ? t.join("") : Buffer.concat(t, t.dataLength);
+	}
+	async promise() {
+		return new Promise((t, e) => {
+			this.on(S, () => e(/* @__PURE__ */ new Error("stream destroyed"))), this.on("error", (i) => e(i)), this.on("end", () => t());
+		});
+	}
+	[Symbol.asyncIterator]() {
+		this[C] = !1;
+		let t = !1, e = async () => (this.pause(), t = !0, {
+			value: void 0,
+			done: !0
+		});
+		return {
+			next: () => {
+				if (t) return e();
+				let r = this.read();
+				if (r !== null) return Promise.resolve({
+					done: !1,
+					value: r
+				});
+				if (this[Q]) return e();
+				let n, o, h = (d) => {
+					this.off("data", a), this.off("end", l), this.off(S, c), e(), o(d);
+				}, a = (d) => {
+					this.off("error", h), this.off("end", l), this.off(S, c), this.pause(), n({
+						value: d,
+						done: !!this[Q]
+					});
+				}, l = () => {
+					this.off("error", h), this.off("data", a), this.off(S, c), e(), n({
+						done: !0,
+						value: void 0
+					});
+				}, c = () => h(/* @__PURE__ */ new Error("stream destroyed"));
+				return new Promise((d, y) => {
+					o = y, n = d, this.once(S, c), this.once("error", h), this.once("end", l), this.once("data", a);
+				});
+			},
+			throw: e,
+			return: e,
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			[Symbol.asyncDispose]: async () => {}
+		};
+	}
+	[Symbol.iterator]() {
+		this[C] = !1;
+		let t = !1, e = () => (this.pause(), this.off(_i, e), this.off(S, e), this.off("end", e), t = !0, {
+			done: !0,
+			value: void 0
+		}), i = () => {
+			if (t) return e();
+			let r = this.read();
+			return r === null ? e() : {
+				done: !1,
+				value: r
+			};
+		};
+		return this.once("end", e), this.once(_i, e), this.once(S, e), {
+			next: i,
+			throw: e,
+			return: e,
+			[Symbol.iterator]() {
+				return this;
+			},
+			[Symbol.dispose]: () => {}
+		};
+	}
+	destroy(t) {
+		if (this[S]) return t ? this.emit("error", t) : this.emit(S), this;
+		this[S] = !0, this[C] = !0, this[b].length = 0, this[_] = 0;
+		let e = this;
+		return typeof e.close == "function" && !this[Ne] && e.close(), t ? this.emit("error", t) : this.emit(S), this;
+	}
+	static get isStream() {
+		return Wr;
+	}
+};
+var Jr = I.writev, ht = Symbol("_autoClose"), H = Symbol("_close"), te = Symbol("_ended"), m = Symbol("_fd"), Ni = Symbol("_finished"), tt = Symbol("_flags"), Ai = Symbol("_flush"), ki = Symbol("_handleChunk"), vi = Symbol("_makeBuf"), ie = Symbol("_mode"), ke = Symbol("_needDrain"), Ut = Symbol("_onerror"), Ht = Symbol("_onopen"), Ii = Symbol("_onread"), Pt = Symbol("_onwrite"), at = Symbol("_open"), U = Symbol("_path"), ot = Symbol("_pos"), Y = Symbol("_queue"), zt = Symbol("_read"), Ci = Symbol("_readSize"), j = Symbol("_reading"), ee = Symbol("_remain"), Fi = Symbol("_size"), ve = Symbol("_write"), gt = Symbol("_writing"), Me = Symbol("_defaultFlag"), bt = Symbol("_errored"), _t = class extends A {
+	[bt] = !1;
+	[m];
+	[U];
+	[Ci];
+	[j] = !1;
+	[Fi];
+	[ee];
+	[ht];
+	constructor(t, e) {
+		if (e = e || {}, super(e), this.readable = !0, this.writable = !1, typeof t != "string") throw new TypeError("path must be a string");
+		this[bt] = !1, this[m] = typeof e.fd == "number" ? e.fd : void 0, this[U] = t, this[Ci] = e.readSize || 16 * 1024 * 1024, this[j] = !1, this[Fi] = typeof e.size == "number" ? e.size : Infinity, this[ee] = this[Fi], this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : !0, typeof this[m] == "number" ? this[zt]() : this[at]();
+	}
+	get fd() {
+		return this[m];
+	}
+	get path() {
+		return this[U];
+	}
+	write() {
+		throw new TypeError("this is a readable stream");
+	}
+	end() {
+		throw new TypeError("this is a readable stream");
+	}
+	[at]() {
+		I.open(this[U], "r", (t, e) => this[Ht](t, e));
+	}
+	[Ht](t, e) {
+		t ? this[Ut](t) : (this[m] = e, this.emit("open", e), this[zt]());
+	}
+	[vi]() {
+		return Buffer.allocUnsafe(Math.min(this[Ci], this[ee]));
+	}
+	[zt]() {
+		if (!this[j]) {
+			this[j] = !0;
+			let t = this[vi]();
+			if (t.length === 0) return process.nextTick(() => this[Ii](null, 0, t));
+			I.read(this[m], t, 0, t.length, null, (e, i, r) => this[Ii](e, i, r));
+		}
+	}
+	[Ii](t, e, i) {
+		this[j] = !1, t ? this[Ut](t) : this[ki](e, i) && this[zt]();
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
+		}
+	}
+	[Ut](t) {
+		this[j] = !0, this[H](), this.emit("error", t);
+	}
+	[ki](t, e) {
+		let i = !1;
+		return this[ee] -= t, t > 0 && (i = super.write(t < e.length ? e.subarray(0, t) : e)), (t === 0 || this[ee] <= 0) && (i = !1, this[H](), super.end()), i;
+	}
+	emit(t, ...e) {
+		switch (t) {
+			case "prefinish":
+			case "finish": return !1;
+			case "drain": return typeof this[m] == "number" && this[zt](), !1;
+			case "error": return this[bt] ? !1 : (this[bt] = !0, super.emit(t, ...e));
+			default: return super.emit(t, ...e);
+		}
+	}
+}, Be = class extends _t {
+	[at]() {
+		let t = !0;
+		try {
+			this[Ht](null, I.openSync(this[U], "r")), t = !1;
+		} finally {
+			t && this[H]();
+		}
+	}
+	[zt]() {
+		let t = !0;
+		try {
+			if (!this[j]) {
+				this[j] = !0;
+				do {
+					let e = this[vi](), i = e.length === 0 ? 0 : I.readSync(this[m], e, 0, e.length, null);
+					if (!this[ki](i, e)) break;
+				} while (!0);
+				this[j] = !1;
+			}
+			t = !1;
+		} finally {
+			t && this[H]();
+		}
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.closeSync(t), this.emit("close");
+		}
+	}
+}, et = class extends Qr {
+	readable = !1;
+	writable = !0;
+	[bt] = !1;
+	[gt] = !1;
+	[te] = !1;
+	[Y] = [];
+	[ke] = !1;
+	[U];
+	[ie];
+	[ht];
+	[m];
+	[Me];
+	[tt];
+	[Ni] = !1;
+	[ot];
+	constructor(t, e) {
+		e = e || {}, super(e), this[U] = t, this[m] = typeof e.fd == "number" ? e.fd : void 0, this[ie] = e.mode === void 0 ? 438 : e.mode, this[ot] = typeof e.start == "number" ? e.start : void 0, this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : !0;
+		let i = this[ot] !== void 0 ? "r+" : "w";
+		this[Me] = e.flags === void 0, this[tt] = e.flags === void 0 ? i : e.flags, this[m] === void 0 && this[at]();
+	}
+	emit(t, ...e) {
+		if (t === "error") {
+			if (this[bt]) return !1;
+			this[bt] = !0;
+		}
+		return super.emit(t, ...e);
+	}
+	get fd() {
+		return this[m];
+	}
+	get path() {
+		return this[U];
+	}
+	[Ut](t) {
+		this[H](), this[gt] = !0, this.emit("error", t);
+	}
+	[at]() {
+		I.open(this[U], this[tt], this[ie], (t, e) => this[Ht](t, e));
+	}
+	[Ht](t, e) {
+		this[Me] && this[tt] === "r+" && t && t.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t ? this[Ut](t) : (this[m] = e, this.emit("open", e), this[gt] || this[Ai]());
+	}
+	end(t, e) {
+		return t && this.write(t, e), this[te] = !0, !this[gt] && !this[Y].length && typeof this[m] == "number" && this[Pt](null, 0), this;
+	}
+	write(t, e) {
+		return typeof t == "string" && (t = Buffer.from(t, e)), this[te] ? (this.emit("error", /* @__PURE__ */ new Error("write() after end()")), !1) : this[m] === void 0 || this[gt] || this[Y].length ? (this[Y].push(t), this[ke] = !0, !1) : (this[gt] = !0, this[ve](t), !0);
+	}
+	[ve](t) {
+		I.write(this[m], t, 0, t.length, this[ot], (e, i) => this[Pt](e, i));
+	}
+	[Pt](t, e) {
+		t ? this[Ut](t) : (this[ot] !== void 0 && typeof e == "number" && (this[ot] += e), this[Y].length ? this[Ai]() : (this[gt] = !1, this[te] && !this[Ni] ? (this[Ni] = !0, this[H](), this.emit("finish")) : this[ke] && (this[ke] = !1, this.emit("drain"))));
+	}
+	[Ai]() {
+		if (this[Y].length === 0) this[te] && this[Pt](null, 0);
+		else if (this[Y].length === 1) this[ve](this[Y].pop());
+		else {
+			let t = this[Y];
+			this[Y] = [], Jr(this[m], t, this[ot], (e, i) => this[Pt](e, i));
+		}
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
+		}
+	}
+}, Wt = class extends et {
+	[at]() {
+		let t;
+		if (this[Me] && this[tt] === "r+") try {
+			t = I.openSync(this[U], this[tt], this[ie]);
+		} catch (e) {
+			if (e?.code === "ENOENT") return this[tt] = "w", this[at]();
+			throw e;
+		}
+		else t = I.openSync(this[U], this[tt], this[ie]);
+		this[Ht](null, t);
+	}
+	[H]() {
+		if (this[ht] && typeof this[m] == "number") {
+			let t = this[m];
+			this[m] = void 0, I.closeSync(t), this.emit("close");
+		}
+	}
+	[ve](t) {
+		let e = !0;
+		try {
+			this[Pt](null, I.writeSync(this[m], t, 0, t.length, this[ot])), e = !1;
+		} finally {
+			if (e) try {
+				this[H]();
+			} catch {}
+		}
+	}
+};
+var jr = 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"]
+]), Fs = (s) => !!s.sync && !!s.file, ks = (s) => !s.sync && !!s.file, vs = (s) => !!s.sync && !s.file, Ms = (s) => !s.sync && !s.file;
+var Bs = (s) => !!s.file;
+var tn = (s) => {
+	return jr.get(s) || s;
+}, se = (s = {}) => {
+	if (!s) return {};
+	let t = {};
+	for (let [e, i] of Object.entries(s)) {
+		let r = tn(e);
+		t[r] = i;
+	}
+	return t.chmod === void 0 && t.noChmod === !1 && (t.chmod = !0), delete t.noChmod, t;
+};
+var K = (s, t, e, i, r) => Object.assign((n = [], o, h) => {
+	Array.isArray(n) && (o = n, n = {}), typeof o == "function" && (h = o, o = void 0), o = o ? Array.from(o) : [];
+	let a = se(n);
+	if (r?.(a, o), Fs(a)) {
+		if (typeof h == "function") throw new TypeError("callback not supported for sync tar functions");
+		return s(a, o);
+	} else if (ks(a)) {
+		let l = t(a, o);
+		return h ? l.then(() => h(), h) : l;
+	} else if (vs(a)) {
+		if (typeof h == "function") throw new TypeError("callback not supported for sync tar functions");
+		return e(a, o);
+	} else if (Ms(a)) {
+		if (typeof h == "function") throw new TypeError("callback only supported with file option");
+		return i(a, o);
+	}
+	throw new Error("impossible options??");
+}, {
+	syncFile: s,
+	asyncFile: t,
+	syncNoFile: e,
+	asyncNoFile: i,
+	validate: r
+});
+var sn = en.constants || { ZLIB_VERNUM: 4736 }, M = Object.freeze(Object.assign(Object.create(null), {
+	Z_NO_FLUSH: 0,
+	Z_PARTIAL_FLUSH: 1,
+	Z_SYNC_FLUSH: 2,
+	Z_FULL_FLUSH: 3,
+	Z_FINISH: 4,
+	Z_BLOCK: 5,
+	Z_OK: 0,
+	Z_STREAM_END: 1,
+	Z_NEED_DICT: 2,
+	Z_ERRNO: -1,
+	Z_STREAM_ERROR: -2,
+	Z_DATA_ERROR: -3,
+	Z_MEM_ERROR: -4,
+	Z_BUF_ERROR: -5,
+	Z_VERSION_ERROR: -6,
+	Z_NO_COMPRESSION: 0,
+	Z_BEST_SPEED: 1,
+	Z_BEST_COMPRESSION: 9,
+	Z_DEFAULT_COMPRESSION: -1,
+	Z_FILTERED: 1,
+	Z_HUFFMAN_ONLY: 2,
+	Z_RLE: 3,
+	Z_FIXED: 4,
+	Z_DEFAULT_STRATEGY: 0,
+	DEFLATE: 1,
+	INFLATE: 2,
+	GZIP: 3,
+	GUNZIP: 4,
+	DEFLATERAW: 5,
+	INFLATERAW: 6,
+	UNZIP: 7,
+	BROTLI_DECODE: 8,
+	BROTLI_ENCODE: 9,
+	Z_MIN_WINDOWBITS: 8,
+	Z_MAX_WINDOWBITS: 15,
+	Z_DEFAULT_WINDOWBITS: 15,
+	Z_MIN_CHUNK: 64,
+	Z_MAX_CHUNK: 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
+}, sn));
+var rn = Buffer$1.concat, zs = Object.getOwnPropertyDescriptor(Buffer$1, "concat"), nn = (s) => s, Bi = zs?.writable === !0 || zs?.set !== void 0 ? (s) => {
+	Buffer$1.concat = s ? nn : rn;
+} : (s) => {}, Tt = Symbol("_superWrite"), Gt = class extends Error {
+	code;
+	errno;
+	constructor(t, e) {
+		super("zlib: " + t.message, { cause: t }), this.code = t.code, this.errno = t.errno, this.code || (this.code = "ZLIB_ERROR"), this.message = "zlib: " + t.message, Error.captureStackTrace(this, e ?? this.constructor);
+	}
+	get name() {
+		return "ZlibError";
+	}
+}, Pi = Symbol("flushFlag"), re = class extends A {
+	#t = !1;
+	#i = !1;
+	#s;
+	#n;
+	#r;
+	#e;
+	#o;
+	get sawError() {
+		return this.#t;
+	}
+	get handle() {
+		return this.#e;
+	}
+	get flushFlag() {
+		return this.#s;
+	}
+	constructor(t, e) {
+		if (!t || typeof t != "object") throw new TypeError("invalid options for ZlibBase constructor");
+		if (super(t), this.#s = t.flush ?? 0, this.#n = t.finishFlush ?? 0, this.#r = t.fullFlushFlag ?? 0, typeof Ps[e] != "function") throw new TypeError("Compression method not supported: " + e);
+		try {
+			this.#e = new Ps[e](t);
+		} catch (i) {
+			throw new Gt(i, this.constructor);
+		}
+		this.#o = (i) => {
+			this.#t || (this.#t = !0, this.close(), this.emit("error", i));
+		}, this.#e?.on("error", (i) => this.#o(new Gt(i))), this.once("end", () => this.close);
+	}
+	close() {
+		this.#e && (this.#e.close(), this.#e = void 0, this.emit("close"));
+	}
+	reset() {
+		if (!this.#t) return zi(this.#e, "zlib binding closed"), this.#e.reset?.();
+	}
+	flush(t) {
+		this.ended || (typeof t != "number" && (t = this.#r), this.write(Object.assign(Buffer$1.alloc(0), { [Pi]: t })));
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, e = void 0, t = void 0), typeof e == "function" && (i = e, e = void 0), t && (e ? this.write(t, e) : this.write(t)), this.flush(this.#n), this.#i = !0, super.end(i);
+	}
+	get ended() {
+		return this.#i;
+	}
+	[Tt](t) {
+		return super.write(t);
+	}
+	write(t, e, i) {
+		if (typeof e == "function" && (i = e, e = "utf8"), typeof t == "string" && (t = Buffer$1.from(t, e)), this.#t) return;
+		zi(this.#e, "zlib binding closed");
+		let r = this.#e._handle, n = r.close;
+		r.close = () => {};
+		let o = this.#e.close;
+		this.#e.close = () => {}, Bi(!0);
+		let h;
+		try {
+			let l = typeof t[Pi] == "number" ? t[Pi] : this.#s;
+			h = this.#e._processChunk(t, l), Bi(!1);
+		} catch (l) {
+			Bi(!1), this.#o(new Gt(l, this.write));
+		} finally {
+			this.#e && (this.#e._handle = r, r.close = n, this.#e.close = o, this.#e.removeAllListeners("error"));
+		}
+		this.#e && this.#e.on("error", (l) => this.#o(new Gt(l, this.write)));
+		let a;
+		if (h) if (Array.isArray(h) && h.length > 0) {
+			let l = h[0];
+			a = this[Tt](Buffer$1.from(l));
+			for (let c = 1; c < h.length; c++) a = this[Tt](h[c]);
+		} else a = this[Tt](Buffer$1.from(h));
+		return i && i(), a;
+	}
+}, Pe = class extends re {
+	#t;
+	#i;
+	constructor(t, e) {
+		t = t || {}, t.flush = t.flush || M.Z_NO_FLUSH, t.finishFlush = t.finishFlush || M.Z_FINISH, t.fullFlushFlag = M.Z_FULL_FLUSH, super(t, e), this.#t = t.level, this.#i = t.strategy;
+	}
+	params(t, e) {
+		if (!this.sawError) {
+			if (!this.handle) throw new Error("cannot switch params when binding is closed");
+			if (!this.handle.params) throw new Error("not supported in this implementation");
+			if (this.#t !== t || this.#i !== e) {
+				this.flush(M.Z_SYNC_FLUSH), zi(this.handle, "zlib binding closed");
+				let i = this.handle.flush;
+				this.handle.flush = (r, n) => {
+					typeof r == "function" && (n = r, r = this.flushFlag), this.flush(r), n?.();
+				};
+				try {
+					this.handle.params(t, e);
+				} finally {
+					this.handle.flush = i;
+				}
+				this.handle && (this.#t = t, this.#i = e);
+			}
+		}
+	}
+};
+var ze = class extends Pe {
+	#t;
+	constructor(t) {
+		super(t, "Gzip"), this.#t = t && !!t.portable;
+	}
+	[Tt](t) {
+		return this.#t ? (this.#t = !1, t[9] = 255, super[Tt](t)) : super[Tt](t);
+	}
+};
+var Ue = class extends Pe {
+	constructor(t) {
+		super(t, "Unzip");
+	}
+}, He = class extends re {
+	constructor(t, e) {
+		t = t || {}, t.flush = t.flush || M.BROTLI_OPERATION_PROCESS, t.finishFlush = t.finishFlush || M.BROTLI_OPERATION_FINISH, t.fullFlushFlag = M.BROTLI_OPERATION_FLUSH, super(t, e);
+	}
+}, We = class extends He {
+	constructor(t) {
+		super(t, "BrotliCompress");
+	}
+}, Ge = class extends He {
+	constructor(t) {
+		super(t, "BrotliDecompress");
+	}
+}, Ze = class extends re {
+	constructor(t, e) {
+		t = t || {}, t.flush = t.flush || M.ZSTD_e_continue, t.finishFlush = t.finishFlush || M.ZSTD_e_end, t.fullFlushFlag = M.ZSTD_e_flush, super(t, e);
+	}
+}, Ye = class extends Ze {
+	constructor(t) {
+		super(t, "ZstdCompress");
+	}
+}, Ke = class extends Ze {
+	constructor(t) {
+		super(t, "ZstdDecompress");
+	}
+};
+var Us = (s, t) => {
+	if (Number.isSafeInteger(s)) s < 0 ? an(s, t) : hn(s, t);
+	else throw Error("cannot encode number outside of javascript safe integer range");
+	return t;
+}, hn = (s, t) => {
+	t[0] = 128;
+	for (var e = t.length; e > 1; e--) t[e - 1] = s & 255, s = Math.floor(s / 256);
+}, an = (s, t) => {
+	t[0] = 255;
+	var e = !1;
+	s = s * -1;
+	for (var i = t.length; i > 1; i--) {
+		var r = s & 255;
+		s = Math.floor(s / 256), e ? t[i - 1] = Ws(r) : r === 0 ? t[i - 1] = 0 : (e = !0, t[i - 1] = Gs(r));
+	}
+}, Hs = (s) => {
+	let t = s[0], e = t === 128 ? cn(s.subarray(1, s.length)) : t === 255 ? ln(s) : null;
+	if (e === null) throw Error("invalid base256 encoding");
+	if (!Number.isSafeInteger(e)) throw Error("parsed number outside of javascript safe integer range");
+	return e;
+}, ln = (s) => {
+	for (var t = s.length, e = 0, i = !1, r = t - 1; r > -1; r--) {
+		var n = Number(s[r]), o;
+		i ? o = Ws(n) : n === 0 ? o = n : (i = !0, o = Gs(n)), o !== 0 && (e -= o * Math.pow(256, t - r - 1));
+	}
+	return e;
+}, cn = (s) => {
+	for (var t = s.length, e = 0, i = t - 1; i > -1; i--) {
+		var r = Number(s[i]);
+		r !== 0 && (e += r * Math.pow(256, t - i - 1));
+	}
+	return e;
+}, Ws = (s) => (255 ^ s) & 255, Gs = (s) => (255 ^ s) + 1 & 255;
+Ur({}, {
+	code: () => Ve,
+	isCode: () => ne,
+	isName: () => dn,
+	name: () => oe,
+	normalFsTypes: () => Ui
+});
+var ne = (s) => oe.has(s), dn = (s) => Ve.has(s), Ui = new Set([
+	"0",
+	"",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"D"
+]), oe = 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"]
+]), Ve = new Map(Array.from(oe).map((s) => [s[1], s[0]]));
+var un = (s) => s === void 0 || s < 0 ? void 0 : s, F = class {
+	cksumValid = !1;
+	needPax = !1;
+	nullBlock = !1;
+	block;
+	path;
+	mode;
+	uid;
+	gid;
+	size;
+	cksum;
+	#t = "Unsupported";
+	linkpath;
+	uname;
+	gname;
+	devmaj = 0;
+	devmin = 0;
+	atime;
+	ctime;
+	mtime;
+	charset;
+	comment;
+	constructor(t, e = 0, i, r) {
+		Buffer.isBuffer(t) ? this.decode(t, e || 0, i, r) : t && this.#i(t);
+	}
+	decode(t, e, i, r) {
+		if (e || (e = 0), !t || !(t.length >= e + 512)) throw new Error("need 512 bytes for header");
+		let n = xt(t, e + 156, 1), o = Ui.has(n), h = o ? i : void 0, a = o ? r : void 0;
+		if (this.path = h?.path ?? xt(t, e, 100), this.mode = h?.mode ?? a?.mode ?? lt(t, e + 100, 8), this.uid = h?.uid ?? a?.uid ?? lt(t, e + 108, 8), this.gid = h?.gid ?? a?.gid ?? lt(t, e + 116, 8), this.size = un(h?.size ?? a?.size ?? lt(t, e + 124, 12)), this.mtime = h?.mtime ?? a?.mtime ?? Wi(t, e + 136, 12), this.cksum = lt(t, e + 148, 12), a && this.#i(a, !0), h && this.#i(h), ne(n) && (this.#t = n || "0"), this.#t === "0" && this.path.slice(-1) === "/" && (this.#t = "5"), this.#t === "5" && (this.size = 0), this.linkpath = xt(t, e + 157, 100), t.subarray(e + 257, e + 265).toString() === "ustar\x0000") if (this.uname = h?.uname ?? a?.uname ?? xt(t, e + 265, 32), this.gname = h?.gname ?? a?.gname ?? xt(t, e + 297, 32), this.devmaj = h?.devmaj ?? a?.devmaj ?? lt(t, e + 329, 8) ?? 0, this.devmin = h?.devmin ?? a?.devmin ?? lt(t, e + 337, 8) ?? 0, t[e + 475] !== 0) {
+			let c = xt(t, e + 345, 155);
+			this.path = c + "/" + this.path;
+		} else {
+			let c = xt(t, e + 345, 130);
+			c && (this.path = c + "/" + this.path), this.atime = i?.atime ?? r?.atime ?? Wi(t, e + 476, 12), this.ctime = i?.ctime ?? r?.ctime ?? Wi(t, e + 488, 12);
+		}
+		let l = 256;
+		for (let c = e; c < e + 148; c++) l += t[c];
+		for (let c = e + 156; c < e + 512; c++) l += t[c];
+		this.cksumValid = l === this.cksum, this.cksum === void 0 && l === 256 && (this.nullBlock = !0);
+	}
+	#i(t, e = !1) {
+		Object.assign(this, Object.fromEntries(Object.entries(t).filter(([i, r]) => !(r == null || i === "size" && Number(r) < 0 || i === "path" && e || i === "linkpath" && e || i === "global"))));
+	}
+	encode(t, e = 0) {
+		if (t || (t = this.block = Buffer.alloc(512)), this.#t === "Unsupported" && (this.#t = "0"), !(t.length >= e + 512)) throw new Error("need 512 bytes for header");
+		let i = this.ctime || this.atime ? 130 : 155, r = mn(this.path || "", i), n = r[0], o = r[1];
+		this.needPax = !!r[2], this.needPax = Lt(t, e, 100, n) || this.needPax, this.needPax = ct(t, e + 100, 8, this.mode) || this.needPax, this.needPax = ct(t, e + 108, 8, this.uid) || this.needPax, this.needPax = ct(t, e + 116, 8, this.gid) || this.needPax, this.needPax = ct(t, e + 124, 12, this.size) || this.needPax, this.needPax = Gi(t, e + 136, 12, this.mtime) || this.needPax, t[e + 156] = Number(this.#t.codePointAt(0)), this.needPax = Lt(t, e + 157, 100, this.linkpath) || this.needPax, t.write("ustar\x0000", e + 257, 8), this.needPax = Lt(t, e + 265, 32, this.uname) || this.needPax, this.needPax = Lt(t, e + 297, 32, this.gname) || this.needPax, this.needPax = ct(t, e + 329, 8, this.devmaj) || this.needPax, this.needPax = ct(t, e + 337, 8, this.devmin) || this.needPax, this.needPax = Lt(t, e + 345, i, o) || this.needPax, t[e + 475] !== 0 ? this.needPax = Lt(t, e + 345, 155, o) || this.needPax : (this.needPax = Lt(t, e + 345, 130, o) || this.needPax, this.needPax = Gi(t, e + 476, 12, this.atime) || this.needPax, this.needPax = Gi(t, e + 488, 12, this.ctime) || this.needPax);
+		let h = 256;
+		for (let a = e; a < e + 148; a++) h += t[a];
+		for (let a = e + 156; a < e + 512; a++) h += t[a];
+		return this.cksum = h, ct(t, e + 148, 8, this.cksum), this.cksumValid = !0, this.needPax;
+	}
+	get type() {
+		return this.#t === "Unsupported" ? this.#t : oe.get(this.#t);
+	}
+	get typeKey() {
+		return this.#t;
+	}
+	set type(t) {
+		let e = String(Ve.get(t));
+		if (ne(e) || e === "Unsupported") this.#t = e;
+		else if (ne(t)) this.#t = t;
+		else throw new TypeError("invalid entry type: " + t);
+	}
+}, mn = (s, t) => {
+	let i = s, r = "", n, o = posix.parse(s).root || ".";
+	if (Buffer.byteLength(i) < 100) n = [
+		i,
+		r,
+		!1
+	];
+	else {
+		r = posix.dirname(i), i = posix.basename(i);
+		do
+			Buffer.byteLength(i) <= 100 && Buffer.byteLength(r) <= t ? n = [
+				i,
+				r,
+				!1
+			] : Buffer.byteLength(i) > 100 && Buffer.byteLength(r) <= t ? n = [
+				i.slice(0, 99),
+				r,
+				!0
+			] : (i = posix.join(posix.basename(r), i), r = posix.dirname(r));
+		while (r !== o && n === void 0);
+		n || (n = [
+			s.slice(0, 99),
+			"",
+			!0
+		]);
+	}
+	return n;
+}, xt = (s, t, e) => s.subarray(t, t + e).toString("utf8").replace(/\0.*/, ""), Wi = (s, t, e) => pn(lt(s, t, e)), pn = (s) => s === void 0 ? void 0 : /* @__PURE__ */ new Date(s * 1e3), lt = (s, t, e) => Number(s[t]) & 128 ? Hs(s.subarray(t, t + e)) : wn(s, t, e), En = (s) => isNaN(s) ? void 0 : s, wn = (s, t, e) => En(parseInt(s.subarray(t, t + e).toString("utf8").replace(/\0.*$/, "").trim(), 8)), Sn = {
+	12: 8589934591,
+	8: 2097151
+}, ct = (s, t, e, i) => i === void 0 ? !1 : i > Sn[e] || i < 0 ? (Us(i, s.subarray(t, t + e)), !0) : (yn(s, t, e, i), !1), yn = (s, t, e, i) => s.write(Rn(i, e), t, e, "ascii"), Rn = (s, t) => gn(Math.floor(s).toString(8), t), gn = (s, t) => (s.length === t - 1 ? s : new Array(t - s.length - 1).join("0") + s + " ") + "\0", Gi = (s, t, e, i) => i === void 0 ? !1 : ct(s, t, e, i.getTime() / 1e3), bn = new Array(156).join("\0"), Lt = (s, t, e, i) => i === void 0 ? !1 : (s.write(i + bn, t, e, "utf8"), i.length !== Buffer.byteLength(i) || i.length > e);
+var ft = class s {
+	atime;
+	mtime;
+	ctime;
+	charset;
+	comment;
+	gid;
+	uid;
+	gname;
+	uname;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	path;
+	size;
+	mode;
+	global;
+	constructor(t, e = !1) {
+		this.atime = t.atime, this.charset = t.charset, this.comment = t.comment, this.ctime = t.ctime, this.dev = t.dev, this.gid = t.gid, this.global = e, this.gname = t.gname, this.ino = t.ino, this.linkpath = t.linkpath, this.mtime = t.mtime, this.nlink = t.nlink, this.path = t.path, this.size = t.size, this.uid = t.uid, this.uname = t.uname;
+	}
+	encode() {
+		let t = this.encodeBody();
+		if (t === "") return Buffer.allocUnsafe(0);
+		let e = Buffer.byteLength(t), i = 512 * Math.ceil(1 + e / 512), r = Buffer.allocUnsafe(i);
+		for (let n = 0; n < 512; n++) r[n] = 0;
+		new F({
+			path: ("PaxHeader/" + basename(this.path ?? "")).slice(0, 99),
+			mode: this.mode || 420,
+			uid: this.uid,
+			gid: this.gid,
+			size: e,
+			mtime: this.mtime,
+			type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
+			linkpath: "",
+			uname: this.uname || "",
+			gname: this.gname || "",
+			devmaj: 0,
+			devmin: 0,
+			atime: this.atime,
+			ctime: this.ctime
+		}).encode(r), r.write(t, 512, e, "utf8");
+		for (let n = e + 512; n < r.length; n++) r[n] = 0;
+		return r;
+	}
+	encodeBody() {
+		return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
+	}
+	encodeField(t) {
+		if (this[t] === void 0) return "";
+		let e = this[t], i = e instanceof Date ? e.getTime() / 1e3 : e, r = " " + (t === "dev" || t === "ino" || t === "nlink" ? "SCHILY." : "") + t + "=" + i + `
+`, n = Buffer.byteLength(r), o = Math.floor(Math.log(n) / Math.log(10)) + 1;
+		return n + o >= Math.pow(10, o) && (o += 1), o + n + r;
+	}
+	static parse(t, e, i = !1) {
+		return new s(On(Tn(t), e), i);
+	}
+}, On = (s, t) => t ? Object.assign({}, t, s) : s, Tn = (s) => s.replace(/\n$/, "").split(`
+`).reduce(xn, Object.create(null)), xn = (s, t) => {
+	let e = parseInt(t, 10);
+	if (e !== Buffer.byteLength(t) + 1) return s;
+	t = t.slice((e + " ").length);
+	let i = t.split("="), r = i.shift();
+	if (!r) return s;
+	let n = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1"), o = i.join("=").replace(/\0.*/, "");
+	switch (n) {
+		case "path":
+		case "linkpath":
+		case "type":
+		case "charset":
+		case "comment":
+		case "gname":
+		case "uname":
+			s[n] = o;
+			break;
+		case "ctime":
+		case "atime":
+		case "mtime":
+			s[n] = /* @__PURE__ */ new Date(Number(o) * 1e3);
+			break;
+		case "size":
+			let h = +o;
+			h >= 0 && (s[n] = h);
+			break;
+		case "gid":
+		case "uid":
+		case "dev":
+		case "ino":
+		case "nlink":
+		case "mode":
+			s[n] = +o;
+			break;
+	}
+	return s;
+};
+var f = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) !== "win32" ? (s) => String(s) : (s) => String(s).replaceAll(/\\/g, "/");
+var $e = class extends A {
+	extended;
+	globalExtended;
+	header;
+	startBlockSize;
+	blockRemain;
+	remain;
+	type;
+	meta = !1;
+	ignore = !1;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	size = 0;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	dev;
+	ino;
+	nlink;
+	invalid = !1;
+	absolute;
+	unsupported = !1;
+	constructor(t, e, i) {
+		switch (super({}), this.pause(), this.extended = e, this.globalExtended = i, this.header = t, this.remain = t.size ?? 0, this.startBlockSize = 512 * Math.ceil(this.remain / 512), this.blockRemain = this.startBlockSize, this.type = t.type, this.type) {
+			case "File":
+			case "OldFile":
+			case "Link":
+			case "SymbolicLink":
+			case "CharacterDevice":
+			case "BlockDevice":
+			case "Directory":
+			case "FIFO":
+			case "ContiguousFile":
+			case "GNUDumpDir": break;
+			case "NextFileHasLongLinkpath":
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath":
+			case "GlobalExtendedHeader":
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this.meta = !0;
+				break;
+			default: this.ignore = !0;
+		}
+		if (!t.path) throw new Error("no path provided for tar.ReadEntry");
+		this.path = f(t.path), this.mode = t.mode, this.mode && (this.mode = this.mode & 4095), this.uid = t.uid, this.gid = t.gid, this.uname = t.uname, this.gname = t.gname, this.size = this.remain, this.mtime = t.mtime, this.atime = t.atime, this.ctime = t.ctime, this.linkpath = t.linkpath ? f(t.linkpath) : void 0, this.uname = t.uname, this.gname = t.gname, e && this.#t(e), i && this.#t(i, !0);
+	}
+	write(t) {
+		let e = t.length;
+		if (e > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		let i = this.remain, r = this.blockRemain;
+		return this.remain = Math.max(0, i - e), this.blockRemain = Math.max(0, r - e), this.ignore ? !0 : i >= e ? super.write(t) : super.write(t.subarray(0, i));
+	}
+	#t(t, e = !1) {
+		t.path && (t.path = f(t.path)), t.linkpath && (t.linkpath = f(t.linkpath)), Object.assign(this, Object.fromEntries(Object.entries(t).filter(([i, r]) => !(r == null || i === "path" && e))));
+	}
+};
+var Dt = (s, t, e, i = {}) => {
+	s.file && (i.file = s.file), s.cwd && (i.cwd = s.cwd), i.code = e instanceof Error && e.code || t, i.tarCode = t, !s.strict && i.recoverable !== !1 ? (e instanceof Error && (i = Object.assign(e, i), e = e.message), s.emit("warn", t, e, i)) : e instanceof Error ? s.emit("error", Object.assign(e, i)) : s.emit("error", Object.assign(/* @__PURE__ */ new Error(`${t}: ${e}`), i));
+};
+var Nn = 1024 * 1024, Xi = Buffer.from([31, 139]), qi = Buffer.from([
+	40,
+	181,
+	47,
+	253
+]), An = Math.max(Xi.length, qi.length), B = Symbol("state"), Nt = Symbol("writeEntry"), it = Symbol("readEntry"), Zi = Symbol("nextEntry"), Zs = Symbol("processEntry"), V = Symbol("extendedHeader"), he = Symbol("globalExtendedHeader"), dt = Symbol("meta"), Ys = Symbol("emitMeta"), p = Symbol("buffer"), st = Symbol("queue"), ut = Symbol("ended"), Yi = Symbol("emittedEnd"), At = Symbol("emit"), w = Symbol("unzip"), Xe = Symbol("consumeChunk"), qe = Symbol("consumeChunkSub"), Ki = Symbol("consumeBody"), Ks = Symbol("consumeMeta"), Vs = Symbol("consumeHeader"), ae = Symbol("consuming"), Vi = Symbol("bufferConcat"), Qe = Symbol("maybeEnd"), Yt = Symbol("writing"), $ = Symbol("aborted"), Je = Symbol("onDone"), It = Symbol("sawValidEntry"), je = Symbol("sawNullBlock"), ti = Symbol("sawEOF"), $s = Symbol("closeStream"), In = 1e3, le = Symbol("compressedBytesRead"), $i = Symbol("decompressedBytesRead"), Xs = Symbol("checkDecompressionRatio"), Cn = () => !0, rt = class extends EventEmitter {
+	file;
+	strict;
+	maxMetaEntrySize;
+	filter;
+	brotli;
+	zstd;
+	maxDecompressionRatio;
+	writable = !0;
+	readable = !1;
+	[st] = [];
+	[p];
+	[it];
+	[Nt];
+	[B] = "begin";
+	[dt] = "";
+	[V];
+	[he];
+	[ut] = !1;
+	[w];
+	[$] = !1;
+	[It];
+	[je] = !1;
+	[ti] = !1;
+	[Yt] = !1;
+	[ae] = !1;
+	[Yi] = !1;
+	[le] = 0;
+	[$i] = 0;
+	constructor(t = {}) {
+		super(), this.file = t.file || "", this.on(Je, () => {
+			(this[B] === "begin" || this[It] === !1) && this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format");
+		}), t.ondone ? this.on(Je, t.ondone) : this.on(Je, () => {
+			this.emit("prefinish"), this.emit("finish"), this.emit("end");
+		}), this.strict = !!t.strict, this.maxDecompressionRatio = typeof t.maxDecompressionRatio == "number" ? t.maxDecompressionRatio : In, this.maxMetaEntrySize = t.maxMetaEntrySize || Nn, this.filter = typeof t.filter == "function" ? t.filter : Cn;
+		let e = t.file && (t.file.endsWith(".tar.br") || t.file.endsWith(".tbr"));
+		this.brotli = !(t.gzip || t.zstd) && t.brotli !== void 0 ? t.brotli : e ? void 0 : !1;
+		let i = t.file && (t.file.endsWith(".tar.zst") || t.file.endsWith(".tzst"));
+		this.zstd = !(t.gzip || t.brotli) && t.zstd !== void 0 ? t.zstd : i ? !0 : void 0, this.on("end", () => this[$s]()), typeof t.onwarn == "function" && this.on("warn", t.onwarn), typeof t.onReadEntry == "function" && this.on("entry", t.onReadEntry);
+	}
+	warn(t, e, i = {}) {
+		Dt(this, t, e, i);
+	}
+	[Vs](t, e) {
+		this[It] === void 0 && (this[It] = !1);
+		let i;
+		try {
+			i = new F(t, e, this[V], this[he]);
+		} catch (r) {
+			return this.warn("TAR_ENTRY_INVALID", r);
+		}
+		if (i.nullBlock) this[je] ? (this[ti] = !0, this[B] === "begin" && (this[B] = "header"), this[At]("eof")) : (this[je] = !0, this[At]("nullBlock"));
+		else if (this[je] = !1, !i.cksumValid) this.warn("TAR_ENTRY_INVALID", "checksum failure", { header: i });
+		else if (!i.path) this.warn("TAR_ENTRY_INVALID", "path is required", { header: i });
+		else {
+			let r = i.type;
+			if (/^(Symbolic)?Link$/.test(r) && !i.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath required", { header: i });
+			else if (!/^(Symbolic)?Link$/.test(r) && !/^(Global)?ExtendedHeader$/.test(r) && i.linkpath) this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", { header: i });
+			else {
+				let n = this[Nt] = new $e(i, this[V], this[he]);
+				if (!this[It]) if (n.remain) {
+					let o = () => {
+						n.invalid || (this[It] = !0);
+					};
+					n.on("end", o);
+				} else this[It] = !0;
+				n.meta ? n.size > this.maxMetaEntrySize ? (n.ignore = !0, this[At]("ignoredEntry", n), this[B] = "ignore", n.resume()) : n.size > 0 && (this[dt] = "", n.on("data", (o) => this[dt] += o), this[B] = "meta") : (this[V] = void 0, n.ignore = n.ignore || !this.filter(n.path, n), n.ignore ? (this[At]("ignoredEntry", n), this[B] = n.remain ? "ignore" : "header", n.resume()) : (n.remain ? this[B] = "body" : (this[B] = "header", n.end()), this[it] ? this[st].push(n) : (this[st].push(n), this[Zi]())));
+			}
+		}
+	}
+	[$s]() {
+		queueMicrotask(() => this.emit("close"));
+	}
+	[Zs](t) {
+		let e = !0;
+		if (!t) this[it] = void 0, e = !1;
+		else if (Array.isArray(t)) {
+			let [i, ...r] = t;
+			this.emit(i, ...r);
+		} else this[it] = t, this.emit("entry", t), t.emittedEnd || (t.on("end", () => this[Zi]()), e = !1);
+		return e;
+	}
+	[Zi]() {
+		do		;
+while (this[Zs](this[st].shift()));
+		if (this[st].length === 0) {
+			let t = this[it];
+			!t || t.flowing || t.size === t.remain ? this[Yt] || this.emit("drain") : t.once("drain", () => this.emit("drain"));
+		}
+	}
+	[Ki](t, e) {
+		let i = this[Nt];
+		if (!i) throw new Error("attempt to consume body without entry??");
+		let r = i.blockRemain ?? 0, n = r >= t.length && e === 0 ? t : t.subarray(e, e + r);
+		return i.write(n), i.blockRemain || (this[B] = "header", this[Nt] = void 0, i.end()), n.length;
+	}
+	[Ks](t, e) {
+		let i = this[Nt], r = this[Ki](t, e);
+		return !this[Nt] && i && this[Ys](i), r;
+	}
+	[At](t, e, i) {
+		this[st].length === 0 && !this[it] ? this.emit(t, e, i) : this[st].push([
+			t,
+			e,
+			i
+		]);
+	}
+	[Ys](t) {
+		switch (this[At]("meta", this[dt]), t.type) {
+			case "ExtendedHeader":
+			case "OldExtendedHeader":
+				this[V] = ft.parse(this[dt], this[V], !1);
+				break;
+			case "GlobalExtendedHeader":
+				this[he] = ft.parse(this[dt], this[he], !0);
+				break;
+			case "NextFileHasLongPath":
+			case "OldGnuLongPath": {
+				let e = this[V] ?? Object.create(null);
+				this[V] = e, e.path = this[dt].replace(/\0.*/, "");
+				break;
+			}
+			case "NextFileHasLongLinkpath": {
+				let e = this[V] || Object.create(null);
+				this[V] = e, e.linkpath = this[dt].replace(/\0.*/, "");
+				break;
+			}
+			default: throw new Error("unknown meta: " + t.type);
+		}
+	}
+	abort(t) {
+		if (!this[$]) {
+			if (this[w]) {
+				let e = this[w];
+				e.write = () => !0, e.end = () => e, e.emit = () => !1, e.destroy?.();
+			}
+			this[$] = !0, this.emit("abort", t), this.warn("TAR_ABORT", t, { recoverable: !1 });
+		}
+	}
+	[Xs](t) {
+		this[$i] += t.length;
+		let e = this[$i] / this[le];
+		return e > this.maxDecompressionRatio ? (this.abort(/* @__PURE__ */ new Error(`max decompression ratio exceeded: ${e.toFixed(2)} > ${this.maxDecompressionRatio}`)), !1) : !0;
+	}
+	write(t, e, i) {
+		if (typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, typeof e == "string" ? e : "utf8")), this[$]) return i?.(), !1;
+		if ((this[w] === void 0 || this.brotli === void 0 && this[w] === !1) && t) {
+			if (this[p] && (t = Buffer.concat([this[p], t]), this[p] = void 0), t.length < An) return this[p] = t, i?.(), !0;
+			for (let a = 0; this[w] === void 0 && a < Xi.length; a++) t[a] !== Xi[a] && (this[w] = !1);
+			let o = !1;
+			if (this[w] === !1 && this.zstd !== !1) {
+				o = !0;
+				for (let a = 0; a < qi.length; a++) if (t[a] !== qi[a]) {
+					o = !1;
+					break;
+				}
+			}
+			let h = this.brotli === void 0 && !o;
+			if (this[w] === !1 && h) if (t.length < 512) if (this[ut]) this.brotli = !0;
+			else return this[p] = t, i?.(), !0;
+			else try {
+				new F(t.subarray(0, 512)), this.brotli = !1;
+			} catch {
+				this.brotli = !0;
+			}
+			if (this[w] === void 0 || this[w] === !1 && (this.brotli || o)) {
+				let a = this[ut];
+				this[ut] = !1, this[w] = this[w] === void 0 ? new Ue({}) : o ? new Ke({}) : new Ge({}), this[w].on("data", (c) => {
+					this[Xs](c) && this[Xe](c);
+				}), this[w].on("error", (c) => {
+					this[$] || this.abort(c);
+				}), this[w].on("end", () => {
+					this[ut] = !0, this[Xe]();
+				}), this[Yt] = !0, this[le] += t.length;
+				let l = !!this[w][a ? "end" : "write"](t);
+				return this[Yt] = !1, i?.(), l;
+			}
+		}
+		this[Yt] = !0, this[w] ? (this[le] += t.length, this[w].write(t)) : this[Xe](t), this[Yt] = !1;
+		let n = this[st].length > 0 ? !1 : this[it] ? this[it].flowing : !0;
+		return !n && this[st].length === 0 && this[it]?.once("drain", () => this.emit("drain")), i?.(), n;
+	}
+	[Vi](t) {
+		t && !this[$] && (this[p] = this[p] ? Buffer.concat([this[p], t]) : t);
+	}
+	[Qe]() {
+		if (this[ut] && !this[Yi] && !this[$] && !this[ae]) {
+			this[Yi] = !0;
+			let t = this[Nt];
+			if (t?.blockRemain) {
+				let e = this[p] ? this[p].length : 0;
+				this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${t.blockRemain} more bytes, only ${e} available)`, { entry: t }), this[p] && t.write(this[p]), t.end();
+			}
+			this[At](Je);
+		}
+	}
+	[Xe](t) {
+		if (this[ae] && t) this[Vi](t);
+		else if (!t && !this[p]) this[Qe]();
+		else if (t) {
+			if (this[ae] = !0, this[p]) {
+				this[Vi](t);
+				let e = this[p];
+				this[p] = void 0, this[qe](e);
+			} else this[qe](t);
+			for (; this[p] && this[p]?.length >= 512 && !this[$] && !this[ti];) {
+				let e = this[p];
+				this[p] = void 0, this[qe](e);
+			}
+			this[ae] = !1;
+		}
+		(!this[p] || this[ut]) && this[Qe]();
+	}
+	[qe](t) {
+		let e = 0, i = t.length;
+		for (; e + 512 <= i && !this[$] && !this[ti];) switch (this[B]) {
+			case "begin":
+			case "header":
+				this[Vs](t, e), e += 512;
+				break;
+			case "ignore":
+			case "body":
+				e += this[Ki](t, e);
+				break;
+			case "meta":
+				e += this[Ks](t, e);
+				break;
+			default: throw new Error("invalid state: " + this[B]);
+		}
+		e < i && (this[p] = this[p] ? Buffer.concat([t.subarray(e), this[p]]) : t.subarray(e));
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, e = void 0, t = void 0), typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, e)), i && this.once("finish", i), this[$] || (this[w] ? (t && (this[le] += t.length, this[w].write(t)), this[w].end()) : (this[ut] = !0, (this.brotli === void 0 || this.zstd === void 0) && (t = t || Buffer.alloc(0)), t && this.write(t), this[Qe]())), this;
+	}
+};
+var mt = (s) => {
+	let t = s.length - 1, e = -1;
+	for (; t > -1 && s.charAt(t) === "/";) e = t, t--;
+	return e === -1 ? s : s.slice(0, e);
+};
+var vn = (s) => {
+	let t = s.onReadEntry;
+	s.onReadEntry = t ? (e) => {
+		t(e), e.resume();
+	} : (e) => e.resume();
+}, Qi = (s, t) => {
+	let e = new Map(t.map((o) => [mt(o), !0])), i = s.filter, r = 100, n = (o, h = "", a = 0) => {
+		if (a >= r) return e.set(o, !1), !1;
+		let l = h || parse(o).root || ".", c;
+		if (o === l) c = !1;
+		else {
+			let d = e.get(o);
+			c = d !== void 0 ? d : n(dirname(o), l, a + 1);
+		}
+		return e.set(o, c), c;
+	};
+	s.filter = i ? (o, h) => i(o, h) && n(mt(o)) : (o) => n(mt(o));
+}, Mn = (s) => {
+	let t = new rt(s), e = s.file, i;
+	try {
+		i = Kt.openSync(e, "r");
+		let r = Kt.fstatSync(i), n = s.maxReadSize || 16 * 1024 * 1024;
+		if (r.size < n) {
+			let o = Buffer.allocUnsafe(r.size), h = Kt.readSync(i, o, 0, r.size, 0);
+			t.end(h === o.byteLength ? o : o.subarray(0, h));
+		} else {
+			let o = 0, h = Buffer.allocUnsafe(n);
+			for (; o < r.size;) {
+				let a = Kt.readSync(i, h, 0, n, o);
+				if (a === 0) break;
+				o += a, t.write(h.subarray(0, a));
+			}
+			t.end();
+		}
+	} finally {
+		if (typeof i == "number") try {
+			Kt.closeSync(i);
+		} catch {}
+	}
+}, Bn = (s, t) => {
+	let e = new rt(s), i = s.maxReadSize || 16 * 1024 * 1024, r = s.file;
+	return new Promise((o, h) => {
+		e.on("error", h), e.on("end", o), Kt.stat(r, (a, l) => {
+			if (a) h(a);
+			else {
+				let c = new _t(r, {
+					readSize: i,
+					size: l.size
+				});
+				c.on("error", h), c.pipe(e);
+			}
+		});
+	});
+}, Ct = K(Mn, Bn, (s) => new rt(s), (s) => new rt(s), (s, t) => {
+	t?.length && Qi(s, t), s.noResume || vn(s);
+});
+var Ji = (s, t, e) => (s &= 4095, e && (s = (s | 384) & -19), t && (s & 256 && (s |= 64), s & 32 && (s |= 8), s & 4 && (s |= 1)), s);
+var { isAbsolute: zn, parse: qs } = win32, ce = (s) => {
+	let t = "", e = qs(s);
+	for (; zn(s) || e.root;) {
+		let i = s.charAt(0) === "/" && s.slice(0, 4) !== "//?/" ? "/" : e.root;
+		s = s.slice(i.length), t += i, e = qs(s);
+	}
+	return [t, s];
+};
+var ei = [
+	"|",
+	"<",
+	">",
+	"?",
+	":"
+], ji = ei.map((s) => String.fromCodePoint(61440 + Number(s.codePointAt(0)))), Un = new Map(ei.map((s, t) => [s, ji[t]])), Hn = new Map(ji.map((s, t) => [s, ei[t]])), ts = (s) => ei.reduce((t, e) => t.split(e).join(Un.get(e)), s), Qs = (s) => ji.reduce((t, e) => t.split(e).join(Hn.get(e)), s);
+var rr = (s, t) => t ? (s = f(s).replace(/^\.(\/|$)/, ""), mt(t) + "/" + s) : f(s), Wn = 16 * 1024 * 1024, tr = Symbol("process"), er = Symbol("file"), ir = Symbol("directory"), is = Symbol("symlink"), sr = Symbol("hardlink"), fe = Symbol("header"), ii = Symbol("read"), ss = Symbol("lstat"), si = Symbol("onlstat"), rs = Symbol("onread"), ns = Symbol("onreadlink"), os = Symbol("openfile"), hs = Symbol("onopenfile"), pt = Symbol("close"), ri = Symbol("mode"), as = Symbol("awaitDrain"), es = Symbol("ondrain"), q = Symbol("prefix"), de = class extends A {
+	path;
+	portable;
+	myuid = process.getuid && process.getuid() || 0;
+	myuser = process.env.USER || "";
+	maxReadSize;
+	linkCache;
+	statCache;
+	preservePaths;
+	cwd;
+	strict;
+	mtime;
+	noPax;
+	noMtime;
+	prefix;
+	fd;
+	blockLen = 0;
+	blockRemain = 0;
+	buf;
+	pos = 0;
+	remain = 0;
+	length = 0;
+	offset = 0;
+	win32;
+	absolute;
+	header;
+	type;
+	linkpath;
+	stat;
+	onWriteEntry;
+	#t = !1;
+	constructor(t, e = {}) {
+		let i = se(e);
+		super(), this.path = f(t), this.portable = !!i.portable, this.maxReadSize = i.maxReadSize || Wn, this.linkCache = i.linkCache || /* @__PURE__ */ new Map(), this.statCache = i.statCache || /* @__PURE__ */ new Map(), this.preservePaths = !!i.preservePaths, this.cwd = f(i.cwd || process.cwd()), this.strict = !!i.strict, this.noPax = !!i.noPax, this.noMtime = !!i.noMtime, this.mtime = i.mtime, this.prefix = i.prefix ? f(i.prefix) : void 0, this.onWriteEntry = i.onWriteEntry, typeof i.onwarn == "function" && this.on("warn", i.onwarn);
+		let r = !1;
+		if (!this.preservePaths) {
+			let [o, h] = ce(this.path);
+			o && typeof h == "string" && (this.path = h, r = o);
+		}
+		this.win32 = !!i.win32 || process.platform === "win32", this.win32 && (this.path = Qs(this.path.replaceAll(/\\/g, "/")), t = t.replaceAll(/\\/g, "/")), this.absolute = f(i.absolute || js.resolve(this.cwd, t)), this.path === "" && (this.path = "./"), r && this.warn("TAR_ENTRY_INFO", `stripping ${r} from absolute path`, {
+			entry: this,
+			path: r + this.path
+		});
+		let n = this.statCache.get(this.absolute);
+		n ? this[si](n) : this[ss]();
+	}
+	warn(t, e, i = {}) {
+		return Dt(this, t, e, i);
+	}
+	emit(t, ...e) {
+		return t === "error" && (this.#t = !0), super.emit(t, ...e);
+	}
+	[ss]() {
+		I.lstat(this.absolute, (t, e) => {
+			if (t) return this.emit("error", t);
+			this[si](e);
+		});
+	}
+	[si](t) {
+		this.statCache.set(this.absolute, t), this.stat = t, t.isFile() || (t.size = 0), this.type = Gn(t), this.emit("stat", t), this[tr]();
+	}
+	[tr]() {
+		switch (this.type) {
+			case "File": return this[er]();
+			case "Directory": return this[ir]();
+			case "SymbolicLink": return this[is]();
+			default: return this.end();
+		}
+	}
+	[ri](t) {
+		return Ji(t, this.type === "Directory", this.portable);
+	}
+	[q](t) {
+		return rr(t, this.prefix);
+	}
+	[fe]() {
+		if (!this.stat) throw new Error("cannot write header before stat");
+		this.type === "Directory" && this.portable && (this.noMtime = !0), this.onWriteEntry?.(this), this.header = new F({
+			path: this[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](this.linkpath) : this.linkpath,
+			mode: this[ri](this.stat.mode),
+			uid: this.portable ? void 0 : this.stat.uid,
+			gid: this.portable ? void 0 : this.stat.gid,
+			size: this.stat.size,
+			mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime,
+			type: this.type === "Unsupported" ? void 0 : this.type,
+			uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : "",
+			atime: this.portable ? void 0 : this.stat.atime,
+			ctime: this.portable ? void 0 : this.stat.ctime
+		}), this.header.encode() && !this.noPax && super.write(new ft({
+			atime: this.portable ? void 0 : this.header.atime,
+			ctime: this.portable ? void 0 : this.header.ctime,
+			gid: this.portable ? void 0 : this.header.gid,
+			mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime,
+			path: this[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](this.linkpath) : this.linkpath,
+			size: this.header.size,
+			uid: this.portable ? void 0 : this.header.uid,
+			uname: this.portable ? void 0 : this.header.uname,
+			dev: this.portable ? void 0 : this.stat.dev,
+			ino: this.portable ? void 0 : this.stat.ino,
+			nlink: this.portable ? void 0 : this.stat.nlink
+		}).encode());
+		let t = this.header?.block;
+		if (!t) throw new Error("failed to encode header");
+		super.write(t);
+	}
+	[ir]() {
+		if (!this.stat) throw new Error("cannot create directory entry without stat");
+		this.path.slice(-1) !== "/" && (this.path += "/"), this.stat.size = 0, this[fe](), this.end();
+	}
+	[is]() {
+		I.readlink(this.absolute, (t, e) => {
+			if (t) return this.emit("error", t);
+			this[ns](e);
+		});
+	}
+	[ns](t) {
+		this.linkpath = f(t), this[fe](), this.end();
+	}
+	[sr](t) {
+		if (!this.stat) throw new Error("cannot create link entry without stat");
+		this.type = "Link", this.linkpath = f(js.relative(this.cwd, t)), this.stat.size = 0, this[fe](), this.end();
+	}
+	[er]() {
+		if (!this.stat) throw new Error("cannot create file entry without stat");
+		if (this.stat.nlink > 1) {
+			let t = `${this.stat.dev}:${this.stat.ino}`, e = this.linkCache.get(t);
+			if (e?.indexOf(this.cwd) === 0) return this[sr](e);
+			this.linkCache.set(t, this.absolute);
+		}
+		if (this[fe](), this.stat.size === 0) return this.end();
+		this[os]();
+	}
+	[os]() {
+		I.open(this.absolute, "r", (t, e) => {
+			if (t) return this.emit("error", t);
+			this[hs](e);
+		});
+	}
+	[hs](t) {
+		if (this.fd = t, this.#t) return this[pt]();
+		if (!this.stat) throw new Error("should stat before calling onopenfile");
+		this.blockLen = 512 * Math.ceil(this.stat.size / 512), this.blockRemain = this.blockLen;
+		let e = Math.min(this.blockLen, this.maxReadSize);
+		this.buf = Buffer.allocUnsafe(e), this.offset = 0, this.pos = 0, this.remain = this.stat.size, this.length = this.buf.length, this[ii]();
+	}
+	[ii]() {
+		let { fd: t, buf: e, offset: i, length: r, pos: n } = this;
+		if (t === void 0 || e === void 0) throw new Error("cannot read file without first opening");
+		I.read(t, e, i, r, n, (o, h) => {
+			if (o) return this[pt](() => this.emit("error", o));
+			this[rs](h);
+		});
+	}
+	[pt](t = () => {}) {
+		this.fd !== void 0 && I.close(this.fd, t);
+	}
+	[rs](t) {
+		if (t <= 0 && this.remain > 0) {
+			let r = Object.assign(/* @__PURE__ */ new Error("encountered unexpected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[pt](() => this.emit("error", r));
+		}
+		if (t > this.remain) {
+			let r = Object.assign(/* @__PURE__ */ new Error("did not encounter expected EOF"), {
+				path: this.absolute,
+				syscall: "read",
+				code: "EOF"
+			});
+			return this[pt](() => this.emit("error", r));
+		}
+		if (!this.buf) throw new Error("should have created buffer prior to reading");
+		if (t === this.remain) for (let r = t; r < this.length && t < this.blockRemain; r++) this.buf[r + this.offset] = 0, t++, this.remain++;
+		let e = this.offset === 0 && t === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + t);
+		this.write(e) ? this[es]() : this[as](() => this[es]());
+	}
+	[as](t) {
+		this.once("drain", t);
+	}
+	write(t, e, i) {
+		if (typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, typeof e == "string" ? e : "utf8")), this.blockRemain < t.length) {
+			let r = Object.assign(/* @__PURE__ */ new Error("writing more data than expected"), { path: this.absolute });
+			return this.emit("error", r);
+		}
+		return this.remain -= t.length, this.blockRemain -= t.length, this.pos += t.length, this.offset += t.length, super.write(t, null, i);
+	}
+	[es]() {
+		if (!this.remain) return this.blockRemain && super.write(Buffer.alloc(this.blockRemain)), this[pt]((t) => t ? this.emit("error", t) : this.end());
+		if (!this.buf) throw new Error("buffer lost somehow in ONDRAIN");
+		this.offset >= this.length && (this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length)), this.offset = 0), this.length = this.buf.length - this.offset, this[ii]();
+	}
+}, ni = class extends de {
+	sync = !0;
+	[ss]() {
+		this[si](I.lstatSync(this.absolute));
+	}
+	[is]() {
+		this[ns](I.readlinkSync(this.absolute));
+	}
+	[os]() {
+		this[hs](I.openSync(this.absolute, "r"));
+	}
+	[ii]() {
+		let t = !0;
+		try {
+			let { fd: e, buf: i, offset: r, length: n, pos: o } = this;
+			if (e === void 0 || i === void 0) throw new Error("fd and buf must be set in READ method");
+			let h = I.readSync(e, i, r, n, o);
+			this[rs](h), t = !1;
+		} finally {
+			if (t) try {
+				this[pt](() => {});
+			} catch {}
+		}
+	}
+	[as](t) {
+		t();
+	}
+	[pt](t = () => {}) {
+		this.fd !== void 0 && I.closeSync(this.fd), t();
+	}
+}, oi = class extends A {
+	blockLen = 0;
+	blockRemain = 0;
+	buf = 0;
+	pos = 0;
+	remain = 0;
+	length = 0;
+	preservePaths;
+	portable;
+	strict;
+	noPax;
+	noMtime;
+	readEntry;
+	type;
+	prefix;
+	path;
+	mode;
+	uid;
+	gid;
+	uname;
+	gname;
+	header;
+	mtime;
+	atime;
+	ctime;
+	linkpath;
+	size;
+	onWriteEntry;
+	warn(t, e, i = {}) {
+		return Dt(this, t, e, i);
+	}
+	constructor(t, e = {}) {
+		let i = se(e);
+		super(), this.preservePaths = !!i.preservePaths, this.portable = !!i.portable, this.strict = !!i.strict, this.noPax = !!i.noPax, this.noMtime = !!i.noMtime, this.onWriteEntry = i.onWriteEntry, this.readEntry = t;
+		let { type: r } = t;
+		if (r === "Unsupported") throw new Error("writing entry that should be ignored");
+		this.type = r, this.type === "Directory" && this.portable && (this.noMtime = !0), this.prefix = i.prefix, this.path = f(t.path), this.mode = t.mode !== void 0 ? this[ri](t.mode) : void 0, this.uid = this.portable ? void 0 : t.uid, this.gid = this.portable ? void 0 : t.gid, this.uname = this.portable ? void 0 : t.uname, this.gname = this.portable ? void 0 : t.gname, this.size = t.size, this.mtime = this.noMtime ? void 0 : i.mtime || t.mtime, this.atime = this.portable ? void 0 : t.atime, this.ctime = this.portable ? void 0 : t.ctime, this.linkpath = t.linkpath !== void 0 ? f(t.linkpath) : void 0, typeof i.onwarn == "function" && this.on("warn", i.onwarn);
+		let n = !1;
+		if (!this.preservePaths) {
+			let [h, a] = ce(this.path);
+			h && typeof a == "string" && (this.path = a, n = h);
+		}
+		this.remain = t.size, this.blockRemain = t.startBlockSize, this.onWriteEntry?.(this), this.header = new F({
+			path: this[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](this.linkpath) : this.linkpath,
+			mode: this.mode,
+			uid: this.portable ? void 0 : this.uid,
+			gid: this.portable ? void 0 : this.gid,
+			size: this.size,
+			mtime: this.noMtime ? void 0 : this.mtime,
+			type: this.type,
+			uname: this.portable ? void 0 : this.uname,
+			atime: this.portable ? void 0 : this.atime,
+			ctime: this.portable ? void 0 : this.ctime
+		}), n && this.warn("TAR_ENTRY_INFO", `stripping ${n} from absolute path`, {
+			entry: this,
+			path: n + this.path
+		}), this.header.encode() && !this.noPax && super.write(new ft({
+			atime: this.portable ? void 0 : this.atime,
+			ctime: this.portable ? void 0 : this.ctime,
+			gid: this.portable ? void 0 : this.gid,
+			mtime: this.noMtime ? void 0 : this.mtime,
+			path: this[q](this.path),
+			linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[q](this.linkpath) : this.linkpath,
+			size: this.size,
+			uid: this.portable ? void 0 : this.uid,
+			uname: this.portable ? void 0 : this.uname,
+			dev: this.portable ? void 0 : this.readEntry.dev,
+			ino: this.portable ? void 0 : this.readEntry.ino,
+			nlink: this.portable ? void 0 : this.readEntry.nlink
+		}).encode());
+		let o = this.header?.block;
+		if (!o) throw new Error("failed to encode header");
+		super.write(o), t.pipe(this);
+	}
+	[q](t) {
+		return rr(t, this.prefix);
+	}
+	[ri](t) {
+		return Ji(t, this.type === "Directory", this.portable);
+	}
+	write(t, e, i) {
+		typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, typeof e == "string" ? e : "utf8"));
+		let r = t.length;
+		if (r > this.blockRemain) throw new Error("writing more to entry than is appropriate");
+		return this.blockRemain -= r, super.write(t, i);
+	}
+	end(t, e, i) {
+		return this.blockRemain && super.write(Buffer.alloc(this.blockRemain)), typeof t == "function" && (i = t, e = void 0, t = void 0), typeof e == "function" && (i = e, e = void 0), typeof t == "string" && (t = Buffer.from(t, e ?? "utf8")), i && this.once("finish", i), t ? super.end(t, i) : super.end(i), this;
+	}
+}, Gn = (s) => s.isFile() ? "File" : s.isDirectory() ? "Directory" : s.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
+var hi = class s {
+	tail;
+	head;
+	length = 0;
+	static create(t = []) {
+		return new s(t);
+	}
+	constructor(t = []) {
+		for (let e of t) this.push(e);
+	}
+	*[Symbol.iterator]() {
+		for (let t = this.head; t; t = t.next) yield t.value;
+	}
+	removeNode(t) {
+		if (t.list !== this) throw new Error("removing node which does not belong to this list");
+		let e = t.next, i = t.prev;
+		return e && (e.prev = i), i && (i.next = e), t === this.head && (this.head = e), t === this.tail && (this.tail = i), this.length--, t.next = void 0, t.prev = void 0, t.list = void 0, e;
+	}
+	unshiftNode(t) {
+		if (t === this.head) return;
+		t.list && t.list.removeNode(t);
+		let e = this.head;
+		t.list = this, t.next = e, e && (e.prev = t), this.head = t, this.tail || (this.tail = t), this.length++;
+	}
+	pushNode(t) {
+		if (t === this.tail) return;
+		t.list && t.list.removeNode(t);
+		let e = this.tail;
+		t.list = this, t.prev = e, e && (e.next = t), this.tail = t, this.head || (this.head = t), this.length++;
+	}
+	push(...t) {
+		for (let e = 0, i = t.length; e < i; e++) Yn(this, t[e]);
+		return this.length;
+	}
+	unshift(...t) {
+		for (var e = 0, i = t.length; e < i; e++) Kn(this, t[e]);
+		return this.length;
+	}
+	pop() {
+		if (!this.tail) return;
+		let t = this.tail.value, e = this.tail;
+		return this.tail = this.tail.prev, this.tail ? this.tail.next = void 0 : this.head = void 0, e.list = void 0, this.length--, t;
+	}
+	shift() {
+		if (!this.head) return;
+		let t = this.head.value, e = this.head;
+		return this.head = this.head.next, this.head ? this.head.prev = void 0 : this.tail = void 0, e.list = void 0, this.length--, t;
+	}
+	forEach(t, e) {
+		e = e || this;
+		for (let i = this.head, r = 0; i; r++) t.call(e, i.value, r, this), i = i.next;
+	}
+	forEachReverse(t, e) {
+		e = e || this;
+		for (let i = this.tail, r = this.length - 1; i; r--) t.call(e, i.value, r, this), i = i.prev;
+	}
+	get(t) {
+		let e = 0, i = this.head;
+		for (; i && e < t; e++) i = i.next;
+		if (e === t && i) return i.value;
+	}
+	getReverse(t) {
+		let e = 0, i = this.tail;
+		for (; i && e < t; e++) i = i.prev;
+		if (e === t && i) return i.value;
+	}
+	map(t, e) {
+		e = e || this;
+		let i = new s();
+		for (let r = this.head; r;) i.push(t.call(e, r.value, this)), r = r.next;
+		return i;
+	}
+	mapReverse(t, e) {
+		e = e || this;
+		var i = new s();
+		for (let r = this.tail; r;) i.push(t.call(e, r.value, this)), r = r.prev;
+		return i;
+	}
+	reduce(t, e) {
+		let i, r = this.head;
+		if (arguments.length > 1) i = e;
+		else if (this.head) r = this.head.next, i = this.head.value;
+		else throw new TypeError("Reduce of empty list with no initial value");
+		for (var n = 0; r; n++) i = t(i, r.value, n), r = r.next;
+		return i;
+	}
+	reduceReverse(t, e) {
+		let i, r = this.tail;
+		if (arguments.length > 1) i = e;
+		else if (this.tail) r = this.tail.prev, i = this.tail.value;
+		else throw new TypeError("Reduce of empty list with no initial value");
+		for (let n = this.length - 1; r; n--) i = t(i, r.value, n), r = r.prev;
+		return i;
+	}
+	toArray() {
+		let t = new Array(this.length);
+		for (let e = 0, i = this.head; i; e++) t[e] = i.value, i = i.next;
+		return t;
+	}
+	toArrayReverse() {
+		let t = new Array(this.length);
+		for (let e = 0, i = this.tail; i; e++) t[e] = i.value, i = i.prev;
+		return t;
+	}
+	slice(t = 0, e = this.length) {
+		e < 0 && (e += this.length), t < 0 && (t += this.length);
+		let i = new s();
+		if (e < t || e < 0) return i;
+		t < 0 && (t = 0), e > this.length && (e = this.length);
+		let r = this.head, n = 0;
+		for (n = 0; r && n < t; n++) r = r.next;
+		for (; r && n < e; n++, r = r.next) i.push(r.value);
+		return i;
+	}
+	sliceReverse(t = 0, e = this.length) {
+		e < 0 && (e += this.length), t < 0 && (t += this.length);
+		let i = new s();
+		if (e < t || e < 0) return i;
+		t < 0 && (t = 0), e > this.length && (e = this.length);
+		let r = this.length, n = this.tail;
+		for (; n && r > e; r--) n = n.prev;
+		for (; n && r > t; r--, n = n.prev) i.push(n.value);
+		return i;
+	}
+	splice(t, e = 0, ...i) {
+		t > this.length && (t = this.length - 1), t < 0 && (t = this.length + t);
+		let r = this.head;
+		for (let o = 0; r && o < t; o++) r = r.next;
+		let n = [];
+		for (let o = 0; r && o < e; o++) n.push(r.value), r = this.removeNode(r);
+		r ? r !== this.tail && (r = r.prev) : r = this.tail;
+		for (let o of i) r = Zn(this, r, o);
+		return n;
+	}
+	reverse() {
+		let t = this.head, e = this.tail;
+		for (let i = t; i; i = i.prev) {
+			let r = i.prev;
+			i.prev = i.next, i.next = r;
+		}
+		return this.head = e, this.tail = t, this;
+	}
+};
+function Zn(s, t, e) {
+	let n = new ue(e, t, t ? t.next : s.head, s);
+	return n.next === void 0 && (s.tail = n), n.prev === void 0 && (s.head = n), s.length++, n;
+}
+function Yn(s, t) {
+	s.tail = new ue(t, s.tail, void 0, s), s.head || (s.head = s.tail), s.length++;
+}
+function Kn(s, t) {
+	s.head = new ue(t, void 0, s.head, s), s.tail || (s.tail = s.head), s.length++;
+}
+var ue = class {
+	list;
+	next;
+	prev;
+	value;
+	constructor(t, e, i, r) {
+		this.list = r, this.value = t, e ? (e.next = this, this.prev = e) : this.prev = void 0, i ? (i.prev = this, this.next = i) : this.next = void 0;
+	}
+};
+var pi = class {
+	path;
+	absolute;
+	entry;
+	stat;
+	readdir;
+	pending = !1;
+	pendingLink = !1;
+	ignore = !1;
+	piped = !1;
+	constructor(t, e) {
+		this.path = t || "./", this.absolute = e;
+	}
+}, nr = Buffer.alloc(1024), li = Symbol("onStat"), me = Symbol("ended"), W = Symbol("queue"), pe = Symbol("pendingLinks"), Et = Symbol("current"), Ft = Symbol("process"), Ee = Symbol("processing"), ai = Symbol("processJob"), G = Symbol("jobs"), ls = Symbol("jobDone"), ci = Symbol("addFSEntry"), or = Symbol("addTarEntry"), ds = Symbol("stat"), us = Symbol("readdir"), fi = Symbol("onreaddir"), di = Symbol("pipe"), hr = Symbol("entry"), cs = Symbol("entryOpt"), ui = Symbol("writeEntryClass"), lr = Symbol("write"), fs = Symbol("ondrain"), wt = class extends A {
+	sync = !1;
+	opt;
+	cwd;
+	maxReadSize;
+	preservePaths;
+	strict;
+	noPax;
+	prefix;
+	linkCache;
+	statCache;
+	file;
+	portable;
+	zip;
+	readdirCache;
+	noDirRecurse;
+	follow;
+	noMtime;
+	mtime;
+	filter;
+	jobs;
+	[ui];
+	onWriteEntry;
+	[W];
+	[pe] = /* @__PURE__ */ new Map();
+	[G] = 0;
+	[Ee] = !1;
+	[me] = !1;
+	constructor(t = {}) {
+		if (super(), this.opt = t, this.file = t.file || "", this.cwd = t.cwd || process.cwd(), this.maxReadSize = t.maxReadSize, this.preservePaths = !!t.preservePaths, this.strict = !!t.strict, this.noPax = !!t.noPax, this.prefix = f(t.prefix || ""), this.linkCache = t.linkCache || /* @__PURE__ */ new Map(), this.statCache = t.statCache || /* @__PURE__ */ new Map(), this.readdirCache = t.readdirCache || /* @__PURE__ */ new Map(), this.onWriteEntry = t.onWriteEntry, this[ui] = de, typeof t.onwarn == "function" && this.on("warn", t.onwarn), this.portable = !!t.portable, t.gzip || t.brotli || t.zstd) {
+			if ((t.gzip ? 1 : 0) + (t.brotli ? 1 : 0) + (t.zstd ? 1 : 0) > 1) throw new TypeError("gzip, brotli, zstd are mutually exclusive");
+			if (t.gzip && (typeof t.gzip != "object" && (t.gzip = {}), this.portable && (t.gzip.portable = !0), this.zip = new ze(t.gzip)), t.brotli && (typeof t.brotli != "object" && (t.brotli = {}), this.zip = new We(t.brotli)), t.zstd && (typeof t.zstd != "object" && (t.zstd = {}), this.zip = new Ye(t.zstd)), !this.zip) throw new Error("impossible");
+			let e = this.zip;
+			e.on("data", (i) => super.write(i)), e.on("end", () => super.end()), e.on("drain", () => this[fs]()), this.on("resume", () => e.resume());
+		} else this.on("drain", this[fs]);
+		this.noDirRecurse = !!t.noDirRecurse, this.follow = !!t.follow, this.noMtime = !!t.noMtime, t.mtime && (this.mtime = t.mtime), this.filter = typeof t.filter == "function" ? t.filter : () => !0, this[W] = new hi(), this[G] = 0, this.jobs = Number(t.jobs) || 4, this[Ee] = !1, this[me] = !1;
+	}
+	[lr](t) {
+		return super.write(t);
+	}
+	add(t) {
+		return this.write(t), this;
+	}
+	end(t, e, i) {
+		return typeof t == "function" && (i = t, t = void 0), typeof e == "function" && (i = e, e = void 0), t && this.add(t), this[me] = !0, this[Ft](), i && i(), this;
+	}
+	write(t) {
+		if (this[me]) throw new Error("write after end");
+		return typeof t == "string" ? this[ci](t) : this[or](t), this.flowing;
+	}
+	[or](t) {
+		let e = f(js.resolve(this.cwd, t.path));
+		if (!this.filter(t.path, t)) t.resume();
+		else {
+			let i = new pi(t.path, e);
+			i.entry = new oi(t, this[cs](i)), i.entry.on("end", () => this[ls](i)), this[G] += 1, this[W].push(i);
+		}
+		this[Ft]();
+	}
+	[ci](t) {
+		let e = f(js.resolve(this.cwd, t));
+		this[W].push(new pi(t, e)), this[Ft]();
+	}
+	[ds](t) {
+		t.pending = !0, this[G] += 1;
+		I[this.follow ? "stat" : "lstat"](t.absolute, (i, r) => {
+			t.pending = !1, this[G] -= 1, i ? this.emit("error", i) : this[li](t, r);
+		});
+	}
+	[li](t, e) {
+		if (this.statCache.set(t.absolute, e), t.stat = e, !this.filter(t.path, e)) t.ignore = !0;
+		else if (e.isFile() && e.nlink > 1 && !this.linkCache.get(`${e.dev}:${e.ino}`) && !this.sync) if (t === this[Et]) this[ai](t);
+		else {
+			let i = `${e.dev}:${e.ino}`, r = this[pe].get(i);
+			r ? r.push(t) : this[pe].set(i, [t]), t.pendingLink = !0, t.pending = !0;
+		}
+		this[Ft]();
+	}
+	[us](t) {
+		t.pending = !0, this[G] += 1, I.readdir(t.absolute, (e, i) => {
+			if (t.pending = !1, this[G] -= 1, e) return this.emit("error", e);
+			this[fi](t, i);
+		});
+	}
+	[fi](t, e) {
+		this.readdirCache.set(t.absolute, e), t.readdir = e, this[Ft]();
+	}
+	[Ft]() {
+		if (!this[Ee]) {
+			this[Ee] = !0;
+			for (let t = this[W].head; t && this[G] < this.jobs; t = t.next) if (this[ai](t.value), t.value.ignore) {
+				let e = t.next;
+				this[W].removeNode(t), t.next = e;
+			}
+			this[Ee] = !1, this[me] && this[W].length === 0 && this[G] === 0 && (this.zip ? this.zip.end(nr) : (super.write(nr), super.end()));
+		}
+	}
+	get [Et]() {
+		return this[W] && this[W].head && this[W].head.value;
+	}
+	[ls](t) {
+		this[W].shift(), this[G] -= 1;
+		let { stat: e } = t;
+		if (e && e.isFile() && e.nlink > 1) {
+			let i = `${e.dev}:${e.ino}`, r = this[pe].get(i);
+			if (r) {
+				this[pe].delete(i);
+				for (let n of r) n.pending = !1, this[ai](n);
+			}
+		}
+		this[Ft]();
+	}
+	[ai](t) {
+		if (t.pending && t.pendingLink && t === this[Et] && (t.pending = !1, t.pendingLink = !1), !t.pending) {
+			if (t.entry) {
+				t === this[Et] && !t.piped && this[di](t);
+				return;
+			}
+			if (!t.stat) {
+				let e = this.statCache.get(t.absolute);
+				e ? this[li](t, e) : this[ds](t);
+			}
+			if (t.stat && !t.ignore) {
+				if (!this.noDirRecurse && t.stat.isDirectory() && !t.readdir) {
+					let e = this.readdirCache.get(t.absolute);
+					if (e ? this[fi](t, e) : this[us](t), !t.readdir) return;
+				}
+				if (t.entry = this[hr](t), !t.entry) {
+					t.ignore = !0;
+					return;
+				}
+				t === this[Et] && !t.piped && this[di](t);
+			}
+		}
+	}
+	[cs](t) {
+		return {
+			onwarn: (e, i, r) => this.warn(e, i, r),
+			noPax: this.noPax,
+			cwd: this.cwd,
+			absolute: t.absolute,
+			preservePaths: this.preservePaths,
+			maxReadSize: this.maxReadSize,
+			strict: this.strict,
+			portable: this.portable,
+			linkCache: this.linkCache,
+			statCache: this.statCache,
+			noMtime: this.noMtime,
+			mtime: this.mtime,
+			prefix: this.prefix,
+			onWriteEntry: this.onWriteEntry
+		};
+	}
+	[hr](t) {
+		this[G] += 1;
+		try {
+			return new this[ui](t.path, this[cs](t)).on("end", () => this[ls](t)).on("error", (i) => this.emit("error", i));
+		} catch (e) {
+			this.emit("error", e);
+		}
+	}
+	[fs]() {
+		this[Et] && this[Et].entry && this[Et].entry.resume();
+	}
+	[di](t) {
+		t.piped = !0, t.readdir && t.readdir.forEach((r) => {
+			let n = t.path, o = n === "./" ? "" : n.replace(/\/*$/, "/");
+			this[ci](o + r);
+		});
+		let e = t.entry, i = this.zip;
+		if (!e) throw new Error("cannot pipe without source");
+		i ? e.on("data", (r) => {
+			i.write(r) || e.pause();
+		}) : e.on("data", (r) => {
+			super.write(r) || e.pause();
+		});
+	}
+	pause() {
+		return this.zip && this.zip.pause(), super.pause();
+	}
+	warn(t, e, i = {}) {
+		Dt(this, t, e, i);
+	}
+}, kt = class extends wt {
+	sync = !0;
+	constructor(t) {
+		super(t), this[ui] = ni;
+	}
+	pause() {}
+	resume() {}
+	[ds](t) {
+		let e = this.follow ? "statSync" : "lstatSync";
+		this[li](t, I[e](t.absolute));
+	}
+	[us](t) {
+		this[fi](t, I.readdirSync(t.absolute));
+	}
+	[di](t) {
+		let e = t.entry, i = this.zip;
+		if (t.readdir && t.readdir.forEach((r) => {
+			let n = t.path, o = n === "./" ? "" : n.replace(/\/*$/, "/");
+			this[ci](o + r);
+		}), !e) throw new Error("Cannot pipe without source");
+		i ? e.on("data", (r) => {
+			i.write(r);
+		}) : e.on("data", (r) => {
+			super[lr](r);
+		});
+	}
+}, Vn = (s, t) => {
+	let e = new kt(s), i = new Wt(s.file, { mode: s.mode || 438 });
+	e.pipe(i), fr(e, t);
+}, $n = (s, t) => {
+	let e = new wt(s), i = new et(s.file, { mode: s.mode || 438 });
+	e.pipe(i);
+	let r = new Promise((n, o) => {
+		i.on("error", o), i.on("close", n), e.on("error", o);
+	});
+	return dr(e, t).catch((n) => e.emit("error", n)), r;
+}, fr = (s, t) => {
+	t.forEach((e) => {
+		e.charAt(0) === "@" ? Ct({
+			file: path.resolve(s.cwd, e.slice(1)),
+			sync: !0,
+			noResume: !0,
+			onReadEntry: (i) => s.add(i)
+		}) : s.add(e);
+	}), s.end();
+}, dr = async (s, t) => {
+	for (let e of t) e.charAt(0) === "@" ? await Ct({
+		file: path.resolve(String(s.cwd), e.slice(1)),
+		noResume: !0,
+		onReadEntry: (i) => {
+			s.add(i);
+		}
+	}) : s.add(e);
+	s.end();
+}, Xn = (s, t) => {
+	let e = new kt(s);
+	return fr(e, t), e;
+}, qn = (s, t) => {
+	let e = new wt(s);
+	return dr(e, t).catch((i) => e.emit("error", i)), e;
+};
+K(Vn, $n, Xn, qn, (s, t) => {
+	if (!t?.length) throw new TypeError("no paths specified to add to archive");
+});
+var Er = (process.env.__FAKE_PLATFORM__ || process.platform) === "win32", { O_CREAT: wr, O_NOFOLLOW: ur, O_TRUNC: Sr, O_WRONLY: yr } = I.constants, Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || I.constants.UV_FS_O_FILEMAP || 0, jn = Er && !!Rr, to = 512 * 1024, eo = Rr | Sr | wr | yr, mr = !Er && typeof ur == "number" ? ur | Sr | wr | yr : null, ms = mr !== null ? () => mr : jn ? (s) => s < to ? eo : "w" : () => "w";
+var ps = (s, t, e) => {
+	try {
+		return Kt.lchownSync(s, t, e);
+	} catch (i) {
+		if (i?.code !== "ENOENT") throw i;
+	}
+}, Ei = (s, t, e, i) => {
+	Kt.lchown(s, t, e, (r) => {
+		i(r && r?.code !== "ENOENT" ? r : null);
+	});
+}, io = (s, t, e, i, r) => {
+	if (t.isDirectory()) Es(path.resolve(s, t.name), e, i, (n) => {
+		if (n) return r(n);
+		Ei(path.resolve(s, t.name), e, i, r);
+	});
+	else Ei(path.resolve(s, t.name), e, i, r);
+}, Es = (s, t, e, i) => {
+	Kt.readdir(s, { withFileTypes: !0 }, (r, n) => {
+		if (r) {
+			if (r.code === "ENOENT") return i();
+			if (r.code !== "ENOTDIR" && r.code !== "ENOTSUP") return i(r);
+		}
+		if (r || !n.length) return Ei(s, t, e, i);
+		let o = n.length, h = null, a = (l) => {
+			if (!h) {
+				if (l) return i(h = l);
+				if (--o === 0) return Ei(s, t, e, i);
+			}
+		};
+		for (let l of n) io(s, l, t, e, a);
+	});
+}, so = (s, t, e, i) => {
+	t.isDirectory() && ws(path.resolve(s, t.name), e, i), ps(path.resolve(s, t.name), e, i);
+}, ws = (s, t, e) => {
+	let i;
+	try {
+		i = Kt.readdirSync(s, { withFileTypes: !0 });
+	} catch (r) {
+		let n = r;
+		if (n?.code === "ENOENT") return;
+		if (n?.code === "ENOTDIR" || n?.code === "ENOTSUP") return ps(s, t, e);
+		throw n;
+	}
+	for (let r of i) so(s, r, t, e);
+	return ps(s, t, e);
+};
+var Se = class extends Error {
+	path;
+	code;
+	syscall = "chdir";
+	constructor(t, e) {
+		super(`${e}: Cannot cd into '${t}'`), this.path = t, this.code = e;
+	}
+	get name() {
+		return "CwdError";
+	}
+};
+var St = class extends Error {
+	path;
+	symlink;
+	syscall = "symlink";
+	code = "TAR_SYMLINK_ERROR";
+	constructor(t, e) {
+		super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"), this.symlink = t, this.path = e;
+	}
+	get name() {
+		return "SymlinkError";
+	}
+};
+var no = (s, t) => {
+	Kt.stat(s, (e, i) => {
+		(e || !i.isDirectory()) && (e = new Se(s, e?.code || "ENOTDIR")), t(e);
+	});
+}, gr = (s, t, e) => {
+	s = f(s);
+	let i = t.umask ?? 18, r = t.mode | 448, n = (r & i) !== 0, o = t.uid, h = t.gid, a = typeof o == "number" && typeof h == "number" && (o !== t.processUid || h !== t.processGid), l = t.preserve, c = t.unlink, d = f(t.cwd), y = (E, x) => {
+		E ? e(E) : x && a ? Es(x, o, h, (Le) => y(Le)) : n ? Kt.chmod(s, r, e) : e();
+	};
+	if (s === d) return no(s, y);
+	if (l) return ro.mkdir(s, {
+		mode: r,
+		recursive: !0
+	}).then((E) => y(null, E ?? void 0), y);
+	Ss(d, f(path.relative(d, s)).split("/"), r, c, d, void 0, y);
+}, Ss = (s, t, e, i, r, n, o) => {
+	if (t.length === 0) return o(null, n);
+	let h = t.shift(), a = f(path.resolve(s + "/" + h));
+	Kt.mkdir(a, e, br(a, t, e, i, r, n, o));
+}, br = (s, t, e, i, r, n, o) => (h) => {
+	h ? Kt.lstat(s, (a, l) => {
+		if (a) a.path = a.path && f(a.path), o(a);
+		else if (l.isDirectory()) Ss(s, t, e, i, r, n, o);
+		else if (i) Kt.unlink(s, (c) => {
+			if (c) return o(c);
+			Kt.mkdir(s, e, br(s, t, e, i, r, n, o));
+		});
+		else {
+			if (l.isSymbolicLink()) return o(new St(s, s + "/" + t.join("/")));
+			o(h);
+		}
+	}) : (n = n || s, Ss(s, t, e, i, r, n, o));
+}, oo = (s) => {
+	let t = !1, e;
+	try {
+		t = Kt.statSync(s).isDirectory();
+	} catch (i) {
+		e = i?.code;
+	} finally {
+		if (!t) throw new Se(s, e ?? "ENOTDIR");
+	}
+}, _r = (s, t) => {
+	s = f(s);
+	let e = t.umask ?? 18, i = t.mode | 448, r = (i & e) !== 0, n = t.uid, o = t.gid, h = typeof n == "number" && typeof o == "number" && (n !== t.processUid || o !== t.processGid), a = t.preserve, l = t.unlink, c = f(t.cwd), d = (E) => {
+		E && h && ws(E, n, o), r && Kt.chmodSync(s, i);
+	};
+	if (s === c) return oo(c), d();
+	if (a) return d(Kt.mkdirSync(s, {
+		mode: i,
+		recursive: !0
+	}) ?? void 0);
+	let T = f(path.relative(c, s)).split("/"), D;
+	for (let E = T.shift(), x = c; E && (x += "/" + E); E = T.shift()) {
+		x = f(path.resolve(x));
+		try {
+			Kt.mkdirSync(x, i), D = D || x;
+		} catch {
+			let Le = Kt.lstatSync(x);
+			if (Le.isDirectory()) continue;
+			if (l) {
+				Kt.unlinkSync(x), Kt.mkdirSync(x, i), D = D || x;
+				continue;
+			} else if (Le.isSymbolicLink()) return new St(x, x + "/" + T.join("/"));
+		}
+	}
+	return d(D);
+};
+var ys = Object.create(null), Or = 1e4, Vt = /* @__PURE__ */ new Set(), Tr = (s) => {
+	Vt.has(s) ? Vt.delete(s) : ys[s] = s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"), Vt.add(s);
+	let t = ys[s], e = Vt.size - Or;
+	if (e > Or / 10) {
+		for (let i of Vt) if (Vt.delete(i), delete ys[i], --e <= 0) break;
+	}
+	return t;
+};
+var ao = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32", lo = (s) => s.split("/").slice(0, -1).reduce((e, i) => {
+	let r = e.at(-1);
+	return r !== void 0 && (i = join(r, i)), e.push(i || "/"), e;
+}, []), yi = class {
+	#t = /* @__PURE__ */ new Map();
+	#i = /* @__PURE__ */ new Map();
+	#s = /* @__PURE__ */ new Set();
+	reserve(t, e) {
+		t = ao ? ["win32 parallelization disabled"] : t.map((r) => mt(join(Tr(r))));
+		let i = new Set(t.map((r) => lo(r)).reduce((r, n) => r.concat(n)));
+		this.#i.set(e, {
+			dirs: i,
+			paths: t
+		});
+		for (let r of t) {
+			let n = this.#t.get(r);
+			n ? n.push(e) : this.#t.set(r, [e]);
+		}
+		for (let r of i) {
+			let n = this.#t.get(r);
+			if (!n) this.#t.set(r, [new Set([e])]);
+			else {
+				let o = n.at(-1);
+				o instanceof Set ? o.add(e) : n.push(new Set([e]));
+			}
+		}
+		return this.#r(e);
+	}
+	#n(t) {
+		let e = this.#i.get(t);
+		if (!e) throw new Error("function does not have any path reservations");
+		return {
+			paths: e.paths.map((i) => this.#t.get(i)),
+			dirs: [...e.dirs].map((i) => this.#t.get(i))
+		};
+	}
+	check(t) {
+		let { paths: e, dirs: i } = this.#n(t);
+		return e.every((r) => r && r[0] === t) && i.every((r) => r && r[0] instanceof Set && r[0].has(t));
+	}
+	#r(t) {
+		return this.#s.has(t) || !this.check(t) ? !1 : (this.#s.add(t), t(() => this.#e(t)), !0);
+	}
+	#e(t) {
+		if (!this.#s.has(t)) return !1;
+		let e = this.#i.get(t);
+		if (!e) throw new Error("invalid reservation");
+		let { paths: i, dirs: r } = e, n = /* @__PURE__ */ new Set();
+		for (let o of i) {
+			let h = this.#t.get(o);
+			if (!h || h?.[0] !== t) continue;
+			let a = h[1];
+			if (!a) {
+				this.#t.delete(o);
+				continue;
+			}
+			if (h.shift(), typeof a == "function") n.add(a);
+			else for (let l of a) n.add(l);
+		}
+		for (let o of r) {
+			let h = this.#t.get(o), a = h?.[0];
+			if (!(!h || !(a instanceof Set))) if (a.size === 1 && h.length === 1) {
+				this.#t.delete(o);
+				continue;
+			} else if (a.size === 1) {
+				h.shift();
+				let l = h[0];
+				typeof l == "function" && n.add(l);
+			} else a.delete(t);
+		}
+		return this.#s.delete(t), n.forEach((o) => this.#r(o)), !0;
+	}
+};
+var Lr = () => process.umask();
+var Dr = Symbol("onEntry"), _s = Symbol("checkFs"), Nr = Symbol("checkFs2"), Os = Symbol("isReusable"), P = Symbol("makeFs"), Ts = Symbol("file"), xs = Symbol("directory"), gi = Symbol("link"), Ar = Symbol("symlink"), Ir = Symbol("hardlink"), Re = Symbol("ensureNoSymlink"), Cr = Symbol("unsupported"), Fr = Symbol("checkPath"), Rs = Symbol("stripAbsolutePath"), yt = Symbol("mkdir"), O = Symbol("onError"), Ri = Symbol("pending"), kr = Symbol("pend"), $t = Symbol("unpend"), gs = Symbol("ended"), bs = Symbol("maybeClose"), Ls = Symbol("skip"), ge = Symbol("doChown"), be = Symbol("uid"), _e = Symbol("gid"), Oe = Symbol("checkedCwd"), Te = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === "win32", uo = 1024, mo = (s, t) => {
+	if (!Te) return Kt.unlink(s, t);
+	let e = s + ".DELETE." + randomBytes(16).toString("hex");
+	Kt.rename(s, e, (i) => {
+		if (i) return t(i);
+		Kt.unlink(e, t);
+	});
+}, po = (s) => {
+	if (!Te) return Kt.unlinkSync(s);
+	let t = s + ".DELETE." + randomBytes(16).toString("hex");
+	Kt.renameSync(s, t), Kt.unlinkSync(t);
+}, vr = (s, t, e) => s !== void 0 && s === s >>> 0 ? s : t !== void 0 && t === t >>> 0 ? t : e, Xt = class extends rt {
+	[gs] = !1;
+	[Oe] = !1;
+	[Ri] = 0;
+	reservations = new yi();
+	transform;
+	writable = !0;
+	readable = !1;
+	uid;
+	gid;
+	setOwner;
+	preserveOwner;
+	processGid;
+	processUid;
+	maxDepth;
+	forceChown;
+	win32;
+	newer;
+	keep;
+	noMtime;
+	preservePaths;
+	unlink;
+	cwd;
+	strip;
+	processUmask;
+	umask;
+	dmode;
+	fmode;
+	chmod;
+	constructor(t = {}) {
+		if (t.ondone = () => {
+			this[gs] = !0, this[bs]();
+		}, super(t), this.transform = t.transform, this.chmod = !!t.chmod, typeof t.uid == "number" || typeof t.gid == "number") {
+			if (typeof t.uid != "number" || typeof t.gid != "number") throw new TypeError("cannot set owner without number uid and gid");
+			if (t.preserveOwner) throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
+			this.uid = t.uid, this.gid = t.gid, this.setOwner = !0;
+		} else this.uid = void 0, this.gid = void 0, this.setOwner = !1;
+		this.preserveOwner = t.preserveOwner === void 0 && typeof t.uid != "number" ? process.getuid?.() === 0 : !!t.preserveOwner, this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0, this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0, this.maxDepth = typeof t.maxDepth == "number" ? t.maxDepth : uo, this.forceChown = t.forceChown === !0, this.win32 = !!t.win32 || Te, this.newer = !!t.newer, this.keep = !!t.keep, this.noMtime = !!t.noMtime, this.preservePaths = !!t.preservePaths, this.unlink = !!t.unlink, this.cwd = f(path.resolve(t.cwd || process.cwd())), this.strip = Number(t.strip) || 0, this.processUmask = this.chmod ? typeof t.processUmask == "number" ? t.processUmask : Lr() : 0, this.umask = typeof t.umask == "number" ? t.umask : this.processUmask, this.dmode = t.dmode || 511 & ~this.umask, this.fmode = t.fmode || 438 & ~this.umask, this.on("entry", (e) => this[Dr](e));
+	}
+	warn(t, e, i = {}) {
+		return (t === "TAR_BAD_ARCHIVE" || t === "TAR_ABORT") && (i.recoverable = !1), super.warn(t, e, i);
+	}
+	[bs]() {
+		this[gs] && this[Ri] === 0 && (this.emit("prefinish"), this.emit("finish"), this.emit("end"));
+	}
+	[Rs](t, e) {
+		let i = t[e], { type: r } = t;
+		if (!i || this.preservePaths) return !0;
+		let [n, o] = ce(i), h = o.replaceAll(/\\/g, "/").split("/");
+		if (h.includes("..") || Te && /^[a-z]:\.\.$/i.test(h[0] ?? "")) {
+			if (e === "path" || r === "Link") return this.warn("TAR_ENTRY_ERROR", `${e} contains '..'`, {
+				entry: t,
+				[e]: i
+			}), !1;
+			let a = path.posix.dirname(t.path), l = path.posix.normalize(path.posix.join(a, h.join("/")));
+			if (l.startsWith("../") || l === "..") return this.warn("TAR_ENTRY_ERROR", `${e} escapes extraction directory`, {
+				entry: t,
+				[e]: i
+			}), !1;
+		}
+		return n && (t[e] = String(o), this.warn("TAR_ENTRY_INFO", `stripping ${n} from absolute ${e}`, {
+			entry: t,
+			[e]: i
+		})), !0;
+	}
+	[Fr](t) {
+		let e = f(t.path), i = e.split("/");
+		if (this.strip) {
+			if (i.length < this.strip) return !1;
+			if (t.type === "Link") {
+				let r = f(String(t.linkpath)).split("/");
+				if (r.length >= this.strip) t.linkpath = r.slice(this.strip).join("/");
+				else return !1;
+			}
+			i.splice(0, this.strip), t.path = i.join("/");
+		}
+		if (isFinite(this.maxDepth) && i.length > this.maxDepth) return this.warn("TAR_ENTRY_ERROR", "path excessively deep", {
+			entry: t,
+			path: e,
+			depth: i.length,
+			maxDepth: this.maxDepth
+		}), !1;
+		if (!this[Rs](t, "path") || !this[Rs](t, "linkpath")) return !1;
+		if (t.absolute = path.isAbsolute(t.path) ? f(path.resolve(t.path)) : f(path.resolve(this.cwd, t.path)), !this.preservePaths && typeof t.absolute == "string" && t.absolute.indexOf(this.cwd + "/") !== 0 && t.absolute !== this.cwd) return this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
+			entry: t,
+			path: f(t.path),
+			resolvedPath: t.absolute,
+			cwd: this.cwd
+		}), !1;
+		if (t.absolute === this.cwd && t.type !== "Directory" && t.type !== "GNUDumpDir") return !1;
+		if (this.win32) {
+			let { root: r } = path.win32.parse(String(t.absolute));
+			t.absolute = r + ts(String(t.absolute).slice(r.length));
+			let { root: n } = path.win32.parse(t.path);
+			t.path = n + ts(t.path.slice(n.length));
+		}
+		return !0;
+	}
+	[Dr](t) {
+		if (!this[Fr](t)) return t.resume();
+		switch (co.equal(typeof t.absolute, "string"), t.type) {
+			case "Directory":
+			case "GNUDumpDir": t.mode && (t.mode = t.mode | 448);
+			case "File":
+			case "OldFile":
+			case "ContiguousFile":
+			case "Link":
+			case "SymbolicLink": return this[_s](t);
+			default: return this[Cr](t);
+		}
+	}
+	[O](t, e) {
+		t.name === "CwdError" ? this.emit("error", t) : (this.warn("TAR_ENTRY_ERROR", t, { entry: e }), this[$t](), e.resume());
+	}
+	[yt](t, e, i) {
+		gr(f(t), {
+			uid: this.uid,
+			gid: this.gid,
+			processUid: this.processUid,
+			processGid: this.processGid,
+			umask: this.processUmask,
+			preserve: this.preservePaths,
+			unlink: this.unlink,
+			cwd: this.cwd,
+			mode: e
+		}, i);
+	}
+	[ge](t) {
+		return this.forceChown || this.preserveOwner && (typeof t.uid == "number" && t.uid !== this.processUid || typeof t.gid == "number" && t.gid !== this.processGid) || typeof this.uid == "number" && this.uid !== this.processUid || typeof this.gid == "number" && this.gid !== this.processGid;
+	}
+	[be](t) {
+		return vr(this.uid, t.uid, this.processUid);
+	}
+	[_e](t) {
+		return vr(this.gid, t.gid, this.processGid);
+	}
+	[Ts](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.fmode, r = new et(String(t.absolute), {
+			flags: ms(t.size),
+			mode: i,
+			autoClose: !1
+		});
+		r.on("error", (a) => {
+			r.fd && Kt.close(r.fd, () => {}), r.write = () => !0, this[O](a, t), e();
+		});
+		let n = 1, o = (a) => {
+			if (a) {
+				r.fd && Kt.close(r.fd, () => {}), this[O](a, t), e();
+				return;
+			}
+			--n === 0 && r.fd !== void 0 && Kt.close(r.fd, (l) => {
+				l ? this[O](l, t) : this[$t](), e();
+			});
+		};
+		r.on("finish", () => {
+			let a = String(t.absolute), l = r.fd;
+			if (typeof l == "number" && t.mtime && !this.noMtime) {
+				n++;
+				let c = t.atime || /* @__PURE__ */ new Date(), d = t.mtime;
+				Kt.futimes(l, c, d, (y) => y ? Kt.utimes(a, c, d, (T) => o(T && y)) : o());
+			}
+			if (typeof l == "number" && this[ge](t)) {
+				n++;
+				let c = this[be](t), d = this[_e](t);
+				typeof c == "number" && typeof d == "number" && Kt.fchown(l, c, d, (y) => y ? Kt.chown(a, c, d, (T) => o(T && y)) : o());
+			}
+			o();
+		});
+		let h = this.transform && this.transform(t) || t;
+		h !== t && (h.on("error", (a) => {
+			this[O](a, t), e();
+		}), t.pipe(h)), h.pipe(r);
+	}
+	[xs](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.dmode;
+		this[yt](String(t.absolute), i, (r) => {
+			if (r) {
+				this[O](r, t), e();
+				return;
+			}
+			let n = 1, o = () => {
+				--n === 0 && (e(), this[$t](), t.resume());
+			};
+			t.mtime && !this.noMtime && (n++, Kt.utimes(String(t.absolute), t.atime || /* @__PURE__ */ new Date(), t.mtime, o)), this[ge](t) && (n++, Kt.chown(String(t.absolute), Number(this[be](t)), Number(this[_e](t)), o)), o();
+		});
+	}
+	[Cr](t) {
+		t.unsupported = !0, this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${t.type}`, { entry: t }), t.resume();
+	}
+	[Ar](t, e) {
+		let i = f(path.relative(this.cwd, path.resolve(path.dirname(String(t.absolute)), String(t.linkpath)))).split("/");
+		this[Re](t, this.cwd, i, () => this[gi](t, String(t.linkpath), "symlink", e), (r) => {
+			this[O](r, t), e();
+		});
+	}
+	[Ir](t, e) {
+		let i = f(path.resolve(this.cwd, String(t.linkpath))), r = f(String(t.linkpath)).split("/");
+		this[Re](t, this.cwd, r, () => this[gi](t, i, "link", e), (n) => {
+			this[O](n, t), e();
+		});
+	}
+	[Re](t, e, i, r, n) {
+		let o = i.shift();
+		if (this.preservePaths || o === void 0) return r();
+		let h = path.resolve(e, o);
+		Kt.lstat(h, (a, l) => {
+			if (a) return r();
+			if (l?.isSymbolicLink()) return n(new St(h, path.resolve(h, i.join("/"))));
+			this[Re](t, h, i, r, n);
+		});
+	}
+	[kr]() {
+		this[Ri]++;
+	}
+	[$t]() {
+		this[Ri]--, this[bs]();
+	}
+	[Ls](t) {
+		this[$t](), t.resume();
+	}
+	[Os](t, e) {
+		return t.type === "File" && !this.unlink && e.isFile() && e.nlink <= 1 && !Te;
+	}
+	[_s](t) {
+		this[kr]();
+		let e = [t.path];
+		t.linkpath && e.push(t.linkpath), this.reservations.reserve(e, (i) => this[Nr](t, i));
+	}
+	[Nr](t, e) {
+		let i = (h) => {
+			e(h);
+		}, r = () => {
+			this[yt](this.cwd, this.dmode, (h) => {
+				if (h) {
+					this[O](h, t), i();
+					return;
+				}
+				this[Oe] = !0, n();
+			});
+		}, n = () => {
+			if (t.absolute !== this.cwd) {
+				let h = f(path.dirname(String(t.absolute)));
+				if (h !== this.cwd) return this[yt](h, this.dmode, (a) => {
+					if (a) {
+						this[O](a, t), i();
+						return;
+					}
+					o();
+				});
+			}
+			o();
+		}, o = () => {
+			Kt.lstat(String(t.absolute), (h, a) => {
+				if (a && (this.keep || this.newer && a.mtime > (t.mtime ?? a.mtime))) {
+					this[Ls](t), i();
+					return;
+				}
+				if (h || this[Os](t, a)) return this[P](null, t, i);
+				if (a.isDirectory()) {
+					if (t.type === "Directory") {
+						let l = this.chmod && t.mode && (a.mode & 4095) !== t.mode, c = (d) => this[P](d ?? null, t, i);
+						return l ? Kt.chmod(String(t.absolute), Number(t.mode), c) : c();
+					}
+					if (t.absolute !== this.cwd) return Kt.rmdir(String(t.absolute), (l) => this[P](l ?? null, t, i));
+				}
+				if (t.absolute === this.cwd) return this[P](null, t, i);
+				mo(String(t.absolute), (l) => this[P](l ?? null, t, i));
+			});
+		};
+		this[Oe] ? n() : r();
+	}
+	[P](t, e, i) {
+		if (t) {
+			this[O](t, e), i();
+			return;
+		}
+		switch (e.type) {
+			case "File":
+			case "OldFile":
+			case "ContiguousFile": return this[Ts](e, i);
+			case "Link": return this[Ir](e, i);
+			case "SymbolicLink": return this[Ar](e, i);
+			case "Directory":
+			case "GNUDumpDir": return this[xs](e, i);
+		}
+	}
+	[gi](t, e, i, r) {
+		Kt[i](e, String(t.absolute), (n) => {
+			n ? this[O](n, t) : (this[$t](), t.resume()), r();
+		});
+	}
+}, ye = (s) => {
+	try {
+		return [null, s()];
+	} catch (t) {
+		return [t, null];
+	}
+}, xe = class extends Xt {
+	sync = !0;
+	[P](t, e) {
+		return super[P](t, e, () => {});
+	}
+	[_s](t) {
+		if (!this[Oe]) {
+			let n = this[yt](this.cwd, this.dmode);
+			if (n) return this[O](n, t);
+			this[Oe] = !0;
+		}
+		if (t.absolute !== this.cwd) {
+			let n = f(path.dirname(String(t.absolute)));
+			if (n !== this.cwd) {
+				let o = this[yt](n, this.dmode);
+				if (o) return this[O](o, t);
+			}
+		}
+		let [e, i] = ye(() => Kt.lstatSync(String(t.absolute)));
+		if (i && (this.keep || this.newer && i.mtime > (t.mtime ?? i.mtime))) return this[Ls](t);
+		if (e || this[Os](t, i)) return this[P](null, t);
+		if (i.isDirectory()) {
+			if (t.type === "Directory") {
+				let [h] = this.chmod && t.mode && (i.mode & 4095) !== t.mode ? ye(() => {
+					Kt.chmodSync(String(t.absolute), Number(t.mode));
+				}) : [];
+				return this[P](h, t);
+			}
+			let [n] = ye(() => Kt.rmdirSync(String(t.absolute)));
+			this[P](n, t);
+		}
+		let [r] = t.absolute === this.cwd ? [] : ye(() => po(String(t.absolute)));
+		this[P](r, t);
+	}
+	[Ts](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.fmode, r = (h) => {
+			let a;
+			try {
+				Kt.closeSync(n);
+			} catch (l) {
+				a = l;
+			}
+			(h || a) && this[O](h || a, t), e();
+		}, n;
+		try {
+			n = Kt.openSync(String(t.absolute), ms(t.size), i);
+		} catch (h) {
+			return r(h);
+		}
+		let o = this.transform && this.transform(t) || t;
+		o !== t && (o.on("error", (h) => this[O](h, t)), t.pipe(o)), o.on("data", (h) => {
+			try {
+				Kt.writeSync(n, h, 0, h.length);
+			} catch (a) {
+				r(a);
+			}
+		}), o.on("end", () => {
+			let h = null;
+			if (t.mtime && !this.noMtime) {
+				let a = t.atime || /* @__PURE__ */ new Date(), l = t.mtime;
+				try {
+					Kt.futimesSync(n, a, l);
+				} catch (c) {
+					try {
+						Kt.utimesSync(String(t.absolute), a, l);
+					} catch {
+						h = c;
+					}
+				}
+			}
+			if (this[ge](t)) {
+				let a = this[be](t), l = this[_e](t);
+				try {
+					Kt.fchownSync(n, Number(a), Number(l));
+				} catch (c) {
+					try {
+						Kt.chownSync(String(t.absolute), Number(a), Number(l));
+					} catch {
+						h = h || c;
+					}
+				}
+			}
+			r(h);
+		});
+	}
+	[xs](t, e) {
+		let i = typeof t.mode == "number" ? t.mode & 4095 : this.dmode, r = this[yt](String(t.absolute), i);
+		if (r) {
+			this[O](r, t), e();
+			return;
+		}
+		if (t.mtime && !this.noMtime) try {
+			Kt.utimesSync(String(t.absolute), t.atime || /* @__PURE__ */ new Date(), t.mtime);
+		} catch {}
+		if (this[ge](t)) try {
+			Kt.chownSync(String(t.absolute), Number(this[be](t)), Number(this[_e](t)));
+		} catch {}
+		e(), t.resume();
+	}
+	[yt](t, e) {
+		try {
+			return _r(f(t), {
+				uid: this.uid,
+				gid: this.gid,
+				processUid: this.processUid,
+				processGid: this.processGid,
+				umask: this.processUmask,
+				preserve: this.preservePaths,
+				unlink: this.unlink,
+				cwd: this.cwd,
+				mode: e
+			});
+		} catch (i) {
+			return i;
+		}
+	}
+	[Re](t, e, i, r, n) {
+		if (this.preservePaths || i.length === 0) return r();
+		let o = e;
+		for (let h of i) {
+			o = path.resolve(o, h);
+			let [a, l] = ye(() => Kt.lstatSync(o));
+			if (a) return r();
+			if (l.isSymbolicLink()) return n(new St(o, path.resolve(e, i.join("/"))));
+		}
+		r();
+	}
+	[gi](t, e, i, r) {
+		let n = `${i}Sync`;
+		try {
+			Kt[n](e, String(t.absolute)), r(), t.resume();
+		} catch (o) {
+			return this[O](o, t);
+		}
+	}
+};
+var Eo = (s) => {
+	let t = new xe(s), e = s.file, i = Kt.statSync(e);
+	new Be(e, {
+		readSize: s.maxReadSize || 16 * 1024 * 1024,
+		size: i.size
+	}).pipe(t);
+}, wo = (s, t) => {
+	let e = new Xt(s), i = s.maxReadSize || 16 * 1024 * 1024, r = s.file;
+	return new Promise((o, h) => {
+		e.on("error", h), e.on("close", o), Kt.stat(r, (a, l) => {
+			if (a) h(a);
+			else {
+				let c = new _t(r, {
+					readSize: i,
+					size: l.size
+				});
+				c.on("error", h), c.pipe(e);
+			}
+		});
+	});
+}, So = K(Eo, wo, (s) => new xe(s), (s) => new Xt(s), (s, t) => {
+	t?.length && Qi(s, t);
+});
+var yo = (s, t) => {
+	let e = new kt(s), i = !0, r, n;
+	try {
+		try {
+			r = Kt.openSync(s.file, "r+");
+		} catch (a) {
+			if (a?.code === "ENOENT") r = Kt.openSync(s.file, "w+");
+			else throw a;
+		}
+		let o = Kt.fstatSync(r), h = Buffer.alloc(512);
+		t: for (n = 0; n < o.size; n += 512) {
+			for (let c = 0, d = 0; c < 512; c += d) {
+				if (d = Kt.readSync(r, h, c, h.length - c, n + c), n === 0 && h[0] === 31 && h[1] === 139) throw new Error("cannot append to compressed archives");
+				if (!d) break t;
+			}
+			let a = new F(h);
+			if (!a.cksumValid) break;
+			let l = 512 * Math.ceil((a.size || 0) / 512);
+			if (n + l + 512 > o.size) break;
+			n += l, s.mtimeCache && a.mtime && s.mtimeCache.set(String(a.path), a.mtime);
+		}
+		i = !1, Ro(s, e, n, r, t);
+	} finally {
+		if (i) try {
+			Kt.closeSync(r);
+		} catch {}
+	}
+}, Ro = (s, t, e, i, r) => {
+	let n = new Wt(s.file, {
+		fd: i,
+		start: e
+	});
+	t.pipe(n), bo(t, r);
+}, go = (s, t) => {
+	t = Array.from(t);
+	let e = new wt(s), i = (n, o, h) => {
+		let a = (T, D) => {
+			T ? Kt.close(n, (E) => h(T)) : h(null, D);
+		}, l = 0;
+		if (o === 0) return a(null, 0);
+		let c = 0, d = Buffer.alloc(512), y = (T, D) => {
+			if (T || D === void 0) return a(T);
+			if (c += D, c < 512 && D) return Kt.read(n, d, c, d.length - c, l + c, y);
+			if (l === 0 && d[0] === 31 && d[1] === 139) return a(/* @__PURE__ */ new Error("cannot append to compressed archives"));
+			if (c < 512) return a(null, l);
+			let E = new F(d);
+			if (!E.cksumValid) return a(null, l);
+			let x = 512 * Math.ceil((E.size ?? 0) / 512);
+			if (l + x + 512 > o || (l += x + 512, l >= o)) return a(null, l);
+			s.mtimeCache && E.mtime && s.mtimeCache.set(String(E.path), E.mtime), c = 0, Kt.read(n, d, 0, 512, l, y);
+		};
+		Kt.read(n, d, 0, 512, l, y);
+	};
+	return new Promise((n, o) => {
+		e.on("error", o);
+		let h = "r+", a = (l, c) => {
+			if (l && l.code === "ENOENT" && h === "r+") return h = "w+", Kt.open(s.file, h, a);
+			if (l || !c) return o(l);
+			Kt.fstat(c, (d, y) => {
+				if (d) return Kt.close(c, () => o(d));
+				i(c, y.size, (T, D) => {
+					if (T) return o(T);
+					let E = new et(s.file, {
+						fd: c,
+						start: D
+					});
+					e.pipe(E), E.on("error", o), E.on("close", n), _o(e, t);
+				});
+			});
+		};
+		Kt.open(s.file, h, a);
+	});
+}, bo = (s, t) => {
+	t.forEach((e) => {
+		e.charAt(0) === "@" ? Ct({
+			file: path.resolve(s.cwd, e.slice(1)),
+			sync: !0,
+			noResume: !0,
+			onReadEntry: (i) => s.add(i)
+		}) : s.add(e);
+	}), s.end();
+}, _o = async (s, t) => {
+	for (let e of t) e.charAt(0) === "@" ? await Ct({
+		file: path.resolve(String(s.cwd), e.slice(1)),
+		noResume: !0,
+		onReadEntry: (i) => s.add(i)
+	}) : s.add(e);
+	s.end();
+}, vt = K(yo, go, () => {
+	throw new TypeError("file is required");
+}, () => {
+	throw new TypeError("file is required");
+}, (s, t) => {
+	if (!Bs(s)) throw new TypeError("file is required");
+	if (s.gzip || s.brotli || s.zstd || s.file.endsWith(".br") || s.file.endsWith(".tbr")) throw new TypeError("cannot append to compressed archives");
+	if (!t?.length) throw new TypeError("no paths specified to add/replace");
+});
+K(vt.syncFile, vt.asyncFile, vt.syncNoFile, vt.asyncNoFile, (s, t = []) => {
+	vt.validate?.(s, t), To(s);
+});
+var To = (s) => {
+	let t = s.filter;
+	s.mtimeCache || (s.mtimeCache = /* @__PURE__ */ new Map()), s.filter = t ? (e, i) => t(e, i) && !((s.mtimeCache?.get(e) ?? i.mtime ?? 0) > (i.mtime ?? 0)) : (e, i) => !((s.mtimeCache?.get(e) ?? i.mtime ?? 0) > (i.mtime ?? 0));
+};
+//#endregion
 //#region ../../packages/memory/src/embeddings.ts
 /**
 * Text used to generate embeddings for a memo.
@@ -593,7 +3620,10 @@ function createFastEmbedEngineImpl(cacheDir) {
 }
 async function loadEmbedder(cacheDir) {
 	const { FlagEmbedding, EmbeddingModel } = await import("fastembed");
-	if (cacheDir !== void 0) mkdirSync(cacheDir, { recursive: true });
+	if (cacheDir !== void 0) {
+		mkdirSync(cacheDir, { recursive: true });
+		await ensureEmbeddingModelFiles(cacheDir);
+	}
 	const model = EmbeddingModel.BGESmallZH;
 	const initOpts = cacheDir !== void 0 ? {
 		model,
@@ -613,6 +3643,58 @@ async function loadEmbedder(cacheDir) {
 * into `<cacheDir>/<name>/` from the staged archive `<cacheDir>/<name>.tar.gz`.
 */
 const BGESMALLZH_CACHE_NAME = "fast-bge-small-zh-v1.5";
+/** Escape hatch for air-gapped installs and tests: points at an archive file. */
+const EMBEDDING_MODEL_URL_ENV = "SCREAM_CODE_EMBEDDING_MODEL_URL";
+function modelWeightsPath(cacheDir) {
+	return join(cacheDir, BGESMALLZH_CACHE_NAME, "model_optimized.onnx");
+}
+function sha256File(filePath) {
+	return readFile(filePath).then((data) => createHash("sha256").update(data).digest("hex"));
+}
+/**
+* Stage the embedding model files when they are missing: download the pinned
+* archive (HTTP status verified — unlike fastembed's own downloader), extract,
+* and verify the weights payload against the pinned sha256.
+*
+* A partially extracted tree or a hash mismatch is removed so the caller keeps
+* the honest "weights missing" state the setup card is gated on — never a
+* directory that only looks installed.
+*/
+async function ensureEmbeddingModelFiles(cacheDir, options) {
+	if (hasEmbeddingModelCache(cacheDir)) return;
+	mkdirSync(cacheDir, { recursive: true });
+	const modelDir = join(cacheDir, BGESMALLZH_CACHE_NAME);
+	const stagingPath = join(cacheDir, `${BGESMALLZH_CACHE_NAME}.tar.gz.part`);
+	const url = options?.sourceUrl ?? process.env[EMBEDDING_MODEL_URL_ENV] ?? "https://github.com/LIUTod/scream-code/releases/download/embedding-models-v1/fast-bge-small-zh-v1.5.tar.gz";
+	try {
+		let response;
+		try {
+			response = await fetch(url);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`fetch failed for ${url}: ${message}`, { cause: error });
+		}
+		if (!response.ok) throw new Error(`model source returned HTTP ${response.status} for ${url}`);
+		await writeFile(stagingPath, Buffer.from(await response.arrayBuffer()));
+		await So({
+			file: stagingPath,
+			cwd: cacheDir
+		});
+		const weightsPath = modelWeightsPath(cacheDir);
+		if (!existsSync(weightsPath) || statSync(weightsPath).size === 0) throw new Error(`model package did not contain weights after extraction: ${url}`);
+		const sha256 = await sha256File(weightsPath);
+		const expected = options?.expectedOnnxSha256 ?? "1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38";
+		if (sha256 !== expected) throw new Error(`model weights sha256 mismatch (${sha256.slice(0, 12)}… != ${expected.slice(0, 12)}…): ${url}`);
+	} catch (error) {
+		rmSync(modelDir, {
+			recursive: true,
+			force: true
+		});
+		throw error instanceof Error ? error : new Error(String(error));
+	} finally {
+		rmSync(stagingPath, { force: true });
+	}
+}
 const PLATFORM_FAILURE = /@anush008\/tokenizers|Failed to load native binding|Unsupported (?:OS|platform|architecture)|ERR_DLOPEN_FAILED|invalid ELF header|Exec format error|is not a valid Win32 application|GLIBC_\d+[^"\n]*not found|Error loading shared library|cannot open shared object file/iu;
 const ARCHIVE_FAILURE = /\bTAR_[A-Z_]+|incorrect header check|unexpected end of file|invalid tar|zlib/iu;
 const NETWORK_FAILURE = /\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EHOSTUNREACH|socket hang up|fetch failed)\b|network error|HTTP \d{3}/iu;
@@ -944,7 +4026,7 @@ var MemoryMemoStore = class MemoryMemoStore {
 			}
 			for (const legacyPath of legacyPaths) {
 				await unlink(legacyPath).catch(() => {});
-				await rmdir(dirname$1(legacyPath)).catch(() => {});
+				await rmdir(dirname$2(legacyPath)).catch(() => {});
 			}
 			await writeFile(markerPath, `${migratedCount}\n`, "utf8").catch(() => {});
 		} finally {
@@ -1390,7 +4472,7 @@ var MemoryMemoStore = class MemoryMemoStore {
 		};
 	}
 	async ensureDir() {
-		await mkdir(dirname$1(this.dbPath), { recursive: true });
+		await mkdir(dirname$2(this.dbPath), { recursive: true });
 	}
 	async withWriteLock(fn) {
 		const next = this.writeLock.then(fn, fn);
@@ -1918,7 +5000,7 @@ var DreamTracker = class {
 			state: this.state
 		};
 		try {
-			await mkdir(dirname$1(this.lockPath), { recursive: true });
+			await mkdir(dirname$2(this.lockPath), { recursive: true });
 			await writeFileAtomic(this.lockPath, JSON.stringify(data, null, 2));
 		} catch {}
 	}
@@ -1952,7 +5034,7 @@ var DreamTracker = class {
 		}
 		for (const candidate of candidates) try {
 			await rm(candidate);
-			await rmdir(dirname$1(candidate)).catch(() => {});
+			await rmdir(dirname$2(candidate)).catch(() => {});
 		} catch {}
 	}
 };
@@ -2024,7 +5106,7 @@ var KnowledgeStore = class {
 	}
 	async _doInit() {
 		if (this.initialized) return;
-		await mkdir(dirname$1(this.dbPath), { recursive: true });
+		await mkdir(dirname$2(this.dbPath), { recursive: true });
 		this.db = new DatabaseSync(this.dbPath);
 		this.db.exec("PRAGMA journal_mode = WAL;");
 		this.db.exec("PRAGMA foreign_keys = ON;");
@@ -4172,4 +7254,4 @@ async function chunkVectorFallback(store, queryVec, topK) {
 	return results;
 }
 //#endregion
-export { sharedMemoStore as A, buildProjectTagCloud as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, probeLocalEmbeddingSupport as F, join$1 as G, basename$1 as H, createMemoryMemo as I, relative$1 as J, normalize as K, toSummary as L, clearEmbeddingModelCache as M, createFastEmbedEngine as N, stripMemoryTags as O, hasEmbeddingModelCache as P, generateTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, dirname$1 as U, rankMemos as V, isAbsolute$1 as W, resolve$1 as Y, splitLargeSection as _, isSupportedFile as a, sharedKnowledgeStoreReady as b, buildExtractionUserPrompt as c, extractQueryEntities as d, parseExtractionResponse as f, estimateTokens as g, chunkText as h, ingestFile as i, classifyEmbeddingFailure as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, parse as q, ingestDirectory as r, EXTRACTION_SYSTEM_PROMPT as s, multiSearch as t, extractJsonFromText as u, stripMarkdown as v, buildConsolidationPlan as w, KnowledgeStore as x, sharedKnowledgeStore as y, normalizeTags as z };
+export { sharedMemoStore as A, buildProjectTagCloud as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, probeLocalEmbeddingSupport as F, join$1 as G, basename$1 as H, createMemoryMemo as I, relative$1 as J, normalize as K, toSummary as L, clearEmbeddingModelCache as M, createFastEmbedEngine as N, stripMemoryTags as O, hasEmbeddingModelCache as P, generateTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, dirname$2 as U, rankMemos as V, isAbsolute$1 as W, resolve$1 as Y, splitLargeSection as _, isSupportedFile as a, sharedKnowledgeStoreReady as b, buildExtractionUserPrompt as c, extractQueryEntities as d, parseExtractionResponse as f, estimateTokens as g, chunkText as h, ingestFile as i, classifyEmbeddingFailure as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, parse$1 as q, ingestDirectory as r, EXTRACTION_SYSTEM_PROMPT as s, multiSearch as t, extractJsonFromText as u, stripMarkdown as v, buildConsolidationPlan as w, KnowledgeStore as x, sharedKnowledgeStore as y, normalizeTags as z };