@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/chunk-R4IFXNY5-Csrv6AhU.cjs

@@ -0,0 +1,1946 @@
+const require_chunk_QAYAQNCG = require("./chunk-QAYAQNCG-ROQh1hrZ.cjs");
+const require_chunk_QIQMJJZ4 = require("./chunk-QIQMJJZ4-Cm4e9-4O.cjs");
+let node_module = require("node:module");
+//#region ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
+const balanced = (a, b, str) => {
+	const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+	const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+	const r = ma !== null && mb != null && range(ma, mb, str);
+	return r && {
+		start: r[0],
+		end: r[1],
+		pre: str.slice(0, r[0]),
+		body: str.slice(r[0] + ma.length, r[1]),
+		post: str.slice(r[1] + mb.length)
+	};
+};
+const maybeMatch = (reg, str) => {
+	const m = str.match(reg);
+	return m ? m[0] : null;
+};
+const range = (a, b, str) => {
+	let begs, beg, left, right = void 0, result;
+	let ai = str.indexOf(a);
+	let bi = str.indexOf(b, ai + 1);
+	let i = ai;
+	if (ai >= 0 && bi > 0) {
+		if (a === b) return [ai, bi];
+		begs = [];
+		left = str.length;
+		while (i >= 0 && !result) {
+			if (i === ai) {
+				begs.push(i);
+				ai = str.indexOf(a, i + 1);
+			} else if (begs.length === 1) {
+				const r = begs.pop();
+				if (r !== void 0) result = [r, bi];
+			} else {
+				beg = begs.pop();
+				if (beg !== void 0 && beg < left) {
+					left = beg;
+					right = bi;
+				}
+				bi = str.indexOf(b, i + 1);
+			}
+			i = ai < bi && ai >= 0 ? ai : bi;
+		}
+		if (begs.length && right !== void 0) result = [left, right];
+	}
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/brace-expansion@5.0.6/node_modules/brace-expansion/dist/esm/index.js
+const escSlash = "\0SLASH" + Math.random() + "\0";
+const escOpen = "\0OPEN" + Math.random() + "\0";
+const escClose = "\0CLOSE" + Math.random() + "\0";
+const escComma = "\0COMMA" + Math.random() + "\0";
+const escPeriod = "\0PERIOD" + Math.random() + "\0";
+const escSlashPattern = new RegExp(escSlash, "g");
+const escOpenPattern = new RegExp(escOpen, "g");
+const escClosePattern = new RegExp(escClose, "g");
+const escCommaPattern = new RegExp(escComma, "g");
+const escPeriodPattern = new RegExp(escPeriod, "g");
+const slashPattern = /\\\\/g;
+const openPattern = /\\{/g;
+const closePattern = /\\}/g;
+const commaPattern = /\\,/g;
+const periodPattern = /\\\./g;
+const EXPANSION_MAX = 1e5;
+function numeric(str) {
+	return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+	return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+	return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+/**
+* Basically just str.split(","), but handling cases
+* where we have nested braced sections, which should be
+* treated as individual members, like {a,{b,c},d}
+*/
+function parseCommaParts(str) {
+	if (!str) return [""];
+	const parts = [];
+	const m = balanced("{", "}", str);
+	if (!m) return str.split(",");
+	const { pre, body, post } = m;
+	const p = pre.split(",");
+	p[p.length - 1] += "{" + body + "}";
+	const postParts = parseCommaParts(post);
+	if (post.length) {
+		p[p.length - 1] += postParts.shift();
+		p.push.apply(p, postParts);
+	}
+	parts.push.apply(parts, p);
+	return parts;
+}
+function expand(str, options = {}) {
+	if (!str) return [];
+	const { max = EXPANSION_MAX } = options;
+	if (str.slice(0, 2) === "{}") str = "\\{\\}" + str.slice(2);
+	return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+}
+function embrace(str) {
+	return "{" + str + "}";
+}
+function isPadded(el) {
+	return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+	return i <= y;
+}
+function gte(i, y) {
+	return i >= y;
+}
+function expand_(str, max, isTop) {
+	/** @type {string[]} */
+	const expansions = [];
+	const m = balanced("{", "}", str);
+	if (!m) return [str];
+	const pre = m.pre;
+	const post = m.post.length ? expand_(m.post, max, false) : [""];
+	if (/\$$/.test(m.pre)) for (let k = 0; k < post.length && k < max; k++) {
+		const expansion = pre + "{" + m.body + "}" + post[k];
+		expansions.push(expansion);
+	}
+	else {
+		const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+		const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+		const isSequence = isNumericSequence || isAlphaSequence;
+		const isOptions = m.body.indexOf(",") >= 0;
+		if (!isSequence && !isOptions) {
+			if (m.post.match(/,(?!,).*\}/)) {
+				str = m.pre + "{" + m.body + escClose + m.post;
+				return expand_(str, max, true);
+			}
+			return [str];
+		}
+		let n;
+		if (isSequence) n = m.body.split(/\.\./);
+		else {
+			n = parseCommaParts(m.body);
+			if (n.length === 1 && n[0] !== void 0) {
+				n = expand_(n[0], max, false).map(embrace);
+				/* c8 ignore start */
+				if (n.length === 1) return post.map((p) => m.pre + n[0] + p);
+			}
+		}
+		let N;
+		if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+			const x = numeric(n[0]);
+			const y = numeric(n[1]);
+			const width = Math.max(n[0].length, n[1].length);
+			let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+			let test = lte;
+			if (y < x) {
+				incr *= -1;
+				test = gte;
+			}
+			const pad = n.some(isPadded);
+			N = [];
+			for (let i = x; test(i, y) && N.length < max; i += incr) {
+				let c;
+				if (isAlphaSequence) {
+					c = String.fromCharCode(i);
+					if (c === "\\") c = "";
+				} else {
+					c = String(i);
+					if (pad) {
+						const need = width - c.length;
+						if (need > 0) {
+							const z = new Array(need + 1).join("0");
+							if (i < 0) c = "-" + z + c.slice(1);
+							else c = z + c;
+						}
+					}
+				}
+				N.push(c);
+			}
+		} else {
+			N = [];
+			for (let j = 0; j < n.length; j++) N.push.apply(N, expand_(n[j], max, false));
+		}
+		for (let j = 0; j < N.length; j++) for (let k = 0; k < post.length && expansions.length < max; k++) {
+			const expansion = pre + N[j] + post[k];
+			if (!isTop || isSequence || expansion) expansions.push(expansion);
+		}
+	}
+	return expansions;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+	if (typeof pattern !== "string") throw new TypeError("invalid pattern");
+	if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/brace-expressions.js
+const posixClasses = {
+	"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+	"[:alpha:]": ["\\p{L}\\p{Nl}", true],
+	"[:ascii:]": ["\\x00-\\x7f", false],
+	"[:blank:]": ["\\p{Zs}\\t", true],
+	"[:cntrl:]": ["\\p{Cc}", true],
+	"[:digit:]": ["\\p{Nd}", true],
+	"[:graph:]": [
+		"\\p{Z}\\p{C}",
+		true,
+		true
+	],
+	"[:lower:]": ["\\p{Ll}", true],
+	"[:print:]": ["\\p{C}", true],
+	"[:punct:]": ["\\p{P}", true],
+	"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+	"[:upper:]": ["\\p{Lu}", true],
+	"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+	"[:xdigit:]": ["A-Fa-f0-9", false]
+};
+const braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const rangesToString = (ranges) => ranges.join("");
+const parseClass = (glob, position) => {
+	const pos = position;
+	/* c8 ignore start */
+	if (glob.charAt(pos) !== "[") throw new Error("not in a brace expression");
+	/* c8 ignore stop */
+	const ranges = [];
+	const negs = [];
+	let i = pos + 1;
+	let sawStart = false;
+	let uflag = false;
+	let escaping = false;
+	let negate = false;
+	let endPos = pos;
+	let rangeStart = "";
+	WHILE: while (i < glob.length) {
+		const c = glob.charAt(i);
+		if ((c === "!" || c === "^") && i === pos + 1) {
+			negate = true;
+			i++;
+			continue;
+		}
+		if (c === "]" && sawStart && !escaping) {
+			endPos = i + 1;
+			break;
+		}
+		sawStart = true;
+		if (c === "\\") {
+			if (!escaping) {
+				escaping = true;
+				i++;
+				continue;
+			}
+		}
+		if (c === "[" && !escaping) {
+			for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) if (glob.startsWith(cls, i)) {
+				if (rangeStart) return [
+					"$.",
+					false,
+					glob.length - pos,
+					true
+				];
+				i += cls.length;
+				if (neg) negs.push(unip);
+				else ranges.push(unip);
+				uflag = uflag || u;
+				continue WHILE;
+			}
+		}
+		escaping = false;
+		if (rangeStart) {
+			if (c > rangeStart) ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+			else if (c === rangeStart) ranges.push(braceEscape(c));
+			rangeStart = "";
+			i++;
+			continue;
+		}
+		if (glob.startsWith("-]", i + 1)) {
+			ranges.push(braceEscape(c + "-"));
+			i += 2;
+			continue;
+		}
+		if (glob.startsWith("-", i + 1)) {
+			rangeStart = c;
+			i += 2;
+			continue;
+		}
+		ranges.push(braceEscape(c));
+		i++;
+	}
+	if (endPos < i) return [
+		"",
+		false,
+		0,
+		false
+	];
+	if (!ranges.length && !negs.length) return [
+		"$.",
+		false,
+		glob.length - pos,
+		true
+	];
+	if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) return [
+		regexpEscape(ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0]),
+		false,
+		endPos - pos,
+		false
+	];
+	const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+	const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+	return [
+		ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs,
+		uflag,
+		endPos - pos,
+		true
+	];
+};
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/unescape.js
+/**
+* Un-escape a string that has been escaped with {@link escape}.
+*
+* If the {@link MinimatchOptions.windowsPathsNoEscape} option is used, then
+* square-bracket escapes are removed, but not backslash escapes.
+*
+* For example, it will turn the string `'[*]'` into `*`, but it will not
+* turn `'\\*'` into `'*'`, because `\` is a path separator in
+* `windowsPathsNoEscape` mode.
+*
+* When `windowsPathsNoEscape` is not set, then both square-bracket escapes and
+* backslash escapes are removed.
+*
+* Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
+* or unescaped.
+*
+* When `magicalBraces` is not set, escapes of braces (`{` and `}`) will not be
+* unescaped.
+*/
+const unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+	if (magicalBraces) return windowsPathsNoEscape ? s.replace(/\[([^/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1");
+	return windowsPathsNoEscape ? s.replace(/\[([^/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/ast.js
+var _a;
+const types = new Set([
+	"!",
+	"?",
+	"+",
+	"*",
+	"@"
+]);
+const isExtglobType = (c) => types.has(c);
+const isExtglobAST = (c) => isExtglobType(c.type);
+const adoptionMap = new Map([
+	["!", ["@"]],
+	["?", ["?", "@"]],
+	["@", ["@"]],
+	["*", [
+		"*",
+		"+",
+		"?",
+		"@"
+	]],
+	["+", ["+", "@"]]
+]);
+const adoptionWithSpaceMap = new Map([
+	["!", ["?"]],
+	["@", ["?"]],
+	["+", ["?", "*"]]
+]);
+const adoptionAnyMap = new Map([
+	["!", ["?", "@"]],
+	["?", ["?", "@"]],
+	["@", ["?", "@"]],
+	["*", [
+		"*",
+		"+",
+		"?",
+		"@"
+	]],
+	["+", [
+		"+",
+		"@",
+		"?",
+		"*"
+	]]
+]);
+const usurpMap = new Map([
+	["!", new Map([["!", "@"]])],
+	["?", new Map([["*", "*"], ["+", "*"]])],
+	["@", new Map([
+		["!", "!"],
+		["?", "?"],
+		["@", "@"],
+		["*", "*"],
+		["+", "+"]
+	])],
+	["+", new Map([["?", "*"], ["*", "*"]])]
+]);
+const startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+const startNoDot = "(?!\\.)";
+const addPatternStart = new Set(["[", "."]);
+const justDots = new Set(["..", "."]);
+const reSpecials = /* @__PURE__ */ new Set("().*{}+?[]^$\\!");
+const regExpEscape$1 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const qmark = "[^/]";
+const star$1 = "[^/]*?";
+const starNoEmpty = "[^/]+?";
+let ID = 0;
+var AST = class {
+	type;
+	#root;
+	#hasMagic;
+	#uflag = false;
+	#parts = [];
+	#parent;
+	#parentIndex;
+	#negs;
+	#filledNegs = false;
+	#options;
+	#toString;
+	#emptyExt = false;
+	id = ++ID;
+	get depth() {
+		return (this.#parent?.depth ?? -1) + 1;
+	}
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return {
+			"@@type": "AST",
+			id: this.id,
+			type: this.type,
+			root: this.#root.id,
+			parent: this.#parent?.id,
+			depth: this.depth,
+			partsLength: this.#parts.length,
+			parts: this.#parts
+		};
+	}
+	constructor(type, parent, options = {}) {
+		this.type = type;
+		if (type) this.#hasMagic = true;
+		this.#parent = parent;
+		this.#root = this.#parent ? this.#parent.#root : this;
+		this.#options = this.#root === this ? options : this.#root.#options;
+		this.#negs = this.#root === this ? [] : this.#root.#negs;
+		if (type === "!" && !this.#root.#filledNegs) this.#negs.push(this);
+		this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+	}
+	get hasMagic() {
+		/* c8 ignore start */
+		if (this.#hasMagic !== void 0) return this.#hasMagic;
+		/* c8 ignore stop */
+		for (const p of this.#parts) {
+			if (typeof p === "string") continue;
+			if (p.type || p.hasMagic) return this.#hasMagic = true;
+		}
+		return this.#hasMagic;
+	}
+	toString() {
+		return this.#toString !== void 0 ? this.#toString : !this.type ? this.#toString = this.#parts.map((p) => String(p)).join("") : this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+	}
+	#fillNegs() {
+		/* c8 ignore start */
+		if (this !== this.#root) throw new Error("should only call on root");
+		if (this.#filledNegs) return this;
+		/* c8 ignore stop */
+		this.toString();
+		this.#filledNegs = true;
+		let n;
+		while (n = this.#negs.pop()) {
+			if (n.type !== "!") continue;
+			let p = n;
+			let pp = p.#parent;
+			while (pp) {
+				for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) for (const part of n.#parts) {
+					/* c8 ignore start */
+					if (typeof part === "string") throw new Error("string part in extglob AST??");
+					/* c8 ignore stop */
+					part.copyIn(pp.#parts[i]);
+				}
+				p = pp;
+				pp = p.#parent;
+			}
+		}
+		return this;
+	}
+	push(...parts) {
+		for (const p of parts) {
+			if (p === "") continue;
+			/* c8 ignore start */
+			if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) throw new Error("invalid part: " + p);
+			/* c8 ignore stop */
+			this.#parts.push(p);
+		}
+	}
+	toJSON() {
+		const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+		if (this.isStart() && !this.type) ret.unshift([]);
+		if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) ret.push({});
+		return ret;
+	}
+	isStart() {
+		if (this.#root === this) return true;
+		if (!this.#parent?.isStart()) return false;
+		if (this.#parentIndex === 0) return true;
+		const p = this.#parent;
+		for (let i = 0; i < this.#parentIndex; i++) {
+			const pp = p.#parts[i];
+			if (!(pp instanceof _a && pp.type === "!")) return false;
+		}
+		return true;
+	}
+	isEnd() {
+		if (this.#root === this) return true;
+		if (this.#parent?.type === "!") return true;
+		if (!this.#parent?.isEnd()) return false;
+		if (!this.type) return this.#parent?.isEnd();
+		/* c8 ignore start */
+		const pl = this.#parent ? this.#parent.#parts.length : 0;
+		/* c8 ignore stop */
+		return this.#parentIndex === pl - 1;
+	}
+	copyIn(part) {
+		if (typeof part === "string") this.push(part);
+		else this.push(part.clone(this));
+	}
+	clone(parent) {
+		const c = new _a(this.type, parent);
+		for (const p of this.#parts) c.copyIn(p);
+		return c;
+	}
+	static #parseAST(str, ast, pos, opt, extDepth) {
+		const maxDepth = opt.maxExtglobRecursion ?? 2;
+		let escaping = false;
+		let inBrace = false;
+		let braceStart = -1;
+		let braceNeg = false;
+		if (ast.type === null) {
+			let i = pos;
+			let acc = "";
+			while (i < str.length) {
+				const c = str.charAt(i++);
+				if (escaping || c === "\\") {
+					escaping = !escaping;
+					acc += c;
+					continue;
+				}
+				if (inBrace) {
+					if (i === braceStart + 1) {
+						if (c === "^" || c === "!") braceNeg = true;
+					} else if (c === "]" && !(i === braceStart + 2 && braceNeg)) inBrace = false;
+					acc += c;
+					continue;
+				} else if (c === "[") {
+					inBrace = true;
+					braceStart = i;
+					braceNeg = false;
+					acc += c;
+					continue;
+				}
+				if (!opt.noext && isExtglobType(c) && str.charAt(i) === "(" && extDepth <= maxDepth) {
+					ast.push(acc);
+					acc = "";
+					const ext = new _a(c, ast);
+					i = _a.#parseAST(str, ext, i, opt, extDepth + 1);
+					ast.push(ext);
+					continue;
+				}
+				acc += c;
+			}
+			ast.push(acc);
+			return i;
+		}
+		let i = pos + 1;
+		let part = new _a(null, ast);
+		const parts = [];
+		let acc = "";
+		while (i < str.length) {
+			const c = str.charAt(i++);
+			if (escaping || c === "\\") {
+				escaping = !escaping;
+				acc += c;
+				continue;
+			}
+			if (inBrace) {
+				if (i === braceStart + 1) {
+					if (c === "^" || c === "!") braceNeg = true;
+				} else if (c === "]" && !(i === braceStart + 2 && braceNeg)) inBrace = false;
+				acc += c;
+				continue;
+			} else if (c === "[") {
+				inBrace = true;
+				braceStart = i;
+				braceNeg = false;
+				acc += c;
+				continue;
+			}
+			/* c8 ignore stop */
+			if (!opt.noext && isExtglobType(c) && str.charAt(i) === "(" && (extDepth <= maxDepth || ast && ast.#canAdoptType(c))) {
+				const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
+				part.push(acc);
+				acc = "";
+				const ext = new _a(c, part);
+				part.push(ext);
+				i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
+				continue;
+			}
+			if (c === "|") {
+				part.push(acc);
+				acc = "";
+				parts.push(part);
+				part = new _a(null, ast);
+				continue;
+			}
+			if (c === ")") {
+				if (acc === "" && ast.#parts.length === 0) ast.#emptyExt = true;
+				part.push(acc);
+				acc = "";
+				ast.push(...parts, part);
+				return i;
+			}
+			acc += c;
+		}
+		ast.type = null;
+		ast.#hasMagic = void 0;
+		ast.#parts = [str.substring(pos - 1)];
+		return i;
+	}
+	#canAdoptWithSpace(child) {
+		return this.#canAdopt(child, adoptionWithSpaceMap);
+	}
+	#canAdopt(child, map = adoptionMap) {
+		if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) return false;
+		const gc = child.#parts[0];
+		if (!gc || typeof gc !== "object" || gc.type === null) return false;
+		return this.#canAdoptType(gc.type, map);
+	}
+	#canAdoptType(c, map = adoptionAnyMap) {
+		return !!map.get(this.type)?.includes(c);
+	}
+	#adoptWithSpace(child, index) {
+		const gc = child.#parts[0];
+		const blank = new _a(null, gc, this.options);
+		blank.#parts.push("");
+		gc.push(blank);
+		this.#adopt(child, index);
+	}
+	#adopt(child, index) {
+		const gc = child.#parts[0];
+		this.#parts.splice(index, 1, ...gc.#parts);
+		for (const p of gc.#parts) if (typeof p === "object") p.#parent = this;
+		this.#toString = void 0;
+	}
+	#canUsurpType(c) {
+		return !!usurpMap.get(this.type)?.has(c);
+	}
+	#canUsurp(child) {
+		if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) return false;
+		const gc = child.#parts[0];
+		if (!gc || typeof gc !== "object" || gc.type === null) return false;
+		return this.#canUsurpType(gc.type);
+	}
+	#usurp(child) {
+		const m = usurpMap.get(this.type);
+		const gc = child.#parts[0];
+		const nt = m?.get(gc.type);
+		/* c8 ignore start - impossible */
+		if (!nt) return false;
+		/* c8 ignore stop */
+		this.#parts = gc.#parts;
+		for (const p of this.#parts) if (typeof p === "object") p.#parent = this;
+		this.type = nt;
+		this.#toString = void 0;
+		this.#emptyExt = false;
+	}
+	static fromGlob(pattern, options = {}) {
+		const ast = new _a(null, void 0, options);
+		_a.#parseAST(pattern, ast, 0, options, 0);
+		return ast;
+	}
+	toMMPattern() {
+		/* c8 ignore start */
+		if (this !== this.#root) return this.#root.toMMPattern();
+		/* c8 ignore stop */
+		const glob = this.toString();
+		const [re, body, hasMagic, uflag] = this.toRegExpSource();
+		if (!(hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase())) return body;
+		const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+		return Object.assign(new RegExp(`^${re}$`, flags), {
+			_src: re,
+			_glob: glob
+		});
+	}
+	get options() {
+		return this.#options;
+	}
+	toRegExpSource(allowDot) {
+		const dot = allowDot ?? !!this.#options.dot;
+		if (this.#root === this) {
+			this.#flatten();
+			this.#fillNegs();
+		}
+		if (!isExtglobAST(this)) {
+			const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
+			const src = this.#parts.map((p) => {
+				const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+				this.#hasMagic = this.#hasMagic || hasMagic;
+				this.#uflag = this.#uflag || uflag;
+				return re;
+			}).join("");
+			let start = "";
+			if (this.isStart()) {
+				if (typeof this.#parts[0] === "string") {
+					if (!(this.#parts.length === 1 && justDots.has(this.#parts[0]))) {
+						const aps = addPatternStart;
+						const needNoTrav = dot && aps.has(src.charAt(0)) || src.startsWith("\\.") && aps.has(src.charAt(2)) || src.startsWith("\\.\\.") && aps.has(src.charAt(4));
+						const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+						start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+					}
+				}
+			}
+			let end = "";
+			if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") end = "(?:$|\\/)";
+			return [
+				start + src + end,
+				unescape(src),
+				this.#hasMagic = !!this.#hasMagic,
+				this.#uflag
+			];
+		}
+		const repeated = this.type === "*" || this.type === "+";
+		const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+		let body = this.#partsToRegExp(dot);
+		if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+			const s = this.toString();
+			const me = this;
+			me.#parts = [s];
+			me.type = null;
+			me.#hasMagic = void 0;
+			return [
+				s,
+				unescape(this.toString()),
+				false,
+				false
+			];
+		}
+		let bodyDotAllowed = !repeated || allowDot || dot || false ? "" : this.#partsToRegExp(true);
+		if (bodyDotAllowed === body) bodyDotAllowed = "";
+		if (bodyDotAllowed) body = `(?:${body})(?:${bodyDotAllowed})*?`;
+		let final = "";
+		if (this.type === "!" && this.#emptyExt) final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+		else {
+			const close = this.type === "!" ? "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + "[^/]*?)" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+			final = start + body + close;
+		}
+		return [
+			final,
+			unescape(body),
+			this.#hasMagic = !!this.#hasMagic,
+			this.#uflag
+		];
+	}
+	#flatten() {
+		if (!isExtglobAST(this)) {
+			for (const p of this.#parts) if (typeof p === "object") p.#flatten();
+		} else {
+			let iterations = 0;
+			let done = false;
+			do {
+				done = true;
+				for (let i = 0; i < this.#parts.length; i++) {
+					const c = this.#parts[i];
+					if (typeof c === "object") {
+						c.#flatten();
+						if (this.#canAdopt(c)) {
+							done = false;
+							this.#adopt(c, i);
+						} else if (this.#canAdoptWithSpace(c)) {
+							done = false;
+							this.#adoptWithSpace(c, i);
+						} else if (this.#canUsurp(c)) {
+							done = false;
+							this.#usurp(c);
+						}
+					}
+				}
+			} while (!done && ++iterations < 10);
+		}
+		this.#toString = void 0;
+	}
+	#partsToRegExp(dot) {
+		return this.#parts.map((p) => {
+			/* c8 ignore start */
+			if (typeof p === "string") throw new Error("string type in extglob ast??");
+			/* c8 ignore stop */
+			const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+			this.#uflag = this.#uflag || uflag;
+			return re;
+		}).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+	}
+	static #parseGlob(glob, hasMagic, noEmpty = false) {
+		let escaping = false;
+		let re = "";
+		let uflag = false;
+		let inStar = false;
+		for (let i = 0; i < glob.length; i++) {
+			const c = glob.charAt(i);
+			if (escaping) {
+				escaping = false;
+				re += (reSpecials.has(c) ? "\\" : "") + c;
+				continue;
+			}
+			if (c === "*") {
+				if (inStar) continue;
+				inStar = true;
+				re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star$1;
+				hasMagic = true;
+				continue;
+			} else inStar = false;
+			if (c === "\\") {
+				if (i === glob.length - 1) re += "\\\\";
+				else escaping = true;
+				continue;
+			}
+			if (c === "[") {
+				const [src, needUflag, consumed, magic] = parseClass(glob, i);
+				if (consumed) {
+					re += src;
+					uflag = uflag || needUflag;
+					i += consumed - 1;
+					hasMagic = hasMagic || magic;
+					continue;
+				}
+			}
+			if (c === "?") {
+				re += qmark;
+				hasMagic = true;
+				continue;
+			}
+			re += regExpEscape$1(c);
+		}
+		return [
+			re,
+			unescape(glob),
+			!!hasMagic,
+			uflag
+		];
+	}
+};
+_a = AST;
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/escape.js
+/**
+* Escape all magic characters in a glob pattern.
+*
+* If the {@link MinimatchOptions.windowsPathsNoEscape}
+* option is used, then characters are escaped by wrapping in `[]`, because
+* a magic character wrapped in a character class can only be satisfied by
+* that exact character.  In this mode, `\` is _not_ escaped, because it is
+* not interpreted as a magic character, but instead as a path separator.
+*
+* If the {@link MinimatchOptions.magicalBraces} option is used,
+* then braces (`{` and `}`) will be escaped.
+*/
+const escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+	if (magicalBraces) return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+	return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js
+const minimatch = (p, pattern, options = {}) => {
+	assertValidPattern(pattern);
+	if (!options.nocomment && pattern.charAt(0) === "#") return false;
+	return new Minimatch(pattern, options).match(p);
+};
+const starDotExtRE = /^\*+([^+@!?*[(]*)$/;
+const starDotExtTest = (ext) => (f) => !f.startsWith(".") && f.endsWith(ext);
+const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
+const starDotExtTestNocase = (ext) => {
+	ext = ext.toLowerCase();
+	return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext);
+};
+const starDotExtTestNocaseDot = (ext) => {
+	ext = ext.toLowerCase();
+	return (f) => f.toLowerCase().endsWith(ext);
+};
+const starDotStarRE = /^\*+\.\*+$/;
+const starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+const starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+const dotStarRE = /^\.\*+$/;
+const dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+const starRE = /^\*+$/;
+const starTest = (f) => f.length !== 0 && !f.startsWith(".");
+const starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+const qmarksRE = /^\?+([^+@!?*[(]*)?$/;
+const qmarksTestNocase = ([$0, ext = ""]) => {
+	const noext = qmarksTestNoExt([$0]);
+	if (!ext) return noext;
+	ext = ext.toLowerCase();
+	return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestNocaseDot = ([$0, ext = ""]) => {
+	const noext = qmarksTestNoExtDot([$0]);
+	if (!ext) return noext;
+	ext = ext.toLowerCase();
+	return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestDot = ([$0, ext = ""]) => {
+	const noext = qmarksTestNoExtDot([$0]);
+	return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTest = ([$0, ext = ""]) => {
+	const noext = qmarksTestNoExt([$0]);
+	return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTestNoExt = ([$0]) => {
+	const len = $0.length;
+	return (f) => f.length === len && !f.startsWith(".");
+};
+const qmarksTestNoExtDot = ([$0]) => {
+	const len = $0.length;
+	return (f) => f.length === len && f !== "." && f !== "..";
+};
+/* c8 ignore start */
+const defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+const path = {
+	win32: { sep: "\\" },
+	posix: { sep: "/" }
+};
+minimatch.sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
+const GLOBSTAR = Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+const star = "[^/]*?";
+const twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+const twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+const filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+const ext = (a, b = {}) => Object.assign({}, a, b);
+const defaults = (def) => {
+	if (!def || typeof def !== "object" || !Object.keys(def).length) return minimatch;
+	const orig = minimatch;
+	const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+	return Object.assign(m, {
+		Minimatch: class Minimatch extends orig.Minimatch {
+			constructor(pattern, options = {}) {
+				super(pattern, ext(def, options));
+			}
+			static defaults(options) {
+				return orig.defaults(ext(def, options)).Minimatch;
+			}
+		},
+		AST: class AST extends orig.AST {
+			/* c8 ignore start */
+			constructor(type, parent, options = {}) {
+				super(type, parent, ext(def, options));
+			}
+			/* c8 ignore stop */
+			static fromGlob(pattern, options = {}) {
+				return orig.AST.fromGlob(pattern, ext(def, options));
+			}
+		},
+		unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+		escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+		filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+		defaults: (options) => orig.defaults(ext(def, options)),
+		makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+		braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+		match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+		sep: orig.sep,
+		GLOBSTAR
+	});
+};
+minimatch.defaults = defaults;
+const braceExpand = (pattern, options = {}) => {
+	assertValidPattern(pattern);
+	if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) return [pattern];
+	return expand(pattern, { max: options.braceExpandMax });
+};
+minimatch.braceExpand = braceExpand;
+const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+const match = (list, pattern, options = {}) => {
+	const mm = new Minimatch(pattern, options);
+	list = list.filter((f) => mm.match(f));
+	if (mm.options.nonull && !list.length) list.push(pattern);
+	return list;
+};
+minimatch.match = match;
+const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+	options;
+	set;
+	pattern;
+	windowsPathsNoEscape;
+	nonegate;
+	negate;
+	comment;
+	empty;
+	preserveMultipleSlashes;
+	partial;
+	globSet;
+	globParts;
+	nocase;
+	isWindows;
+	platform;
+	windowsNoMagicRoot;
+	maxGlobstarRecursion;
+	regexp;
+	constructor(pattern, options = {}) {
+		assertValidPattern(pattern);
+		options = options || {};
+		this.options = options;
+		this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
+		this.pattern = pattern;
+		this.platform = options.platform || defaultPlatform;
+		this.isWindows = this.platform === "win32";
+		const awe = "allowWindowsEscape";
+		this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
+		if (this.windowsPathsNoEscape) this.pattern = this.pattern.replace(/\\/g, "/");
+		this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+		this.regexp = null;
+		this.negate = false;
+		this.nonegate = !!options.nonegate;
+		this.comment = false;
+		this.empty = false;
+		this.partial = !!options.partial;
+		this.nocase = !!this.options.nocase;
+		this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+		this.globSet = [];
+		this.globParts = [];
+		this.set = [];
+		this.make();
+	}
+	hasMagic() {
+		if (this.options.magicalBraces && this.set.length > 1) return true;
+		for (const pattern of this.set) for (const part of pattern) if (typeof part !== "string") return true;
+		return false;
+	}
+	debug(..._) {}
+	make() {
+		const pattern = this.pattern;
+		const options = this.options;
+		if (!options.nocomment && pattern.charAt(0) === "#") {
+			this.comment = true;
+			return;
+		}
+		if (!pattern) {
+			this.empty = true;
+			return;
+		}
+		this.parseNegate();
+		this.globSet = [...new Set(this.braceExpand())];
+		if (options.debug) this.debug = (...args) => console.error(...args);
+		this.debug(this.pattern, this.globSet);
+		const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+		this.globParts = this.preprocess(rawGlobParts);
+		this.debug(this.pattern, this.globParts);
+		let set = this.globParts.map((s, _, __) => {
+			if (this.isWindows && this.windowsNoMagicRoot) {
+				const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+				const isDrive = /^[a-z]:/i.test(s[0]);
+				if (isUNC) return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+				else if (isDrive) return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+			}
+			return s.map((ss) => this.parse(ss));
+		});
+		this.debug(this.pattern, set);
+		this.set = set.filter((s) => s.indexOf(false) === -1);
+		if (this.isWindows) for (let i = 0; i < this.set.length; i++) {
+			const p = this.set[i];
+			if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) p[2] = "?";
+		}
+		this.debug(this.pattern, this.set);
+	}
+	preprocess(globParts) {
+		if (this.options.noglobstar) {
+			for (const partset of globParts) for (let j = 0; j < partset.length; j++) if (partset[j] === "**") partset[j] = "*";
+		}
+		const { optimizationLevel = 1 } = this.options;
+		if (optimizationLevel >= 2) {
+			globParts = this.firstPhasePreProcess(globParts);
+			globParts = this.secondPhasePreProcess(globParts);
+		} else if (optimizationLevel >= 1) globParts = this.levelOneOptimize(globParts);
+		else globParts = this.adjascentGlobstarOptimize(globParts);
+		return globParts;
+	}
+	adjascentGlobstarOptimize(globParts) {
+		return globParts.map((parts) => {
+			let gs = -1;
+			while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+				let i = gs;
+				while (parts[i + 1] === "**") i++;
+				if (i !== gs) parts.splice(gs, i - gs);
+			}
+			return parts;
+		});
+	}
+	levelOneOptimize(globParts) {
+		return globParts.map((parts) => {
+			parts = parts.reduce((set, part) => {
+				const prev = set[set.length - 1];
+				if (part === "**" && prev === "**") return set;
+				if (part === "..") {
+					if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+						set.pop();
+						return set;
+					}
+				}
+				set.push(part);
+				return set;
+			}, []);
+			return parts.length === 0 ? [""] : parts;
+		});
+	}
+	levelTwoFileOptimize(parts) {
+		if (!Array.isArray(parts)) parts = this.slashSplit(parts);
+		let didSomething = false;
+		do {
+			didSomething = false;
+			if (!this.preserveMultipleSlashes) {
+				for (let i = 1; i < parts.length - 1; i++) {
+					const p = parts[i];
+					if (i === 1 && p === "" && parts[0] === "") continue;
+					if (p === "." || p === "") {
+						didSomething = true;
+						parts.splice(i, 1);
+						i--;
+					}
+				}
+				if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+					didSomething = true;
+					parts.pop();
+				}
+			}
+			let dd = 0;
+			while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+				const p = parts[dd - 1];
+				if (p && p !== "." && p !== ".." && p !== "**" && !(this.isWindows && /^[a-z]:$/i.test(p))) {
+					didSomething = true;
+					parts.splice(dd - 1, 2);
+					dd -= 2;
+				}
+			}
+		} while (didSomething);
+		return parts.length === 0 ? [""] : parts;
+	}
+	firstPhasePreProcess(globParts) {
+		let didSomething = false;
+		do {
+			didSomething = false;
+			for (let parts of globParts) {
+				let gs = -1;
+				while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+					let gss = gs;
+					while (parts[gss + 1] === "**") gss++;
+					if (gss > gs) parts.splice(gs + 1, gss - gs);
+					let next = parts[gs + 1];
+					const p = parts[gs + 2];
+					const p2 = parts[gs + 3];
+					if (next !== "..") continue;
+					if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") continue;
+					didSomething = true;
+					parts.splice(gs, 1);
+					const other = parts.slice(0);
+					other[gs] = "**";
+					globParts.push(other);
+					gs--;
+				}
+				if (!this.preserveMultipleSlashes) {
+					for (let i = 1; i < parts.length - 1; i++) {
+						const p = parts[i];
+						if (i === 1 && p === "" && parts[0] === "") continue;
+						if (p === "." || p === "") {
+							didSomething = true;
+							parts.splice(i, 1);
+							i--;
+						}
+					}
+					if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+						didSomething = true;
+						parts.pop();
+					}
+				}
+				let dd = 0;
+				while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+					const p = parts[dd - 1];
+					if (p && p !== "." && p !== ".." && p !== "**") {
+						didSomething = true;
+						const splin = dd === 1 && parts[dd + 1] === "**" ? ["."] : [];
+						parts.splice(dd - 1, 2, ...splin);
+						if (parts.length === 0) parts.push("");
+						dd -= 2;
+					}
+				}
+			}
+		} while (didSomething);
+		return globParts;
+	}
+	secondPhasePreProcess(globParts) {
+		for (let i = 0; i < globParts.length - 1; i++) for (let j = i + 1; j < globParts.length; j++) {
+			const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+			if (matched) {
+				globParts[i] = [];
+				globParts[j] = matched;
+				break;
+			}
+		}
+		return globParts.filter((gs) => gs.length);
+	}
+	partsMatch(a, b, emptyGSMatch = false) {
+		let ai = 0;
+		let bi = 0;
+		let result = [];
+		let which = "";
+		while (ai < a.length && bi < b.length) if (a[ai] === b[bi]) {
+			result.push(which === "b" ? b[bi] : a[ai]);
+			ai++;
+			bi++;
+		} else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+			result.push(a[ai]);
+			ai++;
+		} else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+			result.push(b[bi]);
+			bi++;
+		} else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+			if (which === "b") return false;
+			which = "a";
+			result.push(a[ai]);
+			ai++;
+			bi++;
+		} else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+			if (which === "a") return false;
+			which = "b";
+			result.push(b[bi]);
+			ai++;
+			bi++;
+		} else return false;
+		return a.length === b.length && result;
+	}
+	parseNegate() {
+		if (this.nonegate) return;
+		const pattern = this.pattern;
+		let negate = false;
+		let negateOffset = 0;
+		for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+			negate = !negate;
+			negateOffset++;
+		}
+		if (negateOffset) this.pattern = pattern.slice(negateOffset);
+		this.negate = negate;
+	}
+	matchOne(file, pattern, partial = false) {
+		let fileStartIndex = 0;
+		let patternStartIndex = 0;
+		if (this.isWindows) {
+			const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+			const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+			const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+			const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+			const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
+			const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+			if (typeof fdi === "number" && typeof pdi === "number") {
+				const [fd, pd] = [file[fdi], pattern[pdi]];
+				if (fd.toLowerCase() === pd.toLowerCase()) {
+					pattern[pdi] = fd;
+					patternStartIndex = pdi;
+					fileStartIndex = fdi;
+				}
+			}
+		}
+		const { optimizationLevel = 1 } = this.options;
+		if (optimizationLevel >= 2) file = this.levelTwoFileOptimize(file);
+		if (pattern.includes(GLOBSTAR)) return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+		return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+	}
+	#matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+		const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+		const lastgs = pattern.lastIndexOf(GLOBSTAR);
+		const [head, body, tail] = partial ? [
+			pattern.slice(patternIndex, firstgs),
+			pattern.slice(firstgs + 1),
+			[]
+		] : [
+			pattern.slice(patternIndex, firstgs),
+			pattern.slice(firstgs + 1, lastgs),
+			pattern.slice(lastgs + 1)
+		];
+		if (head.length) {
+			const fileHead = file.slice(fileIndex, fileIndex + head.length);
+			if (!this.#matchOne(fileHead, head, partial, 0, 0)) return false;
+			fileIndex += head.length;
+			patternIndex += head.length;
+		}
+		let fileTailMatch = 0;
+		if (tail.length) {
+			if (tail.length + fileIndex > file.length) return false;
+			let tailStart = file.length - tail.length;
+			if (this.#matchOne(file, tail, partial, tailStart, 0)) fileTailMatch = tail.length;
+			else {
+				if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) return false;
+				tailStart--;
+				if (!this.#matchOne(file, tail, partial, tailStart, 0)) return false;
+				fileTailMatch = tail.length + 1;
+			}
+		}
+		if (!body.length) {
+			let sawSome = !!fileTailMatch;
+			for (let i = fileIndex; i < file.length - fileTailMatch; i++) {
+				const f = String(file[i]);
+				sawSome = true;
+				if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) return false;
+			}
+			return partial || sawSome;
+		}
+		const bodySegments = [[[], 0]];
+		let currentBody = bodySegments[0];
+		let nonGsParts = 0;
+		const nonGsPartsSums = [0];
+		for (const b of body) if (b === GLOBSTAR) {
+			nonGsPartsSums.push(nonGsParts);
+			currentBody = [[], 0];
+			bodySegments.push(currentBody);
+		} else {
+			currentBody[0].push(b);
+			nonGsParts++;
+		}
+		let i = bodySegments.length - 1;
+		const fileLength = file.length - fileTailMatch;
+		for (const b of bodySegments) b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+		return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+	}
+	#matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+		const bs = bodySegments[bodyIndex];
+		if (!bs) {
+			for (let i = fileIndex; i < file.length; i++) {
+				sawTail = true;
+				const f = file[i];
+				if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) return false;
+			}
+			return sawTail;
+		}
+		const [body, after] = bs;
+		while (fileIndex <= after) {
+			if (this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0) && globStarDepth < this.maxGlobstarRecursion) {
+				const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+				if (sub !== false) return sub;
+			}
+			const f = file[fileIndex];
+			if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) return false;
+			fileIndex++;
+		}
+		return partial || null;
+	}
+	#matchOne(file, pattern, partial, fileIndex, patternIndex) {
+		let fi;
+		let pi;
+		let pl;
+		let fl;
+		for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+			this.debug("matchOne loop");
+			let p = pattern[pi];
+			let f = file[fi];
+			this.debug(pattern, p, f);
+			/* c8 ignore start */
+			if (p === false || p === GLOBSTAR) return false;
+			/* c8 ignore stop */
+			let hit;
+			if (typeof p === "string") {
+				hit = f === p;
+				this.debug("string match", p, f, hit);
+			} else {
+				hit = p.test(f);
+				this.debug("pattern match", p, f, hit);
+			}
+			if (!hit) return false;
+		}
+		if (fi === fl && pi === pl) return true;
+		else if (fi === fl) return partial;
+		else if (pi === pl) return fi === fl - 1 && file[fi] === "";
+		else throw new Error("wtf?");
+		/* c8 ignore stop */
+	}
+	braceExpand() {
+		return braceExpand(this.pattern, this.options);
+	}
+	parse(pattern) {
+		assertValidPattern(pattern);
+		const options = this.options;
+		if (pattern === "**") return GLOBSTAR;
+		if (pattern === "") return "";
+		let m;
+		let fastTest = null;
+		if (m = pattern.match(starRE)) fastTest = options.dot ? starTestDot : starTest;
+		else if (m = pattern.match(starDotExtRE)) fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+		else if (m = pattern.match(qmarksRE)) fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+		else if (m = pattern.match(starDotStarRE)) fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+		else if (m = pattern.match(dotStarRE)) fastTest = dotStarTest;
+		const re = AST.fromGlob(pattern, this.options).toMMPattern();
+		if (fastTest && typeof re === "object") Reflect.defineProperty(re, "test", { value: fastTest });
+		return re;
+	}
+	makeRe() {
+		if (this.regexp || this.regexp === false) return this.regexp;
+		const set = this.set;
+		if (!set.length) {
+			this.regexp = false;
+			return this.regexp;
+		}
+		const options = this.options;
+		const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+		const flags = new Set(options.nocase ? ["i"] : []);
+		let re = set.map((pattern) => {
+			const pp = pattern.map((p) => {
+				if (p instanceof RegExp) for (const f of p.flags.split("")) flags.add(f);
+				return typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+			});
+			pp.forEach((p, i) => {
+				const next = pp[i + 1];
+				const prev = pp[i - 1];
+				if (p !== GLOBSTAR || prev === GLOBSTAR) return;
+				if (prev === void 0) if (next !== void 0 && next !== GLOBSTAR) pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+				else pp[i] = twoStar;
+				else if (next === void 0) pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
+				else if (next !== GLOBSTAR) {
+					pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+					pp[i + 1] = GLOBSTAR;
+				}
+			});
+			const filtered = pp.filter((p) => p !== GLOBSTAR);
+			if (this.partial && filtered.length >= 1) {
+				const prefixes = [];
+				for (let i = 1; i <= filtered.length; i++) prefixes.push(filtered.slice(0, i).join("/"));
+				return "(?:" + prefixes.join("|") + ")";
+			}
+			return filtered.join("/");
+		}).join("|");
+		const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+		re = "^" + open + re + close + "$";
+		if (this.partial) re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+		if (this.negate) re = "^(?!" + re + ").+$";
+		try {
+			this.regexp = new RegExp(re, [...flags].join(""));
+		} catch {
+			this.regexp = false;
+		}
+		/* c8 ignore stop */
+		return this.regexp;
+	}
+	slashSplit(p) {
+		if (this.preserveMultipleSlashes) return p.split("/");
+		else if (this.isWindows && /^\/\/[^/]+/.test(p)) return ["", ...p.split(/\/+/)];
+		else return p.split(/\/+/);
+	}
+	match(f, partial = this.partial) {
+		this.debug("match", f, this.pattern);
+		if (this.comment) return false;
+		if (this.empty) return f === "";
+		if (f === "/" && partial) return true;
+		const options = this.options;
+		if (this.isWindows) f = f.split("\\").join("/");
+		const ff = this.slashSplit(f);
+		this.debug(this.pattern, "split", ff);
+		const set = this.set;
+		this.debug(this.pattern, "set", set);
+		let filename = ff[ff.length - 1];
+		if (!filename) for (let i = ff.length - 2; !filename && i >= 0; i--) filename = ff[i];
+		for (const pattern of set) {
+			let file = ff;
+			if (options.matchBase && pattern.length === 1) file = [filename];
+			if (this.matchOne(file, pattern, partial)) {
+				if (options.flipNegate) return true;
+				return !this.negate;
+			}
+		}
+		if (options.flipNegate) return false;
+		return this.negate;
+	}
+	static defaults(def) {
+		return minimatch.defaults(def).Minimatch;
+	}
+};
+/* c8 ignore stop */
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+//#endregion
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-R4IFXNY5.js
+(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function M(n) {
+	if (n < 1024) return String(n);
+	if (n < 1024 * 1024) {
+		let c = n / 1024;
+		return c < 10 ? `${c.toFixed(1)}K` : `${Math.round(c)}K`;
+	}
+	if (n < 1024 * 1024 * 1024) {
+		let c = n / 1048576;
+		return c < 10 ? `${c.toFixed(1)}M` : `${Math.round(c)}M`;
+	}
+	let s = n / (1024 * 1024 * 1024);
+	return s < 10 ? `${s.toFixed(1)}G` : `${Math.round(s)}G`;
+}
+function T(n) {
+	let c = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	][n.getMonth()], w = String(n.getDate()).padStart(2, " ");
+	if (n > /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).getTime() - 4320 * 60 * 60 * 1e3)) return `${c} ${w} ${String(n.getHours()).padStart(2, "0")}:${String(n.getMinutes()).padStart(2, "0")}`;
+	return `${c} ${w}  ${n.getFullYear()}`;
+}
+function C(n) {
+	return n.isDirectory ? "/" : n.isSymbolicLink ? "@" : (n.mode & 73) !== 0 ? "*" : "";
+}
+var k = {
+	name: "ls",
+	summary: "list directory contents",
+	usage: "ls [OPTION]... [FILE]...",
+	options: [
+		"-a, --all            do not ignore entries starting with .",
+		"-A, --almost-all     do not list . and ..",
+		"-d, --directory      list directories themselves, not their contents",
+		"-F, --classify       append indicator (one of */=>@) to entries",
+		"-h, --human-readable with -l, print sizes like 1K 234M 2G etc.",
+		"-l                   use a long listing format",
+		"-r, --reverse        reverse order while sorting",
+		"-R, --recursive      list subdirectories recursively",
+		"-S                   sort by file size, largest first",
+		"-t                   sort by time, newest first",
+		"-1                   list one file per line",
+		"    --help           display this help and exit"
+	]
+}, G = {
+	showAll: {
+		short: "a",
+		long: "all",
+		type: "boolean"
+	},
+	showAlmostAll: {
+		short: "A",
+		long: "almost-all",
+		type: "boolean"
+	},
+	longFormat: {
+		short: "l",
+		type: "boolean"
+	},
+	humanReadable: {
+		short: "h",
+		long: "human-readable",
+		type: "boolean"
+	},
+	recursive: {
+		short: "R",
+		long: "recursive",
+		type: "boolean"
+	},
+	reverse: {
+		short: "r",
+		long: "reverse",
+		type: "boolean"
+	},
+	sortBySize: {
+		short: "S",
+		type: "boolean"
+	},
+	classifyFiles: {
+		short: "F",
+		long: "classify",
+		type: "boolean"
+	},
+	directoryOnly: {
+		short: "d",
+		long: "directory",
+		type: "boolean"
+	},
+	sortByTime: {
+		short: "t",
+		type: "boolean"
+	},
+	onePerLine: {
+		short: "1",
+		type: "boolean"
+	}
+}, Z = {
+	name: "ls",
+	async execute(n, s$1) {
+		if (require_chunk_QAYAQNCG.o(n)) return require_chunk_QAYAQNCG.s(k);
+		let c = require_chunk_QIQMJJZ4.x("ls", n, G);
+		if (!c.ok) return c.error;
+		let w = c.result.flags.showAll, S = c.result.flags.showAlmostAll, y = c.result.flags.longFormat, P = c.result.flags.humanReadable, b = c.result.flags.recursive, g = c.result.flags.reverse, v = c.result.flags.sortBySize, $ = c.result.flags.classifyFiles, A = c.result.flags.directoryOnly;
+		c.result.flags.sortByTime;
+		c.result.flags.onePerLine;
+		let r = c.result.positional;
+		r.length === 0 && r.push(".");
+		let a = "", l = "", u = 0;
+		for (let f = 0; f < r.length; f++) {
+			let o = r[f];
+			if (f > 0 && a && !a.endsWith(`
+
+`) && (a += `
+`), A) {
+				let i = s$1.fs.resolvePath(s$1.cwd, o);
+				try {
+					let t = await s$1.fs.stat(i);
+					if (y) {
+						let e = t.isDirectory ? "drwxr-xr-x" : "-rw-r--r--", d = $ ? C(await s$1.fs.lstat(i)) : t.isDirectory ? "/" : "", h = t.size ?? 0, m = P ? M(h).padStart(5) : String(h).padStart(5), F = T(t.mtime ?? /* @__PURE__ */ new Date(0));
+						a += `${e} 1 user user ${m} ${F} ${o}${d}
+`;
+					} else {
+						let e = $ ? C(await s$1.fs.lstat(i)) : "";
+						a += `${o}${e}
+`;
+					}
+				} catch {
+					l += `ls: cannot access '${o}': No such file or directory
+`, u = 2;
+				}
+				continue;
+			}
+			if (o.includes("*") || o.includes("?") || o.includes("[")) {
+				let i = await _(o, s$1, w, S, y, g, P, v, $);
+				a += i.stdout, l += i.stderr, i.exitCode !== 0 && (u = i.exitCode);
+			} else {
+				let i = await O(o, s$1, w, S, y, b, r.length > 1, g, P, v, $);
+				a += i.stdout, l += i.stderr, i.exitCode !== 0 && (u = i.exitCode);
+			}
+		}
+		return {
+			stdout: a,
+			stderr: l,
+			exitCode: u
+		};
+	}
+};
+async function _(n, s, c, w, S, y = !1, P = !1, b = !1, g = !1) {
+	let v = c || w, $ = s.fs.getAllPaths(), A = s.fs.resolvePath(s.cwd, "."), p = [];
+	for (let r of $) {
+		let a = r.startsWith(A) && r.slice(A.length + 1) || r;
+		if (minimatch(a, n) || minimatch(r, n)) {
+			let l = a.split("/").pop() || a;
+			if (!v && l.startsWith(".")) continue;
+			p.push(a || r);
+		}
+	}
+	if (p.length === 0) return {
+		stdout: "",
+		stderr: `ls: ${n}: No such file or directory
+`,
+		exitCode: 2
+	};
+	if (b) {
+		let r = [];
+		for (let a of p) {
+			let l = s.fs.resolvePath(s.cwd, a);
+			try {
+				let u = await s.fs.stat(l);
+				r.push({
+					path: a,
+					size: u.size ?? 0
+				});
+			} catch {
+				r.push({
+					path: a,
+					size: 0
+				});
+			}
+		}
+		r.sort((a, l) => l.size - a.size), p.length = 0, p.push(...r.map((a) => a.path));
+	} else p.sort();
+	if (y && p.reverse(), S) {
+		let r = [];
+		for (let a of p) {
+			let l = s.fs.resolvePath(s.cwd, a);
+			try {
+				let u = await s.fs.stat(l), f = u.isDirectory ? "drwxr-xr-x" : "-rw-r--r--", o = g ? C(await s.fs.lstat(l)) : u.isDirectory ? "/" : "", i = u.size ?? 0, t = P ? M(i).padStart(5) : String(i).padStart(5), d = T(u.mtime ?? /* @__PURE__ */ new Date(0));
+				r.push(`${f} 1 user user ${t} ${d} ${a}${o}`);
+			} catch {
+				r.push(`-rw-r--r-- 1 user user     0 Jan  1 00:00 ${a}`);
+			}
+		}
+		return {
+			stdout: `${r.join(`
+`)}
+`,
+			stderr: "",
+			exitCode: 0
+		};
+	}
+	if (g) {
+		let r = [];
+		for (let a of p) {
+			let l = s.fs.resolvePath(s.cwd, a);
+			try {
+				let u = await s.fs.lstat(l);
+				r.push(`${a}${C(u)}`);
+			} catch {
+				r.push(a);
+			}
+		}
+		return {
+			stdout: `${r.join(`
+`)}
+`,
+			stderr: "",
+			exitCode: 0
+		};
+	}
+	return {
+		stdout: `${p.join(`
+`)}
+`,
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function O(n, s, c, w, S, y, P, b = !1, g = !1, v = !1, $ = !1, A = !1) {
+	let p = c || w, r = s.fs.resolvePath(s.cwd, n);
+	try {
+		let a = await s.fs.stat(r);
+		if (!a.isDirectory) {
+			let f = $ ? C(await s.fs.lstat(r)) : "";
+			if (S) {
+				let o = a.size ?? 0;
+				return {
+					stdout: `-rw-r--r-- 1 user user ${g ? M(o).padStart(5) : String(o).padStart(5)} ${T(a.mtime ?? /* @__PURE__ */ new Date(0))} ${n}${f}
+`,
+					stderr: "",
+					exitCode: 0
+				};
+			}
+			return {
+				stdout: `${n}${f}
+`,
+				stderr: "",
+				exitCode: 0
+			};
+		}
+		let l = await s.fs.readdir(r);
+		if (p || (l = l.filter((f) => !f.startsWith("."))), v) {
+			let f = [];
+			for (let o of l) {
+				let i = r === "/" ? `/${o}` : `${r}/${o}`;
+				try {
+					let t = await s.fs.stat(i);
+					f.push({
+						name: o,
+						size: t.size ?? 0
+					});
+				} catch {
+					f.push({
+						name: o,
+						size: 0
+					});
+				}
+			}
+			f.sort((o, i) => i.size - o.size), l = f.map((o) => o.name);
+		} else l.sort();
+		c && (l = [
+			".",
+			"..",
+			...l
+		]), b && l.reverse();
+		let u = "";
+		if ((y || P) && (u += `${n}:
+`), S) {
+			u += `total ${l.length}
+`;
+			let f = l.filter((e) => e === "." || e === ".."), o = l.filter((e) => e !== "." && e !== "..");
+			for (let e of f) u += `drwxr-xr-x 1 user user     0 Jan  1 00:00 ${e}
+`;
+			let i = [];
+			for (let e = 0; e < o.length; e += 100) {
+				let d = o.slice(e, e + 100), h = await Promise.all(d.map(async (m) => {
+					let z = r === "/" ? `/${m}` : `${r}/${m}`;
+					try {
+						let F = await s.fs.stat(z), B = F.isDirectory ? "drwxr-xr-x" : "-rw-r--r--", J = $ ? C(await s.fs.lstat(z)) : F.isDirectory ? "/" : "", W = F.size ?? 0;
+						return {
+							name: m,
+							line: `${B} 1 user user ${g ? M(W).padStart(5) : String(W).padStart(5)} ${T(F.mtime ?? /* @__PURE__ */ new Date(0))} ${m}${J}
+`
+						};
+					} catch {
+						return {
+							name: m,
+							line: `-rw-r--r-- 1 user user     0 Jan  1 00:00 ${m}
+`
+						};
+					}
+				}));
+				i.push(...h);
+			}
+			let t = new Map(o.map((e, d) => [e, d]));
+			i.sort((e, d) => (t.get(e.name) ?? 0) - (t.get(d.name) ?? 0));
+			for (let { line: e } of i) u += e;
+		} else if ($) {
+			let f = [], o = l.filter((t) => t !== "." && t !== ".."), i = l.filter((t) => t === "." || t === "..");
+			for (let t of i) f.push(`${t}/`);
+			for (let t = 0; t < o.length; t += 100) {
+				let e = o.slice(t, t + 100), d = await Promise.all(e.map(async (h) => {
+					let m = r === "/" ? `/${h}` : `${r}/${h}`;
+					try {
+						return `${h}${C(await s.fs.lstat(m))}`;
+					} catch {
+						return h;
+					}
+				}));
+				f.push(...d);
+			}
+			u += f.join(`
+`) + (f.length ? `
+` : "");
+		} else u += l.join(`
+`) + (l.length ? `
+` : "");
+		if (y) {
+			let f = l.filter((t) => t !== "." && t !== ".."), o = [];
+			if (s.fs.readdirWithFileTypes) o = (await s.fs.readdirWithFileTypes(r)).filter((e) => e.isDirectory && f.includes(e.name)).map((e) => ({
+				name: e.name,
+				isDirectory: !0
+			}));
+			else for (let t = 0; t < f.length; t += 100) {
+				let e = f.slice(t, t + 100), d = await Promise.all(e.map(async (h) => {
+					let m = r === "/" ? `/${h}` : `${r}/${h}`;
+					try {
+						return {
+							name: h,
+							isDirectory: (await s.fs.stat(m)).isDirectory
+						};
+					} catch {
+						return {
+							name: h,
+							isDirectory: !1
+						};
+					}
+				}));
+				o.push(...d.filter((h) => h.isDirectory));
+			}
+			o.sort((t, e) => t.name.localeCompare(e.name)), b && o.reverse();
+			let i = [];
+			for (let t = 0; t < o.length; t += 100) {
+				let e = o.slice(t, t + 100), d = await Promise.all(e.map(async (h) => {
+					let z = await O(n === "." ? `./${h.name}` : `${n}/${h.name}`, s, c, w, S, y, !1, b, g, v, $, !0);
+					return {
+						name: h.name,
+						result: z
+					};
+				}));
+				i.push(...d);
+			}
+			i.sort((t, e) => t.name.localeCompare(e.name)), b && i.reverse();
+			for (let { result: t } of i) u += `
+`, u += t.stdout;
+		}
+		return {
+			stdout: u,
+			stderr: "",
+			exitCode: 0
+		};
+	} catch {
+		return {
+			stdout: "",
+			stderr: `ls: ${n}: No such file or directory
+`,
+			exitCode: 2
+		};
+	}
+}
+var q = {
+	name: "ls",
+	flags: [
+		{
+			flag: "-a",
+			type: "boolean"
+		},
+		{
+			flag: "-A",
+			type: "boolean"
+		},
+		{
+			flag: "-l",
+			type: "boolean"
+		},
+		{
+			flag: "-h",
+			type: "boolean"
+		},
+		{
+			flag: "-R",
+			type: "boolean"
+		},
+		{
+			flag: "-r",
+			type: "boolean"
+		},
+		{
+			flag: "-S",
+			type: "boolean"
+		},
+		{
+			flag: "-F",
+			type: "boolean"
+		},
+		{
+			flag: "-d",
+			type: "boolean"
+		},
+		{
+			flag: "-t",
+			type: "boolean"
+		},
+		{
+			flag: "-1",
+			type: "boolean"
+		}
+	],
+	needsFiles: !0
+};
+//#endregion
+Object.defineProperty(exports, "Z", {
+	enumerable: true,
+	get: function() {
+		return Z;
+	}
+});
+Object.defineProperty(exports, "q", {
+	enumerable: true,
+	get: function() {
+		return q;
+	}
+});
+
+//# sourceMappingURL=chunk-R4IFXNY5-Csrv6AhU.cjs.map