@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/chunk-MZFCCXPZ-f-V1JFCy.cjs

@@ -0,0 +1,2895 @@
+const require_chunk = require("./chunk-emK7D4bc.cjs");
+const require_chunk_4RUAZWKT = require("./chunk-4RUAZWKT-D0EYlGEM.cjs");
+const require_chunk_TN7HHBQW = require("./chunk-TN7HHBQW-D_SK6w5n.cjs");
+const require_chunk_QAYAQNCG = require("./chunk-QAYAQNCG-ROQh1hrZ.cjs");
+const require_chunk_TDD4NFYE = require("./chunk-TDD4NFYE-CyVGcZCt.cjs");
+let node_module = require("node:module");
+//#region ../../node_modules/.pnpm/seek-bzip@2.0.0/node_modules/seek-bzip/lib/bitreader.js
+var require_bitreader = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var BITMASK = [
+		0,
+		1,
+		3,
+		7,
+		15,
+		31,
+		63,
+		127,
+		255
+	];
+	var BitReader = function(stream) {
+		this.stream = stream;
+		this.bitOffset = 0;
+		this.curByte = 0;
+		this.hasByte = false;
+	};
+	BitReader.prototype._ensureByte = function() {
+		if (!this.hasByte) {
+			this.curByte = this.stream.readByte();
+			this.hasByte = true;
+		}
+	};
+	BitReader.prototype.read = function(bits) {
+		var result = 0;
+		while (bits > 0) {
+			this._ensureByte();
+			var remaining = 8 - this.bitOffset;
+			if (bits >= remaining) {
+				result <<= remaining;
+				result |= BITMASK[remaining] & this.curByte;
+				this.hasByte = false;
+				this.bitOffset = 0;
+				bits -= remaining;
+			} else {
+				result <<= bits;
+				var shift = remaining - bits;
+				result |= (this.curByte & BITMASK[bits] << shift) >> shift;
+				this.bitOffset += bits;
+				bits = 0;
+			}
+		}
+		return result;
+	};
+	BitReader.prototype.seek = function(pos) {
+		var n_bit = pos % 8;
+		var n_byte = (pos - n_bit) / 8;
+		this.bitOffset = n_bit;
+		this.stream.seek(n_byte);
+		this.hasByte = false;
+	};
+	BitReader.prototype.pi = function() {
+		var buf = new Buffer(6), i;
+		for (i = 0; i < buf.length; i++) buf[i] = this.read(8);
+		return buf.toString("hex");
+	};
+	module.exports = BitReader;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/seek-bzip@2.0.0/node_modules/seek-bzip/lib/stream.js
+var require_stream = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var Stream = function() {};
+	/** Returns the next byte, or -1 for EOF. */
+	Stream.prototype.readByte = function() {
+		throw new Error("abstract method readByte() not implemented");
+	};
+	/** Attempts to fill the buffer; returns number of bytes read, or
+	*  -1 for EOF. */
+	Stream.prototype.read = function(buffer, bufOffset, length) {
+		var bytesRead = 0;
+		while (bytesRead < length) {
+			var c = this.readByte();
+			if (c < 0) return bytesRead === 0 ? -1 : bytesRead;
+			buffer[bufOffset++] = c;
+			bytesRead++;
+		}
+		return bytesRead;
+	};
+	Stream.prototype.seek = function(new_pos) {
+		throw new Error("abstract method seek() not implemented");
+	};
+	Stream.prototype.writeByte = function(_byte) {
+		throw new Error("abstract method readByte() not implemented");
+	};
+	Stream.prototype.write = function(buffer, bufOffset, length) {
+		var i;
+		for (i = 0; i < length; i++) this.writeByte(buffer[bufOffset++]);
+		return length;
+	};
+	Stream.prototype.flush = function() {};
+	module.exports = Stream;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/seek-bzip@2.0.0/node_modules/seek-bzip/lib/crc32.js
+var require_crc32 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	module.exports = (function() {
+		/**
+		* A static CRC lookup table
+		*/
+		var crc32Lookup = new Uint32Array([
+			0,
+			79764919,
+			159529838,
+			222504665,
+			319059676,
+			398814059,
+			445009330,
+			507990021,
+			638119352,
+			583659535,
+			797628118,
+			726387553,
+			890018660,
+			835552979,
+			1015980042,
+			944750013,
+			1276238704,
+			1221641927,
+			1167319070,
+			1095957929,
+			1595256236,
+			1540665371,
+			1452775106,
+			1381403509,
+			1780037320,
+			1859660671,
+			1671105958,
+			1733955601,
+			2031960084,
+			2111593891,
+			1889500026,
+			1952343757,
+			2552477408,
+			2632100695,
+			2443283854,
+			2506133561,
+			2334638140,
+			2414271883,
+			2191915858,
+			2254759653,
+			3190512472,
+			3135915759,
+			3081330742,
+			3009969537,
+			2905550212,
+			2850959411,
+			2762807018,
+			2691435357,
+			3560074640,
+			3505614887,
+			3719321342,
+			3648080713,
+			3342211916,
+			3287746299,
+			3467911202,
+			3396681109,
+			4063920168,
+			4143685023,
+			4223187782,
+			4286162673,
+			3779000052,
+			3858754371,
+			3904687514,
+			3967668269,
+			881225847,
+			809987520,
+			1023691545,
+			969234094,
+			662832811,
+			591600412,
+			771767749,
+			717299826,
+			311336399,
+			374308984,
+			453813921,
+			533576470,
+			25881363,
+			88864420,
+			134795389,
+			214552010,
+			2023205639,
+			2086057648,
+			1897238633,
+			1976864222,
+			1804852699,
+			1867694188,
+			1645340341,
+			1724971778,
+			1587496639,
+			1516133128,
+			1461550545,
+			1406951526,
+			1302016099,
+			1230646740,
+			1142491917,
+			1087903418,
+			2896545431,
+			2825181984,
+			2770861561,
+			2716262478,
+			3215044683,
+			3143675388,
+			3055782693,
+			3001194130,
+			2326604591,
+			2389456536,
+			2200899649,
+			2280525302,
+			2578013683,
+			2640855108,
+			2418763421,
+			2498394922,
+			3769900519,
+			3832873040,
+			3912640137,
+			3992402750,
+			4088425275,
+			4151408268,
+			4197601365,
+			4277358050,
+			3334271071,
+			3263032808,
+			3476998961,
+			3422541446,
+			3585640067,
+			3514407732,
+			3694837229,
+			3640369242,
+			1762451694,
+			1842216281,
+			1619975040,
+			1682949687,
+			2047383090,
+			2127137669,
+			1938468188,
+			2001449195,
+			1325665622,
+			1271206113,
+			1183200824,
+			1111960463,
+			1543535498,
+			1489069629,
+			1434599652,
+			1363369299,
+			622672798,
+			568075817,
+			748617968,
+			677256519,
+			907627842,
+			853037301,
+			1067152940,
+			995781531,
+			51762726,
+			131386257,
+			177728840,
+			240578815,
+			269590778,
+			349224269,
+			429104020,
+			491947555,
+			4046411278,
+			4126034873,
+			4172115296,
+			4234965207,
+			3794477266,
+			3874110821,
+			3953728444,
+			4016571915,
+			3609705398,
+			3555108353,
+			3735388376,
+			3664026991,
+			3290680682,
+			3236090077,
+			3449943556,
+			3378572211,
+			3174993278,
+			3120533705,
+			3032266256,
+			2961025959,
+			2923101090,
+			2868635157,
+			2813903052,
+			2742672763,
+			2604032198,
+			2683796849,
+			2461293480,
+			2524268063,
+			2284983834,
+			2364738477,
+			2175806836,
+			2238787779,
+			1569362073,
+			1498123566,
+			1409854455,
+			1355396672,
+			1317987909,
+			1246755826,
+			1192025387,
+			1137557660,
+			2072149281,
+			2135122070,
+			1912620623,
+			1992383480,
+			1753615357,
+			1816598090,
+			1627664531,
+			1707420964,
+			295390185,
+			358241886,
+			404320391,
+			483945776,
+			43990325,
+			106832002,
+			186451547,
+			266083308,
+			932423249,
+			861060070,
+			1041341759,
+			986742920,
+			613929101,
+			542559546,
+			756411363,
+			701822548,
+			3316196985,
+			3244833742,
+			3425377559,
+			3370778784,
+			3601682597,
+			3530312978,
+			3744426955,
+			3689838204,
+			3819031489,
+			3881883254,
+			3928223919,
+			4007849240,
+			4037393693,
+			4100235434,
+			4180117107,
+			4259748804,
+			2310601993,
+			2373574846,
+			2151335527,
+			2231098320,
+			2596047829,
+			2659030626,
+			2470359227,
+			2550115596,
+			2947551409,
+			2876312838,
+			2788305887,
+			2733848168,
+			3165939309,
+			3094707162,
+			3040238851,
+			2985771188
+		]);
+		var CRC32 = function() {
+			/**
+			* The current CRC
+			*/
+			var crc = 4294967295;
+			/**
+			* @return The current CRC
+			*/
+			this.getCRC = function() {
+				return ~crc >>> 0;
+			};
+			/**
+			* Update the CRC with a single byte
+			* @param value The value to update the CRC with
+			*/
+			this.updateCRC = function(value) {
+				crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
+			};
+			/**
+			* Update the CRC with a sequence of identical bytes
+			* @param value The value to update the CRC with
+			* @param count The number of bytes
+			*/
+			this.updateCRCRun = function(value, count) {
+				while (count-- > 0) crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
+			};
+		};
+		return CRC32;
+	})();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/seek-bzip@2.0.0/node_modules/seek-bzip/package.json
+var require_package = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "seek-bzip",
+		"version": "2.0.0",
+		"contributors": [
+			"C. Scott Ananian (http://cscott.net)",
+			"Eli Skeggs",
+			"Kevin Kwok",
+			"Rob Landley (http://landley.net)"
+		],
+		"description": "a pure-JavaScript Node.JS module for random-access decoding bzip2 data",
+		"main": "./lib/index.js",
+		"repository": {
+			"type": "git",
+			"url": "https://github.com/cscott/seek-bzip.git"
+		},
+		"license": "MIT",
+		"bin": {
+			"seek-bunzip": "./bin/seek-bunzip",
+			"seek-table": "./bin/seek-bzip-table"
+		},
+		"directories": { "test": "test" },
+		"dependencies": { "commander": "^6.0.0" },
+		"devDependencies": {
+			"fibers": "^5.0.0",
+			"mocha": "^8.1.0"
+		},
+		"scripts": { "test": "mocha" }
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/seek-bzip@2.0.0/node_modules/seek-bzip/lib/index.js
+var require_lib = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	var BitReader = require_bitreader();
+	var Stream = require_stream();
+	var CRC32 = require_crc32();
+	var pjson = require_package();
+	var MAX_HUFCODE_BITS = 20;
+	var MAX_SYMBOLS = 258;
+	var SYMBOL_RUNA = 0;
+	var SYMBOL_RUNB = 1;
+	var MIN_GROUPS = 2;
+	var MAX_GROUPS = 6;
+	var GROUP_SIZE = 50;
+	var WHOLEPI = "314159265359";
+	var SQRTPI = "177245385090";
+	var mtf = function(array, index) {
+		var src = array[index], i;
+		for (i = index; i > 0; i--) array[i] = array[i - 1];
+		array[0] = src;
+		return src;
+	};
+	var Err = {
+		OK: 0,
+		LAST_BLOCK: -1,
+		NOT_BZIP_DATA: -2,
+		UNEXPECTED_INPUT_EOF: -3,
+		UNEXPECTED_OUTPUT_EOF: -4,
+		DATA_ERROR: -5,
+		OUT_OF_MEMORY: -6,
+		OBSOLETE_INPUT: -7,
+		END_OF_BLOCK: -8
+	};
+	var ErrorMessages = {};
+	ErrorMessages[Err.LAST_BLOCK] = "Bad file checksum";
+	ErrorMessages[Err.NOT_BZIP_DATA] = "Not bzip data";
+	ErrorMessages[Err.UNEXPECTED_INPUT_EOF] = "Unexpected input EOF";
+	ErrorMessages[Err.UNEXPECTED_OUTPUT_EOF] = "Unexpected output EOF";
+	ErrorMessages[Err.DATA_ERROR] = "Data error";
+	ErrorMessages[Err.OUT_OF_MEMORY] = "Out of memory";
+	ErrorMessages[Err.OBSOLETE_INPUT] = "Obsolete (pre 0.9.5) bzip format not supported.";
+	var _throw = function(status, optDetail) {
+		var msg = ErrorMessages[status] || "unknown error";
+		if (optDetail) msg += ": " + optDetail;
+		var e = new TypeError(msg);
+		e.errorCode = status;
+		throw e;
+	};
+	var Bunzip = function(inputStream, outputStream) {
+		this.writePos = this.writeCurrent = this.writeCount = 0;
+		this._start_bunzip(inputStream, outputStream);
+	};
+	Bunzip.prototype._init_block = function() {
+		if (!this._get_next_block()) {
+			this.writeCount = -1;
+			return false;
+		}
+		this.blockCRC = new CRC32();
+		return true;
+	};
+	Bunzip.prototype._start_bunzip = function(inputStream, outputStream) {
+		var buf = new Buffer(4);
+		if (inputStream.read(buf, 0, 4) !== 4 || String.fromCharCode(buf[0], buf[1], buf[2]) !== "BZh") _throw(Err.NOT_BZIP_DATA, "bad magic");
+		var level = buf[3] - 48;
+		if (level < 1 || level > 9) _throw(Err.NOT_BZIP_DATA, "level out of range");
+		this.reader = new BitReader(inputStream);
+		this.dbufSize = 1e5 * level;
+		this.nextoutput = 0;
+		this.outputStream = outputStream;
+		this.streamCRC = 0;
+	};
+	Bunzip.prototype._get_next_block = function() {
+		var i, j, k;
+		var reader = this.reader;
+		var h = reader.pi();
+		if (h === SQRTPI) return false;
+		if (h !== WHOLEPI) _throw(Err.NOT_BZIP_DATA);
+		this.targetBlockCRC = reader.read(32) >>> 0;
+		this.streamCRC = (this.targetBlockCRC ^ (this.streamCRC << 1 | this.streamCRC >>> 31)) >>> 0;
+		if (reader.read(1)) _throw(Err.OBSOLETE_INPUT);
+		var origPointer = reader.read(24);
+		if (origPointer > this.dbufSize) _throw(Err.DATA_ERROR, "initial position out of bounds");
+		var t = reader.read(16);
+		var symToByte = new Buffer(256), symTotal = 0;
+		for (i = 0; i < 16; i++) if (t & 1 << 15 - i) {
+			var o = i * 16;
+			k = reader.read(16);
+			for (j = 0; j < 16; j++) if (k & 1 << 15 - j) symToByte[symTotal++] = o + j;
+		}
+		var groupCount = reader.read(3);
+		if (groupCount < MIN_GROUPS || groupCount > MAX_GROUPS) _throw(Err.DATA_ERROR);
+		var nSelectors = reader.read(15);
+		if (nSelectors === 0) _throw(Err.DATA_ERROR);
+		var mtfSymbol = new Buffer(256);
+		for (i = 0; i < groupCount; i++) mtfSymbol[i] = i;
+		var selectors = new Buffer(nSelectors);
+		for (i = 0; i < nSelectors; i++) {
+			for (j = 0; reader.read(1); j++) if (j >= groupCount) _throw(Err.DATA_ERROR);
+			selectors[i] = mtf(mtfSymbol, j);
+		}
+		var symCount = symTotal + 2;
+		var groups = [], hufGroup;
+		for (j = 0; j < groupCount; j++) {
+			var length = new Buffer(symCount), temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
+			t = reader.read(5);
+			for (i = 0; i < symCount; i++) {
+				for (;;) {
+					if (t < 1 || t > MAX_HUFCODE_BITS) _throw(Err.DATA_ERROR);
+					if (!reader.read(1)) break;
+					if (!reader.read(1)) t++;
+					else t--;
+				}
+				length[i] = t;
+			}
+			var minLen = maxLen = length[0], maxLen;
+			for (i = 1; i < symCount; i++) if (length[i] > maxLen) maxLen = length[i];
+			else if (length[i] < minLen) minLen = length[i];
+			hufGroup = {};
+			groups.push(hufGroup);
+			hufGroup.permute = new Uint16Array(MAX_SYMBOLS);
+			hufGroup.limit = new Uint32Array(MAX_HUFCODE_BITS + 2);
+			hufGroup.base = new Uint32Array(MAX_HUFCODE_BITS + 1);
+			hufGroup.minLen = minLen;
+			hufGroup.maxLen = maxLen;
+			var pp = 0;
+			for (i = minLen; i <= maxLen; i++) {
+				temp[i] = hufGroup.limit[i] = 0;
+				for (t = 0; t < symCount; t++) if (length[t] === i) hufGroup.permute[pp++] = t;
+			}
+			for (i = 0; i < symCount; i++) temp[length[i]]++;
+			pp = t = 0;
+			for (i = minLen; i < maxLen; i++) {
+				pp += temp[i];
+				hufGroup.limit[i] = pp - 1;
+				pp <<= 1;
+				t += temp[i];
+				hufGroup.base[i + 1] = pp - t;
+			}
+			hufGroup.limit[maxLen + 1] = Number.MAX_VALUE;
+			hufGroup.limit[maxLen] = pp + temp[maxLen] - 1;
+			hufGroup.base[minLen] = 0;
+		}
+		var byteCount = new Uint32Array(256);
+		for (i = 0; i < 256; i++) mtfSymbol[i] = i;
+		var runPos = 0, dbufCount = 0, selector = 0, uc;
+		var dbuf = this.dbuf = new Uint32Array(this.dbufSize);
+		symCount = 0;
+		for (;;) {
+			if (!symCount--) {
+				symCount = GROUP_SIZE - 1;
+				if (selector >= nSelectors) _throw(Err.DATA_ERROR);
+				hufGroup = groups[selectors[selector++]];
+			}
+			i = hufGroup.minLen;
+			j = reader.read(i);
+			for (;; i++) {
+				if (i > hufGroup.maxLen) _throw(Err.DATA_ERROR);
+				if (j <= hufGroup.limit[i]) break;
+				j = j << 1 | reader.read(1);
+			}
+			j -= hufGroup.base[i];
+			if (j < 0 || j >= MAX_SYMBOLS) _throw(Err.DATA_ERROR);
+			var nextSym = hufGroup.permute[j];
+			if (nextSym === SYMBOL_RUNA || nextSym === SYMBOL_RUNB) {
+				if (!runPos) {
+					runPos = 1;
+					t = 0;
+				}
+				if (nextSym === SYMBOL_RUNA) t += runPos;
+				else t += 2 * runPos;
+				runPos <<= 1;
+				continue;
+			}
+			if (runPos) {
+				runPos = 0;
+				if (dbufCount + t > this.dbufSize) _throw(Err.DATA_ERROR);
+				uc = symToByte[mtfSymbol[0]];
+				byteCount[uc] += t;
+				while (t--) dbuf[dbufCount++] = uc;
+			}
+			if (nextSym > symTotal) break;
+			if (dbufCount >= this.dbufSize) _throw(Err.DATA_ERROR);
+			i = nextSym - 1;
+			uc = mtf(mtfSymbol, i);
+			uc = symToByte[uc];
+			byteCount[uc]++;
+			dbuf[dbufCount++] = uc;
+		}
+		if (origPointer < 0 || origPointer >= dbufCount) _throw(Err.DATA_ERROR);
+		j = 0;
+		for (i = 0; i < 256; i++) {
+			k = j + byteCount[i];
+			byteCount[i] = j;
+			j = k;
+		}
+		for (i = 0; i < dbufCount; i++) {
+			uc = dbuf[i] & 255;
+			dbuf[byteCount[uc]] |= i << 8;
+			byteCount[uc]++;
+		}
+		var pos = 0, current = 0, run = 0;
+		if (dbufCount) {
+			pos = dbuf[origPointer];
+			current = pos & 255;
+			pos >>= 8;
+			run = -1;
+		}
+		this.writePos = pos;
+		this.writeCurrent = current;
+		this.writeCount = dbufCount;
+		this.writeRun = run;
+		return true;
+	};
+	Bunzip.prototype._read_bunzip = function(outputBuffer, len) {
+		var copies, previous, outbyte;
+		if (this.writeCount < 0) return 0;
+		var dbuf = this.dbuf, pos = this.writePos, current = this.writeCurrent, dbufCount = this.writeCount;
+		this.outputsize;
+		var run = this.writeRun;
+		while (dbufCount) {
+			dbufCount--;
+			previous = current;
+			pos = dbuf[pos];
+			current = pos & 255;
+			pos >>= 8;
+			if (run++ === 3) {
+				copies = current;
+				outbyte = previous;
+				current = -1;
+			} else {
+				copies = 1;
+				outbyte = current;
+			}
+			this.blockCRC.updateCRCRun(outbyte, copies);
+			while (copies--) {
+				this.outputStream.writeByte(outbyte);
+				this.nextoutput++;
+			}
+			if (current != previous) run = 0;
+		}
+		this.writeCount = dbufCount;
+		if (this.blockCRC.getCRC() !== this.targetBlockCRC) _throw(Err.DATA_ERROR, "Bad block CRC (got " + this.blockCRC.getCRC().toString(16) + " expected " + this.targetBlockCRC.toString(16) + ")");
+		return this.nextoutput;
+	};
+	var coerceInputStream = function(input) {
+		if ("readByte" in input) return input;
+		var inputStream = new Stream();
+		inputStream.pos = 0;
+		inputStream.readByte = function() {
+			return input[this.pos++];
+		};
+		inputStream.seek = function(pos) {
+			this.pos = pos;
+		};
+		inputStream.eof = function() {
+			return this.pos >= input.length;
+		};
+		return inputStream;
+	};
+	var coerceOutputStream = function(output) {
+		var outputStream = new Stream();
+		var resizeOk = true;
+		if (output) if (typeof output === "number") {
+			outputStream.buffer = new Buffer(output);
+			resizeOk = false;
+		} else if ("writeByte" in output) return output;
+		else {
+			outputStream.buffer = output;
+			resizeOk = false;
+		}
+		else outputStream.buffer = new Buffer(16384);
+		outputStream.pos = 0;
+		outputStream.writeByte = function(_byte) {
+			if (resizeOk && this.pos >= this.buffer.length) {
+				var newBuffer = new Buffer(this.buffer.length * 2);
+				this.buffer.copy(newBuffer);
+				this.buffer = newBuffer;
+			}
+			this.buffer[this.pos++] = _byte;
+		};
+		outputStream.getBuffer = function() {
+			if (this.pos !== this.buffer.length) {
+				if (!resizeOk) throw new TypeError("outputsize does not match decoded input");
+				var newBuffer = new Buffer(this.pos);
+				this.buffer.copy(newBuffer, 0, 0, this.pos);
+				this.buffer = newBuffer;
+			}
+			return this.buffer;
+		};
+		outputStream._coerced = true;
+		return outputStream;
+	};
+	Bunzip.Err = Err;
+	Bunzip.decode = function(input, output, multistream) {
+		var inputStream = coerceInputStream(input);
+		var outputStream = coerceOutputStream(output);
+		var bz = new Bunzip(inputStream, outputStream);
+		while (true) {
+			if ("eof" in inputStream && inputStream.eof()) break;
+			if (bz._init_block()) bz._read_bunzip();
+			else {
+				var targetStreamCRC = bz.reader.read(32) >>> 0;
+				if (targetStreamCRC !== bz.streamCRC) _throw(Err.DATA_ERROR, "Bad stream CRC (got " + bz.streamCRC.toString(16) + " expected " + targetStreamCRC.toString(16) + ")");
+				if (multistream && "eof" in inputStream && !inputStream.eof()) bz._start_bunzip(inputStream, outputStream);
+				else break;
+			}
+		}
+		if ("getBuffer" in outputStream) return outputStream.getBuffer();
+	};
+	Bunzip.decodeBlock = function(input, pos, output) {
+		var inputStream = coerceInputStream(input);
+		var outputStream = coerceOutputStream(output);
+		var bz = new Bunzip(inputStream, outputStream);
+		bz.reader.seek(pos);
+		if (bz._get_next_block()) {
+			bz.blockCRC = new CRC32();
+			bz.writeCopies = 0;
+			bz._read_bunzip();
+		}
+		if ("getBuffer" in outputStream) return outputStream.getBuffer();
+	};
+	Bunzip.table = function(input, callback, multistream) {
+		var inputStream = new Stream();
+		inputStream.delegate = coerceInputStream(input);
+		inputStream.pos = 0;
+		inputStream.readByte = function() {
+			this.pos++;
+			return this.delegate.readByte();
+		};
+		if (inputStream.delegate.eof) inputStream.eof = inputStream.delegate.eof.bind(inputStream.delegate);
+		var outputStream = new Stream();
+		outputStream.pos = 0;
+		outputStream.writeByte = function() {
+			this.pos++;
+		};
+		var bz = new Bunzip(inputStream, outputStream);
+		var blockSize = bz.dbufSize;
+		while (true) {
+			if ("eof" in inputStream && inputStream.eof()) break;
+			var position = inputStream.pos * 8 + bz.reader.bitOffset;
+			if (bz.reader.hasByte) position -= 8;
+			if (bz._init_block()) {
+				var start = outputStream.pos;
+				bz._read_bunzip();
+				callback(position, outputStream.pos - start);
+			} else {
+				bz.reader.read(32);
+				if (multistream && "eof" in inputStream && !inputStream.eof()) {
+					bz._start_bunzip(inputStream, outputStream);
+					console.assert(bz.dbufSize === blockSize, "shouldn't change block size within multistream file");
+				} else break;
+			}
+		}
+	};
+	Bunzip.Stream = Stream;
+	Bunzip.version = pjson.version;
+	Bunzip.license = pjson.license;
+	module.exports = Bunzip;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-MZFCCXPZ.js
+var import_lib = /* @__PURE__ */ require_chunk.__toESM(require_lib(), 1);
+(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+var Ke = "file", Je = "link", Ve = "symlink", ke = "directory", Qe = {
+	file: "0",
+	link: "1",
+	symlink: "2",
+	"character-device": "3",
+	"block-device": "4",
+	directory: "5",
+	fifo: "6",
+	"pax-header": "x",
+	"pax-global-header": "g",
+	"gnu-long-name": "L",
+	"gnu-long-link-name": "K"
+}, et = {
+	0: Ke,
+	1: Je,
+	2: Ve,
+	3: "character-device",
+	4: "block-device",
+	5: ke,
+	6: "fifo",
+	x: "pax-header",
+	g: "pax-global-header",
+	L: "gnu-long-name",
+	K: "gnu-long-link-name"
+}, tt = new Uint8Array(512), _ = new Uint8Array(0), T = new TextEncoder(), ze = new TextDecoder();
+function P(e, t, i, r) {
+	r && T.encodeInto(r, e.subarray(t, t + i));
+}
+function L(e, t, i, r) {
+	if (r === void 0) return;
+	let n = r.toString(8).padStart(i - 1, "0");
+	T.encodeInto(n, e.subarray(t, t + i - 1));
+}
+function S(e, t, i) {
+	let r = e.indexOf(0, t), n = r === -1 || r > t + i ? t + i : r;
+	return ze.decode(e.subarray(t, n));
+}
+function ne(e, t, i) {
+	let r = 0, n = t + i;
+	for (let s = t; s < n; s++) {
+		let a = e[s];
+		if (a === 0) break;
+		a !== 32 && (r = r * 8 + (a - 48));
+	}
+	return r;
+}
+function W(e, t, i) {
+	if (e[t] & 128) {
+		let r = 0;
+		r = e[t] & 127;
+		for (let n = 1; n < i; n++) r = r * 256 + e[t + n];
+		if (!Number.isSafeInteger(r)) throw new Error("TAR number too large");
+		return r;
+	}
+	return ne(e, t, i);
+}
+var N = (e) => e.type === "directory" || e.type === "symlink" || e.type === "link" || e.type === "character-device" || e.type === "block-device" || e.type === "fifo";
+async function Ce(e) {
+	if (e == null) return _;
+	if (e instanceof Uint8Array) return e;
+	if (typeof e == "string") return T.encode(e);
+	if (e instanceof ArrayBuffer) return new Uint8Array(e);
+	if (e instanceof Blob) return new Uint8Array(await e.arrayBuffer());
+	throw new TypeError("Unsupported content type for entry body.");
+}
+var we = (e, t) => {
+	let i = e.split("/").filter(Boolean);
+	return t >= i.length ? "" : i.slice(t).join("/");
+};
+function Ae(e, t) {
+	let { strip: i, filter: r, map: n } = t;
+	if (!i && !r && !n) return e;
+	let s = { ...e };
+	if (i && i > 0) {
+		let o = we(s.name, i);
+		if (!o) return null;
+		if (s.name = s.type === "directory" && !o.endsWith("/") ? `${o}/` : o, s.linkname) {
+			let c = s.linkname.startsWith("/");
+			if (c || s.type === "link") {
+				let l = we(s.linkname, i);
+				s.linkname = c ? `/${l}` || "/" : l;
+			}
+		}
+	}
+	if (r?.(s) === !1) return null;
+	let a = n ? n(s) : s;
+	return a && (!a.name || !a.name.trim() || a.name === "." || a.name === "/") ? null : a;
+}
+var re = 32, rt = 48;
+function nt(e) {
+	let t = ne(e, 148, 8), i = 0;
+	for (let r = 0; r < e.length; r++) r >= 148 && r < 156 ? i += re : i += e[r];
+	return t === i;
+}
+function it(e) {
+	e.fill(re, 148, 156);
+	let t = 0;
+	for (let i of e) t += i;
+	for (let i = 153; i >= 148; i--) e[i] = (t & 7) + rt, t >>= 3;
+	e[154] = 0, e[155] = re;
+}
+var st = 256;
+function ot(e) {
+	let t = {};
+	T.encode(e.name).length > 100 && Ee(e.name) === null && (t.path = e.name), e.linkname && T.encode(e.linkname).length > 100 && (t.linkpath = e.linkname), e.uname && T.encode(e.uname).length > 32 && (t.uname = e.uname), e.gname && T.encode(e.gname).length > 32 && (t.gname = e.gname), e.uid != null && e.uid > 2097151 && (t.uid = String(e.uid)), e.gid != null && e.gid > 2097151 && (t.gid = String(e.gid)), e.size != null && e.size > 8589934591 && (t.size = String(e.size)), e.pax && Object.assign(t, e.pax);
+	let i = Object.entries(t);
+	if (i.length === 0) return null;
+	let r = T.encode(i.map(([n, s]) => {
+		let a = `${n}=${s}
+`, o = T.encode(a).length + 1, c = o + String(o).length;
+		return c = o + String(c).length, `${c} ${a}`;
+	}).join(""));
+	return {
+		paxHeader: $e({
+			name: ze.decode(T.encode(`PaxHeader/${e.name}`).slice(0, 100)),
+			size: r.length,
+			type: "pax-header",
+			mode: 420,
+			mtime: e.mtime,
+			uname: e.uname,
+			gname: e.gname,
+			uid: e.uid,
+			gid: e.gid
+		}),
+		paxBody: r
+	};
+}
+function Ee(e) {
+	let t = T.encode(e).length;
+	if (t <= 100 || t > st) return null;
+	for (let i = e.length - 1; i > 0; i--) {
+		if (e[i] !== "/") continue;
+		let r = e.slice(0, i), n = e.slice(i + 1);
+		if (T.encode(r).length <= 155 && T.encode(n).length <= 100) return {
+			prefix: r,
+			name: n
+		};
+	}
+	return null;
+}
+function $e(e) {
+	let t = new Uint8Array(512), i = N(e) ? 0 : e.size ?? 0, r = e.name, n = "";
+	if (!e.pax?.path) {
+		let s = Ee(r);
+		s && (r = s.name, n = s.prefix);
+	}
+	return P(t, 0, 100, r), L(t, 100, 8, e.mode ?? (e.type === "directory" ? 493 : 420)), L(t, 108, 8, e.uid ?? 0), L(t, 116, 8, e.gid ?? 0), L(t, 124, 12, i), L(t, 136, 12, Math.floor((e.mtime?.getTime() ?? Date.now()) / 1e3)), P(t, 156, 1, Qe[e.type ?? "file"]), P(t, 157, 100, e.linkname), P(t, 257, 6, "ustar\0"), P(t, 263, 2, "00"), P(t, 265, 32, e.uname), P(t, 297, 32, e.gname), P(t, 345, 155, n), it(t), t;
+}
+function at(e, t) {
+	if (t && !nt(e)) throw new Error("Invalid tar header checksum.");
+	let i = S(e, 156, 1), r = {
+		name: S(e, 0, 100),
+		mode: ne(e, 100, 8),
+		uid: W(e, 108, 8),
+		gid: W(e, 116, 8),
+		size: W(e, 124, 12),
+		mtime: /* @__PURE__ */ new Date(W(e, 136, 12) * 1e3),
+		type: et[i] || "file",
+		linkname: S(e, 157, 100)
+	}, n = S(e, 257, 6);
+	return N(r) && (r.size = 0), n.trim() === "ustar" && (r.uname = S(e, 265, 32), r.gname = S(e, 297, 32)), n === "ustar" && (r.prefix = S(e, 345, 155)), r;
+}
+var be = {
+	path: ["name", (e) => e],
+	linkpath: ["linkname", (e) => e],
+	size: ["size", (e) => parseInt(e, 10)],
+	mtime: ["mtime", parseFloat],
+	uid: ["uid", (e) => parseInt(e, 10)],
+	gid: ["gid", (e) => parseInt(e, 10)],
+	uname: ["uname", (e) => e],
+	gname: ["gname", (e) => e]
+};
+function lt(e) {
+	let t = new TextDecoder("utf-8"), i = Object.create(null), r = Object.create(null), n = 0;
+	for (; n < e.length;) {
+		let s = e.indexOf(32, n);
+		if (s === -1) break;
+		let a = parseInt(t.decode(e.subarray(n, s)), 10);
+		if (Number.isNaN(a) || a === 0) break;
+		let o = n + a, [c, l] = t.decode(e.subarray(s + 1, o - 1)).split("=", 2);
+		if (c && l !== void 0 && (r[c] = l, Object.hasOwn(be, c))) {
+			let [f, u] = be[c], y = u(l);
+			(typeof y == "string" || !Number.isNaN(y)) && (i[f] = y);
+		}
+		n = o;
+	}
+	return Object.keys(r).length > 0 && (i.pax = r), i;
+}
+function xe(e, t) {
+	t.name !== void 0 && (e.name = t.name), t.linkname !== void 0 && (e.linkname = t.linkname), t.size !== void 0 && (e.size = t.size), t.mtime !== void 0 && (e.mtime = /* @__PURE__ */ new Date(t.mtime * 1e3)), t.uid !== void 0 && (e.uid = t.uid), t.gid !== void 0 && (e.gid = t.gid), t.uname !== void 0 && (e.uname = t.uname), t.gname !== void 0 && (e.gname = t.gname), t.pax && (e.pax = Object.assign({}, e.pax ?? {}, t.pax));
+}
+function ct(e) {
+	switch (e) {
+		case "pax-global-header":
+		case "pax-header": return lt;
+		case "gnu-long-name": return (t) => ({ name: S(t, 0, t.length) });
+		case "gnu-long-link-name": return (t) => ({ linkname: S(t, 0, t.length) });
+		default: return;
+	}
+}
+function ft(e) {
+	let t = $e(e), i = ot(e);
+	if (!i) return [t];
+	let r = -i.paxBody.length & 511, n = r > 0 ? [tt.subarray(0, r)] : [];
+	return [
+		i.paxHeader,
+		i.paxBody,
+		...n,
+		t
+	];
+}
+var ut = new Uint8Array(512 * 2);
+function Be(e, t, i) {
+	let r = null, n = 0, s = !1, a = (o) => {
+		let c = new Error(o);
+		throw t(c), c;
+	};
+	return {
+		add(o) {
+			s && a("No new tar entries after finalize."), r !== null && a("Previous entry must be completed before adding a new one");
+			let c = N(o) ? 0 : o.size;
+			(!Number.isSafeInteger(c) || c < 0) && a("Invalid tar entry size.");
+			try {
+				let l = ft({
+					...o,
+					size: c
+				});
+				for (let f of l) e(f);
+				r = {
+					...o,
+					size: c
+				}, n = 0;
+			} catch (l) {
+				t(l);
+			}
+		},
+		write(o) {
+			r || a("No active tar entry."), s && a("Cannot write data after finalize.");
+			let c = n + o.length;
+			c > r.size && a(`"${r.name}" exceeds given size of ${r.size} bytes.`);
+			try {
+				n = c, e(o);
+			} catch (l) {
+				t(l);
+			}
+		},
+		endEntry() {
+			r || a("No active entry to end."), s && a("Cannot end entry after finalize.");
+			try {
+				n !== r.size && a(`Size mismatch for "${r.name}".`);
+				let o = -r.size & 511;
+				o > 0 && e(new Uint8Array(o)), r = null, n = 0;
+			} catch (o) {
+				throw t(o), o;
+			}
+		},
+		finalize() {
+			s && a("Archive has already been finalized"), r !== null && a("Cannot finalize while an entry is still active");
+			try {
+				e(ut), s = !0, i && i();
+			} catch (o) {
+				t(o);
+			}
+		}
+	};
+}
+var j = 256;
+function dt() {
+	let e = new Array(j), t = e.length - 1, i = 0, r = 0, n = 0, s = (o) => {
+		let c = e[i];
+		o === c.length ? (e[i] = _, i = i + 1 & t) : e[i] = c.subarray(o), n -= o, n === 0 && e.length > j && (e = new Array(j), t = j - 1, i = 0, r = 0);
+	};
+	function a(o, c) {
+		if (c) {
+			let g = 0, d = Math.min(o, n);
+			for (; d > 0;) {
+				let p = e[i], m = Math.min(d, p.length), x = m === p.length ? p : p.subarray(0, m);
+				if (s(m), d -= m, g += m, !c(x)) break;
+			}
+			return g;
+		}
+		if (n < o) return null;
+		if (o === 0) return _;
+		let l = e[i];
+		if (l.length >= o) {
+			let g = l.length === o ? l : l.subarray(0, o);
+			return s(o), g;
+		}
+		let f = new Uint8Array(o), u = 0, y = o;
+		for (; y > 0;) {
+			let g = e[i], d = Math.min(y, g.length);
+			f.set(d === g.length ? g : g.subarray(0, d), u), u += d, y -= d, s(d);
+		}
+		return f;
+	}
+	return {
+		push: (o) => {
+			if (o.length === 0) return;
+			let c = r + 1 & t;
+			if (c === i) {
+				let l = e.length, f = l * 2, u = new Array(f), y = r - i + l & l - 1;
+				if (i < r) for (let g = 0; g < y; g++) u[g] = e[i + g];
+				else if (y > 0) {
+					let g = l - i;
+					for (let d = 0; d < g; d++) u[d] = e[i + d];
+					for (let d = 0; d < r; d++) u[g + d] = e[d];
+				}
+				e = u, t = f - 1, i = 0, r = y, c = r + 1 & t;
+			}
+			e[r] = o, r = c, n += o.length;
+		},
+		available: () => n,
+		peek: (o) => {
+			if (n < o) return null;
+			if (o === 0) return _;
+			let c = e[i];
+			if (c.length >= o) return c.length === o ? c : c.subarray(0, o);
+			let l = new Uint8Array(o), f = 0, u = i;
+			for (; f < o;) {
+				let y = e[u], g = Math.min(o - f, y.length);
+				g === y.length ? l.set(y, f) : l.set(y.subarray(0, g), f), f += g, u = u + 1 & t;
+			}
+			return l;
+		},
+		discard: (o) => {
+			if (o > n) throw new Error("Too many bytes consumed");
+			if (o === 0) return;
+			let c = o;
+			for (; c > 0;) {
+				let l = e[i], f = Math.min(c, l.length);
+				s(f), c -= f;
+			}
+		},
+		pull: a
+	};
+}
+var te = 0, D = 1, H = /* @__PURE__ */ new Error("Tar archive is truncated.");
+function Te(e = {}) {
+	let t = e.strict ?? !1, { available: i, peek: r, push: n, discard: s, pull: a } = dt(), o = te, c = !1, l = !1, f = !1, u = null, y = {}, g = {}, d = {
+		isEntryActive: () => o === D,
+		isBodyComplete: () => !u || u.remaining === 0,
+		canFinish: () => !u || i() >= u.remaining + u.padding,
+		write(p) {
+			if (c) throw new Error("Archive already ended.");
+			n(p);
+		},
+		end() {
+			c = !0;
+		},
+		readHeader() {
+			if (o !== te) throw new Error("Cannot read header while an entry is active");
+			if (!l) for (; !l;) {
+				if (i() < 512) {
+					if (c) {
+						if (i() > 0 && t) throw H;
+						l = !0;
+						return;
+					}
+					return null;
+				}
+				let p = r(512);
+				if (ve(p)) {
+					if (i() < 512 * 2) {
+						if (c) {
+							if (t) throw H;
+							l = !0;
+							return;
+						}
+						return null;
+					}
+					if (ve(r(512 * 2).subarray(512))) {
+						s(512 * 2), l = !0, f = !0;
+						return;
+					}
+					if (t) throw new Error("Invalid tar header.");
+					s(512);
+					continue;
+				}
+				let m;
+				try {
+					m = at(p, t);
+				} catch (E) {
+					if (t) throw E;
+					s(512);
+					continue;
+				}
+				let x = ct(m.type);
+				if (x) {
+					let E = m.size + (-m.size & 511);
+					if (i() < 512 + E) {
+						if (c && t) throw H;
+						return null;
+					}
+					s(512);
+					let v = x(a(E).subarray(0, m.size)), $ = m.type === "pax-global-header" ? y : g;
+					for (let z in v) $[z] = v[z];
+					continue;
+				}
+				s(512);
+				let b = m;
+				return m.prefix && (b.name = `${m.prefix}/${b.name}`), xe(b, y), xe(b, g), b.name.endsWith("/") && b.type === "file" && (b.type = ke), g = {}, u = {
+					header: b,
+					remaining: b.size,
+					padding: -b.size & 511
+				}, o = D, b;
+			}
+		},
+		streamBody(p) {
+			if (o !== D || !u || u.remaining === 0) return 0;
+			let m = Math.min(u.remaining, i());
+			if (m === 0) return 0;
+			let x = a(m, p);
+			return u.remaining -= x, x;
+		},
+		skipPadding() {
+			if (o !== D || !u) return !0;
+			if (u.remaining > 0) throw new Error("Body not fully consumed");
+			return i() < u.padding ? !1 : (s(u.padding), u = null, o = te, !0);
+		},
+		skipEntry() {
+			if (o !== D || !u) return !0;
+			let p = Math.min(u.remaining, i());
+			return p > 0 && (s(p), u.remaining -= p), u.remaining > 0 ? !1 : d.skipPadding();
+		},
+		validateEOF() {
+			if (t) {
+				if (!f) throw H;
+				if (i() > 0 && a(i()).some((p) => p !== 0)) throw new Error("Invalid EOF.");
+			}
+		}
+	};
+	return d;
+}
+function ve(e) {
+	if (e.byteOffset % 8 === 0) {
+		let t = new BigUint64Array(e.buffer, e.byteOffset, e.length / 8);
+		for (let i = 0; i < t.length; i++) if (t[i] !== 0n) return !1;
+		return !0;
+	}
+	for (let t = 0; t < e.length; t++) if (e[t] !== 0) return !1;
+	return !0;
+}
+function Fe() {
+	return new CompressionStream("gzip");
+}
+function Ie() {
+	return new DecompressionStream("gzip");
+}
+function mt() {
+	let e, t;
+	return {
+		readable: new ReadableStream({ start(i) {
+			e = i, t = Be(i.enqueue.bind(i), i.error.bind(i), i.close.bind(i));
+		} }),
+		controller: {
+			add(i) {
+				let r = N(i);
+				return t.add(i), r && t.endEntry(), new WritableStream({
+					write(n) {
+						t.write(n);
+					},
+					close() {
+						r || t.endEntry();
+					},
+					abort(n) {
+						e.error(n);
+					}
+				});
+			},
+			finalize() {
+				t.finalize();
+			},
+			error(i) {
+				e.error(i);
+			}
+		}
+	};
+}
+async function Pe(e) {
+	let t = [], i = e.getReader(), r = 0;
+	try {
+		for (;;) {
+			let { done: a, value: o } = await i.read();
+			if (a) break;
+			t.push(o), r += o.length;
+		}
+		let n = new Uint8Array(r), s = 0;
+		for (let a of t) n.set(a, s), s += a.length;
+		return n;
+	} finally {
+		i.releaseLock();
+	}
+}
+var Se = (e) => e.pipeTo(new WritableStream());
+function ht(e = {}) {
+	let t = Te(e), i = e.strict ?? !1, r = null, n = null, s = !1, a = !1, o = !1, c = !1, l = () => {
+		try {
+			n?.close();
+		} catch {}
+		n = null;
+	}, f = (d) => {
+		if (!c) {
+			c = !0;
+			try {
+				n?.error(d);
+			} catch {}
+			n = null;
+			try {
+				r.error(d);
+			} catch {}
+			r = null;
+		}
+	}, u = () => {
+		if (!c) {
+			c = !0, l();
+			try {
+				r.close();
+			} catch {}
+			r = null;
+		}
+	}, y = () => {
+		if (i) throw new Error("Tar archive is truncated.");
+		u();
+	}, g = () => {
+		if (!(s || c || !r)) {
+			s = !0;
+			try {
+				for (;;) {
+					if (a) {
+						o && (t.validateEOF(), u());
+						break;
+					}
+					if (t.isEntryActive()) {
+						if (o && !t.canFinish()) {
+							y();
+							break;
+						}
+						if (n) {
+							if ((n.desiredSize ?? 1) <= 0) break;
+							if (t.streamBody((d) => (n.enqueue(d), (n.desiredSize ?? 1) > 0)) === 0 && !t.isBodyComplete()) {
+								o && y();
+								break;
+							}
+						} else if (!t.skipEntry()) {
+							o && y();
+							break;
+						}
+						if (t.isBodyComplete() && (l(), !t.skipPadding())) {
+							o && y();
+							break;
+						}
+					} else {
+						if ((r.desiredSize ?? 0) < 0) break;
+						let d = t.readHeader();
+						if (d === null) {
+							o && u();
+							break;
+						}
+						if (d === void 0) {
+							if (o) {
+								t.validateEOF(), u();
+								break;
+							}
+							a = !0;
+							break;
+						}
+						r.enqueue({
+							header: d,
+							body: new ReadableStream({
+								start(p) {
+									d.size === 0 ? p.close() : n = p;
+								},
+								pull: g,
+								cancel() {
+									n = null, g();
+								}
+							})
+						});
+					}
+				}
+			} catch (d) {
+				throw f(d), d;
+			} finally {
+				s = !1;
+			}
+		}
+	};
+	return {
+		readable: new ReadableStream({
+			start(d) {
+				r = d;
+			},
+			pull: g,
+			cancel(d) {
+				d !== void 0 ? f(d) : u();
+			}
+		}, { highWaterMark: 2 }),
+		writable: new WritableStream({
+			write(d) {
+				try {
+					if (a && i && d.some((p) => p !== 0)) throw new Error("Invalid EOF.");
+					t.write(d), g();
+				} catch (p) {
+					throw f(p), p;
+				}
+			},
+			close() {
+				try {
+					o = !0, t.end(), g();
+				} catch (d) {
+					throw f(d), d;
+				}
+			},
+			abort(d) {
+				f(d);
+			}
+		})
+	};
+}
+async function Oe(e) {
+	let { readable: t, controller: i } = mt();
+	return await (async () => {
+		for (let r of e) {
+			let n = i.add(r.header), s = "body" in r ? r.body : r.data;
+			if (!s) {
+				await n.close();
+				continue;
+			}
+			if (s instanceof ReadableStream) await s.pipeTo(n);
+			else if (s instanceof Blob) await s.stream().pipeTo(n);
+			else try {
+				let a = await Ce(s);
+				if (a.length > 0) {
+					let o = n.getWriter();
+					await o.write(a), await o.close();
+				} else await n.close();
+			} catch {
+				throw new TypeError(`Unsupported content type for entry "${r.header.name}".`);
+			}
+		}
+	})().then(() => i.finalize()).catch((r) => i.error(r)), new Uint8Array(await Pe(t));
+}
+async function Ue(e, t = {}) {
+	let i = e instanceof ReadableStream ? e : new ReadableStream({ start(s) {
+		s.enqueue(e instanceof Uint8Array ? e : new Uint8Array(e)), s.close();
+	} }), r = [], n = i.pipeThrough(ht(t));
+	for await (let s of n) {
+		let a;
+		try {
+			a = Ae(s.header, t);
+		} catch (o) {
+			throw await s.body.cancel(), o;
+		}
+		if (a === null) {
+			await Se(s.body);
+			continue;
+		}
+		N(a) ? (await Se(s.body), r.push({ header: a })) : r.push({
+			header: a,
+			data: await Pe(s.body)
+		});
+	}
+	return r;
+}
+var pt = (() => {
+	let e = new Uint32Array(256);
+	for (let t = 0; t < 256; t++) {
+		let i = t << 24;
+		for (let r = 0; r < 8; r++) i = i & 2147483648 ? i << 1 ^ 79764919 : i << 1;
+		e[t] = i >>> 0;
+	}
+	return e;
+})();
+function gt(e, t) {
+	return (e << 8 ^ pt[(e >>> 24 ^ t) & 255]) >>> 0;
+}
+var ie = class {
+	buffer = [];
+	current = 0;
+	bitCount = 0;
+	writeBits(t, i) {
+		for (let r = t - 1; r >= 0; r--) this.current = this.current << 1 | i >>> r & 1, this.bitCount++, this.bitCount === 8 && (this.buffer.push(this.current), this.current = 0, this.bitCount = 0);
+	}
+	writeBit(t) {
+		this.current = this.current << 1 | t & 1, this.bitCount++, this.bitCount === 8 && (this.buffer.push(this.current), this.current = 0, this.bitCount = 0);
+	}
+	finish() {
+		return this.bitCount > 0 && this.buffer.push(this.current << 8 - this.bitCount), new Uint8Array(this.buffer);
+	}
+};
+function yt(e) {
+	let t = [], i = 0;
+	for (; i < e.length;) {
+		let r = e[i], n = 1;
+		for (; i + n < e.length && e[i + n] === r && n < 255;) n++;
+		n >= 4 ? (t.push(r, r, r, r), t.push(n - 4), i += n) : (t.push(r), i++);
+	}
+	return new Uint8Array(t);
+}
+function wt(e) {
+	let t = e.length;
+	if (t === 0) return {
+		transformed: new Uint8Array(0),
+		pointer: 0
+	};
+	let i = bt(e), r = new Uint8Array(t), n = 0;
+	for (let s = 0; s < t; s++) i[s] === 0 ? (n = s, r[s] = e[t - 1]) : r[s] = e[i[s] - 1];
+	return {
+		transformed: r,
+		pointer: n
+	};
+}
+function bt(e) {
+	let t = e.length, i = new Int32Array(t), r = new Int32Array(t);
+	for (let n = 0; n < t; n++) i[n] = n, r[n] = e[n];
+	for (let n = 1; n < t; n *= 2) {
+		let s = r.slice();
+		i.sort((a, o) => s[a] !== s[o] ? s[a] - s[o] : s[(a + n) % t] - s[(o + n) % t]), r[i[0]] = 0;
+		for (let a = 1; a < t; a++) s[i[a]] === s[i[a - 1]] && s[(i[a] + n) % t] === s[(i[a - 1] + n) % t] ? r[i[a]] = r[i[a - 1]] : r[i[a]] = r[i[a - 1]] + 1;
+		if (r[i[t - 1]] === t - 1) break;
+	}
+	return i;
+}
+function xt(e, t) {
+	let i = [];
+	for (let a = 0; a < 256; a++) t[a] && i.push(a);
+	let r = new Array(256).fill(-1);
+	for (let a = 0; a < i.length; a++) r[i[a]] = a;
+	let n = new Uint16Array(e.length), s = i.slice();
+	for (let a = 0; a < e.length; a++) {
+		let o = e[a], c = 0;
+		for (; s[c] !== o;) c++;
+		if (n[a] = c, c > 0) {
+			let l = s[c];
+			for (let f = c; f > 0; f--) s[f] = s[f - 1];
+			s[0] = l;
+		}
+	}
+	return {
+		encoded: n,
+		length: e.length
+	};
+}
+function vt(e, t, i) {
+	let s = i + 1, a = [], o = 0;
+	for (; o < t;) if (e[o] === 0) {
+		let l = 0;
+		for (; o < t && e[o] === 0;) l++, o++;
+		let f = l;
+		for (; f > 0;) f--, f & 1 ? a.push(1) : a.push(0), f >>>= 1;
+	} else a.push(e[o] + 1), o++;
+	a.push(s);
+	let c = new Uint16Array(a.length);
+	for (let l = 0; l < a.length; l++) c[l] = a[l];
+	return {
+		symbols: c,
+		length: a.length,
+		eob: s
+	};
+}
+function Ne(e, t, i) {
+	if (t <= 1) {
+		let l = new Array(e.length).fill(0);
+		for (let f = 0; f < e.length; f++) e[f] > 0 && (l[f] = 1);
+		return {
+			codeLengths: l,
+			maxLen: 1,
+			minLen: 1
+		};
+	}
+	let r = [];
+	for (let l = 0; l < e.length; l++) e[l] > 0 && r.push({
+		freq: e[l],
+		symbol: l,
+		left: null,
+		right: null
+	});
+	if (r.length === 0) return {
+		codeLengths: new Array(e.length).fill(0),
+		maxLen: 0,
+		minLen: 0
+	};
+	if (r.length === 1) {
+		let l = new Array(e.length).fill(0);
+		return l[r[0].symbol] = 1, {
+			codeLengths: l,
+			maxLen: 1,
+			minLen: 1
+		};
+	}
+	for (; r.length > 1;) {
+		r.sort((u, y) => u.freq - y.freq);
+		let l = r.shift(), f = r.shift();
+		r.push({
+			freq: l.freq + f.freq,
+			symbol: -1,
+			left: l,
+			right: f
+		});
+	}
+	let n = new Array(e.length).fill(0);
+	function s(l, f) {
+		if (!l.left && !l.right) {
+			n[l.symbol] = f;
+			return;
+		}
+		l.left && s(l.left, f + 1), l.right && s(l.right, f + 1);
+	}
+	s(r[0], 0);
+	let a = !0;
+	for (; a;) {
+		a = !1;
+		for (let l = 0; l < n.length; l++) n[l] > i && (n[l] = i, a = !0);
+		if (a) {
+			let l = 0;
+			for (let f = 0; f < n.length; f++) n[f] > 0 && (l += 1 / (1 << n[f]));
+			if (l > 1) for (let f = 1; f < i && l > 1; f++) for (let u = 0; u < n.length && l > 1; u++) n[u] === f && (n[u]++, l -= 1 / (1 << f) - 1 / (1 << f + 1));
+			a = !1;
+			for (let f = 0; f < n.length; f++) if (n[f] > i) {
+				a = !0;
+				break;
+			}
+		}
+	}
+	let o = i, c = 0;
+	for (let l = 0; l < n.length; l++) n[l] > 0 && (n[l] < o && (o = n[l]), n[l] > c && (c = n[l]));
+	return {
+		codeLengths: n,
+		maxLen: c,
+		minLen: o
+	};
+}
+function kt(e, t) {
+	let i = new Array(t).fill(0), r = e.slice(0, t), n = Math.max(...r, 0), s = new Array(n + 1).fill(0);
+	for (let c = 0; c < t; c++) r[c] > 0 && s[r[c]]++;
+	let a = new Array(n + 1).fill(0), o = 0;
+	for (let c = 1; c <= n; c++) o = o + s[c - 1] << 1, a[c] = o;
+	for (let c = 0; c < t; c++) r[c] > 0 && (i[c] = a[r[c]]++);
+	return {
+		codes: i,
+		lengths: r
+	};
+}
+function zt(e, t, i) {
+	e.writeBits(24, 3227993), e.writeBits(24, 2511705), e.writeBits(32, i), e.writeBit(0);
+	let { transformed: n, pointer: s } = wt(yt(t));
+	e.writeBits(24, s);
+	let a = new Array(256).fill(!1);
+	for (let h = 0; h < n.length; h++) a[n[h]] = !0;
+	let o = new Array(16).fill(!1);
+	for (let h = 0; h < 16; h++) for (let w = 0; w < 16; w++) if (a[h * 16 + w]) {
+		o[h] = !0;
+		break;
+	}
+	for (let h = 0; h < 16; h++) e.writeBit(o[h] ? 1 : 0);
+	for (let h = 0; h < 16; h++) if (o[h]) for (let w = 0; w < 16; w++) e.writeBit(a[h * 16 + w] ? 1 : 0);
+	let c = 0;
+	for (let h = 0; h < 256; h++) a[h] && c++;
+	let { encoded: l, length: f } = xt(n, a), { symbols: u, length: y } = vt(l, f, c), g = c + 2, d = 50, p = Math.ceil(y / d), m;
+	y < 200 ? m = 2 : y < 600 ? m = 3 : y < 1200 ? m = 4 : y < 2400 ? m = 5 : m = 6, m > p && (m = Math.max(2, p));
+	let x = [];
+	for (let h = 0; h < m; h++) x.push(new Array(g).fill(0));
+	let b = new Int32Array(p);
+	for (let h = 0; h < p; h++) b[h] = h % m;
+	for (let h = 0; h < p; h++) {
+		let w = h * d, k = Math.min(w + d, y), B = b[h];
+		for (let C = w; C < k; C++) x[B][u[C]]++;
+	}
+	function E(h) {
+		for (let w = 0; w < g; w++) h[w] < 1 && (h[w] = 1);
+	}
+	let v = [];
+	for (let h = 0; h < m; h++) E(x[h]), v.push(Ne(x[h], g, 20));
+	for (let h = 0; h < 4; h++) {
+		for (let w = 0; w < m; w++) x[w].fill(0);
+		for (let w = 0; w < p; w++) {
+			let k = w * d, B = Math.min(k + d, y), C = 0, M = Infinity;
+			for (let I = 0; I < m; I++) {
+				let J = 0;
+				for (let V = k; V < B; V++) J += v[I].codeLengths[u[V]] || 20;
+				J < M && (M = J, C = I);
+			}
+			b[w] = C;
+			for (let I = k; I < B; I++) x[C][u[I]]++;
+		}
+		for (let w = 0; w < m; w++) E(x[w]), v[w] = Ne(x[w], g, 20);
+	}
+	e.writeBits(3, m), e.writeBits(15, p);
+	let $ = [], z = [];
+	for (let h = 0; h < m; h++) z.push(h);
+	for (let h = 0; h < p; h++) {
+		let w = b[h], k = 0;
+		for (; z[k] !== w;) k++;
+		if ($.push(k), k > 0) {
+			let B = z[k];
+			for (let C = k; C > 0; C--) z[C] = z[C - 1];
+			z[0] = B;
+		}
+	}
+	for (let h = 0; h < p; h++) {
+		for (let w = 0; w < $[h]; w++) e.writeBit(1);
+		e.writeBit(0);
+	}
+	for (let h = 0; h < m; h++) {
+		let w = v[h].codeLengths, k = w[0];
+		e.writeBits(5, k);
+		for (let B = 0; B < g; B++) {
+			let C = w[B];
+			for (; k < C;) e.writeBit(1), e.writeBit(0), k++;
+			for (; k > C;) e.writeBit(1), e.writeBit(1), k--;
+			e.writeBit(0);
+		}
+	}
+	for (let h = 0; h < m; h++) {
+		let { codes: w, lengths: k } = kt(v[h].codeLengths, g);
+		v[h] = Object.assign(v[h], {
+			_codes: w,
+			_lengths: k
+		});
+	}
+	let he = 0, R = 0;
+	for (let h = 0; h < y; h++) {
+		(R === 0 || R >= d) && (h > 0 && he++, R = 0);
+		let k = v[b[he]], B = u[h], C = k._lengths[B], M = k._codes[B];
+		C > 0 && e.writeBits(C, M), R++;
+	}
+}
+var Ct = 10 * 1024 * 1024;
+function Le(e, t = 9, i = Ct) {
+	if (t < 1 || t > 9) throw new Error("Block size level must be 1-9");
+	if (e.length > i) throw new Error(`Input too large for bzip2 compression (${e.length} bytes, max ${i})`);
+	let r = t * 1e5, n = new ie();
+	n.writeBits(8, 66), n.writeBits(8, 90), n.writeBits(8, 104), n.writeBits(8, 48 + t);
+	let s = 0, a = 0;
+	for (; a < e.length;) {
+		let o = Math.min(a + r, e.length), c = e.subarray(a, o), l = 4294967295;
+		for (let f = 0; f < c.length; f++) l = gt(l, c[f]);
+		l = ~l >>> 0, s = (s << 1 | s >>> 31) >>> 0, s = (s ^ l) >>> 0, zt(n, c, l), a = o;
+	}
+	return n.writeBits(24, 1536581), n.writeBits(24, 3690640), n.writeBits(32, s), n.finish();
+}
+var X = null, Z = null;
+async function Me() {
+	if (X) return X;
+	if (Z) throw Z;
+	try {
+		return X = await require_chunk_TN7HHBQW._.runTrustedAsync(() => Promise.resolve().then(() => require("./lzma-xM_ySpEU.cjs"))), X;
+	} catch {
+		throw Z = /* @__PURE__ */ new Error("xz compression requires node-liblzma which failed to load. Install liblzma-dev (apt) or xz (brew) and reinstall dependencies."), Z;
+	}
+}
+var G = null, q = null;
+async function We() {
+	if (G) return G;
+	if (q) throw q;
+	try {
+		return G = await require_chunk_TN7HHBQW._.runTrustedAsync(() => Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require("./lib-BDS_VKdS.cjs").default, 1))), G;
+	} catch {
+		throw q = /* @__PURE__ */ new Error("zstd compression requires @mongodb-js/zstd which is not installed. Install it with: npm install @mongodb-js/zstd"), q;
+	}
+}
+var A = 100 * 1024 * 1024, De = 512, Re = 1e4;
+function Et(e) {
+	let t = "file";
+	e.isDirectory ? t = "directory" : e.isSymlink && (t = "symlink");
+	let i = e.name;
+	e.isDirectory && !i.endsWith("/") && (i += "/");
+	let r;
+	e.content !== void 0 && (typeof e.content == "string" ? r = new TextEncoder().encode(e.content) : r = e.content);
+	let n = e.isDirectory || e.isSymlink ? 0 : r?.length ?? 0;
+	return {
+		header: {
+			name: i,
+			mode: e.mode ?? (e.isDirectory ? 493 : 420),
+			uid: e.uid ?? 0,
+			gid: e.gid ?? 0,
+			size: n,
+			mtime: e.mtime ?? /* @__PURE__ */ new Date(),
+			type: t,
+			linkname: e.linkTarget ?? "",
+			uname: "user",
+			gname: "user"
+		},
+		body: r
+	};
+}
+async function O(e) {
+	return Oe(e.map(Et));
+}
+async function je(e) {
+	let t = await O(e), n = new ReadableStream({ start(l) {
+		l.enqueue(t), l.close();
+	} }).pipeThrough(Fe()).getReader(), s = [];
+	for (;;) {
+		let { done: l, value: f } = await n.read();
+		if (l) break;
+		s.push(f);
+	}
+	let a = s.reduce((l, f) => l + f.length, 0), o = new Uint8Array(a), c = 0;
+	for (let l of s) o.set(l, c), c += l.length;
+	return o;
+}
+async function F(e) {
+	if (e.length > A) return {
+		entries: [],
+		error: `Archive too large (max ${A} bytes)`
+	};
+	if (e.length < De || e.length % De !== 0) return {
+		entries: [],
+		error: "Invalid tar archive format"
+	};
+	try {
+		let t = await Ue(e), i = [];
+		for (let r of t) {
+			if (i.length >= Re) return {
+				entries: i,
+				error: `Too many entries (max ${Re})`
+			};
+			let n = "file";
+			switch (r.header.type) {
+				case "directory":
+					n = "directory";
+					break;
+				case "symlink":
+					n = "symlink";
+					break;
+				case "link":
+					n = "hardlink";
+					break;
+				case "file":
+					n = "file";
+					break;
+				default: n = "other";
+			}
+			i.push({
+				name: r.header.name,
+				mode: r.header.mode ?? 420,
+				uid: r.header.uid ?? 0,
+				gid: r.header.gid ?? 0,
+				size: r.header.size,
+				mtime: r.header.mtime ?? /* @__PURE__ */ new Date(),
+				type: n,
+				linkTarget: r.header.linkname || void 0,
+				content: r.data ?? new Uint8Array(0)
+			});
+		}
+		return { entries: i };
+	} catch (t) {
+		return {
+			entries: [],
+			error: t instanceof Error ? t.message : "Unknown error"
+		};
+	}
+}
+async function se(e) {
+	if (e.length > A) return {
+		entries: [],
+		error: `Archive too large (max ${A} bytes)`
+	};
+	try {
+		let r = new ReadableStream({ start(c) {
+			c.enqueue(e), c.close();
+		} }).pipeThrough(Ie()).getReader(), n = [], s = 0;
+		for (;;) {
+			let { done: c, value: l } = await r.read();
+			if (c) break;
+			if (s += l.length, s > A) return await r.cancel(), {
+				entries: [],
+				error: `Decompressed archive too large (max ${A} bytes)`
+			};
+			n.push(l);
+		}
+		let a = new Uint8Array(s), o = 0;
+		for (let c of n) a.set(c, o), o += c.length;
+		return F(a);
+	} catch (t) {
+		return {
+			entries: [],
+			error: `Decompression failed: ${t instanceof Error ? t.message : "Unknown error"}`
+		};
+	}
+}
+function oe(e) {
+	return e.length >= 2 && e[0] === 31 && e[1] === 139;
+}
+function ae(e) {
+	return e.length >= 3 && e[0] === 66 && e[1] === 90 && e[2] === 104;
+}
+function le(e) {
+	return e.length >= 6 && e[0] === 253 && e[1] === 55 && e[2] === 122 && e[3] === 88 && e[4] === 90 && e[5] === 0;
+}
+async function $t(e) {
+	let t = import_lib.default.decode(Buffer.from(e));
+	return new Uint8Array(t);
+}
+async function Bt(e) {
+	return Le(e, 9);
+}
+async function Tt(e) {
+	let i = (await Me()).unxzSync(Buffer.from(e));
+	return new Uint8Array(i);
+}
+async function St(e) {
+	let i = (await Me()).xzSync(Buffer.from(e));
+	return new Uint8Array(i);
+}
+async function He(e) {
+	return Bt(await O(e));
+}
+async function _e(e, t) {
+	if (!t?.allowNativeCodecs) throw new Error("xz compression is disabled by default (native codec risk). Pass { allowNativeCodecs: true } to opt in.");
+	return St(await O(e));
+}
+async function ce(e) {
+	if (e.length > A) return {
+		entries: [],
+		error: `Archive too large (max ${A} bytes)`
+	};
+	try {
+		let t = await $t(e);
+		return t.length > A ? {
+			entries: [],
+			error: `Decompressed archive too large (max ${A} bytes)`
+		} : F(t);
+	} catch (t) {
+		return {
+			entries: [],
+			error: t instanceof Error ? t.message : "Unknown error"
+		};
+	}
+}
+async function fe(e, t) {
+	if (!t?.allowNativeCodecs) return {
+		entries: [],
+		error: "xz decompression is disabled by default (native codec risk). Pass { allowNativeCodecs: true } to opt in, or decompress the archive externally before extraction."
+	};
+	if (e.length > A) return {
+		entries: [],
+		error: `Archive too large (max ${A} bytes)`
+	};
+	try {
+		let i = await Tt(e);
+		return i.length > A ? {
+			entries: [],
+			error: `Decompressed archive too large (max ${A} bytes)`
+		} : F(i);
+	} catch (i) {
+		return {
+			entries: [],
+			error: i instanceof Error ? i.message : "Unknown error"
+		};
+	}
+}
+function ue(e) {
+	return e.length >= 4 && e[0] === 40 && e[1] === 181 && e[2] === 47 && e[3] === 253;
+}
+async function Ft(e) {
+	let i = await (await We()).compress(Buffer.from(e), 3);
+	return new Uint8Array(i);
+}
+async function It(e) {
+	let i = await (await We()).decompress(Buffer.from(e));
+	return new Uint8Array(i);
+}
+async function Xe(e, t) {
+	if (!t?.allowNativeCodecs) throw new Error("zstd compression is disabled by default (native codec risk). Pass { allowNativeCodecs: true } to opt in.");
+	return Ft(await O(e));
+}
+async function de(e, t) {
+	if (!t?.allowNativeCodecs) return {
+		entries: [],
+		error: "zstd decompression is disabled by default (native codec risk). Pass { allowNativeCodecs: true } to opt in, or decompress the archive externally before extraction."
+	};
+	if (e.length > A) return {
+		entries: [],
+		error: `Archive too large (max ${A} bytes)`
+	};
+	try {
+		let i = await It(e);
+		return i.length > A ? {
+			entries: [],
+			error: `Decompressed archive too large (max ${A} bytes)`
+		} : F(i);
+	} catch (i) {
+		return {
+			entries: [],
+			error: i instanceof Error ? i.message : "Unknown error"
+		};
+	}
+}
+function Ze(e) {
+	let t = {
+		create: !1,
+		append: !1,
+		update: !1,
+		extract: !1,
+		list: !1,
+		file: "",
+		autoCompress: !1,
+		gzip: !1,
+		bzip2: !1,
+		xz: !1,
+		zstd: !1,
+		verbose: !1,
+		toStdout: !1,
+		keepOldFiles: !1,
+		touch: !1,
+		directory: "",
+		preserve: !1,
+		absoluteNames: !1,
+		strip: 0,
+		exclude: [],
+		filesFrom: "",
+		excludeFrom: "",
+		wildcards: !1
+	}, i = [], r$1 = 0;
+	for (; r$1 < e.length;) {
+		let n = e[r$1];
+		if (n.startsWith("-") && !n.startsWith("--") && n.length > 2) {
+			if (/^-\d+$/.test(n)) {
+				i.push(n), r$1++;
+				continue;
+			}
+			for (let s = 1; s < n.length; s++) {
+				let a = n[s];
+				switch (a) {
+					case "c":
+						t.create = !0;
+						break;
+					case "r":
+						t.append = !0;
+						break;
+					case "u":
+						t.update = !0;
+						break;
+					case "x":
+						t.extract = !0;
+						break;
+					case "t":
+						t.list = !0;
+						break;
+					case "a":
+						t.autoCompress = !0;
+						break;
+					case "z":
+						t.gzip = !0;
+						break;
+					case "j":
+						t.bzip2 = !0;
+						break;
+					case "J":
+						t.xz = !0;
+						break;
+					case "v":
+						t.verbose = !0;
+						break;
+					case "O":
+						t.toStdout = !0;
+						break;
+					case "k":
+						t.keepOldFiles = !0;
+						break;
+					case "m":
+						t.touch = !0;
+						break;
+					case "p":
+						t.preserve = !0;
+						break;
+					case "P":
+						t.absoluteNames = !0;
+						break;
+					case "f":
+						if (s < n.length - 1) t.file = n.substring(s + 1), s = n.length;
+						else {
+							if (r$1++, r$1 >= e.length) return {
+								ok: !1,
+								error: {
+									stdout: "",
+									stderr: `tar: option requires an argument -- 'f'
+`,
+									exitCode: 2
+								}
+							};
+							t.file = e[r$1];
+						}
+						break;
+					case "C":
+						if (s < n.length - 1) t.directory = n.substring(s + 1), s = n.length;
+						else {
+							if (r$1++, r$1 >= e.length) return {
+								ok: !1,
+								error: {
+									stdout: "",
+									stderr: `tar: option requires an argument -- 'C'
+`,
+									exitCode: 2
+								}
+							};
+							t.directory = e[r$1];
+						}
+						break;
+					case "T":
+						if (s < n.length - 1) t.filesFrom = n.substring(s + 1), s = n.length;
+						else {
+							if (r$1++, r$1 >= e.length) return {
+								ok: !1,
+								error: {
+									stdout: "",
+									stderr: `tar: option requires an argument -- 'T'
+`,
+									exitCode: 2
+								}
+							};
+							t.filesFrom = e[r$1];
+						}
+						break;
+					case "X":
+						if (s < n.length - 1) t.excludeFrom = n.substring(s + 1), s = n.length;
+						else {
+							if (r$1++, r$1 >= e.length) return {
+								ok: !1,
+								error: {
+									stdout: "",
+									stderr: `tar: option requires an argument -- 'X'
+`,
+									exitCode: 2
+								}
+							};
+							t.excludeFrom = e[r$1];
+						}
+						break;
+					default: return {
+						ok: !1,
+						error: require_chunk_QAYAQNCG.r("tar", `-${a}`)
+					};
+				}
+			}
+			r$1++;
+			continue;
+		}
+		if (n === "-c" || n === "--create") t.create = !0;
+		else if (n === "-r" || n === "--append") t.append = !0;
+		else if (n === "-u" || n === "--update") t.update = !0;
+		else if (n === "-x" || n === "--extract" || n === "--get") t.extract = !0;
+		else if (n === "-t" || n === "--list") t.list = !0;
+		else if (n === "-a" || n === "--auto-compress") t.autoCompress = !0;
+		else if (n === "-z" || n === "--gzip" || n === "--gunzip") t.gzip = !0;
+		else if (n === "-j" || n === "--bzip2") t.bzip2 = !0;
+		else if (n === "-J" || n === "--xz") t.xz = !0;
+		else if (n === "--zstd") t.zstd = !0;
+		else if (n === "-v" || n === "--verbose") t.verbose = !0;
+		else if (n === "-O" || n === "--to-stdout") t.toStdout = !0;
+		else if (n === "-k" || n === "--keep-old-files") t.keepOldFiles = !0;
+		else if (n === "-m" || n === "--touch") t.touch = !0;
+		else if (n === "--wildcards") t.wildcards = !0;
+		else if (n === "-p" || n === "--preserve" || n === "--preserve-permissions") t.preserve = !0;
+		else if (n === "-P" || n === "--absolute-names") t.absoluteNames = !0;
+		else if (n === "-f" || n === "--file") {
+			if (r$1++, r$1 >= e.length) return {
+				ok: !1,
+				error: {
+					stdout: "",
+					stderr: `tar: option requires an argument -- 'f'
+`,
+					exitCode: 2
+				}
+			};
+			t.file = e[r$1];
+		} else if (n.startsWith("--file=")) t.file = n.substring(7);
+		else if (n === "-C" || n === "--directory") {
+			if (r$1++, r$1 >= e.length) return {
+				ok: !1,
+				error: {
+					stdout: "",
+					stderr: `tar: option requires an argument -- 'C'
+`,
+					exitCode: 2
+				}
+			};
+			t.directory = e[r$1];
+		} else if (n.startsWith("--directory=")) t.directory = n.substring(12);
+		else if (n.startsWith("--strip-components=") || n.startsWith("--strip=")) {
+			let s = n.includes("--strip-components=") ? n.substring(19) : n.substring(8), a = parseInt(s, 10);
+			if (Number.isNaN(a) || a < 0) return {
+				ok: !1,
+				error: {
+					stdout: "",
+					stderr: `tar: invalid number for --strip: '${s}'
+`,
+					exitCode: 2
+				}
+			};
+			t.strip = a;
+		} else if (n.startsWith("--exclude=")) t.exclude.push(n.substring(10));
+		else if (n === "--exclude") {
+			if (r$1++, r$1 >= e.length) return {
+				ok: !1,
+				error: {
+					stdout: "",
+					stderr: `tar: option '--exclude' requires an argument
+`,
+					exitCode: 2
+				}
+			};
+			t.exclude.push(e[r$1]);
+		} else if (n === "-T" || n === "--files-from") {
+			if (r$1++, r$1 >= e.length) return {
+				ok: !1,
+				error: {
+					stdout: "",
+					stderr: `tar: option requires an argument -- 'T'
+`,
+					exitCode: 2
+				}
+			};
+			t.filesFrom = e[r$1];
+		} else if (n.startsWith("--files-from=")) t.filesFrom = n.substring(13);
+		else if (n === "-X" || n === "--exclude-from") {
+			if (r$1++, r$1 >= e.length) return {
+				ok: !1,
+				error: {
+					stdout: "",
+					stderr: `tar: option requires an argument -- 'X'
+`,
+					exitCode: 2
+				}
+			};
+			t.excludeFrom = e[r$1];
+		} else if (n.startsWith("--exclude-from=")) t.excludeFrom = n.substring(15);
+		else if (n === "--") {
+			i.push(...e.slice(r$1 + 1));
+			break;
+		} else {
+			if (n.startsWith("-")) return {
+				ok: !1,
+				error: require_chunk_QAYAQNCG.r("tar", n)
+			};
+			i.push(n);
+		}
+		r$1++;
+	}
+	return {
+		ok: !0,
+		options: t,
+		files: i
+	};
+}
+var Ge = 100, Pt = {
+	name: "tar",
+	summary: "manipulate tape archives",
+	usage: "tar [options] [file...]",
+	description: [
+		"Create, extract, or list contents of tar archives.",
+		"",
+		"One of -c, -r, -u, -x, or -t is required to specify the operation."
+	],
+	options: [
+		"-c, --create           create a new archive",
+		"-r, --append           append files to the end of an archive",
+		"-u, --update           only append files newer than copy in archive",
+		"-x, --extract          extract files from an archive",
+		"-t, --list             list contents of an archive",
+		"-f, --file=ARCHIVE     use archive file ARCHIVE",
+		"-a, --auto-compress    use archive suffix to determine compression",
+		"-z, --gzip             filter archive through gzip",
+		"-j, --bzip2            filter archive through bzip2",
+		"-J, --xz               filter archive through xz",
+		"--zstd                 filter archive through zstd",
+		"-v, --verbose          verbosely list files processed",
+		"-O, --to-stdout        extract files to standard output",
+		"-k, --keep-old-files   don't replace existing files when extracting",
+		"-m, --touch            don't extract file modified time",
+		"-C, --directory=DIR    change to directory DIR before performing operations",
+		"-p, --preserve         preserve permissions",
+		"-P, --absolute-names   do not strip leading '/' or block '..' paths",
+		"-T, --files-from=FILE  read files to extract/create from FILE",
+		"-X, --exclude-from=FILE read exclude patterns from FILE",
+		"--strip=N              strip N leading path components on extraction",
+		"--exclude=PATTERN      exclude files matching PATTERN",
+		"--wildcards            use wildcards for pattern matching",
+		"    --help             display this help and exit"
+	],
+	examples: [
+		"tar -cvf archive.tar file1 file2     Create archive from files",
+		"tar -czvf archive.tar.gz dir/        Create gzip-compressed archive",
+		"tar -cjvf archive.tar.bz2 dir/       Create bzip2-compressed archive",
+		"tar -rf archive.tar newfile.txt      Append file to archive",
+		"tar -uf archive.tar dir/             Update archive with newer files",
+		"tar -xvf archive.tar                 Extract archive",
+		"tar -xvf archive.tar -C /tmp         Extract to /tmp",
+		"tar -tvf archive.tar                 List archive contents",
+		"tar -xzf archive.tar.gz              Extract gzip archive",
+		"tar -xf archive.tar file1.txt        Extract specific file",
+		"tar -xOf archive.tar file.txt        Extract file to stdout",
+		"tar -xf archive.tar --wildcards '*.txt'  Extract matching files"
+	]
+};
+function me(e, t) {
+	let i = e.includes("/") ? e.substring(e.lastIndexOf("/") + 1) : e;
+	for (let r of t) {
+		let n = r.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<GLOBSTAR>>>/g, ".*").replace(/\?/g, ".");
+		if (require_chunk_4RUAZWKT.I1(`^${n}$`).test(e) || require_chunk_4RUAZWKT.I1(`^${n}/`).test(e) || !r.includes("/") && require_chunk_4RUAZWKT.I1(`^${n}$`).test(i)) return !0;
+	}
+	return !1;
+}
+function Y(e, t) {
+	let i = t.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<GLOBSTAR>>>/g, ".*").replace(/\?/g, "."), r = e.includes("/") ? e.substring(e.lastIndexOf("/") + 1) : e;
+	return require_chunk_4RUAZWKT.I1(`^${i}$`).test(e) || require_chunk_4RUAZWKT.I1(`^${i}$`).test(r);
+}
+function qe(e, t) {
+	if (t <= 0) return e;
+	let i = e.split("/").filter((r) => r !== "");
+	return i.length <= t ? "" : i.slice(t).join("/");
+}
+function Ye(e) {
+	return e.split("/").some((t) => t === "..");
+}
+function Ot(e, t) {
+	if (t) return { safePath: e };
+	let i = e.replace(/^\/+/, "");
+	return i.length === 0 ? { safePath: "" } : Ye(i) ? { error: "Path contains '..'" } : { safePath: i };
+}
+function Ut(e) {
+	return `${[
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	][e.getMonth()]} ${e.getDate().toString().padStart(2, " ")} ${e.getHours().toString().padStart(2, "0")}:${e.getMinutes().toString().padStart(2, "0")}`;
+}
+async function K(e, t, i, r) {
+	let n = [], s = [], a = e.fs.resolvePath(t, i);
+	try {
+		let o = await e.fs.stat(a);
+		if (me(i, r)) return {
+			entries: n,
+			errors: s
+		};
+		if (o.isDirectory) {
+			n.push({
+				name: i,
+				isDirectory: !0,
+				mode: o.mode,
+				mtime: o.mtime
+			});
+			let c = await e.fs.readdir(a);
+			for (let l = 0; l < c.length; l += Ge) {
+				let f = c.slice(l, l + Ge), u = await Promise.all(f.map((y) => K(e, t, i ? `${i}/${y}` : y, r)));
+				for (let y of u) n.push(...y.entries), s.push(...y.errors);
+			}
+		} else if (o.isFile) {
+			let c = await e.fs.readFileBuffer(a);
+			n.push({
+				name: i,
+				content: c,
+				mode: o.mode,
+				mtime: o.mtime
+			});
+		} else if (o.isSymbolicLink) {
+			let c = await e.fs.readlink(a);
+			n.push({
+				name: i,
+				isSymlink: !0,
+				linkTarget: c,
+				mode: o.mode,
+				mtime: o.mtime
+			});
+		}
+	} catch (o) {
+		let c = o instanceof Error ? o.message : "unknown error";
+		s.push(`tar: ${i}: ${c}`);
+	}
+	return {
+		entries: n,
+		errors: s
+	};
+}
+async function Nt(e, t, i) {
+	if (i.length === 0) return {
+		stdout: "",
+		stderr: `tar: Cowardly refusing to create an empty archive
+`,
+		exitCode: 2
+	};
+	let r = t.directory ? e.fs.resolvePath(e.cwd, t.directory) : e.cwd, n = [], s = [], a = "";
+	for (let f of i) {
+		let { entries: u, errors: y } = await K(e, r, f, t.exclude);
+		if (n.push(...u), s.push(...y), t.verbose) for (let g of u) a += `${g.name}${g.isDirectory ? "/" : ""}
+`;
+	}
+	if (n.length === 0 && s.length > 0) return {
+		stdout: "",
+		stderr: `${s.join(`
+`)}
+`,
+		exitCode: 2
+	};
+	let o;
+	try {
+		t.gzip ? o = await je(n) : t.bzip2 ? o = await He(n) : t.xz ? o = await _e(n) : t.zstd ? o = await Xe(n) : o = await O(n);
+	} catch (f) {
+		return {
+			stdout: "",
+			stderr: `tar: error creating archive: ${f instanceof Error ? f.message : "unknown error"}
+`,
+			exitCode: 2
+		};
+	}
+	let c = "";
+	if (t.file && t.file !== "-") {
+		let f = e.fs.resolvePath(e.cwd, t.file);
+		try {
+			await e.fs.writeFile(f, o);
+		} catch (u) {
+			let y = u instanceof Error ? u.message : "unknown error";
+			return {
+				stdout: "",
+				stderr: `tar: ${t.file}: ${y}
+`,
+				exitCode: 2
+			};
+		}
+	} else c = Buffer.from(o).toString("latin1");
+	let l = a;
+	return s.length > 0 && (l += `${s.join(`
+`)}
+`), {
+		stdout: c,
+		stderr: l,
+		exitCode: s.length > 0 ? 2 : 0,
+		stdoutKind: c.length > 0 ? "bytes" : "text"
+	};
+}
+async function Lt(e, t, i) {
+	if (!t.file || t.file === "-") return {
+		stdout: "",
+		stderr: `tar: Cannot append to stdin/stdout
+`,
+		exitCode: 2
+	};
+	if (i.length === 0) return {
+		stdout: "",
+		stderr: `tar: Cowardly refusing to append nothing to archive
+`,
+		exitCode: 2
+	};
+	let r = e.fs.resolvePath(e.cwd, t.file), n;
+	try {
+		n = await e.fs.readFileBuffer(r);
+	} catch {
+		return {
+			stdout: "",
+			stderr: `tar: ${t.file}: Cannot open: No such file or directory
+`,
+			exitCode: 2
+		};
+	}
+	let s = await F(n);
+	if (s.error) return {
+		stdout: "",
+		stderr: `tar: ${s.error}
+`,
+		exitCode: 2
+	};
+	let a = s.entries.map((d) => ({
+		name: d.name,
+		content: d.content,
+		mode: d.mode,
+		mtime: d.mtime,
+		isDirectory: d.type === "directory",
+		isSymlink: d.type === "symlink",
+		linkTarget: d.linkTarget,
+		uid: d.uid,
+		gid: d.gid
+	})), o = t.directory ? e.fs.resolvePath(e.cwd, t.directory) : e.cwd, c = [], l = [], f = "";
+	for (let d of i) {
+		let { entries: p, errors: m } = await K(e, o, d, t.exclude);
+		if (c.push(...p), l.push(...m), t.verbose) for (let x of p) f += `${x.name}${x.isDirectory ? "/" : ""}
+`;
+	}
+	let u = [...a, ...c], y;
+	try {
+		y = await O(u);
+	} catch (d) {
+		return {
+			stdout: "",
+			stderr: `tar: error creating archive: ${d instanceof Error ? d.message : "unknown error"}
+`,
+			exitCode: 2
+		};
+	}
+	try {
+		await e.fs.writeFile(r, y);
+	} catch (d) {
+		let p = d instanceof Error ? d.message : "unknown error";
+		return {
+			stdout: "",
+			stderr: `tar: ${t.file}: ${p}
+`,
+			exitCode: 2
+		};
+	}
+	let g = f;
+	return l.length > 0 && (g += `${l.join(`
+`)}
+`), {
+		stdout: "",
+		stderr: g,
+		exitCode: l.length > 0 ? 2 : 0
+	};
+}
+async function Dt(e, t, i) {
+	if (!t.file || t.file === "-") return {
+		stdout: "",
+		stderr: `tar: Cannot update stdin/stdout
+`,
+		exitCode: 2
+	};
+	if (i.length === 0) return {
+		stdout: "",
+		stderr: `tar: Cowardly refusing to update with nothing
+`,
+		exitCode: 2
+	};
+	let r = e.fs.resolvePath(e.cwd, t.file), n;
+	try {
+		n = await e.fs.readFileBuffer(r);
+	} catch {
+		return {
+			stdout: "",
+			stderr: `tar: ${t.file}: Cannot open: No such file or directory
+`,
+			exitCode: 2
+		};
+	}
+	let s = await F(n);
+	if (s.error) return {
+		stdout: "",
+		stderr: `tar: ${s.error}
+`,
+		exitCode: 2
+	};
+	let a = /* @__PURE__ */ new Map();
+	for (let m of s.entries) a.set(m.name, m.mtime);
+	let o = t.directory ? e.fs.resolvePath(e.cwd, t.directory) : e.cwd, c = [], l = [], f = "";
+	for (let m of i) {
+		let { entries: x, errors: b } = await K(e, o, m, t.exclude);
+		l.push(...b);
+		for (let E of x) {
+			let v = a.get(E.name);
+			(!v || E.mtime && E.mtime.getTime() > v.getTime()) && (c.push(E), t.verbose && (f += `${E.name}${E.isDirectory ? "/" : ""}
+`));
+		}
+	}
+	if (c.length === 0) {
+		let m = "";
+		return l.length > 0 && (m = `${l.join(`
+`)}
+`), {
+			stdout: "",
+			stderr: m,
+			exitCode: l.length > 0 ? 2 : 0
+		};
+	}
+	let u = new Set(c.map((m) => m.name)), g = [...s.entries.filter((m) => !u.has(m.name)).map((m) => ({
+		name: m.name,
+		content: m.content,
+		mode: m.mode,
+		mtime: m.mtime,
+		isDirectory: m.type === "directory",
+		isSymlink: m.type === "symlink",
+		linkTarget: m.linkTarget,
+		uid: m.uid,
+		gid: m.gid
+	})), ...c], d;
+	try {
+		d = await O(g);
+	} catch (m) {
+		return {
+			stdout: "",
+			stderr: `tar: error creating archive: ${m instanceof Error ? m.message : "unknown error"}
+`,
+			exitCode: 2
+		};
+	}
+	try {
+		await e.fs.writeFile(r, d);
+	} catch (m) {
+		let x = m instanceof Error ? m.message : "unknown error";
+		return {
+			stdout: "",
+			stderr: `tar: ${t.file}: ${x}
+`,
+			exitCode: 2
+		};
+	}
+	let p = f;
+	return l.length > 0 && (p += `${l.join(`
+`)}
+`), {
+		stdout: "",
+		stderr: p,
+		exitCode: l.length > 0 ? 2 : 0
+	};
+}
+async function Rt(e, t, i) {
+	let r;
+	if (t.file && t.file !== "-") {
+		let p = e.fs.resolvePath(e.cwd, t.file);
+		try {
+			r = await e.fs.readFileBuffer(p);
+		} catch {
+			return {
+				stdout: "",
+				stderr: `tar: ${t.file}: Cannot open: No such file or directory
+`,
+				exitCode: 2
+			};
+		}
+	} else r = Uint8Array.from(e.stdin, (p) => p.charCodeAt(0));
+	let n, s = t.gzip || oe(r), a = t.bzip2 || ae(r), o = t.xz || le(r), c = t.zstd || ue(r);
+	if (s ? n = await se(r) : a ? n = await ce(r) : o ? n = await fe(r) : c ? n = await de(r) : n = await F(r), n.error) return {
+		stdout: "",
+		stderr: `tar: ${n.error}
+`,
+		exitCode: 2
+	};
+	let l = t.directory ? e.fs.resolvePath(e.cwd, t.directory) : e.cwd, f = t.absoluteNames ? i : i.map((p) => p.replace(/^\/+/, "")).filter((p) => p.length > 0), u = "", y = "", g = [];
+	if (t.directory && !t.toStdout) try {
+		await e.fs.mkdir(l, { recursive: !0 });
+	} catch {}
+	for (let p of n.entries) {
+		let m = qe(p.name, t.strip);
+		if (!m) continue;
+		let x = Ot(m, t.absoluteNames);
+		if (x.error) {
+			g.push(`tar: ${m}: ${x.error}`);
+			continue;
+		}
+		let b = x.safePath ?? "";
+		if (!b) continue;
+		let E = b.endsWith("/") ? b.slice(0, -1) : b;
+		if (f.length > 0) {
+			let $;
+			if (t.wildcards ? $ = f.some((z) => Y(b, z) || Y(E, z) || b.startsWith(`${z}/`)) : $ = f.some((z) => b === z || b.startsWith(`${z}/`) || E === z), !$) continue;
+		}
+		if (me(b, t.exclude)) continue;
+		let v = e.fs.resolvePath(l, b);
+		try {
+			if (p.type === "directory") {
+				if (t.toStdout) continue;
+				await e.fs.mkdir(v, { recursive: !0 }), t.verbose && (u += `${b}
+`);
+			} else if (p.type === "file") {
+				if (t.toStdout) {
+					y += new TextDecoder().decode(p.content), t.verbose && (u += `${b}
+`);
+					continue;
+				}
+				if (t.keepOldFiles) try {
+					await e.fs.stat(v), t.verbose && (u += `${b}: not overwritten, file exists
+`);
+					continue;
+				} catch {}
+				let $ = v.substring(0, v.lastIndexOf("/"));
+				if ($) try {
+					await e.fs.mkdir($, { recursive: !0 });
+				} catch {}
+				if (await e.fs.writeFile(v, p.content), t.preserve && p.mode) try {
+					await e.fs.chmod(v, p.mode);
+				} catch {}
+				t.verbose && (u += `${b}
+`);
+			} else if (p.type === "symlink" && p.linkTarget) {
+				if (t.toStdout) continue;
+				if (!t.absoluteNames && (p.linkTarget.startsWith("/") || Ye(p.linkTarget))) {
+					g.push(`tar: ${b}: unsafe symlink target`);
+					continue;
+				}
+				if (t.keepOldFiles) try {
+					await e.fs.stat(v), t.verbose && (u += `${b}: not overwritten, file exists
+`);
+					continue;
+				} catch {}
+				let $ = v.substring(0, v.lastIndexOf("/"));
+				if ($) try {
+					await e.fs.mkdir($, { recursive: !0 });
+				} catch {}
+				try {
+					await e.fs.symlink(p.linkTarget, v);
+				} catch {}
+				t.verbose && (u += `${b}
+`);
+			}
+		} catch ($) {
+			let z = $ instanceof Error ? $.message : "unknown error";
+			g.push(`tar: ${b}: ${z}`);
+		}
+	}
+	let d = u;
+	return g.length > 0 && (d += `${g.join(`
+`)}
+`), {
+		stdout: y,
+		stderr: d,
+		exitCode: g.length > 0 ? 2 : 0
+	};
+}
+async function Mt(e, t, i) {
+	let r;
+	if (t.file && t.file !== "-") {
+		let f = e.fs.resolvePath(e.cwd, t.file);
+		try {
+			r = await e.fs.readFileBuffer(f);
+		} catch {
+			return {
+				stdout: "",
+				stderr: `tar: ${t.file}: Cannot open: No such file or directory
+`,
+				exitCode: 2
+			};
+		}
+	} else r = Uint8Array.from(e.stdin, (f) => f.charCodeAt(0));
+	let n, s = t.gzip || oe(r), a = t.bzip2 || ae(r), o = t.xz || le(r), c = t.zstd || ue(r);
+	if (s ? n = await se(r) : a ? n = await ce(r) : o ? n = await fe(r) : c ? n = await de(r) : n = await F(r), n.error) return {
+		stdout: "",
+		stderr: `tar: ${n.error}
+`,
+		exitCode: 2
+	};
+	let l = "";
+	for (let f of n.entries) {
+		let u = qe(f.name, t.strip);
+		if (!u) continue;
+		let y = u.endsWith("/") ? u.slice(0, -1) : u;
+		if (i.length > 0) {
+			let g;
+			if (t.wildcards ? g = i.some((d) => Y(u, d) || Y(y, d) || u.startsWith(`${d}/`)) : g = i.some((d) => u === d || u.startsWith(`${d}/`) || y === d), !g) continue;
+		}
+		if (!me(u, t.exclude)) if (t.verbose) {
+			let g = f.type === "directory", d = require_chunk_TDD4NFYE.x(f.mode, g), p = `${f.uid}/${f.gid}`, m = f.size.toString().padStart(8, " "), x$1 = Ut(f.mtime), b = `${d} ${p.padEnd(10)} ${m} ${x$1} ${u}`;
+			f.type === "symlink" && f.linkTarget && (b += ` -> ${f.linkTarget}`), l += `${b}
+`;
+		} else l += `${u}
+`;
+	}
+	return {
+		stdout: l,
+		stderr: "",
+		exitCode: 0
+	};
+}
+var sr = {
+	name: "tar",
+	async execute(e, t) {
+		if (require_chunk_QAYAQNCG.o(e)) return require_chunk_QAYAQNCG.s(Pt);
+		let i = Ze(e);
+		if (!i.ok) return i.error;
+		let { options: r, files: n } = i, s$1 = [
+			r.create,
+			r.append,
+			r.update,
+			r.extract,
+			r.list
+		].filter(Boolean).length;
+		if (s$1 === 0) return {
+			stdout: "",
+			stderr: `tar: You must specify one of -c, -r, -u, -x, or -t
+`,
+			exitCode: 2
+		};
+		if (s$1 > 1) return {
+			stdout: "",
+			stderr: `tar: You may not specify more than one of -c, -r, -u, -x, or -t
+`,
+			exitCode: 2
+		};
+		if (r.autoCompress && r.file && r.create) {
+			let c = r.file.toLowerCase();
+			c.endsWith(".tar.gz") || c.endsWith(".tgz") ? r.gzip = !0 : c.endsWith(".tar.bz2") || c.endsWith(".tbz2") ? r.bzip2 = !0 : c.endsWith(".tar.xz") || c.endsWith(".txz") ? r.xz = !0 : (c.endsWith(".tar.zst") || c.endsWith(".tzst")) && (r.zstd = !0);
+		}
+		let a = [
+			r.gzip,
+			r.bzip2,
+			r.xz,
+			r.zstd
+		].filter(Boolean).length;
+		if (a > 1) return {
+			stdout: "",
+			stderr: `tar: You may not specify more than one compression option
+`,
+			exitCode: 2
+		};
+		if ((r.append || r.update) && a > 0) return {
+			stdout: "",
+			stderr: `tar: Cannot append/update compressed archives - decompress first
+`,
+			exitCode: 2
+		};
+		let o$1 = n;
+		if (r.filesFrom) {
+			let c = t.fs.resolvePath(t.cwd, r.filesFrom);
+			try {
+				let f = (await t.fs.readFile(c)).split(`
+`).map((u) => u.trim()).filter((u) => u.length > 0 && !u.startsWith("#"));
+				o$1 = [...n, ...f];
+			} catch {
+				return {
+					stdout: "",
+					stderr: `tar: ${r.filesFrom}: Cannot open: No such file or directory
+`,
+					exitCode: 2
+				};
+			}
+		}
+		if (r.excludeFrom) {
+			let c = t.fs.resolvePath(t.cwd, r.excludeFrom);
+			try {
+				let f = (await t.fs.readFile(c)).split(`
+`).map((u) => u.trim()).filter((u) => u.length > 0 && !u.startsWith("#"));
+				r.exclude.push(...f);
+			} catch {
+				return {
+					stdout: "",
+					stderr: `tar: ${r.excludeFrom}: Cannot open: No such file or directory
+`,
+					exitCode: 2
+				};
+			}
+		}
+		return r.create ? Nt(t, r, o$1) : r.append ? Lt(t, r, o$1) : r.update ? Dt(t, r, o$1) : r.extract ? Rt(t, r, o$1) : Mt(t, r, o$1);
+	}
+}, or = {
+	name: "tar",
+	flags: [
+		{
+			flag: "-c",
+			type: "boolean"
+		},
+		{
+			flag: "-x",
+			type: "boolean"
+		},
+		{
+			flag: "-t",
+			type: "boolean"
+		},
+		{
+			flag: "-f",
+			type: "value",
+			valueHint: "path"
+		},
+		{
+			flag: "-z",
+			type: "boolean"
+		},
+		{
+			flag: "-j",
+			type: "boolean"
+		},
+		{
+			flag: "-v",
+			type: "boolean"
+		},
+		{
+			flag: "-C",
+			type: "value",
+			valueHint: "path"
+		},
+		{
+			flag: "--strip-components",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "--exclude",
+			type: "value",
+			valueHint: "pattern"
+		}
+	],
+	needsArgs: !0
+};
+//#endregion
+Object.defineProperty(exports, "or", {
+	enumerable: true,
+	get: function() {
+		return or;
+	}
+});
+Object.defineProperty(exports, "sr", {
+	enumerable: true,
+	get: function() {
+		return sr;
+	}
+});
+
+//# sourceMappingURL=chunk-MZFCCXPZ-f-V1JFCy.cjs.map