buddy-agent-harness 0.8.0 → 0.9.1

package/dist/dist-ktNZ1sJo.mjs

@@ -0,0 +1,2966 @@
+import { a as __toESM, i as __require, n as unpartial, r as __commonJSMin } from "./esm-CVacKtt6.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+//#region ../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js
+var require_old = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var pathModule = __require("path");
+	var isWindows = process.platform === "win32";
+	var fs$6 = __require("fs");
+	var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+	function rethrow() {
+		var callback;
+		if (DEBUG) {
+			var backtrace = /* @__PURE__ */ new Error();
+			callback = debugCallback;
+		} else callback = missingCallback;
+		return callback;
+		function debugCallback(err) {
+			if (err) {
+				backtrace.message = err.message;
+				err = backtrace;
+				missingCallback(err);
+			}
+		}
+		function missingCallback(err) {
+			if (err) {
+				if (process.throwDeprecation) throw err;
+				else if (!process.noDeprecation) {
+					var msg = "fs: missing callback " + (err.stack || err.message);
+					if (process.traceDeprecation) console.trace(msg);
+					else console.error(msg);
+				}
+			}
+		}
+	}
+	function maybeCallback(cb) {
+		return typeof cb === "function" ? cb : rethrow();
+	}
+	pathModule.normalize;
+	if (isWindows) var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+	else var nextPartRe = /(.*?)(?:[\/]+|$)/g;
+	if (isWindows) var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+	else var splitRootRe = /^[\/]*/;
+	exports.realpathSync = function realpathSync(p, cache) {
+		p = pathModule.resolve(p);
+		if (cache && Object.prototype.hasOwnProperty.call(cache, p)) return cache[p];
+		var original = p, seenLinks = {}, knownHard = {};
+		var pos;
+		var current;
+		var base;
+		var previous;
+		start();
+		function start() {
+			var m = splitRootRe.exec(p);
+			pos = m[0].length;
+			current = m[0];
+			base = m[0];
+			previous = "";
+			if (isWindows && !knownHard[base]) {
+				fs$6.lstatSync(base);
+				knownHard[base] = true;
+			}
+		}
+		while (pos < p.length) {
+			nextPartRe.lastIndex = pos;
+			var result = nextPartRe.exec(p);
+			previous = current;
+			current += result[0];
+			base = previous + result[1];
+			pos = nextPartRe.lastIndex;
+			if (knownHard[base] || cache && cache[base] === base) continue;
+			var resolvedLink;
+			if (cache && Object.prototype.hasOwnProperty.call(cache, base)) resolvedLink = cache[base];
+			else {
+				var stat = fs$6.lstatSync(base);
+				if (!stat.isSymbolicLink()) {
+					knownHard[base] = true;
+					if (cache) cache[base] = base;
+					continue;
+				}
+				var linkTarget = null;
+				if (!isWindows) {
+					var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+					if (seenLinks.hasOwnProperty(id)) linkTarget = seenLinks[id];
+				}
+				if (linkTarget === null) {
+					fs$6.statSync(base);
+					linkTarget = fs$6.readlinkSync(base);
+				}
+				resolvedLink = pathModule.resolve(previous, linkTarget);
+				if (cache) cache[base] = resolvedLink;
+				if (!isWindows) seenLinks[id] = linkTarget;
+			}
+			p = pathModule.resolve(resolvedLink, p.slice(pos));
+			start();
+		}
+		if (cache) cache[original] = p;
+		return p;
+	};
+	exports.realpath = function realpath(p, cache, cb) {
+		if (typeof cb !== "function") {
+			cb = maybeCallback(cache);
+			cache = null;
+		}
+		p = pathModule.resolve(p);
+		if (cache && Object.prototype.hasOwnProperty.call(cache, p)) return process.nextTick(cb.bind(null, null, cache[p]));
+		var original = p, seenLinks = {}, knownHard = {};
+		var pos;
+		var current;
+		var base;
+		var previous;
+		start();
+		function start() {
+			var m = splitRootRe.exec(p);
+			pos = m[0].length;
+			current = m[0];
+			base = m[0];
+			previous = "";
+			if (isWindows && !knownHard[base]) fs$6.lstat(base, function(err) {
+				if (err) return cb(err);
+				knownHard[base] = true;
+				LOOP();
+			});
+			else process.nextTick(LOOP);
+		}
+		function LOOP() {
+			if (pos >= p.length) {
+				if (cache) cache[original] = p;
+				return cb(null, p);
+			}
+			nextPartRe.lastIndex = pos;
+			var result = nextPartRe.exec(p);
+			previous = current;
+			current += result[0];
+			base = previous + result[1];
+			pos = nextPartRe.lastIndex;
+			if (knownHard[base] || cache && cache[base] === base) return process.nextTick(LOOP);
+			if (cache && Object.prototype.hasOwnProperty.call(cache, base)) return gotResolvedLink(cache[base]);
+			return fs$6.lstat(base, gotStat);
+		}
+		function gotStat(err, stat) {
+			if (err) return cb(err);
+			if (!stat.isSymbolicLink()) {
+				knownHard[base] = true;
+				if (cache) cache[base] = base;
+				return process.nextTick(LOOP);
+			}
+			if (!isWindows) {
+				var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+				if (seenLinks.hasOwnProperty(id)) return gotTarget(null, seenLinks[id], base);
+			}
+			fs$6.stat(base, function(err) {
+				if (err) return cb(err);
+				fs$6.readlink(base, function(err, target) {
+					if (!isWindows) seenLinks[id] = target;
+					gotTarget(err, target);
+				});
+			});
+		}
+		function gotTarget(err, target, base) {
+			if (err) return cb(err);
+			var resolvedLink = pathModule.resolve(previous, target);
+			if (cache) cache[base] = resolvedLink;
+			gotResolvedLink(resolvedLink);
+		}
+		function gotResolvedLink(resolvedLink) {
+			p = pathModule.resolve(resolvedLink, p.slice(pos));
+			start();
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js
+var require_fs_realpath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = realpath;
+	realpath.realpath = realpath;
+	realpath.sync = realpathSync;
+	realpath.realpathSync = realpathSync;
+	realpath.monkeypatch = monkeypatch;
+	realpath.unmonkeypatch = unmonkeypatch;
+	var fs$5 = __require("fs");
+	var origRealpath = fs$5.realpath;
+	var origRealpathSync = fs$5.realpathSync;
+	var version = process.version;
+	var ok = /^v[0-5]\./.test(version);
+	var old = require_old();
+	function newError(er) {
+		return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
+	}
+	function realpath(p, cache, cb) {
+		if (ok) return origRealpath(p, cache, cb);
+		if (typeof cache === "function") {
+			cb = cache;
+			cache = null;
+		}
+		origRealpath(p, cache, function(er, result) {
+			if (newError(er)) old.realpath(p, cache, cb);
+			else cb(er, result);
+		});
+	}
+	function realpathSync(p, cache) {
+		if (ok) return origRealpathSync(p, cache);
+		try {
+			return origRealpathSync(p, cache);
+		} catch (er) {
+			if (newError(er)) return old.realpathSync(p, cache);
+			else throw er;
+		}
+	}
+	function monkeypatch() {
+		fs$5.realpath = realpath;
+		fs$5.realpathSync = realpathSync;
+	}
+	function unmonkeypatch() {
+		fs$5.realpath = origRealpath;
+		fs$5.realpathSync = origRealpathSync;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js
+var require_concat_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function(xs, fn) {
+		var res = [];
+		for (var i = 0; i < xs.length; i++) {
+			var x = fn(xs[i], i);
+			if (isArray(x)) res.push.apply(res, x);
+			else res.push(x);
+		}
+		return res;
+	};
+	var isArray = Array.isArray || function(xs) {
+		return Object.prototype.toString.call(xs) === "[object Array]";
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = balanced;
+	function balanced(a, b, str) {
+		if (a instanceof RegExp) a = maybeMatch(a, str);
+		if (b instanceof RegExp) b = maybeMatch(b, str);
+		var r = range(a, b, str);
+		return r && {
+			start: r[0],
+			end: r[1],
+			pre: str.slice(0, r[0]),
+			body: str.slice(r[0] + a.length, r[1]),
+			post: str.slice(r[1] + b.length)
+		};
+	}
+	function maybeMatch(reg, str) {
+		var m = str.match(reg);
+		return m ? m[0] : null;
+	}
+	balanced.range = range;
+	function range(a, b, str) {
+		var begs, beg, left, right, result;
+		var ai = str.indexOf(a);
+		var bi = str.indexOf(b, ai + 1);
+		var 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) result = [begs.pop(), bi];
+				else {
+					beg = begs.pop();
+					if (beg < left) {
+						left = beg;
+						right = bi;
+					}
+					bi = str.indexOf(b, i + 1);
+				}
+				i = ai < bi && ai >= 0 ? ai : bi;
+			}
+			if (begs.length) result = [left, right];
+		}
+		return result;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/brace-expansion@1.1.18/node_modules/brace-expansion/index.js
+var require_brace_expansion = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	require_concat_map();
+	var balanced = require_balanced_match();
+	module.exports = expandTop;
+	var escSlash = "\0SLASH" + Math.random() + "\0";
+	var escOpen = "\0OPEN" + Math.random() + "\0";
+	var escClose = "\0CLOSE" + Math.random() + "\0";
+	var escComma = "\0COMMA" + Math.random() + "\0";
+	var escPeriod = "\0PERIOD" + Math.random() + "\0";
+	var EXPANSION_MAX = 1e5;
+	var EXPANSION_MAX_LENGTH = 4e6;
+	function numeric(str) {
+		return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+	}
+	function escapeBraces(str) {
+		return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+	}
+	function unescapeBraces(str) {
+		return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+	}
+	function parseCommaParts(str) {
+		if (!str) return [""];
+		var parts = [];
+		var m = balanced("{", "}", str);
+		if (!m) return str.split(",");
+		var pre = m.pre;
+		var body = m.body;
+		var post = m.post;
+		var p = pre.split(",");
+		p[p.length - 1] += "{" + body + "}";
+		var 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 expandTop(str, options) {
+		if (!str) return [];
+		options = options || {};
+		var max = options.max == null ? EXPANSION_MAX : options.max;
+		var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength;
+		if (str.substr(0, 2) === "{}") str = "\\{\\}" + str.substr(2);
+		return expand(escapeBraces(str), max, maxLength, 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 combine(acc, base, pre, values, max, maxLength, dropEmpties, outBase) {
+		var out = [];
+		var length = 0;
+		for (var a = 0; a < acc.length; a++) for (var v = 0; v < values.length; v++) {
+			if (out.length >= max) return out;
+			var expansion = acc[a] + pre + values[v];
+			if (dropEmpties && expansion.length === base[a]) continue;
+			if (length + expansion.length > maxLength) return out;
+			out.push(expansion);
+			outBase.push(base[a]);
+			length += expansion.length;
+		}
+		return out;
+	}
+	function expandSequence(body, isAlphaSequence, max, maxLength) {
+		var n = body.split(/\.\./);
+		var N = [];
+		/* c8 ignore start */
+		if (n[0] === void 0 || n[1] === void 0) return N;
+		/* c8 ignore stop */
+		var x = numeric(n[0]);
+		var y = numeric(n[1]);
+		var width = Math.max(n[0].length, n[1].length);
+		var incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+		var test = lte;
+		if (y < x) {
+			incr *= -1;
+			test = gte;
+		}
+		var pad = n.some(isPadded);
+		var length = 0;
+		for (var i = x; test(i, y) && N.length < max; i += incr) {
+			var c;
+			if (isAlphaSequence) {
+				c = String.fromCharCode(i);
+				if (c === "\\") c = "";
+			} else {
+				c = String(i);
+				if (pad) {
+					var need = width - c.length;
+					if (need > 0) {
+						var z = new Array(need + 1).join("0");
+						if (i < 0) c = "-" + z + c.slice(1);
+						else c = z + c;
+					}
+				}
+			}
+			if (length + c.length > maxLength) break;
+			N.push(c);
+			length += c.length;
+		}
+		return N;
+	}
+	function expand(str, max, maxLength, isTop) {
+		var acc = [""];
+		var accBase = [0];
+		var dropEmpties = false;
+		var firstGroup = true;
+		var nextBase;
+		for (;;) {
+			var m = balanced("{", "}", str);
+			if (!m) return combine(acc, accBase, str, [""], max, maxLength, dropEmpties, []);
+			var pre = m.pre;
+			if (/\$$/.test(pre)) return combine(acc, accBase, str, [""], max, maxLength, dropEmpties, []);
+			var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+			var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+			var isSequence = isNumericSequence || isAlphaSequence;
+			var isOptions = m.body.indexOf(",") >= 0;
+			if (!isSequence && !isOptions) {
+				if (m.post.match(/,(?!,).*\}/)) {
+					str = m.pre + "{" + m.body + escClose + m.post;
+					isTop = true;
+					firstGroup = true;
+					dropEmpties = false;
+					accBase = [];
+					for (var b = 0; b < acc.length; b++) accBase.push(acc[b].length);
+					continue;
+				}
+				return combine(acc, accBase, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties, []);
+			}
+			if (firstGroup) {
+				dropEmpties = isTop && !isSequence;
+				firstGroup = false;
+			}
+			var values;
+			if (isSequence) values = expandSequence(m.body, isAlphaSequence, max, maxLength);
+			else {
+				var n = parseCommaParts(m.body);
+				if (n.length === 1 && n[0] !== void 0) {
+					n = expand(n[0], max, maxLength, false).map(embrace);
+					/* c8 ignore start */
+					if (n.length === 1) {
+						nextBase = [];
+						acc = combine(acc, accBase, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length, nextBase);
+						accBase = nextBase;
+						if (!m.post.length) break;
+						str = m.post;
+						continue;
+					}
+				}
+				var dropsEmpties = dropEmpties && !m.post.length && !pre;
+				for (var d = 0; dropsEmpties && d < acc.length; d++) if (acc[d].length !== accBase[d]) dropsEmpties = false;
+				values = [];
+				var valuesLength = 0;
+				outer: for (var j = 0; j < n.length; j++) {
+					var expanded = expand(n[j], max, maxLength, false);
+					for (var k = 0; k < expanded.length; k++) {
+						var v = expanded[k];
+						if (dropsEmpties && !v) continue;
+						if (values.length >= max || valuesLength + v.length > maxLength) break outer;
+						values.push(v);
+						valuesLength += v.length;
+					}
+				}
+			}
+			nextBase = [];
+			acc = combine(acc, accBase, pre, values, max, maxLength, dropEmpties && !m.post.length, nextBase);
+			accBase = nextBase;
+			if (!m.post.length) break;
+			str = m.post;
+		}
+		return acc;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/minimatch@3.1.5/node_modules/minimatch/minimatch.js
+var require_minimatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = minimatch;
+	minimatch.Minimatch = Minimatch;
+	var path$7 = function() {
+		try {
+			return __require("path");
+		} catch (e) {}
+	}() || { sep: "/" };
+	minimatch.sep = path$7.sep;
+	var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+	var expand = require_brace_expansion();
+	var plTypes = {
+		"!": {
+			open: "(?:(?!(?:",
+			close: "))[^/]*?)"
+		},
+		"?": {
+			open: "(?:",
+			close: ")?"
+		},
+		"+": {
+			open: "(?:",
+			close: ")+"
+		},
+		"*": {
+			open: "(?:",
+			close: ")*"
+		},
+		"@": {
+			open: "(?:",
+			close: ")"
+		}
+	};
+	var qmark = "[^/]";
+	var star = qmark + "*?";
+	var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+	var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+	var reSpecials = charSet("().*{}+?[]^$\\!");
+	function charSet(s) {
+		return s.split("").reduce(function(set, c) {
+			set[c] = true;
+			return set;
+		}, {});
+	}
+	var slashSplit = /\/+/;
+	minimatch.filter = filter;
+	function filter(pattern, options) {
+		options = options || {};
+		return function(p, i, list) {
+			return minimatch(p, pattern, options);
+		};
+	}
+	function ext(a, b) {
+		b = b || {};
+		var t = {};
+		Object.keys(a).forEach(function(k) {
+			t[k] = a[k];
+		});
+		Object.keys(b).forEach(function(k) {
+			t[k] = b[k];
+		});
+		return t;
+	}
+	minimatch.defaults = function(def) {
+		if (!def || typeof def !== "object" || !Object.keys(def).length) return minimatch;
+		var orig = minimatch;
+		var m = function minimatch(p, pattern, options) {
+			return orig(p, pattern, ext(def, options));
+		};
+		m.Minimatch = function Minimatch(pattern, options) {
+			return new orig.Minimatch(pattern, ext(def, options));
+		};
+		m.Minimatch.defaults = function defaults(options) {
+			return orig.defaults(ext(def, options)).Minimatch;
+		};
+		m.filter = function filter(pattern, options) {
+			return orig.filter(pattern, ext(def, options));
+		};
+		m.defaults = function defaults(options) {
+			return orig.defaults(ext(def, options));
+		};
+		m.makeRe = function makeRe(pattern, options) {
+			return orig.makeRe(pattern, ext(def, options));
+		};
+		m.braceExpand = function braceExpand(pattern, options) {
+			return orig.braceExpand(pattern, ext(def, options));
+		};
+		m.match = function(list, pattern, options) {
+			return orig.match(list, pattern, ext(def, options));
+		};
+		return m;
+	};
+	Minimatch.defaults = function(def) {
+		return minimatch.defaults(def).Minimatch;
+	};
+	function minimatch(p, pattern, options) {
+		assertValidPattern(pattern);
+		if (!options) options = {};
+		if (!options.nocomment && pattern.charAt(0) === "#") return false;
+		return new Minimatch(pattern, options).match(p);
+	}
+	function Minimatch(pattern, options) {
+		if (!(this instanceof Minimatch)) return new Minimatch(pattern, options);
+		assertValidPattern(pattern);
+		if (!options) options = {};
+		pattern = pattern.trim();
+		if (!options.allowWindowsEscape && path$7.sep !== "/") pattern = pattern.split(path$7.sep).join("/");
+		this.options = options;
+		this.maxGlobstarRecursion = options.maxGlobstarRecursion !== void 0 ? options.maxGlobstarRecursion : 200;
+		this.set = [];
+		this.pattern = pattern;
+		this.regexp = null;
+		this.negate = false;
+		this.comment = false;
+		this.empty = false;
+		this.partial = !!options.partial;
+		this.make();
+	}
+	Minimatch.prototype.debug = function() {};
+	Minimatch.prototype.make = make;
+	function make() {
+		var pattern = this.pattern;
+		var options = this.options;
+		if (!options.nocomment && pattern.charAt(0) === "#") {
+			this.comment = true;
+			return;
+		}
+		if (!pattern) {
+			this.empty = true;
+			return;
+		}
+		this.parseNegate();
+		var set = this.globSet = this.braceExpand();
+		if (options.debug) this.debug = function debug() {
+			console.error.apply(console, arguments);
+		};
+		this.debug(this.pattern, set);
+		set = this.globParts = set.map(function(s) {
+			return s.split(slashSplit);
+		});
+		this.debug(this.pattern, set);
+		set = set.map(function(s, si, set) {
+			return s.map(this.parse, this);
+		}, this);
+		this.debug(this.pattern, set);
+		set = set.filter(function(s) {
+			return s.indexOf(false) === -1;
+		});
+		this.debug(this.pattern, set);
+		this.set = set;
+	}
+	Minimatch.prototype.parseNegate = parseNegate;
+	function parseNegate() {
+		var pattern = this.pattern;
+		var negate = false;
+		var options = this.options;
+		var negateOffset = 0;
+		if (options.nonegate) return;
+		for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
+			negate = !negate;
+			negateOffset++;
+		}
+		if (negateOffset) this.pattern = pattern.substr(negateOffset);
+		this.negate = negate;
+	}
+	minimatch.braceExpand = function(pattern, options) {
+		return braceExpand(pattern, options);
+	};
+	Minimatch.prototype.braceExpand = braceExpand;
+	function braceExpand(pattern, options) {
+		if (!options) {
+			if (this instanceof Minimatch) options = this.options;
+			else options = {};
+		}
+		pattern = typeof pattern === "undefined" ? this.pattern : pattern;
+		assertValidPattern(pattern);
+		if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) return [pattern];
+		return expand(pattern);
+	}
+	var MAX_PATTERN_LENGTH = 65536;
+	var assertValidPattern = function(pattern) {
+		if (typeof pattern !== "string") throw new TypeError("invalid pattern");
+		if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
+	};
+	Minimatch.prototype.parse = parse;
+	var SUBPARSE = {};
+	function parse(pattern, isSub) {
+		assertValidPattern(pattern);
+		var options = this.options;
+		if (pattern === "**") {
+			if (!options.noglobstar) return GLOBSTAR;
+			else pattern = "*";
+		}
+		if (pattern === "") return "";
+		var re = "";
+		var hasMagic = !!options.nocase;
+		var escaping = false;
+		var patternListStack = [];
+		var negativeLists = [];
+		var stateChar;
+		var inClass = false;
+		var reClassStart = -1;
+		var classStart = -1;
+		var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+		var self = this;
+		function clearStateChar() {
+			if (stateChar) {
+				switch (stateChar) {
+					case "*":
+						re += star;
+						hasMagic = true;
+						break;
+					case "?":
+						re += qmark;
+						hasMagic = true;
+						break;
+					default: re += "\\" + stateChar;
+				}
+				self.debug("clearStateChar %j %j", stateChar, re);
+				stateChar = false;
+			}
+		}
+		for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
+			this.debug("%s	%s %s %j", pattern, i, re, c);
+			if (escaping && reSpecials[c]) {
+				re += "\\" + c;
+				escaping = false;
+				continue;
+			}
+			switch (c) {
+				/* istanbul ignore next */
+				case "/": return false;
+				case "\\":
+					clearStateChar();
+					escaping = true;
+					continue;
+				case "?":
+				case "*":
+				case "+":
+				case "@":
+				case "!":
+					this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
+					if (inClass) {
+						this.debug("  in class");
+						if (c === "!" && i === classStart + 1) c = "^";
+						re += c;
+						continue;
+					}
+					if (c === "*" && stateChar === "*") continue;
+					self.debug("call clearStateChar %j", stateChar);
+					clearStateChar();
+					stateChar = c;
+					if (options.noext) clearStateChar();
+					continue;
+				case "(":
+					if (inClass) {
+						re += "(";
+						continue;
+					}
+					if (!stateChar) {
+						re += "\\(";
+						continue;
+					}
+					patternListStack.push({
+						type: stateChar,
+						start: i - 1,
+						reStart: re.length,
+						open: plTypes[stateChar].open,
+						close: plTypes[stateChar].close
+					});
+					re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+					this.debug("plType %j %j", stateChar, re);
+					stateChar = false;
+					continue;
+				case ")":
+					if (inClass || !patternListStack.length) {
+						re += "\\)";
+						continue;
+					}
+					clearStateChar();
+					hasMagic = true;
+					var pl = patternListStack.pop();
+					re += pl.close;
+					if (pl.type === "!") negativeLists.push(pl);
+					pl.reEnd = re.length;
+					continue;
+				case "|":
+					if (inClass || !patternListStack.length || escaping) {
+						re += "\\|";
+						escaping = false;
+						continue;
+					}
+					clearStateChar();
+					re += "|";
+					continue;
+				case "[":
+					clearStateChar();
+					if (inClass) {
+						re += "\\" + c;
+						continue;
+					}
+					inClass = true;
+					classStart = i;
+					reClassStart = re.length;
+					re += c;
+					continue;
+				case "]":
+					if (i === classStart + 1 || !inClass) {
+						re += "\\" + c;
+						escaping = false;
+						continue;
+					}
+					var cs = pattern.substring(classStart + 1, i);
+					try {
+						RegExp("[" + cs + "]");
+					} catch (er) {
+						var sp = this.parse(cs, SUBPARSE);
+						re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+						hasMagic = hasMagic || sp[1];
+						inClass = false;
+						continue;
+					}
+					hasMagic = true;
+					inClass = false;
+					re += c;
+					continue;
+				default:
+					clearStateChar();
+					if (escaping) escaping = false;
+					else if (reSpecials[c] && !(c === "^" && inClass)) re += "\\";
+					re += c;
+			}
+		}
+		if (inClass) {
+			cs = pattern.substr(classStart + 1);
+			sp = this.parse(cs, SUBPARSE);
+			re = re.substr(0, reClassStart) + "\\[" + sp[0];
+			hasMagic = hasMagic || sp[1];
+		}
+		for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+			var tail = re.slice(pl.reStart + pl.open.length);
+			this.debug("setting tail", re, pl);
+			tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
+				if (!$2) $2 = "\\";
+				return $1 + $1 + $2 + "|";
+			});
+			this.debug("tail=%j\n   %s", tail, tail, pl, re);
+			var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+			hasMagic = true;
+			re = re.slice(0, pl.reStart) + t + "\\(" + tail;
+		}
+		clearStateChar();
+		if (escaping) re += "\\\\";
+		var addPatternStart = false;
+		switch (re.charAt(0)) {
+			case "[":
+			case ".":
+			case "(": addPatternStart = true;
+		}
+		for (var n = negativeLists.length - 1; n > -1; n--) {
+			var nl = negativeLists[n];
+			var nlBefore = re.slice(0, nl.reStart);
+			var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+			var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+			var nlAfter = re.slice(nl.reEnd);
+			nlLast += nlAfter;
+			var openParensBefore = nlBefore.split("(").length - 1;
+			var cleanAfter = nlAfter;
+			for (i = 0; i < openParensBefore; i++) cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+			nlAfter = cleanAfter;
+			var dollar = "";
+			if (nlAfter === "" && isSub !== SUBPARSE) dollar = "$";
+			re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+		}
+		if (re !== "" && hasMagic) re = "(?=.)" + re;
+		if (addPatternStart) re = patternStart + re;
+		if (isSub === SUBPARSE) return [re, hasMagic];
+		if (!hasMagic) return globUnescape(pattern);
+		var flags = options.nocase ? "i" : "";
+		try {
+			var regExp = new RegExp("^" + re + "$", flags);
+		} catch (er) /* istanbul ignore next - should be impossible */ {
+			return /* @__PURE__ */ new RegExp("$.");
+		}
+		regExp._glob = pattern;
+		regExp._src = re;
+		return regExp;
+	}
+	minimatch.makeRe = function(pattern, options) {
+		return new Minimatch(pattern, options || {}).makeRe();
+	};
+	Minimatch.prototype.makeRe = makeRe;
+	function makeRe() {
+		if (this.regexp || this.regexp === false) return this.regexp;
+		var set = this.set;
+		if (!set.length) {
+			this.regexp = false;
+			return this.regexp;
+		}
+		var options = this.options;
+		var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+		var flags = options.nocase ? "i" : "";
+		var re = set.map(function(pattern) {
+			return pattern.map(function(p) {
+				return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
+			}).join("\\/");
+		}).join("|");
+		re = "^(?:" + re + ")$";
+		if (this.negate) re = "^(?!" + re + ").*$";
+		try {
+			this.regexp = new RegExp(re, flags);
+		} catch (ex) /* istanbul ignore next - should be impossible */ {
+			this.regexp = false;
+		}
+		return this.regexp;
+	}
+	minimatch.match = function(list, pattern, options) {
+		options = options || {};
+		var mm = new Minimatch(pattern, options);
+		list = list.filter(function(f) {
+			return mm.match(f);
+		});
+		if (mm.options.nonull && !list.length) list.push(pattern);
+		return list;
+	};
+	Minimatch.prototype.match = function match(f, partial) {
+		if (typeof partial === "undefined") partial = this.partial;
+		this.debug("match", f, this.pattern);
+		if (this.comment) return false;
+		if (this.empty) return f === "";
+		if (f === "/" && partial) return true;
+		var options = this.options;
+		if (path$7.sep !== "/") f = f.split(path$7.sep).join("/");
+		f = f.split(slashSplit);
+		this.debug(this.pattern, "split", f);
+		var set = this.set;
+		this.debug(this.pattern, "set", set);
+		var filename;
+		var i = f.length - 1;
+		for (; i >= 0; i--) {
+			filename = f[i];
+			if (filename) break;
+		}
+		for (i = 0; i < set.length; i++) {
+			var pattern = set[i];
+			var file = f;
+			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;
+	};
+	Minimatch.prototype.matchOne = function(file, pattern, partial) {
+		if (pattern.indexOf(GLOBSTAR) !== -1) return this._matchGlobstar(file, pattern, partial, 0, 0);
+		return this._matchOne(file, pattern, partial, 0, 0);
+	};
+	Minimatch.prototype._matchGlobstar = function(file, pattern, partial, fileIndex, patternIndex) {
+		var i;
+		var firstgs = -1;
+		for (i = patternIndex; i < pattern.length; i++) if (pattern[i] === GLOBSTAR) {
+			firstgs = i;
+			break;
+		}
+		var lastgs = -1;
+		for (i = pattern.length - 1; i >= 0; i--) if (pattern[i] === GLOBSTAR) {
+			lastgs = i;
+			break;
+		}
+		var head = pattern.slice(patternIndex, firstgs);
+		var body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs);
+		var tail = partial ? [] : pattern.slice(lastgs + 1);
+		if (head.length) {
+			var fileHead = file.slice(fileIndex, fileIndex + head.length);
+			if (!this._matchOne(fileHead, head, partial, 0, 0)) return false;
+			fileIndex += head.length;
+		}
+		var fileTailMatch = 0;
+		if (tail.length) {
+			if (tail.length + fileIndex > file.length) return false;
+			var 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) {
+			var sawSome = !!fileTailMatch;
+			for (i = fileIndex; i < file.length - fileTailMatch; i++) {
+				var f = String(file[i]);
+				sawSome = true;
+				if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") return false;
+			}
+			return partial || sawSome;
+		}
+		var bodySegments = [[[], 0]];
+		var currentBody = bodySegments[0];
+		var nonGsParts = 0;
+		var nonGsPartsSums = [0];
+		for (var bi = 0; bi < body.length; bi++) {
+			var b = body[bi];
+			if (b === GLOBSTAR) {
+				nonGsPartsSums.push(nonGsParts);
+				currentBody = [[], 0];
+				bodySegments.push(currentBody);
+			} else {
+				currentBody[0].push(b);
+				nonGsParts++;
+			}
+		}
+		var idx = bodySegments.length - 1;
+		var fileLength = file.length - fileTailMatch;
+		for (var si = 0; si < bodySegments.length; si++) bodySegments[si][1] = fileLength - (nonGsPartsSums[idx--] + bodySegments[si][0].length);
+		return !!this._matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+	};
+	Minimatch.prototype._matchGlobStarBodySections = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+		var bs = bodySegments[bodyIndex];
+		if (!bs) {
+			for (var i = fileIndex; i < file.length; i++) {
+				sawTail = true;
+				var f = file[i];
+				if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") return false;
+			}
+			return sawTail;
+		}
+		var body = bs[0];
+		var after = bs[1];
+		while (fileIndex <= after) {
+			if (this._matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0) && globStarDepth < this.maxGlobstarRecursion) {
+				var sub = this._matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+				if (sub !== false) return sub;
+			}
+			var f = file[fileIndex];
+			if (f === "." || f === ".." || !this.options.dot && f.charAt(0) === ".") return false;
+			fileIndex++;
+		}
+		return partial || null;
+	};
+	Minimatch.prototype._matchOne = function(file, pattern, partial, fileIndex, patternIndex) {
+		var fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length;
+		for (; fi < fl && pi < pl; fi++, pi++) {
+			this.debug("matchOne loop");
+			var p = pattern[pi];
+			var f = file[fi];
+			this.debug(pattern, p, f);
+			/* istanbul ignore if */
+			if (p === false || p === GLOBSTAR) return false;
+			var hit;
+			if (typeof p === "string") {
+				hit = f === p;
+				this.debug("string match", p, f, hit);
+			} else {
+				hit = f.match(p);
+				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] === "";
+		/* istanbul ignore next */
+		throw new Error("wtf?");
+	};
+	function globUnescape(s) {
+		return s.replace(/\\(.)/g, "$1");
+	}
+	function regExpEscape(s) {
+		return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (typeof Object.create === "function") module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+				value: ctor,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			} });
+		}
+	};
+	else module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			var TempCtor = function() {};
+			TempCtor.prototype = superCtor.prototype;
+			ctor.prototype = new TempCtor();
+			ctor.prototype.constructor = ctor;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
+var require_inherits = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	try {
+		var util = __require("util");
+		/* istanbul ignore next */
+		if (typeof util.inherits !== "function") throw "";
+		module.exports = util.inherits;
+	} catch (e) {
+		/* istanbul ignore next */
+		module.exports = require_inherits_browser();
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js
+var require_path_is_absolute = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function posix(path) {
+		return path.charAt(0) === "/";
+	}
+	function win32(path) {
+		var result = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/.exec(path);
+		var device = result[1] || "";
+		var isUnc = Boolean(device && device.charAt(1) !== ":");
+		return Boolean(result[2] || isUnc);
+	}
+	module.exports = process.platform === "win32" ? win32 : posix;
+	module.exports.posix = posix;
+	module.exports.win32 = win32;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.setopts = setopts;
+	exports.ownProp = ownProp;
+	exports.makeAbs = makeAbs;
+	exports.finish = finish;
+	exports.mark = mark;
+	exports.isIgnored = isIgnored;
+	exports.childrenIgnored = childrenIgnored;
+	function ownProp(obj, field) {
+		return Object.prototype.hasOwnProperty.call(obj, field);
+	}
+	var fs$4 = __require("fs");
+	var path$6 = __require("path");
+	var minimatch = require_minimatch();
+	var isAbsolute = require_path_is_absolute();
+	var Minimatch = minimatch.Minimatch;
+	function alphasort(a, b) {
+		return a.localeCompare(b, "en");
+	}
+	function setupIgnores(self, options) {
+		self.ignore = options.ignore || [];
+		if (!Array.isArray(self.ignore)) self.ignore = [self.ignore];
+		if (self.ignore.length) self.ignore = self.ignore.map(ignoreMap);
+	}
+	function ignoreMap(pattern) {
+		var gmatcher = null;
+		if (pattern.slice(-3) === "/**") gmatcher = new Minimatch(pattern.replace(/(\/\*\*)+$/, ""), { dot: true });
+		return {
+			matcher: new Minimatch(pattern, { dot: true }),
+			gmatcher
+		};
+	}
+	function setopts(self, pattern, options) {
+		if (!options) options = {};
+		if (options.matchBase && -1 === pattern.indexOf("/")) {
+			if (options.noglobstar) throw new Error("base matching requires globstar");
+			pattern = "**/" + pattern;
+		}
+		self.silent = !!options.silent;
+		self.pattern = pattern;
+		self.strict = options.strict !== false;
+		self.realpath = !!options.realpath;
+		self.realpathCache = options.realpathCache || Object.create(null);
+		self.follow = !!options.follow;
+		self.dot = !!options.dot;
+		self.mark = !!options.mark;
+		self.nodir = !!options.nodir;
+		if (self.nodir) self.mark = true;
+		self.sync = !!options.sync;
+		self.nounique = !!options.nounique;
+		self.nonull = !!options.nonull;
+		self.nosort = !!options.nosort;
+		self.nocase = !!options.nocase;
+		self.stat = !!options.stat;
+		self.noprocess = !!options.noprocess;
+		self.absolute = !!options.absolute;
+		self.fs = options.fs || fs$4;
+		self.maxLength = options.maxLength || Infinity;
+		self.cache = options.cache || Object.create(null);
+		self.statCache = options.statCache || Object.create(null);
+		self.symlinks = options.symlinks || Object.create(null);
+		setupIgnores(self, options);
+		self.changedCwd = false;
+		var cwd = process.cwd();
+		if (!ownProp(options, "cwd")) self.cwd = cwd;
+		else {
+			self.cwd = path$6.resolve(options.cwd);
+			self.changedCwd = self.cwd !== cwd;
+		}
+		self.root = options.root || path$6.resolve(self.cwd, "/");
+		self.root = path$6.resolve(self.root);
+		if (process.platform === "win32") self.root = self.root.replace(/\\/g, "/");
+		self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+		if (process.platform === "win32") self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+		self.nomount = !!options.nomount;
+		options.nonegate = true;
+		options.nocomment = true;
+		options.allowWindowsEscape = false;
+		self.minimatch = new Minimatch(pattern, options);
+		self.options = self.minimatch.options;
+	}
+	function finish(self) {
+		var nou = self.nounique;
+		var all = nou ? [] : Object.create(null);
+		for (var i = 0, l = self.matches.length; i < l; i++) {
+			var matches = self.matches[i];
+			if (!matches || Object.keys(matches).length === 0) {
+				if (self.nonull) {
+					var literal = self.minimatch.globSet[i];
+					if (nou) all.push(literal);
+					else all[literal] = true;
+				}
+			} else {
+				var m = Object.keys(matches);
+				if (nou) all.push.apply(all, m);
+				else m.forEach(function(m) {
+					all[m] = true;
+				});
+			}
+		}
+		if (!nou) all = Object.keys(all);
+		if (!self.nosort) all = all.sort(alphasort);
+		if (self.mark) {
+			for (var i = 0; i < all.length; i++) all[i] = self._mark(all[i]);
+			if (self.nodir) all = all.filter(function(e) {
+				var notDir = !/\/$/.test(e);
+				var c = self.cache[e] || self.cache[makeAbs(self, e)];
+				if (notDir && c) notDir = c !== "DIR" && !Array.isArray(c);
+				return notDir;
+			});
+		}
+		if (self.ignore.length) all = all.filter(function(m) {
+			return !isIgnored(self, m);
+		});
+		self.found = all;
+	}
+	function mark(self, p) {
+		var abs = makeAbs(self, p);
+		var c = self.cache[abs];
+		var m = p;
+		if (c) {
+			var isDir = c === "DIR" || Array.isArray(c);
+			var slash = p.slice(-1) === "/";
+			if (isDir && !slash) m += "/";
+			else if (!isDir && slash) m = m.slice(0, -1);
+			if (m !== p) {
+				var mabs = makeAbs(self, m);
+				self.statCache[mabs] = self.statCache[abs];
+				self.cache[mabs] = self.cache[abs];
+			}
+		}
+		return m;
+	}
+	function makeAbs(self, f) {
+		var abs = f;
+		if (f.charAt(0) === "/") abs = path$6.join(self.root, f);
+		else if (isAbsolute(f) || f === "") abs = f;
+		else if (self.changedCwd) abs = path$6.resolve(self.cwd, f);
+		else abs = path$6.resolve(f);
+		if (process.platform === "win32") abs = abs.replace(/\\/g, "/");
+		return abs;
+	}
+	function isIgnored(self, path) {
+		if (!self.ignore.length) return false;
+		return self.ignore.some(function(item) {
+			return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path));
+		});
+	}
+	function childrenIgnored(self, path) {
+		if (!self.ignore.length) return false;
+		return self.ignore.some(function(item) {
+			return !!(item.gmatcher && item.gmatcher.match(path));
+		});
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/sync.js
+var require_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = globSync;
+	globSync.GlobSync = GlobSync;
+	var rp = require_fs_realpath();
+	var minimatch = require_minimatch();
+	minimatch.Minimatch;
+	require_glob().Glob;
+	__require("util");
+	var path$5 = __require("path");
+	var assert$2 = __require("assert");
+	var isAbsolute = require_path_is_absolute();
+	var common = require_common();
+	var setopts = common.setopts;
+	var ownProp = common.ownProp;
+	var childrenIgnored = common.childrenIgnored;
+	var isIgnored = common.isIgnored;
+	function globSync(pattern, options) {
+		if (typeof options === "function" || arguments.length === 3) throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+		return new GlobSync(pattern, options).found;
+	}
+	function GlobSync(pattern, options) {
+		if (!pattern) throw new Error("must provide pattern");
+		if (typeof options === "function" || arguments.length === 3) throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+		if (!(this instanceof GlobSync)) return new GlobSync(pattern, options);
+		setopts(this, pattern, options);
+		if (this.noprocess) return this;
+		var n = this.minimatch.set.length;
+		this.matches = new Array(n);
+		for (var i = 0; i < n; i++) this._process(this.minimatch.set[i], i, false);
+		this._finish();
+	}
+	GlobSync.prototype._finish = function() {
+		assert$2.ok(this instanceof GlobSync);
+		if (this.realpath) {
+			var self = this;
+			this.matches.forEach(function(matchset, index) {
+				var set = self.matches[index] = Object.create(null);
+				for (var p in matchset) try {
+					p = self._makeAbs(p);
+					var real = rp.realpathSync(p, self.realpathCache);
+					set[real] = true;
+				} catch (er) {
+					if (er.syscall === "stat") set[self._makeAbs(p)] = true;
+					else throw er;
+				}
+			});
+		}
+		common.finish(this);
+	};
+	GlobSync.prototype._process = function(pattern, index, inGlobStar) {
+		assert$2.ok(this instanceof GlobSync);
+		var n = 0;
+		while (typeof pattern[n] === "string") n++;
+		var prefix;
+		switch (n) {
+			case pattern.length:
+				this._processSimple(pattern.join("/"), index);
+				return;
+			case 0:
+				prefix = null;
+				break;
+			default: prefix = pattern.slice(0, n).join("/");
+		}
+		var remain = pattern.slice(n);
+		var read;
+		if (prefix === null) read = ".";
+		else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+			return typeof p === "string" ? p : "[*]";
+		}).join("/"))) {
+			if (!prefix || !isAbsolute(prefix)) prefix = "/" + prefix;
+			read = prefix;
+		} else read = prefix;
+		var abs = this._makeAbs(read);
+		if (childrenIgnored(this, read)) return;
+		if (remain[0] === minimatch.GLOBSTAR) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+		else this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+	};
+	GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar) {
+		var entries = this._readdir(abs, inGlobStar);
+		if (!entries) return;
+		var pn = remain[0];
+		var negate = !!this.minimatch.negate;
+		var rawGlob = pn._glob;
+		var dotOk = this.dot || rawGlob.charAt(0) === ".";
+		var matchedEntries = [];
+		for (var i = 0; i < entries.length; i++) {
+			var e = entries[i];
+			if (e.charAt(0) !== "." || dotOk) {
+				var m;
+				if (negate && !prefix) m = !e.match(pn);
+				else m = e.match(pn);
+				if (m) matchedEntries.push(e);
+			}
+		}
+		var len = matchedEntries.length;
+		if (len === 0) return;
+		if (remain.length === 1 && !this.mark && !this.stat) {
+			if (!this.matches[index]) this.matches[index] = Object.create(null);
+			for (var i = 0; i < len; i++) {
+				var e = matchedEntries[i];
+				if (prefix) {
+					if (prefix.slice(-1) !== "/") e = prefix + "/" + e;
+					else e = prefix + e;
+				}
+				if (e.charAt(0) === "/" && !this.nomount) e = path$5.join(this.root, e);
+				this._emitMatch(index, e);
+			}
+			return;
+		}
+		remain.shift();
+		for (var i = 0; i < len; i++) {
+			var e = matchedEntries[i];
+			var newPattern;
+			if (prefix) newPattern = [prefix, e];
+			else newPattern = [e];
+			this._process(newPattern.concat(remain), index, inGlobStar);
+		}
+	};
+	GlobSync.prototype._emitMatch = function(index, e) {
+		if (isIgnored(this, e)) return;
+		var abs = this._makeAbs(e);
+		if (this.mark) e = this._mark(e);
+		if (this.absolute) e = abs;
+		if (this.matches[index][e]) return;
+		if (this.nodir) {
+			var c = this.cache[abs];
+			if (c === "DIR" || Array.isArray(c)) return;
+		}
+		this.matches[index][e] = true;
+		if (this.stat) this._stat(e);
+	};
+	GlobSync.prototype._readdirInGlobStar = function(abs) {
+		if (this.follow) return this._readdir(abs, false);
+		var entries;
+		var lstat;
+		try {
+			lstat = this.fs.lstatSync(abs);
+		} catch (er) {
+			if (er.code === "ENOENT") return null;
+		}
+		var isSym = lstat && lstat.isSymbolicLink();
+		this.symlinks[abs] = isSym;
+		if (!isSym && lstat && !lstat.isDirectory()) this.cache[abs] = "FILE";
+		else entries = this._readdir(abs, false);
+		return entries;
+	};
+	GlobSync.prototype._readdir = function(abs, inGlobStar) {
+		if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs);
+		if (ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (!c || c === "FILE") return null;
+			if (Array.isArray(c)) return c;
+		}
+		try {
+			return this._readdirEntries(abs, this.fs.readdirSync(abs));
+		} catch (er) {
+			this._readdirError(abs, er);
+			return null;
+		}
+	};
+	GlobSync.prototype._readdirEntries = function(abs, entries) {
+		if (!this.mark && !this.stat) for (var i = 0; i < entries.length; i++) {
+			var e = entries[i];
+			if (abs === "/") e = abs + e;
+			else e = abs + "/" + e;
+			this.cache[e] = true;
+		}
+		this.cache[abs] = entries;
+		return entries;
+	};
+	GlobSync.prototype._readdirError = function(f, er) {
+		switch (er.code) {
+			case "ENOTSUP":
+			case "ENOTDIR":
+				var abs = this._makeAbs(f);
+				this.cache[abs] = "FILE";
+				if (abs === this.cwdAbs) {
+					var error = /* @__PURE__ */ new Error(er.code + " invalid cwd " + this.cwd);
+					error.path = this.cwd;
+					error.code = er.code;
+					throw error;
+				}
+				break;
+			case "ENOENT":
+			case "ELOOP":
+			case "ENAMETOOLONG":
+			case "UNKNOWN":
+				this.cache[this._makeAbs(f)] = false;
+				break;
+			default:
+				this.cache[this._makeAbs(f)] = false;
+				if (this.strict) throw er;
+				if (!this.silent) console.error("glob error", er);
+		}
+	};
+	GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar) {
+		var entries = this._readdir(abs, inGlobStar);
+		if (!entries) return;
+		var remainWithoutGlobStar = remain.slice(1);
+		var gspref = prefix ? [prefix] : [];
+		var noGlobStar = gspref.concat(remainWithoutGlobStar);
+		this._process(noGlobStar, index, false);
+		var len = entries.length;
+		if (this.symlinks[abs] && inGlobStar) return;
+		for (var i = 0; i < len; i++) {
+			if (entries[i].charAt(0) === "." && !this.dot) continue;
+			var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+			this._process(instead, index, true);
+			var below = gspref.concat(entries[i], remain);
+			this._process(below, index, true);
+		}
+	};
+	GlobSync.prototype._processSimple = function(prefix, index) {
+		var exists = this._stat(prefix);
+		if (!this.matches[index]) this.matches[index] = Object.create(null);
+		if (!exists) return;
+		if (prefix && isAbsolute(prefix) && !this.nomount) {
+			var trail = /[\/\\]$/.test(prefix);
+			if (prefix.charAt(0) === "/") prefix = path$5.join(this.root, prefix);
+			else {
+				prefix = path$5.resolve(this.root, prefix);
+				if (trail) prefix += "/";
+			}
+		}
+		if (process.platform === "win32") prefix = prefix.replace(/\\/g, "/");
+		this._emitMatch(index, prefix);
+	};
+	GlobSync.prototype._stat = function(f) {
+		var abs = this._makeAbs(f);
+		var needDir = f.slice(-1) === "/";
+		if (f.length > this.maxLength) return false;
+		if (!this.stat && ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (Array.isArray(c)) c = "DIR";
+			if (!needDir || c === "DIR") return c;
+			if (needDir && c === "FILE") return false;
+		}
+		var stat = this.statCache[abs];
+		if (!stat) {
+			var lstat;
+			try {
+				lstat = this.fs.lstatSync(abs);
+			} catch (er) {
+				if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+					this.statCache[abs] = false;
+					return false;
+				}
+			}
+			if (lstat && lstat.isSymbolicLink()) try {
+				stat = this.fs.statSync(abs);
+			} catch (er) {
+				stat = lstat;
+			}
+			else stat = lstat;
+		}
+		this.statCache[abs] = stat;
+		var c = true;
+		if (stat) c = stat.isDirectory() ? "DIR" : "FILE";
+		this.cache[abs] = this.cache[abs] || c;
+		if (needDir && c === "FILE") return false;
+		return c;
+	};
+	GlobSync.prototype._mark = function(p) {
+		return common.mark(this, p);
+	};
+	GlobSync.prototype._makeAbs = function(f) {
+		return common.makeAbs(this, f);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = wrappy;
+	function wrappy(fn, cb) {
+		if (fn && cb) return wrappy(fn)(cb);
+		if (typeof fn !== "function") throw new TypeError("need wrapper function");
+		Object.keys(fn).forEach(function(k) {
+			wrapper[k] = fn[k];
+		});
+		return wrapper;
+		function wrapper() {
+			var args = new Array(arguments.length);
+			for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+			var ret = fn.apply(this, args);
+			var cb = args[args.length - 1];
+			if (typeof ret === "function" && ret !== cb) Object.keys(cb).forEach(function(k) {
+				ret[k] = cb[k];
+			});
+			return ret;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var wrappy = require_wrappy();
+	module.exports = wrappy(once);
+	module.exports.strict = wrappy(onceStrict);
+	once.proto = once(function() {
+		Object.defineProperty(Function.prototype, "once", {
+			value: function() {
+				return once(this);
+			},
+			configurable: true
+		});
+		Object.defineProperty(Function.prototype, "onceStrict", {
+			value: function() {
+				return onceStrict(this);
+			},
+			configurable: true
+		});
+	});
+	function once(fn) {
+		var f = function() {
+			if (f.called) return f.value;
+			f.called = true;
+			return f.value = fn.apply(this, arguments);
+		};
+		f.called = false;
+		return f;
+	}
+	function onceStrict(fn) {
+		var f = function() {
+			if (f.called) throw new Error(f.onceError);
+			f.called = true;
+			return f.value = fn.apply(this, arguments);
+		};
+		f.onceError = (fn.name || "Function wrapped with `once`") + " shouldn't be called more than once";
+		f.called = false;
+		return f;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js
+var require_inflight = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var wrappy = require_wrappy();
+	var reqs = Object.create(null);
+	var once = require_once();
+	module.exports = wrappy(inflight);
+	function inflight(key, cb) {
+		if (reqs[key]) {
+			reqs[key].push(cb);
+			return null;
+		} else {
+			reqs[key] = [cb];
+			return makeres(key);
+		}
+	}
+	function makeres(key) {
+		return once(function RES() {
+			var cbs = reqs[key];
+			var len = cbs.length;
+			var args = slice(arguments);
+			try {
+				for (var i = 0; i < len; i++) cbs[i].apply(null, args);
+			} finally {
+				if (cbs.length > len) {
+					cbs.splice(0, len);
+					process.nextTick(function() {
+						RES.apply(null, args);
+					});
+				} else delete reqs[key];
+			}
+		});
+	}
+	function slice(args) {
+		var length = args.length;
+		var array = [];
+		for (var i = 0; i < length; i++) array[i] = args[i];
+		return array;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/glob@7.2.3/node_modules/glob/glob.js
+var require_glob = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = glob;
+	var rp = require_fs_realpath();
+	var minimatch = require_minimatch();
+	minimatch.Minimatch;
+	var inherits = require_inherits();
+	var EE = __require("events").EventEmitter;
+	var path$4 = __require("path");
+	var assert$1 = __require("assert");
+	var isAbsolute = require_path_is_absolute();
+	var globSync = require_sync();
+	var common = require_common();
+	var setopts = common.setopts;
+	var ownProp = common.ownProp;
+	var inflight = require_inflight();
+	__require("util");
+	var childrenIgnored = common.childrenIgnored;
+	var isIgnored = common.isIgnored;
+	var once = require_once();
+	function glob(pattern, options, cb) {
+		if (typeof options === "function") cb = options, options = {};
+		if (!options) options = {};
+		if (options.sync) {
+			if (cb) throw new TypeError("callback provided to sync glob");
+			return globSync(pattern, options);
+		}
+		return new Glob(pattern, options, cb);
+	}
+	glob.sync = globSync;
+	var GlobSync = glob.GlobSync = globSync.GlobSync;
+	glob.glob = glob;
+	function extend(origin, add) {
+		if (add === null || typeof add !== "object") return origin;
+		var keys = Object.keys(add);
+		var i = keys.length;
+		while (i--) origin[keys[i]] = add[keys[i]];
+		return origin;
+	}
+	glob.hasMagic = function(pattern, options_) {
+		var options = extend({}, options_);
+		options.noprocess = true;
+		var set = new Glob(pattern, options).minimatch.set;
+		if (!pattern) return false;
+		if (set.length > 1) return true;
+		for (var j = 0; j < set[0].length; j++) if (typeof set[0][j] !== "string") return true;
+		return false;
+	};
+	glob.Glob = Glob;
+	inherits(Glob, EE);
+	function Glob(pattern, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = null;
+		}
+		if (options && options.sync) {
+			if (cb) throw new TypeError("callback provided to sync glob");
+			return new GlobSync(pattern, options);
+		}
+		if (!(this instanceof Glob)) return new Glob(pattern, options, cb);
+		setopts(this, pattern, options);
+		this._didRealPath = false;
+		var n = this.minimatch.set.length;
+		this.matches = new Array(n);
+		if (typeof cb === "function") {
+			cb = once(cb);
+			this.on("error", cb);
+			this.on("end", function(matches) {
+				cb(null, matches);
+			});
+		}
+		var self = this;
+		this._processing = 0;
+		this._emitQueue = [];
+		this._processQueue = [];
+		this.paused = false;
+		if (this.noprocess) return this;
+		if (n === 0) return done();
+		var sync = true;
+		for (var i = 0; i < n; i++) this._process(this.minimatch.set[i], i, false, done);
+		sync = false;
+		function done() {
+			--self._processing;
+			if (self._processing <= 0) {
+				if (sync) process.nextTick(function() {
+					self._finish();
+				});
+				else self._finish();
+			}
+		}
+	}
+	Glob.prototype._finish = function() {
+		assert$1(this instanceof Glob);
+		if (this.aborted) return;
+		if (this.realpath && !this._didRealpath) return this._realpath();
+		common.finish(this);
+		this.emit("end", this.found);
+	};
+	Glob.prototype._realpath = function() {
+		if (this._didRealpath) return;
+		this._didRealpath = true;
+		var n = this.matches.length;
+		if (n === 0) return this._finish();
+		var self = this;
+		for (var i = 0; i < this.matches.length; i++) this._realpathSet(i, next);
+		function next() {
+			if (--n === 0) self._finish();
+		}
+	};
+	Glob.prototype._realpathSet = function(index, cb) {
+		var matchset = this.matches[index];
+		if (!matchset) return cb();
+		var found = Object.keys(matchset);
+		var self = this;
+		var n = found.length;
+		if (n === 0) return cb();
+		var set = this.matches[index] = Object.create(null);
+		found.forEach(function(p, i) {
+			p = self._makeAbs(p);
+			rp.realpath(p, self.realpathCache, function(er, real) {
+				if (!er) set[real] = true;
+				else if (er.syscall === "stat") set[p] = true;
+				else self.emit("error", er);
+				if (--n === 0) {
+					self.matches[index] = set;
+					cb();
+				}
+			});
+		});
+	};
+	Glob.prototype._mark = function(p) {
+		return common.mark(this, p);
+	};
+	Glob.prototype._makeAbs = function(f) {
+		return common.makeAbs(this, f);
+	};
+	Glob.prototype.abort = function() {
+		this.aborted = true;
+		this.emit("abort");
+	};
+	Glob.prototype.pause = function() {
+		if (!this.paused) {
+			this.paused = true;
+			this.emit("pause");
+		}
+	};
+	Glob.prototype.resume = function() {
+		if (this.paused) {
+			this.emit("resume");
+			this.paused = false;
+			if (this._emitQueue.length) {
+				var eq = this._emitQueue.slice(0);
+				this._emitQueue.length = 0;
+				for (var i = 0; i < eq.length; i++) {
+					var e = eq[i];
+					this._emitMatch(e[0], e[1]);
+				}
+			}
+			if (this._processQueue.length) {
+				var pq = this._processQueue.slice(0);
+				this._processQueue.length = 0;
+				for (var i = 0; i < pq.length; i++) {
+					var p = pq[i];
+					this._processing--;
+					this._process(p[0], p[1], p[2], p[3]);
+				}
+			}
+		}
+	};
+	Glob.prototype._process = function(pattern, index, inGlobStar, cb) {
+		assert$1(this instanceof Glob);
+		assert$1(typeof cb === "function");
+		if (this.aborted) return;
+		this._processing++;
+		if (this.paused) {
+			this._processQueue.push([
+				pattern,
+				index,
+				inGlobStar,
+				cb
+			]);
+			return;
+		}
+		var n = 0;
+		while (typeof pattern[n] === "string") n++;
+		var prefix;
+		switch (n) {
+			case pattern.length:
+				this._processSimple(pattern.join("/"), index, cb);
+				return;
+			case 0:
+				prefix = null;
+				break;
+			default: prefix = pattern.slice(0, n).join("/");
+		}
+		var remain = pattern.slice(n);
+		var read;
+		if (prefix === null) read = ".";
+		else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+			return typeof p === "string" ? p : "[*]";
+		}).join("/"))) {
+			if (!prefix || !isAbsolute(prefix)) prefix = "/" + prefix;
+			read = prefix;
+		} else read = prefix;
+		var abs = this._makeAbs(read);
+		if (childrenIgnored(this, read)) return cb();
+		if (remain[0] === minimatch.GLOBSTAR) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+		else this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+	};
+	Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+		var self = this;
+		this._readdir(abs, inGlobStar, function(er, entries) {
+			return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+		});
+	};
+	Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+		if (!entries) return cb();
+		var pn = remain[0];
+		var negate = !!this.minimatch.negate;
+		var rawGlob = pn._glob;
+		var dotOk = this.dot || rawGlob.charAt(0) === ".";
+		var matchedEntries = [];
+		for (var i = 0; i < entries.length; i++) {
+			var e = entries[i];
+			if (e.charAt(0) !== "." || dotOk) {
+				var m;
+				if (negate && !prefix) m = !e.match(pn);
+				else m = e.match(pn);
+				if (m) matchedEntries.push(e);
+			}
+		}
+		var len = matchedEntries.length;
+		if (len === 0) return cb();
+		if (remain.length === 1 && !this.mark && !this.stat) {
+			if (!this.matches[index]) this.matches[index] = Object.create(null);
+			for (var i = 0; i < len; i++) {
+				var e = matchedEntries[i];
+				if (prefix) {
+					if (prefix !== "/") e = prefix + "/" + e;
+					else e = prefix + e;
+				}
+				if (e.charAt(0) === "/" && !this.nomount) e = path$4.join(this.root, e);
+				this._emitMatch(index, e);
+			}
+			return cb();
+		}
+		remain.shift();
+		for (var i = 0; i < len; i++) {
+			var e = matchedEntries[i];
+			if (prefix) {
+				if (prefix !== "/") e = prefix + "/" + e;
+				else e = prefix + e;
+			}
+			this._process([e].concat(remain), index, inGlobStar, cb);
+		}
+		cb();
+	};
+	Glob.prototype._emitMatch = function(index, e) {
+		if (this.aborted) return;
+		if (isIgnored(this, e)) return;
+		if (this.paused) {
+			this._emitQueue.push([index, e]);
+			return;
+		}
+		var abs = isAbsolute(e) ? e : this._makeAbs(e);
+		if (this.mark) e = this._mark(e);
+		if (this.absolute) e = abs;
+		if (this.matches[index][e]) return;
+		if (this.nodir) {
+			var c = this.cache[abs];
+			if (c === "DIR" || Array.isArray(c)) return;
+		}
+		this.matches[index][e] = true;
+		var st = this.statCache[abs];
+		if (st) this.emit("stat", e, st);
+		this.emit("match", e);
+	};
+	Glob.prototype._readdirInGlobStar = function(abs, cb) {
+		if (this.aborted) return;
+		if (this.follow) return this._readdir(abs, false, cb);
+		var lstatkey = "lstat\0" + abs;
+		var self = this;
+		var lstatcb = inflight(lstatkey, lstatcb_);
+		if (lstatcb) self.fs.lstat(abs, lstatcb);
+		function lstatcb_(er, lstat) {
+			if (er && er.code === "ENOENT") return cb();
+			var isSym = lstat && lstat.isSymbolicLink();
+			self.symlinks[abs] = isSym;
+			if (!isSym && lstat && !lstat.isDirectory()) {
+				self.cache[abs] = "FILE";
+				cb();
+			} else self._readdir(abs, false, cb);
+		}
+	};
+	Glob.prototype._readdir = function(abs, inGlobStar, cb) {
+		if (this.aborted) return;
+		cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
+		if (!cb) return;
+		if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs, cb);
+		if (ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (!c || c === "FILE") return cb();
+			if (Array.isArray(c)) return cb(null, c);
+		}
+		this.fs.readdir(abs, readdirCb(this, abs, cb));
+	};
+	function readdirCb(self, abs, cb) {
+		return function(er, entries) {
+			if (er) self._readdirError(abs, er, cb);
+			else self._readdirEntries(abs, entries, cb);
+		};
+	}
+	Glob.prototype._readdirEntries = function(abs, entries, cb) {
+		if (this.aborted) return;
+		if (!this.mark && !this.stat) for (var i = 0; i < entries.length; i++) {
+			var e = entries[i];
+			if (abs === "/") e = abs + e;
+			else e = abs + "/" + e;
+			this.cache[e] = true;
+		}
+		this.cache[abs] = entries;
+		return cb(null, entries);
+	};
+	Glob.prototype._readdirError = function(f, er, cb) {
+		if (this.aborted) return;
+		switch (er.code) {
+			case "ENOTSUP":
+			case "ENOTDIR":
+				var abs = this._makeAbs(f);
+				this.cache[abs] = "FILE";
+				if (abs === this.cwdAbs) {
+					var error = /* @__PURE__ */ new Error(er.code + " invalid cwd " + this.cwd);
+					error.path = this.cwd;
+					error.code = er.code;
+					this.emit("error", error);
+					this.abort();
+				}
+				break;
+			case "ENOENT":
+			case "ELOOP":
+			case "ENAMETOOLONG":
+			case "UNKNOWN":
+				this.cache[this._makeAbs(f)] = false;
+				break;
+			default:
+				this.cache[this._makeAbs(f)] = false;
+				if (this.strict) {
+					this.emit("error", er);
+					this.abort();
+				}
+				if (!this.silent) console.error("glob error", er);
+		}
+		return cb();
+	};
+	Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+		var self = this;
+		this._readdir(abs, inGlobStar, function(er, entries) {
+			self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+		});
+	};
+	Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+		if (!entries) return cb();
+		var remainWithoutGlobStar = remain.slice(1);
+		var gspref = prefix ? [prefix] : [];
+		var noGlobStar = gspref.concat(remainWithoutGlobStar);
+		this._process(noGlobStar, index, false, cb);
+		var isSym = this.symlinks[abs];
+		var len = entries.length;
+		if (isSym && inGlobStar) return cb();
+		for (var i = 0; i < len; i++) {
+			if (entries[i].charAt(0) === "." && !this.dot) continue;
+			var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+			this._process(instead, index, true, cb);
+			var below = gspref.concat(entries[i], remain);
+			this._process(below, index, true, cb);
+		}
+		cb();
+	};
+	Glob.prototype._processSimple = function(prefix, index, cb) {
+		var self = this;
+		this._stat(prefix, function(er, exists) {
+			self._processSimple2(prefix, index, er, exists, cb);
+		});
+	};
+	Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
+		if (!this.matches[index]) this.matches[index] = Object.create(null);
+		if (!exists) return cb();
+		if (prefix && isAbsolute(prefix) && !this.nomount) {
+			var trail = /[\/\\]$/.test(prefix);
+			if (prefix.charAt(0) === "/") prefix = path$4.join(this.root, prefix);
+			else {
+				prefix = path$4.resolve(this.root, prefix);
+				if (trail) prefix += "/";
+			}
+		}
+		if (process.platform === "win32") prefix = prefix.replace(/\\/g, "/");
+		this._emitMatch(index, prefix);
+		cb();
+	};
+	Glob.prototype._stat = function(f, cb) {
+		var abs = this._makeAbs(f);
+		var needDir = f.slice(-1) === "/";
+		if (f.length > this.maxLength) return cb();
+		if (!this.stat && ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (Array.isArray(c)) c = "DIR";
+			if (!needDir || c === "DIR") return cb(null, c);
+			if (needDir && c === "FILE") return cb();
+		}
+		var stat = this.statCache[abs];
+		if (stat !== void 0) {
+			if (stat === false) return cb(null, stat);
+			else {
+				var type = stat.isDirectory() ? "DIR" : "FILE";
+				if (needDir && type === "FILE") return cb();
+				else return cb(null, type, stat);
+			}
+		}
+		var self = this;
+		var statcb = inflight("stat\0" + abs, lstatcb_);
+		if (statcb) self.fs.lstat(abs, statcb);
+		function lstatcb_(er, lstat) {
+			if (lstat && lstat.isSymbolicLink()) return self.fs.stat(abs, function(er, stat) {
+				if (er) self._stat2(f, abs, null, lstat, cb);
+				else self._stat2(f, abs, er, stat, cb);
+			});
+			else self._stat2(f, abs, er, lstat, cb);
+		}
+	};
+	Glob.prototype._stat2 = function(f, abs, er, stat, cb) {
+		if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+			this.statCache[abs] = false;
+			return cb();
+		}
+		var needDir = f.slice(-1) === "/";
+		this.statCache[abs] = stat;
+		if (abs.slice(-1) === "/" && stat && !stat.isDirectory()) return cb(null, false, stat);
+		var c = true;
+		if (stat) c = stat.isDirectory() ? "DIR" : "FILE";
+		this.cache[abs] = this.cache[abs] || c;
+		if (needDir && c === "FILE") return cb();
+		return cb(null, c, stat);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/rimraf@2.6.3/node_modules/rimraf/rimraf.js
+var require_rimraf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = rimraf;
+	rimraf.sync = rimrafSync;
+	var assert = __require("assert");
+	var path$3 = __require("path");
+	var fs$3 = __require("fs");
+	var glob = require_glob();
+	var _0666 = parseInt("666", 8);
+	var defaultGlobOpts = {
+		nosort: true,
+		silent: true
+	};
+	var timeout = 0;
+	var isWindows = process.platform === "win32";
+	function defaults(options) {
+		[
+			"unlink",
+			"chmod",
+			"stat",
+			"lstat",
+			"rmdir",
+			"readdir"
+		].forEach(function(m) {
+			options[m] = options[m] || fs$3[m];
+			m = m + "Sync";
+			options[m] = options[m] || fs$3[m];
+		});
+		options.maxBusyTries = options.maxBusyTries || 3;
+		options.emfileWait = options.emfileWait || 1e3;
+		if (options.glob === false) options.disableGlob = true;
+		options.disableGlob = options.disableGlob || false;
+		options.glob = options.glob || defaultGlobOpts;
+	}
+	function rimraf(p, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		assert(p, "rimraf: missing path");
+		assert.equal(typeof p, "string", "rimraf: path should be a string");
+		assert.equal(typeof cb, "function", "rimraf: callback function required");
+		assert(options, "rimraf: invalid options argument provided");
+		assert.equal(typeof options, "object", "rimraf: options should be object");
+		defaults(options);
+		var busyTries = 0;
+		var errState = null;
+		var n = 0;
+		if (options.disableGlob || !glob.hasMagic(p)) return afterGlob(null, [p]);
+		options.lstat(p, function(er, stat) {
+			if (!er) return afterGlob(null, [p]);
+			glob(p, options.glob, afterGlob);
+		});
+		function next(er) {
+			errState = errState || er;
+			if (--n === 0) cb(errState);
+		}
+		function afterGlob(er, results) {
+			if (er) return cb(er);
+			n = results.length;
+			if (n === 0) return cb();
+			results.forEach(function(p) {
+				rimraf_(p, options, function CB(er) {
+					if (er) {
+						if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
+							busyTries++;
+							var time = busyTries * 100;
+							return setTimeout(function() {
+								rimraf_(p, options, CB);
+							}, time);
+						}
+						if (er.code === "EMFILE" && timeout < options.emfileWait) return setTimeout(function() {
+							rimraf_(p, options, CB);
+						}, timeout++);
+						if (er.code === "ENOENT") er = null;
+					}
+					timeout = 0;
+					next(er);
+				});
+			});
+		}
+	}
+	function rimraf_(p, options, cb) {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		options.lstat(p, function(er, st) {
+			if (er && er.code === "ENOENT") return cb(null);
+			if (er && er.code === "EPERM" && isWindows) fixWinEPERM(p, options, er, cb);
+			if (st && st.isDirectory()) return rmdir(p, options, er, cb);
+			options.unlink(p, function(er) {
+				if (er) {
+					if (er.code === "ENOENT") return cb(null);
+					if (er.code === "EPERM") return isWindows ? fixWinEPERM(p, options, er, cb) : rmdir(p, options, er, cb);
+					if (er.code === "EISDIR") return rmdir(p, options, er, cb);
+				}
+				return cb(er);
+			});
+		});
+	}
+	function fixWinEPERM(p, options, er, cb) {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		if (er) assert(er instanceof Error);
+		options.chmod(p, _0666, function(er2) {
+			if (er2) cb(er2.code === "ENOENT" ? null : er);
+			else options.stat(p, function(er3, stats) {
+				if (er3) cb(er3.code === "ENOENT" ? null : er);
+				else if (stats.isDirectory()) rmdir(p, options, er, cb);
+				else options.unlink(p, cb);
+			});
+		});
+	}
+	function fixWinEPERMSync(p, options, er) {
+		assert(p);
+		assert(options);
+		if (er) assert(er instanceof Error);
+		try {
+			options.chmodSync(p, _0666);
+		} catch (er2) {
+			if (er2.code === "ENOENT") return;
+			else throw er;
+		}
+		try {
+			var stats = options.statSync(p);
+		} catch (er3) {
+			if (er3.code === "ENOENT") return;
+			else throw er;
+		}
+		if (stats.isDirectory()) rmdirSync(p, options, er);
+		else options.unlinkSync(p);
+	}
+	function rmdir(p, options, originalEr, cb) {
+		assert(p);
+		assert(options);
+		if (originalEr) assert(originalEr instanceof Error);
+		assert(typeof cb === "function");
+		options.rmdir(p, function(er) {
+			if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) rmkids(p, options, cb);
+			else if (er && er.code === "ENOTDIR") cb(originalEr);
+			else cb(er);
+		});
+	}
+	function rmkids(p, options, cb) {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		options.readdir(p, function(er, files) {
+			if (er) return cb(er);
+			var n = files.length;
+			if (n === 0) return options.rmdir(p, cb);
+			var errState;
+			files.forEach(function(f) {
+				rimraf(path$3.join(p, f), options, function(er) {
+					if (errState) return;
+					if (er) return cb(errState = er);
+					if (--n === 0) options.rmdir(p, cb);
+				});
+			});
+		});
+	}
+	function rimrafSync(p, options) {
+		options = options || {};
+		defaults(options);
+		assert(p, "rimraf: missing path");
+		assert.equal(typeof p, "string", "rimraf: path should be a string");
+		assert(options, "rimraf: missing options");
+		assert.equal(typeof options, "object", "rimraf: options should be object");
+		var results;
+		if (options.disableGlob || !glob.hasMagic(p)) results = [p];
+		else try {
+			options.lstatSync(p);
+			results = [p];
+		} catch (er) {
+			results = glob.sync(p, options.glob);
+		}
+		if (!results.length) return;
+		for (var i = 0; i < results.length; i++) {
+			var p = results[i];
+			try {
+				var st = options.lstatSync(p);
+			} catch (er) {
+				if (er.code === "ENOENT") return;
+				if (er.code === "EPERM" && isWindows) fixWinEPERMSync(p, options, er);
+			}
+			try {
+				if (st && st.isDirectory()) rmdirSync(p, options, null);
+				else options.unlinkSync(p);
+			} catch (er) {
+				if (er.code === "ENOENT") return;
+				if (er.code === "EPERM") return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
+				if (er.code !== "EISDIR") throw er;
+				rmdirSync(p, options, er);
+			}
+		}
+	}
+	function rmdirSync(p, options, originalEr) {
+		assert(p);
+		assert(options);
+		if (originalEr) assert(originalEr instanceof Error);
+		try {
+			options.rmdirSync(p);
+		} catch (er) {
+			if (er.code === "ENOENT") return;
+			if (er.code === "ENOTDIR") throw originalEr;
+			if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") rmkidsSync(p, options);
+		}
+	}
+	function rmkidsSync(p, options) {
+		assert(p);
+		assert(options);
+		options.readdirSync(p).forEach(function(f) {
+			rimrafSync(path$3.join(p, f), options);
+		});
+		var retries = isWindows ? 100 : 1;
+		var i = 0;
+		do {
+			var threw = true;
+			try {
+				var ret = options.rmdirSync(p, options);
+				threw = false;
+				return ret;
+			} finally {
+				if (++i < retries && threw) continue;
+			}
+		} while (true);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/mkdirp@0.5.6/node_modules/mkdirp/index.js
+var require_mkdirp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var path$2 = __require("path");
+	var fs$2 = __require("fs");
+	var _0777 = parseInt("0777", 8);
+	module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+	function mkdirP(p, opts, f, made) {
+		if (typeof opts === "function") {
+			f = opts;
+			opts = {};
+		} else if (!opts || typeof opts !== "object") opts = { mode: opts };
+		var mode = opts.mode;
+		var xfs = opts.fs || fs$2;
+		if (mode === void 0) mode = _0777;
+		if (!made) made = null;
+		var cb = f || /* istanbul ignore next */ function() {};
+		p = path$2.resolve(p);
+		xfs.mkdir(p, mode, function(er) {
+			if (!er) {
+				made = made || p;
+				return cb(null, made);
+			}
+			switch (er.code) {
+				case "ENOENT":
+					/* istanbul ignore if */
+					if (path$2.dirname(p) === p) return cb(er);
+					mkdirP(path$2.dirname(p), opts, function(er, made) {
+						/* istanbul ignore if */
+						if (er) cb(er, made);
+						else mkdirP(p, opts, cb, made);
+					});
+					break;
+				default: xfs.stat(p, function(er2, stat) {
+					if (er2 || !stat.isDirectory()) cb(er, made);
+					else cb(null, made);
+				});
+			}
+		});
+	}
+	mkdirP.sync = function sync(p, opts, made) {
+		if (!opts || typeof opts !== "object") opts = { mode: opts };
+		var mode = opts.mode;
+		var xfs = opts.fs || fs$2;
+		if (mode === void 0) mode = _0777;
+		if (!made) made = null;
+		p = path$2.resolve(p);
+		try {
+			xfs.mkdirSync(p, mode);
+			made = made || p;
+		} catch (err0) {
+			switch (err0.code) {
+				case "ENOENT":
+					made = sync(path$2.dirname(p), opts, made);
+					sync(p, opts, made);
+					break;
+				default:
+					var stat;
+					try {
+						stat = xfs.statSync(p);
+					} catch (err1) /* istanbul ignore next */ {
+						throw err0;
+					}
+					/* istanbul ignore if */
+					if (!stat.isDirectory()) throw err0;
+			}
+		}
+		return made;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/package-manager-detector@1.8.0/node_modules/package-manager-detector/dist/constants.mjs
+var import_temp = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let fs$1 = __require("fs");
+	let path$1 = __require("path");
+	let cnst = __require("constants");
+	let os = __require("os");
+	let rimraf = require_rimraf();
+	let mkdirp = require_mkdirp();
+	__require("os").tmpdir();
+	const rimrafSync = rimraf.sync;
+	let dir = path$1.resolve(os.tmpdir());
+	let RDWR_EXCL = cnst.O_CREAT | cnst.O_TRUNC | cnst.O_RDWR | cnst.O_EXCL;
+	let promisify = function(callback) {
+		if (typeof callback === "function") return [void 0, callback];
+		var promiseCallback;
+		return [new Promise(function(resolve, reject) {
+			promiseCallback = function() {
+				var args = Array.from(arguments);
+				var err = args.shift();
+				process.nextTick(function() {
+					if (err) reject(err);
+					else if (args.length === 1) resolve(args[0]);
+					else resolve(args);
+				});
+			};
+		}), promiseCallback];
+	};
+	var generateName = function(rawAffixes, defaultPrefix) {
+		var affixes = parseAffixes(rawAffixes, defaultPrefix);
+		var now = /* @__PURE__ */ new Date();
+		var name = [
+			affixes.prefix,
+			now.getFullYear(),
+			now.getMonth(),
+			now.getDate(),
+			"-",
+			process.pid,
+			"-",
+			(Math.random() * 4294967296 + 1).toString(36),
+			affixes.suffix
+		].join("");
+		return path$1.join(affixes.dir || dir, name);
+	};
+	var parseAffixes = function(rawAffixes, defaultPrefix) {
+		var affixes = {
+			prefix: null,
+			suffix: null
+		};
+		if (rawAffixes) switch (typeof rawAffixes) {
+			case "string":
+				affixes.prefix = rawAffixes;
+				break;
+			case "object":
+				affixes = rawAffixes;
+				break;
+			default: throw new Error("Unknown affix declaration: " + affixes);
+		}
+		else affixes.prefix = defaultPrefix;
+		return affixes;
+	};
+	var tracking = false;
+	var track = function(value) {
+		tracking = value !== false;
+		return module.exports;
+	};
+	var exitListenerAttached = false;
+	var filesToDelete = [];
+	var dirsToDelete = [];
+	function deleteFileOnExit(filePath) {
+		if (!tracking) return false;
+		attachExitListener();
+		filesToDelete.push(filePath);
+	}
+	function deleteDirOnExit(dirPath) {
+		if (!tracking) return false;
+		attachExitListener();
+		dirsToDelete.push(dirPath);
+	}
+	function attachExitListener() {
+		if (!tracking) return false;
+		if (!exitListenerAttached) {
+			process.addListener("exit", function() {
+				try {
+					cleanupSync();
+				} catch (err) {
+					console.warn("Fail to clean temporary files on exit : ", err);
+					throw err;
+				}
+			});
+			exitListenerAttached = true;
+		}
+	}
+	function cleanupFilesSync() {
+		if (!tracking) return false;
+		var count = 0;
+		var toDelete;
+		while ((toDelete = filesToDelete.shift()) !== void 0) {
+			rimrafSync(toDelete, { maxBusyTries: 6 });
+			count++;
+		}
+		return count;
+	}
+	function cleanupFiles(callback) {
+		var p = promisify(callback);
+		var promise = p[0];
+		callback = p[1];
+		if (!tracking) {
+			callback(/* @__PURE__ */ new Error("not tracking"));
+			return promise;
+		}
+		var count = 0;
+		var left = filesToDelete.length;
+		if (!left) {
+			callback(null, count);
+			return promise;
+		}
+		var toDelete;
+		var rimrafCallback = function(err) {
+			if (!left) return;
+			if (err) {
+				callback(err);
+				left = 0;
+				return;
+			} else count++;
+			left--;
+			if (!left) callback(null, count);
+		};
+		while ((toDelete = filesToDelete.shift()) !== void 0) rimraf(toDelete, { maxBusyTries: 6 }, rimrafCallback);
+		return promise;
+	}
+	function cleanupDirsSync() {
+		if (!tracking) return false;
+		var count = 0;
+		var toDelete;
+		while ((toDelete = dirsToDelete.shift()) !== void 0) {
+			rimrafSync(toDelete, { maxBusyTries: 6 });
+			count++;
+		}
+		return count;
+	}
+	function cleanupDirs(callback) {
+		var p = promisify(callback);
+		var promise = p[0];
+		callback = p[1];
+		if (!tracking) {
+			callback(/* @__PURE__ */ new Error("not tracking"));
+			return promise;
+		}
+		var count = 0;
+		var left = dirsToDelete.length;
+		if (!left) {
+			callback(null, count);
+			return promise;
+		}
+		var toDelete;
+		var rimrafCallback = function(err) {
+			if (!left) return;
+			if (err) {
+				callback(err, count);
+				left = 0;
+				return;
+			} else count++;
+			left--;
+			if (!left) callback(null, count);
+		};
+		while ((toDelete = dirsToDelete.shift()) !== void 0) rimraf(toDelete, { maxBusyTries: 6 }, rimrafCallback);
+		return promise;
+	}
+	function cleanupSync() {
+		if (!tracking) return false;
+		return {
+			files: cleanupFilesSync(),
+			dirs: cleanupDirsSync()
+		};
+	}
+	function cleanup(callback) {
+		var p = promisify(callback);
+		var promise = p[0];
+		callback = p[1];
+		if (!tracking) {
+			callback(/* @__PURE__ */ new Error("not tracking"));
+			return promise;
+		}
+		cleanupFiles(function(fileErr, fileCount) {
+			if (fileErr) callback(fileErr, { files: fileCount });
+			else cleanupDirs(function(dirErr, dirCount) {
+				callback(dirErr, {
+					files: fileCount,
+					dirs: dirCount
+				});
+			});
+		});
+		return promise;
+	}
+	const mkdir = (affixes, callback) => {
+		const p = promisify(callback);
+		const promise = p[0];
+		callback = p[1];
+		let dirPath = generateName(affixes, "d-");
+		mkdirp(dirPath, 448, (err) => {
+			if (!err) deleteDirOnExit(dirPath);
+			callback(err, dirPath);
+		});
+		return promise;
+	};
+	const mkdirSync = (affixes) => {
+		let dirPath = generateName(affixes, "d-");
+		mkdirp.sync(dirPath, 448);
+		deleteDirOnExit(dirPath);
+		return dirPath;
+	};
+	const open = (affixes, callback) => {
+		const p = promisify(callback);
+		const promise = p[0];
+		callback = p[1];
+		const path = generateName(affixes, "f-");
+		fs$1.open(path, RDWR_EXCL, 384, (err, fd) => {
+			if (!err) deleteFileOnExit(path);
+			callback(err, {
+				path,
+				fd
+			});
+		});
+		return promise;
+	};
+	const openSync = (affixes) => {
+		const path = generateName(affixes, "f-");
+		let fd = fs$1.openSync(path, RDWR_EXCL, 384);
+		deleteFileOnExit(path);
+		return {
+			path,
+			fd
+		};
+	};
+	const createWriteStream = (affixes) => {
+		const path = generateName(affixes, "s-");
+		let stream = fs$1.createWriteStream(path, {
+			flags: RDWR_EXCL,
+			mode: 384
+		});
+		deleteFileOnExit(path);
+		return stream;
+	};
+	exports.dir = dir;
+	exports.track = track;
+	exports.mkdir = mkdir;
+	exports.mkdirSync = mkdirSync;
+	exports.open = open;
+	exports.openSync = openSync;
+	exports.path = generateName;
+	exports.cleanup = cleanup;
+	exports.cleanupSync = cleanupSync;
+	exports.createWriteStream = createWriteStream;
+})))(), 1);
+const LOCKS = {
+	"aube-lock.yaml": "aube",
+	"aube-workspace.yaml": "aube",
+	"bun.lock": "bun",
+	"bun.lockb": "bun",
+	"deno.lock": "deno",
+	"nub.lock": "nub",
+	"pnpm-lock.yaml": "pnpm",
+	"pnpm-workspace.yaml": "pnpm",
+	"yarn.lock": "yarn",
+	"package-lock.json": "npm",
+	"npm-shrinkwrap.json": "npm"
+};
+//#endregion
+//#region ../../node_modules/.pnpm/find-installed-packages@4.0.0/node_modules/find-installed-packages/dist/index.mjs
+const CACHE_FILE = ".find-installed-packages.cache";
+function getCacheFilepath() {
+	return path.join(import_temp.dir, CACHE_FILE);
+}
+let memoryCache;
+function getCacheKey(keywords, cwd) {
+	return JSON.stringify({
+		cwd: path.resolve(cwd),
+		keywords: [...keywords].sort()
+	});
+}
+function getCachedPackages(key, fingerprint) {
+	const cache = loadCache();
+	const entry = cache[key];
+	if (entry) {
+		if (typeof entry.fingerprint !== "number" || entry.fingerprint < fingerprint) {
+			delete cache[key];
+			saveCache(cache);
+			return;
+		}
+		return entry.packages;
+	}
+}
+function setCachedPackages(key, fingerprint, packages) {
+	const cache = loadCache();
+	cache[key] = {
+		fingerprint,
+		packages
+	};
+	saveCache(cache);
+}
+// istanbul ignore next
+function loadCache() {
+	if (memoryCache) return memoryCache;
+	const filepath = getCacheFilepath();
+	if (!fs.existsSync(filepath)) {
+		memoryCache = {};
+		return memoryCache;
+	}
+	try {
+		memoryCache = JSON.parse(fs.readFileSync(filepath, { encoding: "utf-8" }));
+		return memoryCache;
+	} catch (_e) {
+		memoryCache = {};
+		return memoryCache;
+	}
+}
+// istanbul ignore next
+function saveCache(cache) {
+	memoryCache = cache;
+	const filepath = getCacheFilepath();
+	fs.writeFileSync(filepath, JSON.stringify(cache));
+}
+async function findPackagesInfo(cwd) {
+	try {
+		await fs.promises.access(cwd);
+	} catch {
+		return [];
+	}
+	return recurseFind(cwd, {});
+}
+async function recurseFind(cwd, walked) {
+	const nodeModulesDir = path.join(cwd, "node_modules");
+	if (walked[nodeModulesDir]) return [];
+	walked[nodeModulesDir] = true;
+	try {
+		await fs.promises.access(nodeModulesDir);
+	} catch {
+		return [];
+	}
+	const dirs = await fs.promises.readdir(nodeModulesDir);
+	const results = [];
+	await Promise.all(dirs.map(async (dir) => {
+		const packagePath = path.join(nodeModulesDir, dir);
+		const stat = await tryStatAsync(packagePath);
+		if (!stat) return;
+		if (!stat.isDirectory()) return;
+		walked[packagePath] = true;
+		if (dir.startsWith("@")) {
+			if (dir === "@types") return;
+			const subDirs = await fs.promises.readdir(packagePath);
+			await Promise.all(subDirs.map(async (sd) => {
+				const subPackagePath = path.join(nodeModulesDir, dir, sd);
+				if (walked[subPackagePath]) return;
+				const subStat = await tryStatAsync(subPackagePath);
+				// istanbul ignore next
+				if (!subStat) return;
+				// istanbul ignore next
+				if (!subStat.isDirectory()) return;
+				walked[subPackagePath] = true;
+				results.push({
+					name: `${dir}/${sd}`,
+					ctimeMs: subStat.ctimeMs,
+					path: subPackagePath
+				});
+				const nested = await recurseFind(subPackagePath, walked);
+				results.push(...nested);
+			}));
+		} else {
+			results.push({
+				name: dir,
+				ctimeMs: stat.ctimeMs,
+				path: packagePath
+			});
+			const nested = await recurseFind(packagePath, walked);
+			results.push(...nested);
+		}
+	}));
+	return results;
+}
+async function tryStatAsync(filePath) {
+	try {
+		return await fs.promises.stat(filePath);
+	} catch {
+		// istanbul ignore next
+		return;
+	}
+}
+/**
+* Files that change whenever the installed tree changes.
+*
+* The lockfile names come from `package-manager-detector` rather than a list of
+* our own, so new package managers arrive with a dependency bump instead of a
+* bug report.
+*/
+const LOCKFILES = Object.keys(LOCKS).concat([".pnp.cjs", ".pnp.data.json"]);
+/**
+* A cheap number that changes when the installed tree changes.
+*
+* Used as the cache stamp. Unlike stat-ing every installed package, this is a
+* handful of `stat` calls, so the cache can short-circuit the whole walk rather
+* than only the manifest reads.
+*
+* The lockfile is looked up from `cwd` upwards, because in a workspace it lives
+* at the repo root rather than next to the project.
+*/
+async function getFingerprint(cwd) {
+	const root = path.resolve(cwd);
+	let fingerprint = 0;
+	const bump = (stat) => {
+		if (stat && stat.mtimeMs > fingerprint) fingerprint = stat.mtimeMs;
+	};
+	bump(await statSafe(path.join(root, "package.json")));
+	bump(await statSafe(path.join(root, "node_modules")));
+	let dir = root;
+	for (;;) {
+		const found = (await Promise.all(LOCKFILES.map((name) => statSafe(path.join(dir, name))))).filter((stat) => !!stat);
+		if (found.length > 0) {
+			found.forEach(bump);
+			break;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return fingerprint;
+}
+async function statSafe(filepath) {
+	try {
+		return await fs.promises.stat(filepath);
+	} catch {
+		return;
+	}
+}
+function hasAllKeywords(actual, expected) {
+	const set = new Set(actual);
+	return !expected.find((key) => !set.has(key));
+}
+/**
+* Read file and ignore ENOENT.
+* When the the folder is a link, the link may be invalid.
+* That will result in ENOENT.
+* @param path file path.
+*/
+async function readFileSafe(path) {
+	try {
+		return await fs.promises.readFile(path, "utf8");
+	} catch (err) {
+		// istanbul ignore next
+		if (err.code === "ENOENT") return void 0;
+		// istanbul ignore next
+		throw err;
+	}
+}
+/**
+* Read and parse the `package.json` of a package folder.
+* Returns `undefined` when it is missing, unreadable, or malformed.
+*/
+async function readManifest(dir) {
+	try {
+		const content = await readFileSafe(path.resolve(dir, "package.json"));
+		if (!content) return void 0;
+		const manifest = JSON.parse(content);
+		return manifest && typeof manifest === "object" ? manifest : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Names of the dependencies to traverse from a manifest.
+*
+* `devDependencies` are only installed for the project itself,
+* so they are included at the root and skipped for everything below it.
+*/
+function dependencyNames(manifest, includeDev) {
+	const names = [
+		...keysOf(manifest.dependencies),
+		...keysOf(manifest.optionalDependencies),
+		...keysOf(manifest.peerDependencies),
+		...includeDev ? keysOf(manifest.devDependencies) : []
+	];
+	return Array.from(new Set(names));
+}
+function keysOf(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value) : [];
+}
+/**
+* Walk the declared dependency graph starting at `cwd`, using the host runtime's
+* module resolver to locate each package.
+*
+* Asking the resolver instead of walking `node_modules` keeps this correct across
+* hoisted layouts (npm, yarn, bun), isolated ones (pnpm, `bun --linker=isolated`),
+* workspaces (where the tree lives at the repo root), and Yarn PnP (where there is
+* no `node_modules` at all).
+*
+* Returns `undefined` when there is nothing to resolve from — no readable
+* `package.json` at `cwd`, or one that declares no dependencies — so the caller
+* can fall back to scanning.
+*/
+async function resolvePackagesInfo(cwd) {
+	const root = path.resolve(cwd);
+	const manifest = await readManifest(root);
+	if (!manifest) return void 0;
+	const deps = dependencyNames(manifest, true);
+	if (deps.length === 0) return void 0;
+	const results = [];
+	await walk(root, deps, /* @__PURE__ */ new Set([root]), results);
+	return results;
+}
+async function walk(from, deps, walked, results) {
+	await Promise.all(deps.map(async (name) => {
+		if (name.indexOf("@types/") === 0) return;
+		const dir = resolvePackageDir(name, from);
+		if (!dir || walked.has(dir)) return;
+		walked.add(dir);
+		const manifest = await readManifest(dir);
+		if (!manifest) return;
+		if (manifest.name) results.push({
+			name: manifest.name,
+			path: dir,
+			manifest
+		});
+		await walk(dir, dependencyNames(manifest, false), walked, results);
+	}));
+}
+/**
+* Locate the folder of `name` as resolved from `fromDir`.
+*
+* Three strategies, most faithful first, because no single one covers every case.
+*
+* Note on coverage: Bun's resolver serves `<pkg>/package.json` even when `exports`
+* does not list it, so strategy 1 always wins under `bun test` and the fallbacks
+* report as uncovered. They are not dead code — under Node they carry real cases:
+* strategy 2 covers an `exports`-restricted package in a `node_modules` tree, and
+* strategy 3 covers one under Yarn PnP, where `resolve.paths` is not PnP-aware.
+*/
+function resolvePackageDir(name, fromDir) {
+	const require = createRequire(path.join(fromDir, "package.json"));
+	try {
+		return path.dirname(require.resolve(`${name}/package.json`));
+	} catch {}
+	try {
+		const lookups = require.resolve.paths(name);
+		if (lookups) for (const lookup of lookups) {
+			const candidate = path.join(lookup, name);
+			if (fs.existsSync(path.join(candidate, "package.json"))) return candidate;
+		}
+	} catch {}
+	try {
+		let dir = path.dirname(require.resolve(name));
+		for (;;) {
+			if (readNameSync(dir) === name) return dir;
+			const parent = path.dirname(dir);
+			if (parent === dir) return void 0;
+			dir = parent;
+		}
+	} catch {}
+}
+function readNameSync(dir) {
+	try {
+		return JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).name;
+	} catch {
+		return;
+	}
+}
+async function findByKeywords(keywords, options) {
+	const { cwd } = unpartial({ cwd: "." }, options);
+	return getPackages(keywords, cwd);
+}
+async function getPackages(keywords, cwd) {
+	const cacheKey = getCacheKey(keywords, cwd);
+	const fingerprint = await getFingerprint(cwd);
+	const cache = getCachedPackages(cacheKey, fingerprint);
+	if (cache) return cache;
+	const names = (await collectManifests(cwd)).filter((manifest) => manifest.name && hasAllKeywords(manifest.keywords, keywords)).map((manifest) => manifest.name);
+	const packages = Array.from(new Set(names));
+	setCachedPackages(cacheKey, fingerprint, packages);
+	return packages;
+}
+/**
+* Prefer the dependency graph as the runtime resolves it.
+* Fall back to scanning `node_modules` when there is nothing to resolve from —
+* no readable manifest at `cwd`, or one without dependencies.
+*/
+async function collectManifests(cwd) {
+	const resolved = await resolvePackagesInfo(cwd);
+	if (resolved) return resolved.map((pkg) => pkg.manifest);
+	const infos = await findPackagesInfo(cwd);
+	return (await Promise.all(infos.map((info) => readManifest(info.path)))).filter((manifest) => !!manifest);
+}
+//#endregion
+export { findByKeywords };