nanos-lint 2.8.0 → 2.8.1

package/dist/{cli-DGez8MSI.js → cli-BAy_Ztvh.js}

@@ -1,11 +1,18 @@
 import { fileURLToPath } from "node:url";
+import * as xi from "node:fs";
 import fs from "node:fs";
-import path from "node:path";
+import path, { posix, win32 } from "node:path";
 import os from "node:os";
 import process$1 from "node:process";
 import childProcess, { execFile, execFileSync } from "node:child_process";
+import crypto from "node:crypto";
 import { promisify, stripVTControlCharacters } from "node:util";
+import Pe, { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { lstatSync, readdir, readdirSync, readlinkSync, realpathSync } from "fs";
+import { lstat, readdir as readdir$1, readlink, realpath } from "node:fs/promises";
 import { EventEmitter } from "node:events";
+import { StringDecoder } from "node:string_decoder";
 //#region src/logger.ts
 const LOG_LEVELS = [
 	"silent",
@@ -1458,13 +1465,19 @@ function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 //#endregion
 //#region src/luals/validation.ts
 /**
-* Verifies that a LuaLS binary exists, has non-trivial size, and is executable.
+* Minimum plausible size of a downloaded LuaLS executable. Release assets are
+* several megabytes, so anything smaller is a truncated download or a stray
+* file. This floor only applies to binaries nanos-lint fetched itself: a
+* user-supplied `LUALS_BIN` may legitimately be a small wrapper script.
 */
-function isBinaryValid(binaryPath) {
-	if (!fs.existsSync(binaryPath)) return false;
+const MIN_DOWNLOADED_BINARY_SIZE_BYTES = 1e5;
+/**
+* Runs `binaryPath --version` and checks that it reports a LuaLS version.
+* Shared by every binary validation path; the size heuristic stays separate
+* because only downloaded archives have a known-plausible size.
+*/
+function reportsLuaLSVersion(binaryPath) {
 	try {
-		const stats = fs.statSync(binaryPath);
-		if (!stats.isFile() || stats.size < 1e5) return false;
 		const output = execFileSync(binaryPath, ["--version"], {
 			timeout: 5e3,
 			stdio: "pipe",
@@ -1476,6 +1489,60 @@ function isBinaryValid(binaryPath) {
 		return false;
 	}
 }
+/**
+* Verifies that a downloaded or cached LuaLS binary exists, has non-trivial
+* size, and is executable.
+*/
+function isBinaryValid(binaryPath) {
+	if (!fs.existsSync(binaryPath)) return false;
+	try {
+		const stats = fs.statSync(binaryPath);
+		if (!stats.isFile() || stats.size < 1e5) return false;
+		return reportsLuaLSVersion(binaryPath);
+	} catch (err) {
+		logger.debug(`[luals] Binary validation check failed for ${binaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+}
+/**
+* Verifies that an explicitly configured binary is a regular file that runs and
+* reports a LuaLS version, without the downloaded-archive size heuristic so
+* wrapper scripts (`LUALS_BIN=/usr/local/bin/lua-language-server`) keep working.
+*/
+function isBinaryRunnable(binaryPath) {
+	try {
+		if (!fs.statSync(binaryPath).isFile()) return false;
+	} catch (err) {
+		logger.debug(`[luals] Binary validation check failed for ${binaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	return reportsLuaLSVersion(binaryPath);
+}
+/**
+* Validates an explicitly configured LuaLS binary (`LUALS_BIN` environment
+* variable or `--luals-bin` CLI option) and returns its path.
+*
+* Both are documented escape hatches, so a typo, a stale path, a directory or an
+* unrelated executable must fail with an actionable error instead of a
+* confusing low-level failure deep inside the check run (#26). Executables are
+* accepted as-is when `--version` reports a version, including the thin wrapper
+* scripts that Homebrew/mason-style installations put on `PATH`: the size floor
+* used for downloaded archives would reject those.
+*
+* @param binaryPath Path exactly as the user supplied it.
+* @param source Name of the setting being validated (`LUALS_BIN` / `--luals-bin`).
+*/
+function assertValidLuaLSBinary(binaryPath, source) {
+	let stats;
+	try {
+		stats = fs.statSync(binaryPath);
+	} catch (err) {
+		throw new LuaLSError(`${source} points to '${binaryPath}', which does not exist or cannot be read: ${err instanceof Error ? err.message : String(err)}`, "ERR_LUALS_BIN_INVALID", `Set ${source} to the full path of a lua-language-server executable, or leave it unset so nanos-lint resolves LuaLS automatically.`, { cause: err });
+	}
+	if (!stats.isFile()) throw new LuaLSError(`${source} points to '${binaryPath}', which is not a regular file (a directory or special file was found).`, "ERR_LUALS_BIN_INVALID", `Point ${source} at the lua-language-server executable itself, or leave it unset so nanos-lint resolves LuaLS automatically.`);
+	if (!isBinaryRunnable(binaryPath)) throw new LuaLSError(`${source} points to '${binaryPath}', which is not a runnable LuaLS binary (running it with '--version' failed or printed no version).`, "ERR_LUALS_BIN_INVALID", `Verify ${source} points at a working lua-language-server executable or wrapper script, or leave it unset so nanos-lint resolves LuaLS automatically.`);
+	return binaryPath;
+}
 //#endregion
 //#region src/luals/cache.ts
 function getBaseLuaLSCacheDir() {
@@ -1516,7 +1583,12 @@ function readLuaLSMetadata(baseCacheDir = getBaseLuaLSCacheDir()) {
 	try {
 		const content = fs.readFileSync(metaPath, "utf-8");
 		const parsed = JSON.parse(content);
-		if (typeof parsed?.lastCheckedWeek === "string" && typeof parsed?.latestVersion === "string") return parsed;
+		const rawVersion = parsed?.latestVersion;
+		const safeVersion = typeof rawVersion === "string" ? sanitizeLuaLSVersion(rawVersion) : null;
+		if (typeof parsed?.lastCheckedWeek === "string" && safeVersion !== null) return {
+			...parsed,
+			latestVersion: safeVersion
+		};
 		try {
 			fs.unlinkSync(metaPath);
 			logger.warn(`[luals] Stale or invalid LuaLS metadata at ${metaPath} purged.`);
@@ -1656,6 +1728,44 @@ function findExistingLuaLSDir(version, baseCacheDir = getBaseLuaLSCacheDir()) {
 }
 //#endregion
 //#region src/luals/download.ts
+const DOWNLOAD_TIMEOUT_MS = 12e4;
+const MAX_ARCHIVE_SIZE_BYTES = 157286400;
+const ALLOWED_DOWNLOAD_DOMAINS = ["github.com", "githubusercontent.com"];
+/**
+* Validates that a download URL uses HTTPS and targets an allowlisted host.
+*/
+function isAllowedDownloadUrl(urlString) {
+	try {
+		const parsed = new URL(urlString);
+		if (parsed.protocol !== "https:") return false;
+		const hostname = parsed.hostname.toLowerCase();
+		return ALLOWED_DOWNLOAD_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+	} catch {
+		return false;
+	}
+}
+/** Chunk size used when hashing an archive, so a 150 MB asset is never buffered whole. */
+const HASH_CHUNK_SIZE_BYTES = 1048576;
+/**
+* Calculates the SHA-256 hash of a file on disk in bounded memory.
+*/
+function computeFileSha256(filePath) {
+	const hash = crypto.createHash("sha256");
+	const fd = fs.openSync(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(HASH_CHUNK_SIZE_BYTES);
+		let position = 0;
+		let bytesRead = fs.readSync(fd, buffer, 0, buffer.length, position);
+		while (bytesRead > 0) {
+			hash.update(buffer.subarray(0, bytesRead));
+			position += bytesRead;
+			bytesRead = fs.readSync(fd, buffer, 0, buffer.length, position);
+		}
+	} finally {
+		fs.closeSync(fd);
+	}
+	return hash.digest("hex");
+}
 const execFileAsync$1 = promisify(execFile);
 /**
 * Escapes single quotes for safe PowerShell single-quoted string interpolation.
@@ -1663,6 +1773,17 @@ const execFileAsync$1 = promisify(execFile);
 function escapePowerShellSingleQuote(str) {
 	return str.replace(/'/g, "''");
 }
+/**
+* Enforces a maximum byte count on an asynchronous download stream.
+*/
+async function* limitDownloadStream(source) {
+	let total = 0;
+	for await (const chunk of source) {
+		total += chunk.length;
+		if (total > 157286400) throw new LuaLSError(`Download exceeded maximum allowed size of ${MAX_ARCHIVE_SIZE_BYTES} bytes`, "ERR_LUALS_DOWNLOAD", "Verify the LuaLS release asset size or specify a local binary with LUALS_BIN.");
+		yield chunk;
+	}
+}
 async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDir, options) {
 	const resolvedVersion = await resolveLuaLSVersion(version);
 	const info = getPlatformInfo(resolvedVersion);
@@ -1697,195 +1818,3594 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 			if (!options?.quiet) logger.info(`[luals] Reusing existing LuaLS ${resolvedVersion} installation from ${existingSourceDir}...`);
 			fs.cpSync(existingSourceDir, tempDir, { recursive: true });
 		} else {
+			if (!isAllowedDownloadUrl(url)) throw new LuaLSError(`Refusing to download LuaLS from untrusted URL: ${url}`, "ERR_LUALS_DOWNLOAD", "Download URLs must use HTTPS and target an allowlisted GitHub host.");
 			if (!options?.quiet) logger.info(`[luals] Downloading LuaLS ${resolvedVersion} from ${url}...`);
 			let response = null;
 			let lastErr = null;
 			for (let attempt = 1; attempt <= 3; attempt++) {
 				try {
-					const res = await fetch(url);
+					const res = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+					if (res.url && !isAllowedDownloadUrl(res.url)) {
+						await res.body?.cancel();
+						throw new LuaLSError(`Redirect to untrusted URL blocked: ${res.url}`, "ERR_LUALS_DOWNLOAD", "Download redirects must stay on allowlisted HTTPS GitHub hosts.");
+					}
 					if (res.ok && res.body) {
 						response = res;
 						break;
 					}
-					await res.body?.cancel();
-					lastErr = /* @__PURE__ */ new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
-				} catch (err) {
-					lastErr = err;
+					await res.body?.cancel();
+					lastErr = /* @__PURE__ */ new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
+				} catch (err) {
+					lastErr = err;
+				}
+				if (attempt < 3) await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
+			}
+			if (!response || !response.body) {
+				if (lastErr instanceof LuaLSError) throw lastErr;
+				throw new LuaLSError(`Failed to download LuaLS from ${url}${lastErr ? `: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}` : ""}`, "ERR_LUALS_DOWNLOAD", "Check your network connection or specify a custom binary with LUALS_BIN.", { cause: lastErr });
+			}
+			const contentLengthHeader = response.headers?.get?.("content-length");
+			if (contentLengthHeader) {
+				const contentLength = parseInt(contentLengthHeader, 10);
+				if (!isNaN(contentLength) && contentLength > 157286400) {
+					await response.body.cancel();
+					throw new LuaLSError(`Archive size (${contentLength} bytes) exceeds maximum limit (${MAX_ARCHIVE_SIZE_BYTES} bytes)`, "ERR_LUALS_DOWNLOAD", "Verify the LuaLS release asset size or specify a local binary with LUALS_BIN.");
+				}
+			}
+			const fileStream = fs.createWriteStream(archivePath);
+			try {
+				const streamSource = typeof Readable.fromWeb === "function" && !("pipe" in response.body) ? Readable.fromWeb(response.body) : response.body;
+				await pipeline(streamSource, limitDownloadStream, fileStream);
+			} catch (streamErr) {
+				try {
+					if (fs.existsSync(archivePath)) fs.unlinkSync(archivePath);
+				} catch (unlinkErr) {}
+				if (streamErr instanceof LuaLSError) throw streamErr;
+				throw new LuaLSError(`Failed to download LuaLS from ${url}: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`, "ERR_LUALS_DOWNLOAD", "Check your network connection or specify a custom binary with LUALS_BIN.", { cause: streamErr });
+			}
+			const archiveSha256 = computeFileSha256(archivePath);
+			logger.info(`[luals] Downloaded ${info.assetName} (SHA-256 ${archiveSha256})`);
+			if (!options?.quiet) logger.info(`[luals] Extracting to ${destDir}...`);
+			try {
+				const tarArgs = process.platform === "win32" ? [
+					"-xf",
+					archivePath,
+					"-C",
+					tempDir
+				] : [
+					"-xf",
+					archivePath,
+					"--no-same-owner",
+					"--no-same-permissions",
+					"-C",
+					tempDir
+				];
+				await execFileAsync$1("tar", tarArgs);
+			} catch (tarErr) {
+				if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync$1("powershell.exe", [
+					"-NoProfile",
+					"-Command",
+					`Expand-Archive -Path '${escapePowerShellSingleQuote(archivePath)}' -DestinationPath '${escapePowerShellSingleQuote(tempDir)}' -Force`
+				]);
+				else throw tarErr;
+			}
+			try {
+				fs.unlinkSync(archivePath);
+			} catch (err) {
+				logger.debug(`[luals] Failed to delete temporary archive ${archivePath}: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+		const tempBinaryPath = path.join(tempDir, info.binaryRelativePath);
+		if (!fs.existsSync(tempBinaryPath)) throw new LuaLSError(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
+		const lstat = fs.lstatSync(tempBinaryPath);
+		if (lstat.isSymbolicLink()) throw new LuaLSError(`Extracted binary at '${tempBinaryPath}' is a symbolic link. Refusing to chmod or execute archive-planted symlinks.`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		if (!lstat.isFile()) throw new LuaLSError(`Extracted binary at '${tempBinaryPath}' is not a regular file.`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		const realBinaryPath = fs.realpathSync(tempBinaryPath);
+		const resolvedTemp = fs.realpathSync(tempDir);
+		if (!realBinaryPath.startsWith(resolvedTemp + path.sep) && realBinaryPath !== resolvedTemp) throw new LuaLSError(`Extracted binary path escapes extraction directory: ${realBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		if (process.platform !== "win32") try {
+			fs.chmodSync(tempBinaryPath, 493);
+		} catch (err) {
+			logger.warn(`[luals] Failed to chmod binary at ${tempBinaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (lstat.size < 1e5) throw new LuaLSError(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
+		if (!isBinaryValid(tempBinaryPath)) throw new LuaLSError(`Extracted LuaLS binary at ${tempBinaryPath} is invalid or non-functional.`, "ERR_LUALS_INVALID_BINARY", "Run 'nanos-lint clean-cache' to remove corrupted downloads or set LUALS_BIN to a custom binary.");
+		fs.writeFileSync(path.join(tempDir, ".complete"), resolvedVersion, "utf-8");
+		for (let attempt = 0; attempt < 5; attempt++) try {
+			fs.renameSync(tempDir, destDir);
+			break;
+		} catch (renameErr) {
+			if (fs.existsSync(binaryPath) && isBinaryValid(binaryPath)) {
+				try {
+					fs.rmSync(tempDir, {
+						recursive: true,
+						force: true
+					});
+				} catch (err) {
+					logger.debug(`[luals] Failed to remove temp directory after concurrent promotion: ${err instanceof Error ? err.message : String(err)}`);
+				}
+				if (!options?.quiet) logger.info(`[luals] Ready: ${binaryPath}`);
+				return binaryPath;
+			}
+			if (attempt < 4) await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+			else {
+				if (fs.existsSync(destDir) && (!fs.existsSync(binaryPath) || !fs.existsSync(completeMarker))) try {
+					fs.rmSync(destDir, {
+						recursive: true,
+						force: true
+					});
+				} catch (err) {
+					logger.warn(`[luals] Failed to clean up broken destination directory ${destDir}: ${err instanceof Error ? err.message : String(err)}`);
+				}
+				throw renameErr;
+			}
+		}
+		if (!options?.quiet) logger.info(`[luals] Ready: ${binaryPath}`);
+		return binaryPath;
+	} finally {
+		if (fs.existsSync(tempDir)) try {
+			fs.rmSync(tempDir, {
+				recursive: true,
+				force: true
+			});
+		} catch (err) {
+			logger.debug(`[luals] Failed to clean up temporary directory ${tempDir}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+}
+//#endregion
+//#region node_modules/glob/dist/esm/index.min.js
+var Gt = (n, t, e) => {
+	let s = n instanceof RegExp ? ce(n, e) : n, i = t instanceof RegExp ? ce(t, e) : t, r = s !== null && i != null && ss(s, i, e);
+	return r && {
+		start: r[0],
+		end: r[1],
+		pre: e.slice(0, r[0]),
+		body: e.slice(r[0] + s.length, r[1]),
+		post: e.slice(r[1] + i.length)
+	};
+};
+var ce = (n, t) => {
+	let e = t.match(n);
+	return e ? e[0] : null;
+};
+var ss = (n, t, e) => {
+	let s, i, r, o, h, a = e.indexOf(n), l = e.indexOf(t, a + 1), u = a;
+	if (a >= 0 && l > 0) {
+		if (n === t) return [a, l];
+		for (s = [], r = e.length; u >= 0 && !h;) {
+			if (u === a) s.push(u), a = e.indexOf(n, u + 1);
+			else if (s.length === 1) {
+				let c = s.pop();
+				c !== void 0 && (h = [c, l]);
+			} else i = s.pop(), i !== void 0 && i < r && (r = i, o = l), l = e.indexOf(t, u + 1);
+			u = a < l && a >= 0 ? a : l;
+		}
+		s.length && o !== void 0 && (h = [r, o]);
+	}
+	return h;
+};
+var fe = "\0SLASH" + Math.random() + "\0";
+var ue = "\0OPEN" + Math.random() + "\0";
+var qt = "\0CLOSE" + Math.random() + "\0";
+var de = "\0COMMA" + Math.random() + "\0";
+var pe = "\0PERIOD" + Math.random() + "\0";
+var is = new RegExp(fe, "g");
+var rs = new RegExp(ue, "g");
+var ns = new RegExp(qt, "g");
+var os$1 = new RegExp(de, "g");
+var hs = new RegExp(pe, "g");
+var as = /\\\\/g;
+var ls = /\\{/g;
+var cs = /\\}/g;
+var fs$1 = /\\,/g;
+var us = /\\./g;
+var ds = 1e5;
+function Ht(n) {
+	return isNaN(n) ? n.charCodeAt(0) : parseInt(n, 10);
+}
+function ps(n) {
+	return n.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs$1, de).replace(us, pe);
+}
+function ms(n) {
+	return n.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os$1, ",").replace(hs, ".");
+}
+function me(n) {
+	if (!n) return [""];
+	let t = [], e = Gt("{", "}", n);
+	if (!e) return n.split(",");
+	let { pre: s, body: i, post: r } = e, o = s.split(",");
+	o[o.length - 1] += "{" + i + "}";
+	let h = me(r);
+	return r.length && (o[o.length - 1] += h.shift(), o.push.apply(o, h)), t.push.apply(t, o), t;
+}
+function ge(n, t = {}) {
+	if (!n) return [];
+	let { max: e = ds } = t;
+	return n.slice(0, 2) === "{}" && (n = "\\{\\}" + n.slice(2)), ht(ps(n), e, !0).map(ms);
+}
+function gs(n) {
+	return "{" + n + "}";
+}
+function ws(n) {
+	return /^-?0\d/.test(n);
+}
+function ys(n, t) {
+	return n <= t;
+}
+function bs(n, t) {
+	return n >= t;
+}
+function ht(n, t, e) {
+	let s = [], i = Gt("{", "}", n);
+	if (!i) return [n];
+	let r = i.pre, o = i.post.length ? ht(i.post, t, !1) : [""];
+	if (/\$$/.test(i.pre)) for (let h = 0; h < o.length && h < t; h++) {
+		let a = r + "{" + i.body + "}" + o[h];
+		s.push(a);
+	}
+	else {
+		let h = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body), a = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body), l = h || a, u = i.body.indexOf(",") >= 0;
+		if (!l && !u) return i.post.match(/,(?!,).*\}/) ? (n = i.pre + "{" + i.body + qt + i.post, ht(n, t, !0)) : [n];
+		let c;
+		if (l) c = i.body.split(/\.\./);
+		else if (c = me(i.body), c.length === 1 && c[0] !== void 0 && (c = ht(c[0], t, !1).map(gs), c.length === 1)) return o.map((f) => i.pre + c[0] + f);
+		let d;
+		if (l && c[0] !== void 0 && c[1] !== void 0) {
+			let f = Ht(c[0]), m = Ht(c[1]), p = Math.max(c[0].length, c[1].length), w = c.length === 3 && c[2] !== void 0 ? Math.abs(Ht(c[2])) : 1, g = ys;
+			m < f && (w *= -1, g = bs);
+			let E = c.some(ws);
+			d = [];
+			for (let y = f; g(y, m); y += w) {
+				let b;
+				if (a) b = String.fromCharCode(y), b === "\\" && (b = "");
+				else if (b = String(y), E) {
+					let z = p - b.length;
+					if (z > 0) {
+						let $ = new Array(z + 1).join("0");
+						y < 0 ? b = "-" + $ + b.slice(1) : b = $ + b;
+					}
+				}
+				d.push(b);
+			}
+		} else {
+			d = [];
+			for (let f = 0; f < c.length; f++) d.push.apply(d, ht(c[f], t, !1));
+		}
+		for (let f = 0; f < d.length; f++) for (let m = 0; m < o.length && s.length < t; m++) {
+			let p = r + d[f] + o[m];
+			(!e || l || p) && s.push(p);
+		}
+	}
+	return s;
+}
+var at = (n) => {
+	if (typeof n != "string") throw new TypeError("invalid pattern");
+	if (n.length > 65536) throw new TypeError("pattern is too long");
+};
+var Ss = {
+	"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", !0],
+	"[:alpha:]": ["\\p{L}\\p{Nl}", !0],
+	"[:ascii:]": ["\\x00-\\x7f", !1],
+	"[:blank:]": ["\\p{Zs}\\t", !0],
+	"[:cntrl:]": ["\\p{Cc}", !0],
+	"[:digit:]": ["\\p{Nd}", !0],
+	"[:graph:]": [
+		"\\p{Z}\\p{C}",
+		!0,
+		!0
+	],
+	"[:lower:]": ["\\p{Ll}", !0],
+	"[:print:]": ["\\p{C}", !0],
+	"[:punct:]": ["\\p{P}", !0],
+	"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", !0],
+	"[:upper:]": ["\\p{Lu}", !0],
+	"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", !0],
+	"[:xdigit:]": ["A-Fa-f0-9", !1]
+};
+var lt = (n) => n.replace(/[[\]\\-]/g, "\\$&");
+var Es = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var we = (n) => n.join("");
+var ye = (n, t) => {
+	let e = t;
+	if (n.charAt(e) !== "[") throw new Error("not in a brace expression");
+	let s = [], i = [], r = e + 1, o = !1, h = !1, a = !1, l = !1, u = e, c = "";
+	t: for (; r < n.length;) {
+		let p = n.charAt(r);
+		if ((p === "!" || p === "^") && r === e + 1) {
+			l = !0, r++;
+			continue;
+		}
+		if (p === "]" && o && !a) {
+			u = r + 1;
+			break;
+		}
+		if (o = !0, p === "\\" && !a) {
+			a = !0, r++;
+			continue;
+		}
+		if (p === "[" && !a) {
+			for (let [w, [g, S, E]] of Object.entries(Ss)) if (n.startsWith(w, r)) {
+				if (c) return [
+					"$.",
+					!1,
+					n.length - e,
+					!0
+				];
+				r += w.length, E ? i.push(g) : s.push(g), h = h || S;
+				continue t;
+			}
+		}
+		if (a = !1, c) {
+			p > c ? s.push(lt(c) + "-" + lt(p)) : p === c && s.push(lt(p)), c = "", r++;
+			continue;
+		}
+		if (n.startsWith("-]", r + 1)) {
+			s.push(lt(p + "-")), r += 2;
+			continue;
+		}
+		if (n.startsWith("-", r + 1)) {
+			c = p, r += 2;
+			continue;
+		}
+		s.push(lt(p)), r++;
+	}
+	if (u < r) return [
+		"",
+		!1,
+		0,
+		!1
+	];
+	if (!s.length && !i.length) return [
+		"$.",
+		!1,
+		n.length - e,
+		!0
+	];
+	if (i.length === 0 && s.length === 1 && /^\\?.$/.test(s[0]) && !l) return [
+		Es(s[0].length === 2 ? s[0].slice(-1) : s[0]),
+		!1,
+		u - e,
+		!1
+	];
+	let d = "[" + (l ? "^" : "") + we(s) + "]", f = "[" + (l ? "" : "^") + we(i) + "]";
+	return [
+		s.length && i.length ? "(" + d + "|" + f + ")" : s.length ? d : f,
+		h,
+		u - e,
+		!0
+	];
+};
+var W = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !0 } = {}) => e ? t ? n.replace(/\[([^\/\\])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1") : t ? n.replace(/\[([^\/\\{}])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+var xs = /* @__PURE__ */ new Set([
+	"!",
+	"?",
+	"+",
+	"*",
+	"@"
+]);
+var be = (n) => xs.has(n);
+var vs = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var Ct = "(?!\\.)";
+var Cs = /* @__PURE__ */ new Set(["[", "."]);
+var Ts = /* @__PURE__ */ new Set(["..", "."]);
+var As = /* @__PURE__ */ new Set("().*{}+?[]^$\\!");
+var ks = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Kt = "[^/]";
+var Se = Kt + "*?";
+var Ee = Kt + "+?";
+var Q = class n {
+	type;
+	#t;
+	#s;
+	#n = !1;
+	#r = [];
+	#o;
+	#S;
+	#w;
+	#c = !1;
+	#h;
+	#u;
+	#f = !1;
+	constructor(t, e, s = {}) {
+		this.type = t, t && (this.#s = !0), this.#o = e, this.#t = this.#o ? this.#o.#t : this, this.#h = this.#t === this ? s : this.#t.#h, this.#w = this.#t === this ? [] : this.#t.#w, t === "!" && !this.#t.#c && this.#w.push(this), this.#S = this.#o ? this.#o.#r.length : 0;
+	}
+	get hasMagic() {
+		if (this.#s !== void 0) return this.#s;
+		for (let t of this.#r) if (typeof t != "string" && (t.type || t.hasMagic)) return this.#s = !0;
+		return this.#s;
+	}
+	toString() {
+		return this.#u !== void 0 ? this.#u : this.type ? this.#u = this.type + "(" + this.#r.map((t) => String(t)).join("|") + ")" : this.#u = this.#r.map((t) => String(t)).join("");
+	}
+	#a() {
+		if (this !== this.#t) throw new Error("should only call on root");
+		if (this.#c) return this;
+		this.toString(), this.#c = !0;
+		let t;
+		for (; t = this.#w.pop();) {
+			if (t.type !== "!") continue;
+			let e = t, s = e.#o;
+			for (; s;) {
+				for (let i = e.#S + 1; !s.type && i < s.#r.length; i++) for (let r of t.#r) {
+					if (typeof r == "string") throw new Error("string part in extglob AST??");
+					r.copyIn(s.#r[i]);
+				}
+				e = s, s = e.#o;
+			}
+		}
+		return this;
+	}
+	push(...t) {
+		for (let e of t) if (e !== "") {
+			if (typeof e != "string" && !(e instanceof n && e.#o === this)) throw new Error("invalid part: " + e);
+			this.#r.push(e);
+		}
+	}
+	toJSON() {
+		let t = this.type === null ? this.#r.slice().map((e) => typeof e == "string" ? e : e.toJSON()) : [this.type, ...this.#r.map((e) => e.toJSON())];
+		return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === this.#t || this.#t.#c && this.#o?.type === "!") && t.push({}), t;
+	}
+	isStart() {
+		if (this.#t === this) return !0;
+		if (!this.#o?.isStart()) return !1;
+		if (this.#S === 0) return !0;
+		let t = this.#o;
+		for (let e = 0; e < this.#S; e++) {
+			let s = t.#r[e];
+			if (!(s instanceof n && s.type === "!")) return !1;
+		}
+		return !0;
+	}
+	isEnd() {
+		if (this.#t === this || this.#o?.type === "!") return !0;
+		if (!this.#o?.isEnd()) return !1;
+		if (!this.type) return this.#o?.isEnd();
+		let t = this.#o ? this.#o.#r.length : 0;
+		return this.#S === t - 1;
+	}
+	copyIn(t) {
+		typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+	}
+	clone(t) {
+		let e = new n(this.type, t);
+		for (let s of this.#r) e.copyIn(s);
+		return e;
+	}
+	static #i(t, e, s, i) {
+		let r = !1, o = !1, h = -1, a = !1;
+		if (e.type === null) {
+			let f = s, m = "";
+			for (; f < t.length;) {
+				let p = t.charAt(f++);
+				if (r || p === "\\") {
+					r = !r, m += p;
+					continue;
+				}
+				if (o) {
+					f === h + 1 ? (p === "^" || p === "!") && (a = !0) : p === "]" && !(f === h + 2 && a) && (o = !1), m += p;
+					continue;
+				} else if (p === "[") {
+					o = !0, h = f, a = !1, m += p;
+					continue;
+				}
+				if (!i.noext && be(p) && t.charAt(f) === "(") {
+					e.push(m), m = "";
+					let w = new n(p, e);
+					f = n.#i(t, w, f, i), e.push(w);
+					continue;
+				}
+				m += p;
+			}
+			return e.push(m), f;
+		}
+		let l = s + 1, u = new n(null, e), c = [], d = "";
+		for (; l < t.length;) {
+			let f = t.charAt(l++);
+			if (r || f === "\\") {
+				r = !r, d += f;
+				continue;
+			}
+			if (o) {
+				l === h + 1 ? (f === "^" || f === "!") && (a = !0) : f === "]" && !(l === h + 2 && a) && (o = !1), d += f;
+				continue;
+			} else if (f === "[") {
+				o = !0, h = l, a = !1, d += f;
+				continue;
+			}
+			if (be(f) && t.charAt(l) === "(") {
+				u.push(d), d = "";
+				let m = new n(f, u);
+				u.push(m), l = n.#i(t, m, l, i);
+				continue;
+			}
+			if (f === "|") {
+				u.push(d), d = "", c.push(u), u = new n(null, e);
+				continue;
+			}
+			if (f === ")") return d === "" && e.#r.length === 0 && (e.#f = !0), u.push(d), d = "", e.push(...c, u), l;
+			d += f;
+		}
+		return e.type = null, e.#s = void 0, e.#r = [t.substring(s - 1)], l;
+	}
+	static fromGlob(t, e = {}) {
+		let s = new n(null, void 0, e);
+		return n.#i(t, s, 0, e), s;
+	}
+	toMMPattern() {
+		if (this !== this.#t) return this.#t.toMMPattern();
+		let t = this.toString(), [e, s, i, r] = this.toRegExpSource();
+		if (!(i || this.#s || this.#h.nocase && !this.#h.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase())) return s;
+		let h = (this.#h.nocase ? "i" : "") + (r ? "u" : "");
+		return Object.assign(new RegExp(`^${e}$`, h), {
+			_src: e,
+			_glob: t
+		});
+	}
+	get options() {
+		return this.#h;
+	}
+	toRegExpSource(t) {
+		let e = t ?? !!this.#h.dot;
+		if (this.#t === this && this.#a(), !this.type) {
+			let a = this.isStart() && this.isEnd() && !this.#r.some((f) => typeof f != "string"), l = this.#r.map((f) => {
+				let [m, p, w, g] = typeof f == "string" ? n.#E(f, this.#s, a) : f.toRegExpSource(t);
+				return this.#s = this.#s || w, this.#n = this.#n || g, m;
+			}).join(""), u = "";
+			if (this.isStart() && typeof this.#r[0] == "string" && !(this.#r.length === 1 && Ts.has(this.#r[0]))) {
+				let m = Cs, p = e && m.has(l.charAt(0)) || l.startsWith("\\.") && m.has(l.charAt(2)) || l.startsWith("\\.\\.") && m.has(l.charAt(4)), w = !e && !t && m.has(l.charAt(0));
+				u = p ? vs : w ? Ct : "";
+			}
+			let c = "";
+			return this.isEnd() && this.#t.#c && this.#o?.type === "!" && (c = "(?:$|\\/)"), [
+				u + l + c,
+				W(l),
+				this.#s = !!this.#s,
+				this.#n
+			];
+		}
+		let s = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:", r = this.#d(e);
+		if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+			let a = this.toString();
+			return this.#r = [a], this.type = null, this.#s = void 0, [
+				a,
+				W(this.toString()),
+				!1,
+				!1
+			];
+		}
+		let o = !s || t || e || !Ct ? "" : this.#d(!0);
+		o === r && (o = ""), o && (r = `(?:${r})(?:${o})*?`);
+		let h = "";
+		if (this.type === "!" && this.#f) h = (this.isStart() && !e ? Ct : "") + Ee;
+		else {
+			let a = this.type === "!" ? "))" + (this.isStart() && !e && !t ? Ct : "") + Se + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : `)${this.type}`;
+			h = i + r + a;
+		}
+		return [
+			h,
+			W(r),
+			this.#s = !!this.#s,
+			this.#n
+		];
+	}
+	#d(t) {
+		return this.#r.map((e) => {
+			if (typeof e == "string") throw new Error("string type in extglob ast??");
+			let [s, i, r, o] = e.toRegExpSource(t);
+			return this.#n = this.#n || o, s;
+		}).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+	}
+	static #E(t, e, s = !1) {
+		let i = !1, r = "", o = !1, h = !1;
+		for (let a = 0; a < t.length; a++) {
+			let l = t.charAt(a);
+			if (i) {
+				i = !1, r += (As.has(l) ? "\\" : "") + l;
+				continue;
+			}
+			if (l === "*") {
+				if (h) continue;
+				h = !0, r += s && /^[*]+$/.test(t) ? Ee : Se, e = !0;
+				continue;
+			} else h = !1;
+			if (l === "\\") {
+				a === t.length - 1 ? r += "\\\\" : i = !0;
+				continue;
+			}
+			if (l === "[") {
+				let [u, c, d, f] = ye(t, a);
+				if (d) {
+					r += u, o = o || c, a += d - 1, e = e || f;
+					continue;
+				}
+			}
+			if (l === "?") {
+				r += Kt, e = !0;
+				continue;
+			}
+			r += ks(l);
+		}
+		return [
+			r,
+			W(t),
+			!!e,
+			o
+		];
+	}
+};
+var tt = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !1 } = {}) => e ? t ? n.replace(/[?*()[\]{}]/g, "[$&]") : n.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? n.replace(/[?*()[\]]/g, "[$&]") : n.replace(/[?*()[\]\\]/g, "\\$&");
+var O = (n, t, e = {}) => (at(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new D(t, e).match(n));
+var Rs = /^\*+([^+@!?\*\[\(]*)$/;
+var Os = (n) => (t) => !t.startsWith(".") && t.endsWith(n);
+var Fs = (n) => (t) => t.endsWith(n);
+var Ds = (n) => (n = n.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(n));
+var Ms = (n) => (n = n.toLowerCase(), (t) => t.toLowerCase().endsWith(n));
+var Ns = /^\*+\.\*+$/;
+var _s = (n) => !n.startsWith(".") && n.includes(".");
+var Ls = (n) => n !== "." && n !== ".." && n.includes(".");
+var Ws = /^\.\*+$/;
+var Ps = (n) => n !== "." && n !== ".." && n.startsWith(".");
+var js = /^\*+$/;
+var Is = (n) => n.length !== 0 && !n.startsWith(".");
+var zs = (n) => n.length !== 0 && n !== "." && n !== "..";
+var Bs = /^\?+([^+@!?\*\[\(]*)?$/;
+var Us = ([n, t = ""]) => {
+	let e = Ce([n]);
+	return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+};
+var $s = ([n, t = ""]) => {
+	let e = Te([n]);
+	return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+};
+var Gs = ([n, t = ""]) => {
+	let e = Te([n]);
+	return t ? (s) => e(s) && s.endsWith(t) : e;
+};
+var Hs = ([n, t = ""]) => {
+	let e = Ce([n]);
+	return t ? (s) => e(s) && s.endsWith(t) : e;
+};
+var Ce = ([n]) => {
+	let t = n.length;
+	return (e) => e.length === t && !e.startsWith(".");
+};
+var Te = ([n]) => {
+	let t = n.length;
+	return (e) => e.length === t && e !== "." && e !== "..";
+};
+var Ae = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var xe = {
+	win32: { sep: "\\" },
+	posix: { sep: "/" }
+};
+O.sep = Ae === "win32" ? xe.win32.sep : xe.posix.sep;
+var A = Symbol("globstar **");
+O.GLOBSTAR = A;
+var Vs = "[^/]*?";
+var Ys = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var Xs = "(?:(?!(?:\\/|^)\\.).)*?";
+var Js = (n, t = {}) => (e) => O(e, n, t);
+O.filter = Js;
+var N = (n, t = {}) => Object.assign({}, n, t);
+var Zs = (n) => {
+	if (!n || typeof n != "object" || !Object.keys(n).length) return O;
+	let t = O;
+	return Object.assign((s, i, r = {}) => t(s, i, N(n, r)), {
+		Minimatch: class extends t.Minimatch {
+			constructor(i, r = {}) {
+				super(i, N(n, r));
+			}
+			static defaults(i) {
+				return t.defaults(N(n, i)).Minimatch;
+			}
+		},
+		AST: class extends t.AST {
+			constructor(i, r, o = {}) {
+				super(i, r, N(n, o));
+			}
+			static fromGlob(i, r = {}) {
+				return t.AST.fromGlob(i, N(n, r));
+			}
+		},
+		unescape: (s, i = {}) => t.unescape(s, N(n, i)),
+		escape: (s, i = {}) => t.escape(s, N(n, i)),
+		filter: (s, i = {}) => t.filter(s, N(n, i)),
+		defaults: (s) => t.defaults(N(n, s)),
+		makeRe: (s, i = {}) => t.makeRe(s, N(n, i)),
+		braceExpand: (s, i = {}) => t.braceExpand(s, N(n, i)),
+		match: (s, i, r = {}) => t.match(s, i, N(n, r)),
+		sep: t.sep,
+		GLOBSTAR: A
+	});
+};
+O.defaults = Zs;
+var ke = (n, t = {}) => (at(n), t.nobrace || !/\{(?:(?!\{).)*\}/.test(n) ? [n] : ge(n, { max: t.braceExpandMax }));
+O.braceExpand = ke;
+var Qs = (n, t = {}) => new D(n, t).makeRe();
+O.makeRe = Qs;
+var ti = (n, t, e = {}) => {
+	let s = new D(t, e);
+	return n = n.filter((i) => s.match(i)), s.options.nonull && !n.length && n.push(t), n;
+};
+O.match = ti;
+var ve = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var ei = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var D = class {
+	options;
+	set;
+	pattern;
+	windowsPathsNoEscape;
+	nonegate;
+	negate;
+	comment;
+	empty;
+	preserveMultipleSlashes;
+	partial;
+	globSet;
+	globParts;
+	nocase;
+	isWindows;
+	platform;
+	windowsNoMagicRoot;
+	regexp;
+	constructor(t, e = {}) {
+		at(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || Ae, this.isWindows = this.platform === "win32";
+		let s = "allowWindowsEscape";
+		this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e[s] === !1, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!e.nonegate, this.comment = !1, this.empty = !1, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+	}
+	hasMagic() {
+		if (this.options.magicalBraces && this.set.length > 1) return !0;
+		for (let t of this.set) for (let e of t) if (typeof e != "string") return !0;
+		return !1;
+	}
+	debug(...t) {}
+	make() {
+		let t = this.pattern, e = this.options;
+		if (!e.nocomment && t.charAt(0) === "#") {
+			this.comment = !0;
+			return;
+		}
+		if (!t) {
+			this.empty = !0;
+			return;
+		}
+		this.parseNegate(), this.globSet = [...new Set(this.braceExpand())], e.debug && (this.debug = (...r) => console.error(...r)), this.debug(this.pattern, this.globSet);
+		let s = this.globSet.map((r) => this.slashSplit(r));
+		this.globParts = this.preprocess(s), this.debug(this.pattern, this.globParts);
+		let i = this.globParts.map((r, o, h) => {
+			if (this.isWindows && this.windowsNoMagicRoot) {
+				let a = r[0] === "" && r[1] === "" && (r[2] === "?" || !ve.test(r[2])) && !ve.test(r[3]), l = /^[a-z]:/i.test(r[0]);
+				if (a) return [...r.slice(0, 4), ...r.slice(4).map((u) => this.parse(u))];
+				if (l) return [r[0], ...r.slice(1).map((u) => this.parse(u))];
+			}
+			return r.map((a) => this.parse(a));
+		});
+		if (this.debug(this.pattern, i), this.set = i.filter((r) => r.indexOf(!1) === -1), this.isWindows) for (let r = 0; r < this.set.length; r++) {
+			let o = this.set[r];
+			o[0] === "" && o[1] === "" && this.globParts[r][2] === "?" && typeof o[3] == "string" && /^[a-z]:$/i.test(o[3]) && (o[2] = "?");
+		}
+		this.debug(this.pattern, this.set);
+	}
+	preprocess(t) {
+		if (this.options.noglobstar) for (let s = 0; s < t.length; s++) for (let i = 0; i < t[s].length; i++) t[s][i] === "**" && (t[s][i] = "*");
+		let { optimizationLevel: e = 1 } = this.options;
+		return e >= 2 ? (t = this.firstPhasePreProcess(t), t = this.secondPhasePreProcess(t)) : e >= 1 ? t = this.levelOneOptimize(t) : t = this.adjascentGlobstarOptimize(t), t;
+	}
+	adjascentGlobstarOptimize(t) {
+		return t.map((e) => {
+			let s = -1;
+			for (; (s = e.indexOf("**", s + 1)) !== -1;) {
+				let i = s;
+				for (; e[i + 1] === "**";) i++;
+				i !== s && e.splice(s, i - s);
+			}
+			return e;
+		});
+	}
+	levelOneOptimize(t) {
+		return t.map((e) => (e = e.reduce((s, i) => {
+			let r = s[s.length - 1];
+			return i === "**" && r === "**" ? s : i === ".." && r && r !== ".." && r !== "." && r !== "**" ? (s.pop(), s) : (s.push(i), s);
+		}, []), e.length === 0 ? [""] : e));
+	}
+	levelTwoFileOptimize(t) {
+		Array.isArray(t) || (t = this.slashSplit(t));
+		let e = !1;
+		do {
+			if (e = !1, !this.preserveMultipleSlashes) {
+				for (let i = 1; i < t.length - 1; i++) {
+					let r = t[i];
+					i === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = !0, t.splice(i, 1), i--);
+				}
+				t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+			}
+			let s = 0;
+			for (; (s = t.indexOf("..", s + 1)) !== -1;) {
+				let i = t[s - 1];
+				i && i !== "." && i !== ".." && i !== "**" && (e = !0, t.splice(s - 1, 2), s -= 2);
+			}
+		} while (e);
+		return t.length === 0 ? [""] : t;
+	}
+	firstPhasePreProcess(t) {
+		let e = !1;
+		do {
+			e = !1;
+			for (let s of t) {
+				let i = -1;
+				for (; (i = s.indexOf("**", i + 1)) !== -1;) {
+					let o = i;
+					for (; s[o + 1] === "**";) o++;
+					o > i && s.splice(i + 1, o - i);
+					let h = s[i + 1], a = s[i + 2], l = s[i + 3];
+					if (h !== ".." || !a || a === "." || a === ".." || !l || l === "." || l === "..") continue;
+					e = !0, s.splice(i, 1);
+					let u = s.slice(0);
+					u[i] = "**", t.push(u), i--;
+				}
+				if (!this.preserveMultipleSlashes) {
+					for (let o = 1; o < s.length - 1; o++) {
+						let h = s[o];
+						o === 1 && h === "" && s[0] === "" || (h === "." || h === "") && (e = !0, s.splice(o, 1), o--);
+					}
+					s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = !0, s.pop());
+				}
+				let r = 0;
+				for (; (r = s.indexOf("..", r + 1)) !== -1;) {
+					let o = s[r - 1];
+					if (o && o !== "." && o !== ".." && o !== "**") {
+						e = !0;
+						let a = r === 1 && s[r + 1] === "**" ? ["."] : [];
+						s.splice(r - 1, 2, ...a), s.length === 0 && s.push(""), r -= 2;
+					}
+				}
+			}
+		} while (e);
+		return t;
+	}
+	secondPhasePreProcess(t) {
+		for (let e = 0; e < t.length - 1; e++) for (let s = e + 1; s < t.length; s++) {
+			let i = this.partsMatch(t[e], t[s], !this.preserveMultipleSlashes);
+			if (i) {
+				t[e] = [], t[s] = i;
+				break;
+			}
+		}
+		return t.filter((e) => e.length);
+	}
+	partsMatch(t, e, s = !1) {
+		let i = 0, r = 0, o = [], h = "";
+		for (; i < t.length && r < e.length;) if (t[i] === e[r]) o.push(h === "b" ? e[r] : t[i]), i++, r++;
+		else if (s && t[i] === "**" && e[r] === t[i + 1]) o.push(t[i]), i++;
+		else if (s && e[r] === "**" && t[i] === e[r + 1]) o.push(e[r]), r++;
+		else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+			if (h === "b") return !1;
+			h = "a", o.push(t[i]), i++, r++;
+		} else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+			if (h === "a") return !1;
+			h = "b", o.push(e[r]), i++, r++;
+		} else return !1;
+		return t.length === e.length && o;
+	}
+	parseNegate() {
+		if (this.nonegate) return;
+		let t = this.pattern, e = !1, s = 0;
+		for (let i = 0; i < t.length && t.charAt(i) === "!"; i++) e = !e, s++;
+		s && (this.pattern = t.slice(s)), this.negate = e;
+	}
+	matchOne(t, e, s = !1) {
+		let i = this.options;
+		if (this.isWindows) {
+			let p = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), w = !p && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), g = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), S = !g && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), E = w ? 3 : p ? 0 : void 0, y = S ? 3 : g ? 0 : void 0;
+			if (typeof E == "number" && typeof y == "number") {
+				let [b, z] = [t[E], e[y]];
+				b.toLowerCase() === z.toLowerCase() && (e[y] = b, y > E ? e = e.slice(y) : E > y && (t = t.slice(E)));
+			}
+		}
+		let { optimizationLevel: r = 1 } = this.options;
+		r >= 2 && (t = this.levelTwoFileOptimize(t)), this.debug("matchOne", this, {
+			file: t,
+			pattern: e
+		}), this.debug("matchOne", t.length, e.length);
+		for (var o = 0, h = 0, a = t.length, l = e.length; o < a && h < l; o++, h++) {
+			this.debug("matchOne loop");
+			var u = e[h], c = t[o];
+			if (this.debug(e, u, c), u === !1) return !1;
+			if (u === A) {
+				this.debug("GLOBSTAR", [
+					e,
+					u,
+					c
+				]);
+				var d = o, f = h + 1;
+				if (f === l) {
+					for (this.debug("** at the end"); o < a; o++) if (t[o] === "." || t[o] === ".." || !i.dot && t[o].charAt(0) === ".") return !1;
+					return !0;
+				}
+				for (; d < a;) {
+					var m = t[d];
+					if (this.debug(`
+globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) return this.debug("globstar found match!", d, a, m), !0;
+					if (m === "." || m === ".." || !i.dot && m.charAt(0) === ".") {
+						this.debug("dot detected!", t, d, e, f);
+						break;
+					}
+					this.debug("globstar swallow a segment, and continue"), d++;
+				}
+				return !!(s && (this.debug(`
+>>> no match, partial?`, t, d, e, f), d === a));
+			}
+			let p;
+			if (typeof u == "string" ? (p = c === u, this.debug("string match", u, c, p)) : (p = u.test(c), this.debug("pattern match", u, c, p)), !p) return !1;
+		}
+		if (o === a && h === l) return !0;
+		if (o === a) return s;
+		if (h === l) return o === a - 1 && t[o] === "";
+		throw new Error("wtf?");
+	}
+	braceExpand() {
+		return ke(this.pattern, this.options);
+	}
+	parse(t) {
+		at(t);
+		let e = this.options;
+		if (t === "**") return A;
+		if (t === "") return "";
+		let s, i = null;
+		(s = t.match(js)) ? i = e.dot ? zs : Is : (s = t.match(Rs)) ? i = (e.nocase ? e.dot ? Ms : Ds : e.dot ? Fs : Os)(s[1]) : (s = t.match(Bs)) ? i = (e.nocase ? e.dot ? $s : Us : e.dot ? Gs : Hs)(s) : (s = t.match(Ns)) ? i = e.dot ? Ls : _s : (s = t.match(Ws)) && (i = Ps);
+		let r = Q.fromGlob(t, this.options).toMMPattern();
+		return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), r;
+	}
+	makeRe() {
+		if (this.regexp || this.regexp === !1) return this.regexp;
+		let t = this.set;
+		if (!t.length) return this.regexp = !1, this.regexp;
+		let e = this.options, s = e.noglobstar ? Vs : e.dot ? Ys : Xs, i = new Set(e.nocase ? ["i"] : []), r = t.map((a) => {
+			let l = a.map((c) => {
+				if (c instanceof RegExp) for (let d of c.flags.split("")) i.add(d);
+				return typeof c == "string" ? ei(c) : c === A ? A : c._src;
+			});
+			l.forEach((c, d) => {
+				let f = l[d + 1], m = l[d - 1];
+				c !== A || m === A || (m === void 0 ? f !== void 0 && f !== A ? l[d + 1] = "(?:\\/|" + s + "\\/)?" + f : l[d] = s : f === void 0 ? l[d - 1] = m + "(?:\\/|\\/" + s + ")?" : f !== A && (l[d - 1] = m + "(?:\\/|\\/" + s + "\\/)" + f, l[d + 1] = A));
+			});
+			let u = l.filter((c) => c !== A);
+			if (this.partial && u.length >= 1) {
+				let c = [];
+				for (let d = 1; d <= u.length; d++) c.push(u.slice(0, d).join("/"));
+				return "(?:" + c.join("|") + ")";
+			}
+			return u.join("/");
+		}).join("|"), [o, h] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+		r = "^" + o + r + h + "$", this.partial && (r = "^(?:\\/|" + o + r.slice(1, -1) + h + ")$"), this.negate && (r = "^(?!" + r + ").+$");
+		try {
+			this.regexp = new RegExp(r, [...i].join(""));
+		} catch {
+			this.regexp = !1;
+		}
+		return this.regexp;
+	}
+	slashSplit(t) {
+		return this.preserveMultipleSlashes ? t.split("/") : this.isWindows && /^\/\/[^\/]+/.test(t) ? ["", ...t.split(/\/+/)] : t.split(/\/+/);
+	}
+	match(t, e = this.partial) {
+		if (this.debug("match", t, this.pattern), this.comment) return !1;
+		if (this.empty) return t === "";
+		if (t === "/" && e) return !0;
+		let s = this.options;
+		this.isWindows && (t = t.split("\\").join("/"));
+		let i = this.slashSplit(t);
+		this.debug(this.pattern, "split", i);
+		let r = this.set;
+		this.debug(this.pattern, "set", r);
+		let o = i[i.length - 1];
+		if (!o) for (let h = i.length - 2; !o && h >= 0; h--) o = i[h];
+		for (let h = 0; h < r.length; h++) {
+			let a = r[h], l = i;
+			if (s.matchBase && a.length === 1 && (l = [o]), this.matchOne(l, a, e)) return s.flipNegate ? !0 : !this.negate;
+		}
+		return s.flipNegate ? !1 : this.negate;
+	}
+	static defaults(t) {
+		return O.defaults(t).Minimatch;
+	}
+};
+O.AST = Q;
+O.Minimatch = D;
+O.escape = tt;
+O.unescape = W;
+var si = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var Oe = /* @__PURE__ */ new Set();
+var Vt = typeof process == "object" && process ? process : {};
+var Fe = (n, t, e, s) => {
+	typeof Vt.emitWarning == "function" ? Vt.emitWarning(n, t, e, s) : console.error(`[${e}] ${t}: ${n}`);
+};
+var At = globalThis.AbortController;
+var Re = globalThis.AbortSignal;
+if (typeof At > "u") {
+	Re = class {
+		onabort;
+		_onabort = [];
+		reason;
+		aborted = !1;
+		addEventListener(e, s) {
+			this._onabort.push(s);
+		}
+	}, At = class {
+		constructor() {
+			t();
+		}
+		signal = new Re();
+		abort(e) {
+			if (!this.signal.aborted) {
+				this.signal.reason = e, this.signal.aborted = !0;
+				for (let s of this.signal._onabort) s(e);
+				this.signal.onabort?.(e);
+			}
+		}
+	};
+	let n = Vt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+		n && (n = !1, Fe("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+	};
+}
+var ii = (n) => !Oe.has(n);
+var q = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+var De = (n) => q(n) ? n <= Math.pow(2, 8) ? Uint8Array : n <= Math.pow(2, 16) ? Uint16Array : n <= Math.pow(2, 32) ? Uint32Array : n <= Number.MAX_SAFE_INTEGER ? Tt : null : null;
+var Tt = class extends Array {
+	constructor(n) {
+		super(n), this.fill(0);
+	}
+};
+var ri = class ct {
+	heap;
+	length;
+	static #t = !1;
+	static create(t) {
+		let e = De(t);
+		if (!e) return [];
+		ct.#t = !0;
+		let s = new ct(t, e);
+		return ct.#t = !1, s;
+	}
+	constructor(t, e) {
+		if (!ct.#t) throw new TypeError("instantiate Stack using Stack.create(n)");
+		this.heap = new e(t), this.length = 0;
+	}
+	push(t) {
+		this.heap[this.length++] = t;
+	}
+	pop() {
+		return this.heap[--this.length];
+	}
+};
+var ft = class Me {
+	#t;
+	#s;
+	#n;
+	#r;
+	#o;
+	#S;
+	#w;
+	#c;
+	get perf() {
+		return this.#c;
+	}
+	ttl;
+	ttlResolution;
+	ttlAutopurge;
+	updateAgeOnGet;
+	updateAgeOnHas;
+	allowStale;
+	noDisposeOnSet;
+	noUpdateTTL;
+	maxEntrySize;
+	sizeCalculation;
+	noDeleteOnFetchRejection;
+	noDeleteOnStaleGet;
+	allowStaleOnFetchAbort;
+	allowStaleOnFetchRejection;
+	ignoreFetchAbort;
+	#h;
+	#u;
+	#f;
+	#a;
+	#i;
+	#d;
+	#E;
+	#b;
+	#p;
+	#R;
+	#m;
+	#C;
+	#T;
+	#g;
+	#y;
+	#x;
+	#A;
+	#e;
+	#_;
+	static unsafeExposeInternals(t) {
+		return {
+			starts: t.#T,
+			ttls: t.#g,
+			autopurgeTimers: t.#y,
+			sizes: t.#C,
+			keyMap: t.#f,
+			keyList: t.#a,
+			valList: t.#i,
+			next: t.#d,
+			prev: t.#E,
+			get head() {
+				return t.#b;
+			},
+			get tail() {
+				return t.#p;
+			},
+			free: t.#R,
+			isBackgroundFetch: (e) => t.#l(e),
+			backgroundFetch: (e, s, i, r) => t.#U(e, s, i, r),
+			moveToTail: (e) => t.#W(e),
+			indexes: (e) => t.#F(e),
+			rindexes: (e) => t.#D(e),
+			isStale: (e) => t.#v(e)
+		};
+	}
+	get max() {
+		return this.#t;
+	}
+	get maxSize() {
+		return this.#s;
+	}
+	get calculatedSize() {
+		return this.#u;
+	}
+	get size() {
+		return this.#h;
+	}
+	get fetchMethod() {
+		return this.#S;
+	}
+	get memoMethod() {
+		return this.#w;
+	}
+	get dispose() {
+		return this.#n;
+	}
+	get onInsert() {
+		return this.#r;
+	}
+	get disposeAfter() {
+		return this.#o;
+	}
+	constructor(t) {
+		let { max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: r, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: a, dispose: l, onInsert: u, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: f, maxSize: m = 0, maxEntrySize: p = 0, sizeCalculation: w, fetchMethod: g, memoMethod: S, noDeleteOnFetchRejection: E, noDeleteOnStaleGet: y, allowStaleOnFetchRejection: b, allowStaleOnFetchAbort: z, ignoreFetchAbort: $, perf: J } = t;
+		if (J !== void 0 && typeof J?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+		if (this.#c = J ?? si, e !== 0 && !q(e)) throw new TypeError("max option must be a nonnegative integer");
+		let Z = e ? De(e) : Array;
+		if (!Z) throw new Error("invalid max value: " + e);
+		if (this.#t = e, this.#s = m, this.maxEntrySize = p || this.#s, this.sizeCalculation = w, this.sizeCalculation) {
+			if (!this.#s && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+			if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+		}
+		if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+		if (this.#w = S, g !== void 0 && typeof g != "function") throw new TypeError("fetchMethod must be a function if specified");
+		if (this.#S = g, this.#A = !!g, this.#f = /* @__PURE__ */ new Map(), this.#a = new Array(e).fill(void 0), this.#i = new Array(e).fill(void 0), this.#d = new Z(e), this.#E = new Z(e), this.#b = 0, this.#p = 0, this.#R = ri.create(e), this.#h = 0, this.#u = 0, typeof l == "function" && (this.#n = l), typeof u == "function" && (this.#r = u), typeof c == "function" ? (this.#o = c, this.#m = []) : (this.#o = void 0, this.#m = void 0), this.#x = !!this.#n, this.#_ = !!this.#r, this.#e = !!this.#o, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!f, this.noDeleteOnFetchRejection = !!E, this.allowStaleOnFetchRejection = !!b, this.allowStaleOnFetchAbort = !!z, this.ignoreFetchAbort = !!$, this.maxEntrySize !== 0) {
+			if (this.#s !== 0 && !q(this.#s)) throw new TypeError("maxSize must be a positive integer if specified");
+			if (!q(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+			this.#G();
+		}
+		if (this.allowStale = !!a, this.noDeleteOnStaleGet = !!y, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = q(i) || i === 0 ? i : 1, this.ttlAutopurge = !!r, this.ttl = s || 0, this.ttl) {
+			if (!q(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+			this.#M();
+		}
+		if (this.#t === 0 && this.ttl === 0 && this.#s === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+		if (!this.ttlAutopurge && !this.#t && !this.#s) {
+			let $t = "LRU_CACHE_UNBOUNDED";
+			ii($t) && (Oe.add($t), Fe("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", $t, Me));
+		}
+	}
+	getRemainingTTL(t) {
+		return this.#f.has(t) ? 1 / 0 : 0;
+	}
+	#M() {
+		let t = new Tt(this.#t), e = new Tt(this.#t);
+		this.#g = t, this.#T = e;
+		let s = this.ttlAutopurge ? new Array(this.#t) : void 0;
+		this.#y = s, this.#j = (o, h, a = this.#c.now()) => {
+			if (e[o] = h !== 0 ? a : 0, t[o] = h, s?.[o] && (clearTimeout(s[o]), s[o] = void 0), h !== 0 && s) {
+				let l = setTimeout(() => {
+					this.#v(o) && this.#O(this.#a[o], "expire");
+				}, h + 1);
+				l.unref && l.unref(), s[o] = l;
+			}
+		}, this.#k = (o) => {
+			e[o] = t[o] !== 0 ? this.#c.now() : 0;
+		}, this.#N = (o, h) => {
+			if (t[h]) {
+				let a = t[h], l = e[h];
+				if (!a || !l) return;
+				o.ttl = a, o.start = l, o.now = i || r();
+				o.remainingTTL = a - (o.now - l);
+			}
+		};
+		let i = 0, r = () => {
+			let o = this.#c.now();
+			if (this.ttlResolution > 0) {
+				i = o;
+				let h = setTimeout(() => i = 0, this.ttlResolution);
+				h.unref && h.unref();
+			}
+			return o;
+		};
+		this.getRemainingTTL = (o) => {
+			let h = this.#f.get(o);
+			if (h === void 0) return 0;
+			let a = t[h], l = e[h];
+			if (!a || !l) return 1 / 0;
+			return a - ((i || r()) - l);
+		}, this.#v = (o) => {
+			let h = e[o], a = t[o];
+			return !!a && !!h && (i || r()) - h > a;
+		};
+	}
+	#k = () => {};
+	#N = () => {};
+	#j = () => {};
+	#v = () => !1;
+	#G() {
+		let t = new Tt(this.#t);
+		this.#u = 0, this.#C = t, this.#P = (e) => {
+			this.#u -= t[e], t[e] = 0;
+		}, this.#I = (e, s, i, r) => {
+			if (this.#l(s)) return 0;
+			if (!q(i)) if (r) {
+				if (typeof r != "function") throw new TypeError("sizeCalculation must be a function");
+				if (i = r(s, e), !q(i)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+			} else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+			return i;
+		}, this.#L = (e, s, i) => {
+			if (t[e] = s, this.#s) {
+				let r = this.#s - t[e];
+				for (; this.#u > r;) this.#B(!0);
+			}
+			this.#u += t[e], i && (i.entrySize = s, i.totalCalculatedSize = this.#u);
+		};
+	}
+	#P = (t) => {};
+	#L = (t, e, s) => {};
+	#I = (t, e, s, i) => {
+		if (s || i) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+		return 0;
+	};
+	*#F({ allowStale: t = this.allowStale } = {}) {
+		if (this.#h) for (let e = this.#p; !(!this.#z(e) || ((t || !this.#v(e)) && (yield e), e === this.#b));) e = this.#E[e];
+	}
+	*#D({ allowStale: t = this.allowStale } = {}) {
+		if (this.#h) for (let e = this.#b; !(!this.#z(e) || ((t || !this.#v(e)) && (yield e), e === this.#p));) e = this.#d[e];
+	}
+	#z(t) {
+		return t !== void 0 && this.#f.get(this.#a[t]) === t;
+	}
+	*entries() {
+		for (let t of this.#F()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+	}
+	*rentries() {
+		for (let t of this.#D()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+	}
+	*keys() {
+		for (let t of this.#F()) {
+			let e = this.#a[t];
+			e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+		}
+	}
+	*rkeys() {
+		for (let t of this.#D()) {
+			let e = this.#a[t];
+			e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+		}
+	}
+	*values() {
+		for (let t of this.#F()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
+	}
+	*rvalues() {
+		for (let t of this.#D()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	[Symbol.toStringTag] = "LRUCache";
+	find(t, e = {}) {
+		for (let s of this.#F()) {
+			let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+			if (r !== void 0 && t(r, this.#a[s], this)) return this.get(this.#a[s], e);
+		}
+	}
+	forEach(t, e = this) {
+		for (let s of this.#F()) {
+			let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+			r !== void 0 && t.call(e, r, this.#a[s], this);
+		}
+	}
+	rforEach(t, e = this) {
+		for (let s of this.#D()) {
+			let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+			r !== void 0 && t.call(e, r, this.#a[s], this);
+		}
+	}
+	purgeStale() {
+		let t = !1;
+		for (let e of this.#D({ allowStale: !0 })) this.#v(e) && (this.#O(this.#a[e], "expire"), t = !0);
+		return t;
+	}
+	info(t) {
+		let e = this.#f.get(t);
+		if (e === void 0) return;
+		let s = this.#i[e], i = this.#l(s) ? s.__staleWhileFetching : s;
+		if (i === void 0) return;
+		let r = { value: i };
+		if (this.#g && this.#T) {
+			let o = this.#g[e], h = this.#T[e];
+			if (o && h) r.ttl = o - (this.#c.now() - h), r.start = Date.now();
+		}
+		return this.#C && (r.size = this.#C[e]), r;
+	}
+	dump() {
+		let t = [];
+		for (let e of this.#F({ allowStale: !0 })) {
+			let s = this.#a[e], i = this.#i[e], r = this.#l(i) ? i.__staleWhileFetching : i;
+			if (r === void 0 || s === void 0) continue;
+			let o = { value: r };
+			if (this.#g && this.#T) {
+				o.ttl = this.#g[e];
+				let h = this.#c.now() - this.#T[e];
+				o.start = Math.floor(Date.now() - h);
+			}
+			this.#C && (o.size = this.#C[e]), t.unshift([s, o]);
+		}
+		return t;
+	}
+	load(t) {
+		this.clear();
+		for (let [e, s] of t) {
+			if (s.start) {
+				let i = Date.now() - s.start;
+				s.start = this.#c.now() - i;
+			}
+			this.set(e, s.value, s);
+		}
+	}
+	set(t, e, s = {}) {
+		if (e === void 0) return this.delete(t), this;
+		let { ttl: i = this.ttl, start: r, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: a } = s, { noUpdateTTL: l = this.noUpdateTTL } = s, u = this.#I(t, e, s.size || 0, h);
+		if (this.maxEntrySize && u > this.maxEntrySize) return a && (a.set = "miss", a.maxEntrySizeExceeded = !0), this.#O(t, "set"), this;
+		let c = this.#h === 0 ? void 0 : this.#f.get(t);
+		if (c === void 0) c = this.#h === 0 ? this.#p : this.#R.length !== 0 ? this.#R.pop() : this.#h === this.#t ? this.#B(!1) : this.#h, this.#a[c] = t, this.#i[c] = e, this.#f.set(t, c), this.#d[this.#p] = c, this.#E[c] = this.#p, this.#p = c, this.#h++, this.#L(c, u, a), a && (a.set = "add"), l = !1, this.#_ && this.#r?.(e, t, "add");
+		else {
+			this.#W(c);
+			let d = this.#i[c];
+			if (e !== d) {
+				if (this.#A && this.#l(d)) {
+					d.__abortController.abort(/* @__PURE__ */ new Error("replaced"));
+					let { __staleWhileFetching: f } = d;
+					f !== void 0 && !o && (this.#x && this.#n?.(f, t, "set"), this.#e && this.#m?.push([
+						f,
+						t,
+						"set"
+					]));
+				} else o || (this.#x && this.#n?.(d, t, "set"), this.#e && this.#m?.push([
+					d,
+					t,
+					"set"
+				]));
+				if (this.#P(c), this.#L(c, u, a), this.#i[c] = e, a) {
+					a.set = "replace";
+					let f = d && this.#l(d) ? d.__staleWhileFetching : d;
+					f !== void 0 && (a.oldValue = f);
+				}
+			} else a && (a.set = "update");
+			this.#_ && this.onInsert?.(e, t, e === d ? "update" : "replace");
+		}
+		if (i !== 0 && !this.#g && this.#M(), this.#g && (l || this.#j(c, i, r), a && this.#N(a, c)), !o && this.#e && this.#m) {
+			let d = this.#m, f;
+			for (; f = d?.shift();) this.#o?.(...f);
+		}
+		return this;
+	}
+	pop() {
+		try {
+			for (; this.#h;) {
+				let t = this.#i[this.#b];
+				if (this.#B(!0), this.#l(t)) {
+					if (t.__staleWhileFetching) return t.__staleWhileFetching;
+				} else if (t !== void 0) return t;
+			}
+		} finally {
+			if (this.#e && this.#m) {
+				let t = this.#m, e;
+				for (; e = t?.shift();) this.#o?.(...e);
+			}
+		}
+	}
+	#B(t) {
+		let e = this.#b, s = this.#a[e], i = this.#i[e];
+		return this.#A && this.#l(i) ? i.__abortController.abort(/* @__PURE__ */ new Error("evicted")) : (this.#x || this.#e) && (this.#x && this.#n?.(i, s, "evict"), this.#e && this.#m?.push([
+			i,
+			s,
+			"evict"
+		])), this.#P(e), this.#y?.[e] && (clearTimeout(this.#y[e]), this.#y[e] = void 0), t && (this.#a[e] = void 0, this.#i[e] = void 0, this.#R.push(e)), this.#h === 1 ? (this.#b = this.#p = 0, this.#R.length = 0) : this.#b = this.#d[e], this.#f.delete(s), this.#h--, e;
+	}
+	has(t, e = {}) {
+		let { updateAgeOnHas: s = this.updateAgeOnHas, status: i } = e, r = this.#f.get(t);
+		if (r !== void 0) {
+			let o = this.#i[r];
+			if (this.#l(o) && o.__staleWhileFetching === void 0) return !1;
+			if (this.#v(r)) i && (i.has = "stale", this.#N(i, r));
+			else return s && this.#k(r), i && (i.has = "hit", this.#N(i, r)), !0;
+		} else i && (i.has = "miss");
+		return !1;
+	}
+	peek(t, e = {}) {
+		let { allowStale: s = this.allowStale } = e, i = this.#f.get(t);
+		if (i === void 0 || !s && this.#v(i)) return;
+		let r = this.#i[i];
+		return this.#l(r) ? r.__staleWhileFetching : r;
+	}
+	#U(t, e, s, i) {
+		let r = e === void 0 ? void 0 : this.#i[e];
+		if (this.#l(r)) return r;
+		let o = new At(), { signal: h } = s;
+		h?.addEventListener("abort", () => o.abort(h.reason), { signal: o.signal });
+		let a = {
+			signal: o.signal,
+			options: s,
+			context: i
+		}, l = (p, w = !1) => {
+			let { aborted: g } = o.signal, S = s.ignoreFetchAbort && p !== void 0, E = s.ignoreFetchAbort || !!(s.allowStaleOnFetchAbort && p !== void 0);
+			if (s.status && (g && !w ? (s.status.fetchAborted = !0, s.status.fetchError = o.signal.reason, S && (s.status.fetchAbortIgnored = !0)) : s.status.fetchResolved = !0), g && !S && !w) return c(o.signal.reason, E);
+			let y = f, b = this.#i[e];
+			return (b === f || S && w && b === void 0) && (p === void 0 ? y.__staleWhileFetching !== void 0 ? this.#i[e] = y.__staleWhileFetching : this.#O(t, "fetch") : (s.status && (s.status.fetchUpdated = !0), this.set(t, p, a.options))), p;
+		}, u = (p) => (s.status && (s.status.fetchRejected = !0, s.status.fetchError = p), c(p, !1)), c = (p, w) => {
+			let { aborted: g } = o.signal, S = g && s.allowStaleOnFetchAbort, E = S || s.allowStaleOnFetchRejection, y = E || s.noDeleteOnFetchRejection, b = f;
+			if (this.#i[e] === f && (!y || !w && b.__staleWhileFetching === void 0 ? this.#O(t, "fetch") : S || (this.#i[e] = b.__staleWhileFetching)), E) return s.status && b.__staleWhileFetching !== void 0 && (s.status.returnedStale = !0), b.__staleWhileFetching;
+			if (b.__returned === b) throw p;
+		}, d = (p, w) => {
+			let g = this.#S?.(t, r, a);
+			g && g instanceof Promise && g.then((S) => p(S === void 0 ? void 0 : S), w), o.signal.addEventListener("abort", () => {
+				(!s.ignoreFetchAbort || s.allowStaleOnFetchAbort) && (p(void 0), s.allowStaleOnFetchAbort && (p = (S) => l(S, !0)));
+			});
+		};
+		s.status && (s.status.fetchDispatched = !0);
+		let f = new Promise(d).then(l, u), m = Object.assign(f, {
+			__abortController: o,
+			__staleWhileFetching: r,
+			__returned: void 0
+		});
+		return e === void 0 ? (this.set(t, m, {
+			...a.options,
+			status: void 0
+		}), e = this.#f.get(t)) : this.#i[e] = m, m;
+	}
+	#l(t) {
+		if (!this.#A) return !1;
+		let e = t;
+		return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof At;
+	}
+	async fetch(t, e = {}) {
+		let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: a = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: u = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: f = this.ignoreFetchAbort, allowStaleOnFetchAbort: m = this.allowStaleOnFetchAbort, context: p, forceRefresh: w = !1, status: g, signal: S } = e;
+		if (!this.#A) return g && (g.fetch = "get"), this.get(t, {
+			allowStale: s,
+			updateAgeOnGet: i,
+			noDeleteOnStaleGet: r,
+			status: g
+		});
+		let E = {
+			allowStale: s,
+			updateAgeOnGet: i,
+			noDeleteOnStaleGet: r,
+			ttl: o,
+			noDisposeOnSet: h,
+			size: a,
+			sizeCalculation: l,
+			noUpdateTTL: u,
+			noDeleteOnFetchRejection: c,
+			allowStaleOnFetchRejection: d,
+			allowStaleOnFetchAbort: m,
+			ignoreFetchAbort: f,
+			status: g,
+			signal: S
+		}, y = this.#f.get(t);
+		if (y === void 0) {
+			g && (g.fetch = "miss");
+			let b = this.#U(t, y, E, p);
+			return b.__returned = b;
+		} else {
+			let b = this.#i[y];
+			if (this.#l(b)) {
+				let Z = s && b.__staleWhileFetching !== void 0;
+				return g && (g.fetch = "inflight", Z && (g.returnedStale = !0)), Z ? b.__staleWhileFetching : b.__returned = b;
+			}
+			let z = this.#v(y);
+			if (!w && !z) return g && (g.fetch = "hit"), this.#W(y), i && this.#k(y), g && this.#N(g, y), b;
+			let $ = this.#U(t, y, E, p), J = $.__staleWhileFetching !== void 0 && s;
+			return g && (g.fetch = z ? "stale" : "refresh", J && z && (g.returnedStale = !0)), J ? $.__staleWhileFetching : $.__returned = $;
+		}
+	}
+	async forceFetch(t, e = {}) {
+		let s = await this.fetch(t, e);
+		if (s === void 0) throw new Error("fetch() returned undefined");
+		return s;
+	}
+	memo(t, e = {}) {
+		let s = this.#w;
+		if (!s) throw new Error("no memoMethod provided to constructor");
+		let { context: i, forceRefresh: r, ...o } = e, h = this.get(t, o);
+		if (!r && h !== void 0) return h;
+		let a = s(t, h, {
+			options: o,
+			context: i
+		});
+		return this.set(t, a, o), a;
+	}
+	get(t, e = {}) {
+		let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, status: o } = e, h = this.#f.get(t);
+		if (h !== void 0) {
+			let a = this.#i[h], l = this.#l(a);
+			return o && this.#N(o, h), this.#v(h) ? (o && (o.get = "stale"), l ? (o && s && a.__staleWhileFetching !== void 0 && (o.returnedStale = !0), s ? a.__staleWhileFetching : void 0) : (r || this.#O(t, "expire"), o && s && (o.returnedStale = !0), s ? a : void 0)) : (o && (o.get = "hit"), l ? a.__staleWhileFetching : (this.#W(h), i && this.#k(h), a));
+		} else o && (o.get = "miss");
+	}
+	#$(t, e) {
+		this.#E[e] = t, this.#d[t] = e;
+	}
+	#W(t) {
+		t !== this.#p && (t === this.#b ? this.#b = this.#d[t] : this.#$(this.#E[t], this.#d[t]), this.#$(this.#p, t), this.#p = t);
+	}
+	delete(t) {
+		return this.#O(t, "delete");
+	}
+	#O(t, e) {
+		let s = !1;
+		if (this.#h !== 0) {
+			let i = this.#f.get(t);
+			if (i !== void 0) if (this.#y?.[i] && (clearTimeout(this.#y?.[i]), this.#y[i] = void 0), s = !0, this.#h === 1) this.#H(e);
+			else {
+				this.#P(i);
+				let r = this.#i[i];
+				if (this.#l(r) ? r.__abortController.abort(/* @__PURE__ */ new Error("deleted")) : (this.#x || this.#e) && (this.#x && this.#n?.(r, t, e), this.#e && this.#m?.push([
+					r,
+					t,
+					e
+				])), this.#f.delete(t), this.#a[i] = void 0, this.#i[i] = void 0, i === this.#p) this.#p = this.#E[i];
+				else if (i === this.#b) this.#b = this.#d[i];
+				else {
+					let o = this.#E[i];
+					this.#d[o] = this.#d[i];
+					let h = this.#d[i];
+					this.#E[h] = this.#E[i];
+				}
+				this.#h--, this.#R.push(i);
+			}
+		}
+		if (this.#e && this.#m?.length) {
+			let i = this.#m, r;
+			for (; r = i?.shift();) this.#o?.(...r);
+		}
+		return s;
+	}
+	clear() {
+		return this.#H("delete");
+	}
+	#H(t) {
+		for (let e of this.#D({ allowStale: !0 })) {
+			let s = this.#i[e];
+			if (this.#l(s)) s.__abortController.abort(/* @__PURE__ */ new Error("deleted"));
+			else {
+				let i = this.#a[e];
+				this.#x && this.#n?.(s, i, t), this.#e && this.#m?.push([
+					s,
+					i,
+					t
+				]);
+			}
+		}
+		if (this.#f.clear(), this.#i.fill(void 0), this.#a.fill(void 0), this.#g && this.#T) {
+			this.#g.fill(0), this.#T.fill(0);
+			for (let e of this.#y ?? []) e !== void 0 && clearTimeout(e);
+			this.#y?.fill(void 0);
+		}
+		if (this.#C && this.#C.fill(0), this.#b = 0, this.#p = 0, this.#R.length = 0, this.#u = 0, this.#h = 0, this.#e && this.#m) {
+			let e = this.#m, s;
+			for (; s = e?.shift();) this.#o?.(...s);
+		}
+	}
+};
+var Ne = typeof process == "object" && process ? process : {
+	stdout: null,
+	stderr: null
+};
+var oi = (n) => !!n && typeof n == "object" && (n instanceof V || n instanceof Pe || hi(n) || ai(n));
+var hi = (n) => !!n && typeof n == "object" && n instanceof EventEmitter && typeof n.pipe == "function" && n.pipe !== Pe.Writable.prototype.pipe;
+var ai = (n) => !!n && typeof n == "object" && n instanceof EventEmitter && typeof n.write == "function" && typeof n.end == "function";
+var G = Symbol("EOF");
+var H = Symbol("maybeEmitEnd");
+var K = Symbol("emittedEnd");
+var kt = Symbol("emittingEnd");
+var ut = Symbol("emittedError");
+var Rt = Symbol("closed");
+var _e = Symbol("read");
+var Ot = Symbol("flush");
+var Le = Symbol("flushChunk");
+var P = Symbol("encoding");
+var et = Symbol("decoder");
+var v = Symbol("flowing");
+var dt = Symbol("paused");
+var st = Symbol("resume");
+var C = Symbol("buffer");
+var F = Symbol("pipes");
+var T = Symbol("bufferLength");
+var Yt = Symbol("bufferPush");
+var Ft = Symbol("bufferShift");
+var k = Symbol("objectMode");
+var x = Symbol("destroyed");
+var Xt = Symbol("error");
+var Jt = Symbol("emitData");
+var We = Symbol("emitEnd");
+var Zt = Symbol("emitEnd2");
+var B = Symbol("async");
+var Qt = Symbol("abort");
+var Dt = Symbol("aborted");
+var pt = Symbol("signal");
+var Y = Symbol("dataListeners");
+var M = Symbol("discarded");
+var mt = (n) => Promise.resolve().then(n);
+var li = (n) => n();
+var ci = (n) => n === "end" || n === "finish" || n === "prefinish";
+var fi = (n) => n instanceof ArrayBuffer || !!n && typeof n == "object" && n.constructor && n.constructor.name === "ArrayBuffer" && n.byteLength >= 0;
+var ui = (n) => !Buffer.isBuffer(n) && ArrayBuffer.isView(n);
+var Mt = class {
+	src;
+	dest;
+	opts;
+	ondrain;
+	constructor(t, e, s) {
+		this.src = t, this.dest = e, this.opts = s, this.ondrain = () => t[st](), this.dest.on("drain", this.ondrain);
+	}
+	unpipe() {
+		this.dest.removeListener("drain", this.ondrain);
+	}
+	proxyErrors(t) {}
+	end() {
+		this.unpipe(), this.opts.end && this.dest.end();
+	}
+};
+var te = class extends Mt {
+	unpipe() {
+		this.src.removeListener("error", this.proxyErrors), super.unpipe();
+	}
+	constructor(t, e, s) {
+		super(t, e, s), this.proxyErrors = (i) => this.dest.emit("error", i), t.on("error", this.proxyErrors);
+	}
+};
+var di = (n) => !!n.objectMode;
+var pi = (n) => !n.objectMode && !!n.encoding && n.encoding !== "buffer";
+var V = class extends EventEmitter {
+	[v] = !1;
+	[dt] = !1;
+	[F] = [];
+	[C] = [];
+	[k];
+	[P];
+	[B];
+	[et];
+	[G] = !1;
+	[K] = !1;
+	[kt] = !1;
+	[Rt] = !1;
+	[ut] = null;
+	[T] = 0;
+	[x] = !1;
+	[pt];
+	[Dt] = !1;
+	[Y] = 0;
+	[M] = !1;
+	writable = !0;
+	readable = !0;
+	constructor(...t) {
+		let e = t[0] || {};
+		if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
+		di(e) ? (this[k] = !0, this[P] = null) : pi(e) ? (this[P] = e.encoding, this[k] = !1) : (this[k] = !1, this[P] = null), this[B] = !!e.async, this[et] = this[P] ? new StringDecoder(this[P]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[C] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[F] });
+		let { signal: s } = e;
+		s && (this[pt] = s, s.aborted ? this[Qt]() : s.addEventListener("abort", () => this[Qt]()));
+	}
+	get bufferLength() {
+		return this[T];
+	}
+	get encoding() {
+		return this[P];
+	}
+	set encoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	setEncoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	get objectMode() {
+		return this[k];
+	}
+	set objectMode(t) {
+		throw new Error("objectMode must be set at instantiation time");
+	}
+	get async() {
+		return this[B];
+	}
+	set async(t) {
+		this[B] = this[B] || !!t;
+	}
+	[Qt]() {
+		this[Dt] = !0, this.emit("abort", this[pt]?.reason), this.destroy(this[pt]?.reason);
+	}
+	get aborted() {
+		return this[Dt];
+	}
+	set aborted(t) {}
+	write(t, e, s) {
+		if (this[Dt]) return !1;
+		if (this[G]) throw new Error("write after end");
+		if (this[x]) return this.emit("error", Object.assign(/* @__PURE__ */ new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+		typeof e == "function" && (s = e, e = "utf8"), e || (e = "utf8");
+		let i = this[B] ? mt : li;
+		if (!this[k] && !Buffer.isBuffer(t)) {
+			if (ui(t)) t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+			else if (fi(t)) t = Buffer.from(t);
+			else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+		}
+		return this[k] ? (this[v] && this[T] !== 0 && this[Ot](!0), this[v] ? this.emit("data", t) : this[Yt](t), this[T] !== 0 && this.emit("readable"), s && i(s), this[v]) : t.length ? (typeof t == "string" && (e !== this[P] || this[et]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[P] && (t = this[et].write(t)), this[v] && this[T] !== 0 && this[Ot](!0), this[v] ? this.emit("data", t) : this[Yt](t), this[T] !== 0 && this.emit("readable"), s && i(s), this[v]) : (this[T] !== 0 && this.emit("readable"), s && i(s), this[v]);
+	}
+	read(t) {
+		if (this[x]) return null;
+		if (this[M] = !1, this[T] === 0 || t === 0 || t && t > this[T]) return this[H](), null;
+		this[k] && (t = null), this[C].length > 1 && !this[k] && (this[C] = [this[P] ? this[C].join("") : Buffer.concat(this[C], this[T])]);
+		let e = this[_e](t || null, this[C][0]);
+		return this[H](), e;
+	}
+	[_e](t, e) {
+		if (this[k]) this[Ft]();
+		else {
+			let s = e;
+			t === s.length || t === null ? this[Ft]() : typeof s == "string" ? (this[C][0] = s.slice(t), e = s.slice(0, t), this[T] -= t) : (this[C][0] = s.subarray(t), e = s.subarray(0, t), this[T] -= t);
+		}
+		return this.emit("data", e), !this[C].length && !this[G] && this.emit("drain"), e;
+	}
+	end(t, e, s) {
+		return typeof t == "function" && (s = t, t = void 0), typeof e == "function" && (s = e, e = "utf8"), t !== void 0 && this.write(t, e), s && this.once("end", s), this[G] = !0, this.writable = !1, (this[v] || !this[dt]) && this[H](), this;
+	}
+	[st]() {
+		this[x] || (!this[Y] && !this[F].length && (this[M] = !0), this[dt] = !1, this[v] = !0, this.emit("resume"), this[C].length ? this[Ot]() : this[G] ? this[H]() : this.emit("drain"));
+	}
+	resume() {
+		return this[st]();
+	}
+	pause() {
+		this[v] = !1, this[dt] = !0, this[M] = !1;
+	}
+	get destroyed() {
+		return this[x];
+	}
+	get flowing() {
+		return this[v];
+	}
+	get paused() {
+		return this[dt];
+	}
+	[Yt](t) {
+		this[k] ? this[T] += 1 : this[T] += t.length, this[C].push(t);
+	}
+	[Ft]() {
+		return this[k] ? this[T] -= 1 : this[T] -= this[C][0].length, this[C].shift();
+	}
+	[Ot](t = !1) {
+		do		;
+while (this[Le](this[Ft]()) && this[C].length);
+		!t && !this[C].length && !this[G] && this.emit("drain");
+	}
+	[Le](t) {
+		return this.emit("data", t), this[v];
+	}
+	pipe(t, e) {
+		if (this[x]) return t;
+		this[M] = !1;
+		let s = this[K];
+		return e = e || {}, t === Ne.stdout || t === Ne.stderr ? e.end = !1 : e.end = e.end !== !1, e.proxyErrors = !!e.proxyErrors, s ? e.end && t.end() : (this[F].push(e.proxyErrors ? new te(this, t, e) : new Mt(this, t, e)), this[B] ? mt(() => this[st]()) : this[st]()), t;
+	}
+	unpipe(t) {
+		let e = this[F].find((s) => s.dest === t);
+		e && (this[F].length === 1 ? (this[v] && this[Y] === 0 && (this[v] = !1), this[F] = []) : this[F].splice(this[F].indexOf(e), 1), e.unpipe());
+	}
+	addListener(t, e) {
+		return this.on(t, e);
+	}
+	on(t, e) {
+		let s = super.on(t, e);
+		if (t === "data") this[M] = !1, this[Y]++, !this[F].length && !this[v] && this[st]();
+		else if (t === "readable" && this[T] !== 0) super.emit("readable");
+		else if (ci(t) && this[K]) super.emit(t), this.removeAllListeners(t);
+		else if (t === "error" && this[ut]) {
+			let i = e;
+			this[B] ? mt(() => i.call(this, this[ut])) : i.call(this, this[ut]);
+		}
+		return s;
+	}
+	removeListener(t, e) {
+		return this.off(t, e);
+	}
+	off(t, e) {
+		let s = super.off(t, e);
+		return t === "data" && (this[Y] = this.listeners("data").length, this[Y] === 0 && !this[M] && !this[F].length && (this[v] = !1)), s;
+	}
+	removeAllListeners(t) {
+		let e = super.removeAllListeners(t);
+		return (t === "data" || t === void 0) && (this[Y] = 0, !this[M] && !this[F].length && (this[v] = !1)), e;
+	}
+	get emittedEnd() {
+		return this[K];
+	}
+	[H]() {
+		!this[kt] && !this[K] && !this[x] && this[C].length === 0 && this[G] && (this[kt] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[Rt] && this.emit("close"), this[kt] = !1);
+	}
+	emit(t, ...e) {
+		let s = e[0];
+		if (t !== "error" && t !== "close" && t !== x && this[x]) return !1;
+		if (t === "data") return !this[k] && !s ? !1 : this[B] ? (mt(() => this[Jt](s)), !0) : this[Jt](s);
+		if (t === "end") return this[We]();
+		if (t === "close") {
+			if (this[Rt] = !0, !this[K] && !this[x]) return !1;
+			let r = super.emit("close");
+			return this.removeAllListeners("close"), r;
+		} else if (t === "error") {
+			this[ut] = s, super.emit(Xt, s);
+			let r = !this[pt] || this.listeners("error").length ? super.emit("error", s) : !1;
+			return this[H](), r;
+		} else if (t === "resume") {
+			let r = super.emit("resume");
+			return this[H](), r;
+		} else if (t === "finish" || t === "prefinish") {
+			let r = super.emit(t);
+			return this.removeAllListeners(t), r;
+		}
+		let i = super.emit(t, ...e);
+		return this[H](), i;
+	}
+	[Jt](t) {
+		for (let s of this[F]) s.dest.write(t) === !1 && this.pause();
+		let e = this[M] ? !1 : super.emit("data", t);
+		return this[H](), e;
+	}
+	[We]() {
+		return this[K] ? !1 : (this[K] = !0, this.readable = !1, this[B] ? (mt(() => this[Zt]()), !0) : this[Zt]());
+	}
+	[Zt]() {
+		if (this[et]) {
+			let e = this[et].end();
+			if (e) {
+				for (let s of this[F]) s.dest.write(e);
+				this[M] || super.emit("data", e);
+			}
+		}
+		for (let e of this[F]) e.end();
+		let t = super.emit("end");
+		return this.removeAllListeners("end"), t;
+	}
+	async collect() {
+		let t = Object.assign([], { dataLength: 0 });
+		this[k] || (t.dataLength = 0);
+		let e = this.promise();
+		return this.on("data", (s) => {
+			t.push(s), this[k] || (t.dataLength += s.length);
+		}), await e, t;
+	}
+	async concat() {
+		if (this[k]) throw new Error("cannot concat in objectMode");
+		let t = await this.collect();
+		return this[P] ? t.join("") : Buffer.concat(t, t.dataLength);
+	}
+	async promise() {
+		return new Promise((t, e) => {
+			this.on(x, () => e(/* @__PURE__ */ new Error("stream destroyed"))), this.on("error", (s) => e(s)), this.on("end", () => t());
+		});
+	}
+	[Symbol.asyncIterator]() {
+		this[M] = !1;
+		let t = !1, e = async () => (this.pause(), t = !0, {
+			value: void 0,
+			done: !0
+		});
+		return {
+			next: () => {
+				if (t) return e();
+				let i = this.read();
+				if (i !== null) return Promise.resolve({
+					done: !1,
+					value: i
+				});
+				if (this[G]) return e();
+				let r, o, h = (c) => {
+					this.off("data", a), this.off("end", l), this.off(x, u), e(), o(c);
+				}, a = (c) => {
+					this.off("error", h), this.off("end", l), this.off(x, u), this.pause(), r({
+						value: c,
+						done: !!this[G]
+					});
+				}, l = () => {
+					this.off("error", h), this.off("data", a), this.off(x, u), e(), r({
+						done: !0,
+						value: void 0
+					});
+				}, u = () => h(/* @__PURE__ */ new Error("stream destroyed"));
+				return new Promise((c, d) => {
+					o = d, r = c, this.once(x, u), this.once("error", h), this.once("end", l), this.once("data", a);
+				});
+			},
+			throw: e,
+			return: e,
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			[Symbol.asyncDispose]: async () => {}
+		};
+	}
+	[Symbol.iterator]() {
+		this[M] = !1;
+		let t = !1, e = () => (this.pause(), this.off(Xt, e), this.off(x, e), this.off("end", e), t = !0, {
+			done: !0,
+			value: void 0
+		}), s = () => {
+			if (t) return e();
+			let i = this.read();
+			return i === null ? e() : {
+				done: !1,
+				value: i
+			};
+		};
+		return this.once("end", e), this.once(Xt, e), this.once(x, e), {
+			next: s,
+			throw: e,
+			return: e,
+			[Symbol.iterator]() {
+				return this;
+			},
+			[Symbol.dispose]: () => {}
+		};
+	}
+	destroy(t) {
+		if (this[x]) return t ? this.emit("error", t) : this.emit(x), this;
+		this[x] = !0, this[M] = !0, this[C].length = 0, this[T] = 0;
+		let e = this;
+		return typeof e.close == "function" && !this[Rt] && e.close(), t ? this.emit("error", t) : this.emit(x), this;
+	}
+	static get isStream() {
+		return oi;
+	}
+};
+var vi = realpathSync.native;
+var wt = {
+	lstatSync,
+	readdir,
+	readdirSync,
+	readlinkSync,
+	realpathSync: vi,
+	promises: {
+		lstat,
+		readdir: readdir$1,
+		readlink,
+		realpath
+	}
+};
+var Ue = (n) => !n || n === wt || n === xi ? wt : {
+	...wt,
+	...n,
+	promises: {
+		...wt.promises,
+		...n.promises || {}
+	}
+};
+var $e = /^\\\\\?\\([a-z]:)\\?$/i;
+var Ri = (n) => n.replace(/\//g, "\\").replace($e, "$1\\");
+var Oi = /[\\\/]/;
+var L = 0;
+var Ge = 1;
+var He = 2;
+var U = 4;
+var qe = 6;
+var Ke = 8;
+var X = 10;
+var Ve = 12;
+var _ = 15;
+var gt = ~_;
+var se = 16;
+var je = 32;
+var yt = 64;
+var j = 128;
+var Nt = 256;
+var Lt = 512;
+var Ie = yt | j | Lt;
+var Fi = 1023;
+var ie = (n) => n.isFile() ? Ke : n.isDirectory() ? U : n.isSymbolicLink() ? X : n.isCharacterDevice() ? He : n.isBlockDevice() ? qe : n.isSocket() ? Ve : n.isFIFO() ? Ge : L;
+var ze = new ft({ max: 4096 });
+var bt = (n) => {
+	let t = ze.get(n);
+	if (t) return t;
+	let e = n.normalize("NFKD");
+	return ze.set(n, e), e;
+};
+var Be = new ft({ max: 4096 });
+var _t = (n) => {
+	let t = Be.get(n);
+	if (t) return t;
+	let e = bt(n.toLowerCase());
+	return Be.set(n, e), e;
+};
+var Wt = class extends ft {
+	constructor() {
+		super({ max: 256 });
+	}
+};
+var ne = class extends ft {
+	constructor(t = 16384) {
+		super({
+			maxSize: t,
+			sizeCalculation: (e) => e.length + 1
+		});
+	}
+};
+var Ye = Symbol("PathScurry setAsCwd");
+var R = class {
+	name;
+	root;
+	roots;
+	parent;
+	nocase;
+	isCWD = !1;
+	#t;
+	#s;
+	get dev() {
+		return this.#s;
+	}
+	#n;
+	get mode() {
+		return this.#n;
+	}
+	#r;
+	get nlink() {
+		return this.#r;
+	}
+	#o;
+	get uid() {
+		return this.#o;
+	}
+	#S;
+	get gid() {
+		return this.#S;
+	}
+	#w;
+	get rdev() {
+		return this.#w;
+	}
+	#c;
+	get blksize() {
+		return this.#c;
+	}
+	#h;
+	get ino() {
+		return this.#h;
+	}
+	#u;
+	get size() {
+		return this.#u;
+	}
+	#f;
+	get blocks() {
+		return this.#f;
+	}
+	#a;
+	get atimeMs() {
+		return this.#a;
+	}
+	#i;
+	get mtimeMs() {
+		return this.#i;
+	}
+	#d;
+	get ctimeMs() {
+		return this.#d;
+	}
+	#E;
+	get birthtimeMs() {
+		return this.#E;
+	}
+	#b;
+	get atime() {
+		return this.#b;
+	}
+	#p;
+	get mtime() {
+		return this.#p;
+	}
+	#R;
+	get ctime() {
+		return this.#R;
+	}
+	#m;
+	get birthtime() {
+		return this.#m;
+	}
+	#C;
+	#T;
+	#g;
+	#y;
+	#x;
+	#A;
+	#e;
+	#_;
+	#M;
+	#k;
+	get parentPath() {
+		return (this.parent || this).fullpath();
+	}
+	get path() {
+		return this.parentPath;
+	}
+	constructor(t, e = L, s, i, r, o, h) {
+		this.name = t, this.#C = r ? _t(t) : bt(t), this.#e = e & Fi, this.nocase = r, this.roots = i, this.root = s || this, this.#_ = o, this.#g = h.fullpath, this.#x = h.relative, this.#A = h.relativePosix, this.parent = h.parent, this.parent ? this.#t = this.parent.#t : this.#t = Ue(h.fs);
+	}
+	depth() {
+		return this.#T !== void 0 ? this.#T : this.parent ? this.#T = this.parent.depth() + 1 : this.#T = 0;
+	}
+	childrenCache() {
+		return this.#_;
+	}
+	resolve(t) {
+		if (!t) return this;
+		let e = this.getRootString(t), i = t.substring(e.length).split(this.splitSep);
+		return e ? this.getRoot(e).#N(i) : this.#N(i);
+	}
+	#N(t) {
+		let e = this;
+		for (let s of t) e = e.child(s);
+		return e;
+	}
+	children() {
+		let t = this.#_.get(this);
+		if (t) return t;
+		let e = Object.assign([], { provisional: 0 });
+		return this.#_.set(this, e), this.#e &= ~se, e;
+	}
+	child(t, e) {
+		if (t === "" || t === ".") return this;
+		if (t === "..") return this.parent || this;
+		let s = this.children(), i = this.nocase ? _t(t) : bt(t);
+		for (let a of s) if (a.#C === i) return a;
+		let r = this.parent ? this.sep : "", o = this.#g ? this.#g + r + t : void 0, h = this.newChild(t, L, {
+			...e,
+			parent: this,
+			fullpath: o
+		});
+		return this.canReaddir() || (h.#e |= j), s.push(h), h;
+	}
+	relative() {
+		if (this.isCWD) return "";
+		if (this.#x !== void 0) return this.#x;
+		let t = this.name, e = this.parent;
+		if (!e) return this.#x = this.name;
+		let s = e.relative();
+		return s + (!s || !e.parent ? "" : this.sep) + t;
+	}
+	relativePosix() {
+		if (this.sep === "/") return this.relative();
+		if (this.isCWD) return "";
+		if (this.#A !== void 0) return this.#A;
+		let t = this.name, e = this.parent;
+		if (!e) return this.#A = this.fullpathPosix();
+		let s = e.relativePosix();
+		return s + (!s || !e.parent ? "" : "/") + t;
+	}
+	fullpath() {
+		if (this.#g !== void 0) return this.#g;
+		let t = this.name, e = this.parent;
+		if (!e) return this.#g = this.name;
+		let i = e.fullpath() + (e.parent ? this.sep : "") + t;
+		return this.#g = i;
+	}
+	fullpathPosix() {
+		if (this.#y !== void 0) return this.#y;
+		if (this.sep === "/") return this.#y = this.fullpath();
+		if (!this.parent) {
+			let i = this.fullpath().replace(/\\/g, "/");
+			return /^[a-z]:\//i.test(i) ? this.#y = `//?/${i}` : this.#y = i;
+		}
+		let t = this.parent, e = t.fullpathPosix(), s = e + (!e || !t.parent ? "" : "/") + this.name;
+		return this.#y = s;
+	}
+	isUnknown() {
+		return (this.#e & _) === L;
+	}
+	isType(t) {
+		return this[`is${t}`]();
+	}
+	getType() {
+		return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+	}
+	isFile() {
+		return (this.#e & _) === Ke;
+	}
+	isDirectory() {
+		return (this.#e & _) === U;
+	}
+	isCharacterDevice() {
+		return (this.#e & _) === He;
+	}
+	isBlockDevice() {
+		return (this.#e & _) === qe;
+	}
+	isFIFO() {
+		return (this.#e & _) === Ge;
+	}
+	isSocket() {
+		return (this.#e & _) === Ve;
+	}
+	isSymbolicLink() {
+		return (this.#e & X) === X;
+	}
+	lstatCached() {
+		return this.#e & je ? this : void 0;
+	}
+	readlinkCached() {
+		return this.#M;
+	}
+	realpathCached() {
+		return this.#k;
+	}
+	readdirCached() {
+		let t = this.children();
+		return t.slice(0, t.provisional);
+	}
+	canReadlink() {
+		if (this.#M) return !0;
+		if (!this.parent) return !1;
+		let t = this.#e & _;
+		return !(t !== L && t !== X || this.#e & Nt || this.#e & j);
+	}
+	calledReaddir() {
+		return !!(this.#e & se);
+	}
+	isENOENT() {
+		return !!(this.#e & j);
+	}
+	isNamed(t) {
+		return this.nocase ? this.#C === _t(t) : this.#C === bt(t);
+	}
+	async readlink() {
+		let t = this.#M;
+		if (t) return t;
+		if (this.canReadlink() && this.parent) try {
+			let e = await this.#t.promises.readlink(this.fullpath()), s = (await this.parent.realpath())?.resolve(e);
+			if (s) return this.#M = s;
+		} catch (e) {
+			this.#D(e.code);
+			return;
+		}
+	}
+	readlinkSync() {
+		let t = this.#M;
+		if (t) return t;
+		if (this.canReadlink() && this.parent) try {
+			let e = this.#t.readlinkSync(this.fullpath()), s = this.parent.realpathSync()?.resolve(e);
+			if (s) return this.#M = s;
+		} catch (e) {
+			this.#D(e.code);
+			return;
+		}
+	}
+	#j(t) {
+		this.#e |= se;
+		for (let e = t.provisional; e < t.length; e++) {
+			let s = t[e];
+			s && s.#v();
+		}
+	}
+	#v() {
+		this.#e & j || (this.#e = (this.#e | j) & gt, this.#G());
+	}
+	#G() {
+		let t = this.children();
+		t.provisional = 0;
+		for (let e of t) e.#v();
+	}
+	#P() {
+		this.#e |= Lt, this.#L();
+	}
+	#L() {
+		if (this.#e & yt) return;
+		let t = this.#e;
+		(t & _) === U && (t &= gt), this.#e = t | yt, this.#G();
+	}
+	#I(t = "") {
+		t === "ENOTDIR" || t === "EPERM" ? this.#L() : t === "ENOENT" ? this.#v() : this.children().provisional = 0;
+	}
+	#F(t = "") {
+		t === "ENOTDIR" ? this.parent.#L() : t === "ENOENT" && this.#v();
+	}
+	#D(t = "") {
+		let e = this.#e;
+		e |= Nt, t === "ENOENT" && (e |= j), (t === "EINVAL" || t === "UNKNOWN") && (e &= gt), this.#e = e, t === "ENOTDIR" && this.parent && this.parent.#L();
+	}
+	#z(t, e) {
+		return this.#U(t, e) || this.#B(t, e);
+	}
+	#B(t, e) {
+		let s = ie(t), i = this.newChild(t.name, s, { parent: this }), r = i.#e & _;
+		return r !== U && r !== X && r !== L && (i.#e |= yt), e.unshift(i), e.provisional++, i;
+	}
+	#U(t, e) {
+		for (let s = e.provisional; s < e.length; s++) {
+			let i = e[s];
+			if ((this.nocase ? _t(t.name) : bt(t.name)) === i.#C) return this.#l(t, i, s, e);
+		}
+	}
+	#l(t, e, s, i) {
+		let r = e.name;
+		return e.#e = e.#e & gt | ie(t), r !== t.name && (e.name = t.name), s !== i.provisional && (s === i.length - 1 ? i.pop() : i.splice(s, 1), i.unshift(e)), i.provisional++, e;
+	}
+	async lstat() {
+		if ((this.#e & j) === 0) try {
+			return this.#$(await this.#t.promises.lstat(this.fullpath())), this;
+		} catch (t) {
+			this.#F(t.code);
+		}
+	}
+	lstatSync() {
+		if ((this.#e & j) === 0) try {
+			return this.#$(this.#t.lstatSync(this.fullpath())), this;
+		} catch (t) {
+			this.#F(t.code);
+		}
+	}
+	#$(t) {
+		let { atime: e, atimeMs: s, birthtime: i, birthtimeMs: r, blksize: o, blocks: h, ctime: a, ctimeMs: l, dev: u, gid: c, ino: d, mode: f, mtime: m, mtimeMs: p, nlink: w, rdev: g, size: S, uid: E } = t;
+		this.#b = e, this.#a = s, this.#m = i, this.#E = r, this.#c = o, this.#f = h, this.#R = a, this.#d = l, this.#s = u, this.#S = c, this.#h = d, this.#n = f, this.#p = m, this.#i = p, this.#r = w, this.#w = g, this.#u = S, this.#o = E;
+		let y = ie(t);
+		this.#e = this.#e & gt | y | je, y !== L && y !== U && y !== X && (this.#e |= yt);
+	}
+	#W = [];
+	#O = !1;
+	#H(t) {
+		this.#O = !1;
+		let e = this.#W.slice();
+		this.#W.length = 0, e.forEach((s) => s(null, t));
+	}
+	readdirCB(t, e = !1) {
+		if (!this.canReaddir()) {
+			e ? t(null, []) : queueMicrotask(() => t(null, []));
+			return;
+		}
+		let s = this.children();
+		if (this.calledReaddir()) {
+			let r = s.slice(0, s.provisional);
+			e ? t(null, r) : queueMicrotask(() => t(null, r));
+			return;
+		}
+		if (this.#W.push(t), this.#O) return;
+		this.#O = !0;
+		let i = this.fullpath();
+		this.#t.readdir(i, { withFileTypes: !0 }, (r, o) => {
+			if (r) this.#I(r.code), s.provisional = 0;
+			else {
+				for (let h of o) this.#z(h, s);
+				this.#j(s);
+			}
+			this.#H(s.slice(0, s.provisional));
+		});
+	}
+	#q;
+	async readdir() {
+		if (!this.canReaddir()) return [];
+		let t = this.children();
+		if (this.calledReaddir()) return t.slice(0, t.provisional);
+		let e = this.fullpath();
+		if (this.#q) await this.#q;
+		else {
+			let s = () => {};
+			this.#q = new Promise((i) => s = i);
+			try {
+				for (let i of await this.#t.promises.readdir(e, { withFileTypes: !0 })) this.#z(i, t);
+				this.#j(t);
+			} catch (i) {
+				this.#I(i.code), t.provisional = 0;
+			}
+			this.#q = void 0, s();
+		}
+		return t.slice(0, t.provisional);
+	}
+	readdirSync() {
+		if (!this.canReaddir()) return [];
+		let t = this.children();
+		if (this.calledReaddir()) return t.slice(0, t.provisional);
+		let e = this.fullpath();
+		try {
+			for (let s of this.#t.readdirSync(e, { withFileTypes: !0 })) this.#z(s, t);
+			this.#j(t);
+		} catch (s) {
+			this.#I(s.code), t.provisional = 0;
+		}
+		return t.slice(0, t.provisional);
+	}
+	canReaddir() {
+		if (this.#e & Ie) return !1;
+		let t = _ & this.#e;
+		return t === L || t === U || t === X;
+	}
+	shouldWalk(t, e) {
+		return (this.#e & U) === U && !(this.#e & Ie) && !t.has(this) && (!e || e(this));
+	}
+	async realpath() {
+		if (this.#k) return this.#k;
+		if (!((Lt | Nt | j) & this.#e)) try {
+			let t = await this.#t.promises.realpath(this.fullpath());
+			return this.#k = this.resolve(t);
+		} catch {
+			this.#P();
+		}
+	}
+	realpathSync() {
+		if (this.#k) return this.#k;
+		if (!((Lt | Nt | j) & this.#e)) try {
+			let t = this.#t.realpathSync(this.fullpath());
+			return this.#k = this.resolve(t);
+		} catch {
+			this.#P();
+		}
+	}
+	[Ye](t) {
+		if (t === this) return;
+		t.isCWD = !1, this.isCWD = !0;
+		let e = /* @__PURE__ */ new Set([]), s = [], i = this;
+		for (; i && i.parent;) e.add(i), i.#x = s.join(this.sep), i.#A = s.join("/"), i = i.parent, s.push("..");
+		for (i = t; i && i.parent && !e.has(i);) i.#x = void 0, i.#A = void 0, i = i.parent;
+	}
+};
+var Pt = class n extends R {
+	sep = "\\";
+	splitSep = Oi;
+	constructor(t, e = L, s, i, r, o, h) {
+		super(t, e, s, i, r, o, h);
+	}
+	newChild(t, e = L, s = {}) {
+		return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+	}
+	getRootString(t) {
+		return win32.parse(t).root;
+	}
+	getRoot(t) {
+		if (t = Ri(t.toUpperCase()), t === this.root.name) return this.root;
+		for (let [e, s] of Object.entries(this.roots)) if (this.sameRoot(t, e)) return this.roots[t] = s;
+		return this.roots[t] = new it(t, this).root;
+	}
+	sameRoot(t, e = this.root.name) {
+		return t = t.toUpperCase().replace(/\//g, "\\").replace($e, "$1\\"), t === e;
+	}
+};
+var jt = class n extends R {
+	splitSep = "/";
+	sep = "/";
+	constructor(t, e = L, s, i, r, o, h) {
+		super(t, e, s, i, r, o, h);
+	}
+	getRootString(t) {
+		return t.startsWith("/") ? "/" : "";
+	}
+	getRoot(t) {
+		return this.root;
+	}
+	newChild(t, e = L, s = {}) {
+		return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+	}
+};
+var It = class {
+	root;
+	rootPath;
+	roots;
+	cwd;
+	#t;
+	#s;
+	#n;
+	nocase;
+	#r;
+	constructor(t = process.cwd(), e, s, { nocase: i, childrenCacheSize: r = 16384, fs: o = wt } = {}) {
+		this.#r = Ue(o), (t instanceof URL || t.startsWith("file://")) && (t = fileURLToPath(t));
+		let h = e.resolve(t);
+		this.roots = Object.create(null), this.rootPath = this.parseRootPath(h), this.#t = new Wt(), this.#s = new Wt(), this.#n = new ne(r);
+		let a = h.substring(this.rootPath.length).split(s);
+		if (a.length === 1 && !a[0] && a.pop(), i === void 0) throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+		this.nocase = i, this.root = this.newRoot(this.#r), this.roots[this.rootPath] = this.root;
+		let l = this.root, u = a.length - 1, c = e.sep, d = this.rootPath, f = !1;
+		for (let m of a) {
+			let p = u--;
+			l = l.child(m, {
+				relative: new Array(p).fill("..").join(c),
+				relativePosix: new Array(p).fill("..").join("/"),
+				fullpath: d += (f ? "" : c) + m
+			}), f = !0;
+		}
+		this.cwd = l;
+	}
+	depth(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.depth();
+	}
+	childrenCache() {
+		return this.#n;
+	}
+	resolve(...t) {
+		let e = "";
+		for (let r = t.length - 1; r >= 0; r--) {
+			let o = t[r];
+			if (!(!o || o === ".") && (e = e ? `${o}/${e}` : o, this.isAbsolute(o))) break;
+		}
+		let s = this.#t.get(e);
+		if (s !== void 0) return s;
+		let i = this.cwd.resolve(e).fullpath();
+		return this.#t.set(e, i), i;
+	}
+	resolvePosix(...t) {
+		let e = "";
+		for (let r = t.length - 1; r >= 0; r--) {
+			let o = t[r];
+			if (!(!o || o === ".") && (e = e ? `${o}/${e}` : o, this.isAbsolute(o))) break;
+		}
+		let s = this.#s.get(e);
+		if (s !== void 0) return s;
+		let i = this.cwd.resolve(e).fullpathPosix();
+		return this.#s.set(e, i), i;
+	}
+	relative(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.relative();
+	}
+	relativePosix(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.relativePosix();
+	}
+	basename(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.name;
+	}
+	dirname(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), (t.parent || t).fullpath();
+	}
+	async readdir(t = this.cwd, e = { withFileTypes: !0 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s } = e;
+		if (t.canReaddir()) {
+			let i = await t.readdir();
+			return s ? i : i.map((r) => r.name);
+		} else return [];
+	}
+	readdirSync(t = this.cwd, e = { withFileTypes: !0 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0 } = e;
+		return t.canReaddir() ? s ? t.readdirSync() : t.readdirSync().map((i) => i.name) : [];
+	}
+	async lstat(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstat();
+	}
+	lstatSync(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstatSync();
+	}
+	async readlink(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = await t.readlink();
+		return e ? s : s?.fullpath();
+	}
+	readlinkSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = t.readlinkSync();
+		return e ? s : s?.fullpath();
+	}
+	async realpath(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = await t.realpath();
+		return e ? s : s?.fullpath();
+	}
+	realpathSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = t.realpathSync();
+		return e ? s : s?.fullpath();
+	}
+	async walk(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = [];
+		(!r || r(t)) && h.push(s ? t : t.fullpath());
+		let a = /* @__PURE__ */ new Set(), l = (c, d) => {
+			a.add(c), c.readdirCB((f, m) => {
+				if (f) return d(f);
+				let p = m.length;
+				if (!p) return d();
+				let w = () => {
+					--p === 0 && d();
+				};
+				for (let g of m) (!r || r(g)) && h.push(s ? g : g.fullpath()), i && g.isSymbolicLink() ? g.realpath().then((S) => S?.isUnknown() ? S.lstat() : S).then((S) => S?.shouldWalk(a, o) ? l(S, w) : w()) : g.shouldWalk(a, o) ? l(g, w) : w();
+			}, !0);
+		}, u = t;
+		return new Promise((c, d) => {
+			l(u, (f) => {
+				if (f) return d(f);
+				c(h);
+			});
+		});
+	}
+	walkSync(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = [];
+		(!r || r(t)) && h.push(s ? t : t.fullpath());
+		let a = /* @__PURE__ */ new Set([t]);
+		for (let l of a) {
+			let u = l.readdirSync();
+			for (let c of u) {
+				(!r || r(c)) && h.push(s ? c : c.fullpath());
+				let d = c;
+				if (c.isSymbolicLink()) {
+					if (!(i && (d = c.realpathSync()))) continue;
+					d.isUnknown() && d.lstatSync();
+				}
+				d.shouldWalk(a, o) && a.add(d);
+			}
+		}
+		return h;
+	}
+	[Symbol.asyncIterator]() {
+		return this.iterate();
+	}
+	iterate(t = this.cwd, e = {}) {
+		return typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd), this.stream(t, e)[Symbol.asyncIterator]();
+	}
+	[Symbol.iterator]() {
+		return this.iterateSync();
+	}
+	*iterateSync(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e;
+		(!r || r(t)) && (yield s ? t : t.fullpath());
+		let h = /* @__PURE__ */ new Set([t]);
+		for (let a of h) {
+			let l = a.readdirSync();
+			for (let u of l) {
+				(!r || r(u)) && (yield s ? u : u.fullpath());
+				let c = u;
+				if (u.isSymbolicLink()) {
+					if (!(i && (c = u.realpathSync()))) continue;
+					c.isUnknown() && c.lstatSync();
+				}
+				c.shouldWalk(h, o) && h.add(c);
+			}
+		}
+	}
+	stream(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = new V({ objectMode: !0 });
+		(!r || r(t)) && h.write(s ? t : t.fullpath());
+		let a = /* @__PURE__ */ new Set(), l = [t], u = 0, c = () => {
+			let d = !1;
+			for (; !d;) {
+				let f = l.shift();
+				if (!f) {
+					u === 0 && h.end();
+					return;
+				}
+				u++, a.add(f);
+				let m = (w, g, S = !1) => {
+					if (w) return h.emit("error", w);
+					if (i && !S) {
+						let E = [];
+						for (let y of g) y.isSymbolicLink() && E.push(y.realpath().then((b) => b?.isUnknown() ? b.lstat() : b));
+						if (E.length) {
+							Promise.all(E).then(() => m(null, g, !0));
+							return;
+						}
+					}
+					for (let E of g) E && (!r || r(E)) && (h.write(s ? E : E.fullpath()) || (d = !0));
+					u--;
+					for (let E of g) {
+						let y = E.realpathCached() || E;
+						y.shouldWalk(a, o) && l.push(y);
+					}
+					d && !h.flowing ? h.once("drain", c) : p || c();
+				}, p = !0;
+				f.readdirCB(m, !0), p = !1;
+			}
+		};
+		return c(), h;
+	}
+	streamSync(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = new V({ objectMode: !0 }), a = /* @__PURE__ */ new Set();
+		(!r || r(t)) && h.write(s ? t : t.fullpath());
+		let l = [t], u = 0, c = () => {
+			let d = !1;
+			for (; !d;) {
+				let f = l.shift();
+				if (!f) {
+					u === 0 && h.end();
+					return;
+				}
+				u++, a.add(f);
+				let m = f.readdirSync();
+				for (let p of m) (!r || r(p)) && (h.write(s ? p : p.fullpath()) || (d = !0));
+				u--;
+				for (let p of m) {
+					let w = p;
+					if (p.isSymbolicLink()) {
+						if (!(i && (w = p.realpathSync()))) continue;
+						w.isUnknown() && w.lstatSync();
+					}
+					w.shouldWalk(a, o) && l.push(w);
 				}
-				if (attempt < 3) await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
-			}
-			if (!response || !response.body) {
-				if (lastErr instanceof LuaLSError) throw lastErr;
-				throw new LuaLSError(`Failed to download LuaLS from ${url}${lastErr ? `: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}` : ""}`, "ERR_LUALS_DOWNLOAD", "Check your network connection or specify a custom binary with LUALS_BIN.", { cause: lastErr });
-			}
-			const arrayBuffer = await response.arrayBuffer();
-			fs.writeFileSync(archivePath, Buffer.from(arrayBuffer));
-			if (!options?.quiet) logger.info(`[luals] Extracting to ${destDir}...`);
-			try {
-				await execFileAsync$1("tar", [
-					"-xf",
-					archivePath,
-					"-C",
-					tempDir
-				]);
-			} catch (tarErr) {
-				if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync$1("powershell.exe", [
-					"-NoProfile",
-					"-Command",
-					`Expand-Archive -Path '${escapePowerShellSingleQuote(archivePath)}' -DestinationPath '${escapePowerShellSingleQuote(tempDir)}' -Force`
-				]);
-				else throw tarErr;
 			}
-			try {
-				fs.unlinkSync(archivePath);
-			} catch (err) {
-				logger.debug(`[luals] Failed to delete temporary archive ${archivePath}: ${err instanceof Error ? err.message : String(err)}`);
+			d && !h.flowing && h.once("drain", c);
+		};
+		return c(), h;
+	}
+	chdir(t = this.cwd) {
+		let e = this.cwd;
+		this.cwd = typeof t == "string" ? this.cwd.resolve(t) : t, this.cwd[Ye](e);
+	}
+};
+var it = class extends It {
+	sep = "\\";
+	constructor(t = process.cwd(), e = {}) {
+		let { nocase: s = !0 } = e;
+		super(t, win32, "\\", {
+			...e,
+			nocase: s
+		}), this.nocase = s;
+		for (let i = this.cwd; i; i = i.parent) i.nocase = this.nocase;
+	}
+	parseRootPath(t) {
+		return win32.parse(t).root.toUpperCase();
+	}
+	newRoot(t) {
+		return new Pt(this.rootPath, U, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+	}
+	isAbsolute(t) {
+		return t.startsWith("/") || t.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(t);
+	}
+};
+var rt = class extends It {
+	sep = "/";
+	constructor(t = process.cwd(), e = {}) {
+		let { nocase: s = !1 } = e;
+		super(t, posix, "/", {
+			...e,
+			nocase: s
+		}), this.nocase = s;
+	}
+	parseRootPath(t) {
+		return "/";
+	}
+	newRoot(t) {
+		return new jt(this.rootPath, U, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+	}
+	isAbsolute(t) {
+		return t.startsWith("/");
+	}
+};
+var St = class extends rt {
+	constructor(t = process.cwd(), e = {}) {
+		let { nocase: s = !0 } = e;
+		super(t, {
+			...e,
+			nocase: s
+		});
+	}
+};
+process.platform;
+var Xe = process.platform === "win32" ? it : process.platform === "darwin" ? St : rt;
+var Di = (n) => n.length >= 1;
+var Mi = (n) => n.length >= 1;
+var Ni = Symbol.for("nodejs.util.inspect.custom");
+var nt = class n {
+	#t;
+	#s;
+	#n;
+	length;
+	#r;
+	#o;
+	#S;
+	#w;
+	#c;
+	#h;
+	#u = !0;
+	constructor(t, e, s, i) {
+		if (!Di(t)) throw new TypeError("empty pattern list");
+		if (!Mi(e)) throw new TypeError("empty glob list");
+		if (e.length !== t.length) throw new TypeError("mismatched pattern list and glob list lengths");
+		if (this.length = t.length, s < 0 || s >= this.length) throw new TypeError("index out of range");
+		if (this.#t = t, this.#s = e, this.#n = s, this.#r = i, this.#n === 0) {
+			if (this.isUNC()) {
+				let [r, o, h, a, ...l] = this.#t, [u, c, d, f, ...m] = this.#s;
+				l[0] === "" && (l.shift(), m.shift());
+				let p = [
+					r,
+					o,
+					h,
+					a,
+					""
+				].join("/"), w = [
+					u,
+					c,
+					d,
+					f,
+					""
+				].join("/");
+				this.#t = [p, ...l], this.#s = [w, ...m], this.length = this.#t.length;
+			} else if (this.isDrive() || this.isAbsolute()) {
+				let [r, ...o] = this.#t, [h, ...a] = this.#s;
+				o[0] === "" && (o.shift(), a.shift());
+				let l = r + "/", u = h + "/";
+				this.#t = [l, ...o], this.#s = [u, ...a], this.length = this.#t.length;
 			}
 		}
-		const tempBinaryPath = path.join(tempDir, info.binaryRelativePath);
-		if (process.platform !== "win32") try {
-			fs.chmodSync(tempBinaryPath, 493);
-		} catch (err) {
-			logger.warn(`[luals] Failed to chmod binary at ${tempBinaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	[Ni]() {
+		return "Pattern <" + this.#s.slice(this.#n).join("/") + ">";
+	}
+	pattern() {
+		return this.#t[this.#n];
+	}
+	isString() {
+		return typeof this.#t[this.#n] == "string";
+	}
+	isGlobstar() {
+		return this.#t[this.#n] === A;
+	}
+	isRegExp() {
+		return this.#t[this.#n] instanceof RegExp;
+	}
+	globString() {
+		return this.#S = this.#S || (this.#n === 0 ? this.isAbsolute() ? this.#s[0] + this.#s.slice(1).join("/") : this.#s.join("/") : this.#s.slice(this.#n).join("/"));
+	}
+	hasMore() {
+		return this.length > this.#n + 1;
+	}
+	rest() {
+		return this.#o !== void 0 ? this.#o : this.hasMore() ? (this.#o = new n(this.#t, this.#s, this.#n + 1, this.#r), this.#o.#h = this.#h, this.#o.#c = this.#c, this.#o.#w = this.#w, this.#o) : this.#o = null;
+	}
+	isUNC() {
+		let t = this.#t;
+		return this.#c !== void 0 ? this.#c : this.#c = this.#r === "win32" && this.#n === 0 && t[0] === "" && t[1] === "" && typeof t[2] == "string" && !!t[2] && typeof t[3] == "string" && !!t[3];
+	}
+	isDrive() {
+		let t = this.#t;
+		return this.#w !== void 0 ? this.#w : this.#w = this.#r === "win32" && this.#n === 0 && this.length > 1 && typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]);
+	}
+	isAbsolute() {
+		let t = this.#t;
+		return this.#h !== void 0 ? this.#h : this.#h = t[0] === "" && t.length > 1 || this.isDrive() || this.isUNC();
+	}
+	root() {
+		let t = this.#t[0];
+		return typeof t == "string" && this.isAbsolute() && this.#n === 0 ? t : "";
+	}
+	checkFollowGlobstar() {
+		return !(this.#n === 0 || !this.isGlobstar() || !this.#u);
+	}
+	markFollowGlobstar() {
+		return this.#n === 0 || !this.isGlobstar() || !this.#u ? !1 : (this.#u = !1, !0);
+	}
+};
+var _i = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux";
+var ot = class {
+	relative;
+	relativeChildren;
+	absolute;
+	absoluteChildren;
+	platform;
+	mmopts;
+	constructor(t, { nobrace: e, nocase: s, noext: i, noglobstar: r, platform: o = _i }) {
+		this.relative = [], this.absolute = [], this.relativeChildren = [], this.absoluteChildren = [], this.platform = o, this.mmopts = {
+			dot: !0,
+			nobrace: e,
+			nocase: s,
+			noext: i,
+			noglobstar: r,
+			optimizationLevel: 2,
+			platform: o,
+			nocomment: !0,
+			nonegate: !0
+		};
+		for (let h of t) this.add(h);
+	}
+	add(t) {
+		let e = new D(t, this.mmopts);
+		for (let s = 0; s < e.set.length; s++) {
+			let i = e.set[s], r = e.globParts[s];
+			if (!i || !r) throw new Error("invalid pattern object");
+			for (; i[0] === "." && r[0] === ".";) i.shift(), r.shift();
+			let o = new nt(i, r, 0, this.platform), h = new D(o.globString(), this.mmopts), a = r[r.length - 1] === "**", l = o.isAbsolute();
+			l ? this.absolute.push(h) : this.relative.push(h), a && (l ? this.absoluteChildren.push(h) : this.relativeChildren.push(h));
 		}
-		if (!fs.existsSync(tempBinaryPath) || fs.statSync(tempBinaryPath).size < 1e5) throw new LuaLSError(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
-		if (!isBinaryValid(tempBinaryPath)) throw new LuaLSError(`Extracted LuaLS binary at ${tempBinaryPath} is invalid or non-functional.`, "ERR_LUALS_INVALID_BINARY", "Run 'nanos-lint clean-cache' to remove corrupted downloads or set LUALS_BIN to a custom binary.");
-		fs.writeFileSync(path.join(tempDir, ".complete"), resolvedVersion, "utf-8");
-		for (let attempt = 0; attempt < 5; attempt++) try {
-			fs.renameSync(tempDir, destDir);
-			break;
-		} catch (renameErr) {
-			if (fs.existsSync(binaryPath) && isBinaryValid(binaryPath)) {
-				try {
-					fs.rmSync(tempDir, {
-						recursive: true,
-						force: true
-					});
-				} catch (err) {
-					logger.debug(`[luals] Failed to remove temp directory after concurrent promotion: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	ignored(t) {
+		let e = t.fullpath(), s = `${e}/`, i = t.relative() || ".", r = `${i}/`;
+		for (let o of this.relative) if (o.match(i) || o.match(r)) return !0;
+		for (let o of this.absolute) if (o.match(e) || o.match(s)) return !0;
+		return !1;
+	}
+	childrenIgnored(t) {
+		let e = t.fullpath() + "/", s = (t.relative() || ".") + "/";
+		for (let i of this.relativeChildren) if (i.match(s)) return !0;
+		for (let i of this.absoluteChildren) if (i.match(e)) return !0;
+		return !1;
+	}
+};
+var oe = class n {
+	store;
+	constructor(t = /* @__PURE__ */ new Map()) {
+		this.store = t;
+	}
+	copy() {
+		return new n(new Map(this.store));
+	}
+	hasWalked(t, e) {
+		return this.store.get(t.fullpath())?.has(e.globString());
+	}
+	storeWalked(t, e) {
+		let s = t.fullpath(), i = this.store.get(s);
+		i ? i.add(e.globString()) : this.store.set(s, /* @__PURE__ */ new Set([e.globString()]));
+	}
+};
+var he = class {
+	store = /* @__PURE__ */ new Map();
+	add(t, e, s) {
+		let i = (e ? 2 : 0) | (s ? 1 : 0), r = this.store.get(t);
+		this.store.set(t, r === void 0 ? i : i & r);
+	}
+	entries() {
+		return [...this.store.entries()].map(([t, e]) => [
+			t,
+			!!(e & 2),
+			!!(e & 1)
+		]);
+	}
+};
+var ae = class {
+	store = /* @__PURE__ */ new Map();
+	add(t, e) {
+		if (!t.canReaddir()) return;
+		let s = this.store.get(t);
+		s ? s.find((i) => i.globString() === e.globString()) || s.push(e) : this.store.set(t, [e]);
+	}
+	get(t) {
+		let e = this.store.get(t);
+		if (!e) throw new Error("attempting to walk unknown path");
+		return e;
+	}
+	entries() {
+		return this.keys().map((t) => [t, this.store.get(t)]);
+	}
+	keys() {
+		return [...this.store.keys()].filter((t) => t.canReaddir());
+	}
+};
+var Et = class n {
+	hasWalkedCache;
+	matches = new he();
+	subwalks = new ae();
+	patterns;
+	follow;
+	dot;
+	opts;
+	constructor(t, e) {
+		this.opts = t, this.follow = !!t.follow, this.dot = !!t.dot, this.hasWalkedCache = e ? e.copy() : new oe();
+	}
+	processPatterns(t, e) {
+		this.patterns = e;
+		let s = e.map((i) => [t, i]);
+		for (let [i, r] of s) {
+			this.hasWalkedCache.storeWalked(i, r);
+			let o = r.root(), h = r.isAbsolute() && this.opts.absolute !== !1;
+			if (o) {
+				i = i.resolve(o === "/" && this.opts.root !== void 0 ? this.opts.root : o);
+				let c = r.rest();
+				if (c) r = c;
+				else {
+					this.matches.add(i, !0, !1);
+					continue;
 				}
-				if (!options?.quiet) logger.info(`[luals] Ready: ${binaryPath}`);
-				return binaryPath;
 			}
-			if (attempt < 4) await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
-			else {
-				if (fs.existsSync(destDir) && (!fs.existsSync(binaryPath) || !fs.existsSync(completeMarker))) try {
-					fs.rmSync(destDir, {
-						recursive: true,
-						force: true
-					});
-				} catch (err) {
-					logger.warn(`[luals] Failed to clean up broken destination directory ${destDir}: ${err instanceof Error ? err.message : String(err)}`);
-				}
-				throw renameErr;
+			if (i.isENOENT()) continue;
+			let a, l, u = !1;
+			for (; typeof (a = r.pattern()) == "string" && (l = r.rest());) i = i.resolve(a), r = l, u = !0;
+			if (a = r.pattern(), l = r.rest(), u) {
+				if (this.hasWalkedCache.hasWalked(i, r)) continue;
+				this.hasWalkedCache.storeWalked(i, r);
 			}
+			if (typeof a == "string") {
+				let c = a === ".." || a === "" || a === ".";
+				this.matches.add(i.resolve(a), h, c);
+				continue;
+			} else if (a === A) {
+				(!i.isSymbolicLink() || this.follow || r.checkFollowGlobstar()) && this.subwalks.add(i, r);
+				let c = l?.pattern(), d = l?.rest();
+				if (!l || (c === "" || c === ".") && !d) this.matches.add(i, h, c === "" || c === ".");
+				else if (c === "..") {
+					let f = i.parent || i;
+					d ? this.hasWalkedCache.hasWalked(f, d) || this.subwalks.add(f, d) : this.matches.add(f, h, !0);
+				}
+			} else a instanceof RegExp && this.subwalks.add(i, r);
 		}
-		if (!options?.quiet) logger.info(`[luals] Ready: ${binaryPath}`);
-		return binaryPath;
-	} finally {
-		if (fs.existsSync(tempDir)) try {
-			fs.rmSync(tempDir, {
-				recursive: true,
-				force: true
+		return this;
+	}
+	subwalkTargets() {
+		return this.subwalks.keys();
+	}
+	child() {
+		return new n(this.opts, this.hasWalkedCache);
+	}
+	filterEntries(t, e) {
+		let s = this.subwalks.get(t), i = this.child();
+		for (let r of e) for (let o of s) {
+			let h = o.isAbsolute(), a = o.pattern(), l = o.rest();
+			a === A ? i.testGlobstar(r, o, l, h) : a instanceof RegExp ? i.testRegExp(r, a, l, h) : i.testString(r, a, l, h);
+		}
+		return i;
+	}
+	testGlobstar(t, e, s, i) {
+		if ((this.dot || !t.name.startsWith(".")) && (e.hasMore() || this.matches.add(t, i, !1), t.canReaddir() && (this.follow || !t.isSymbolicLink() ? this.subwalks.add(t, e) : t.isSymbolicLink() && (s && e.checkFollowGlobstar() ? this.subwalks.add(t, s) : e.markFollowGlobstar() && this.subwalks.add(t, e)))), s) {
+			let r = s.pattern();
+			if (typeof r == "string" && r !== ".." && r !== "" && r !== ".") this.testString(t, r, s.rest(), i);
+			else if (r === "..") {
+				let o = t.parent || t;
+				this.subwalks.add(o, s);
+			} else r instanceof RegExp && this.testRegExp(t, r, s.rest(), i);
+		}
+	}
+	testRegExp(t, e, s, i) {
+		e.test(t.name) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, !1));
+	}
+	testString(t, e, s, i) {
+		t.isNamed(e) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, !1));
+	}
+};
+var Li = (n, t) => typeof n == "string" ? new ot([n], t) : Array.isArray(n) ? new ot(n, t) : n;
+var zt = class {
+	path;
+	patterns;
+	opts;
+	seen = /* @__PURE__ */ new Set();
+	paused = !1;
+	aborted = !1;
+	#t = [];
+	#s;
+	#n;
+	signal;
+	maxDepth;
+	includeChildMatches;
+	constructor(t, e, s) {
+		if (this.patterns = t, this.path = e, this.opts = s, this.#n = !s.posix && s.platform === "win32" ? "\\" : "/", this.includeChildMatches = s.includeChildMatches !== !1, (s.ignore || !this.includeChildMatches) && (this.#s = Li(s.ignore ?? [], s), !this.includeChildMatches && typeof this.#s.add != "function")) throw new Error("cannot ignore child matches, ignore lacks add() method.");
+		this.maxDepth = s.maxDepth || 1 / 0, s.signal && (this.signal = s.signal, this.signal.addEventListener("abort", () => {
+			this.#t.length = 0;
+		}));
+	}
+	#r(t) {
+		return this.seen.has(t) || !!this.#s?.ignored?.(t);
+	}
+	#o(t) {
+		return !!this.#s?.childrenIgnored?.(t);
+	}
+	pause() {
+		this.paused = !0;
+	}
+	resume() {
+		if (this.signal?.aborted) return;
+		this.paused = !1;
+		let t;
+		for (; !this.paused && (t = this.#t.shift());) t();
+	}
+	onResume(t) {
+		this.signal?.aborted || (this.paused ? this.#t.push(t) : t());
+	}
+	async matchCheck(t, e) {
+		if (e && this.opts.nodir) return;
+		let s;
+		if (this.opts.realpath) {
+			if (s = t.realpathCached() || await t.realpath(), !s) return;
+			t = s;
+		}
+		let r = t.isUnknown() || this.opts.stat ? await t.lstat() : t;
+		if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+			let o = await r.realpath();
+			o && (o.isUnknown() || this.opts.stat) && await o.lstat();
+		}
+		return this.matchCheckTest(r, e);
+	}
+	matchCheckTest(t, e) {
+		return t && (this.maxDepth === 1 / 0 || t.depth() <= this.maxDepth) && (!e || t.canReaddir()) && (!this.opts.nodir || !t.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !t.isSymbolicLink() || !t.realpathCached()?.isDirectory()) && !this.#r(t) ? t : void 0;
+	}
+	matchCheckSync(t, e) {
+		if (e && this.opts.nodir) return;
+		let s;
+		if (this.opts.realpath) {
+			if (s = t.realpathCached() || t.realpathSync(), !s) return;
+			t = s;
+		}
+		let r = t.isUnknown() || this.opts.stat ? t.lstatSync() : t;
+		if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+			let o = r.realpathSync();
+			o && (o?.isUnknown() || this.opts.stat) && o.lstatSync();
+		}
+		return this.matchCheckTest(r, e);
+	}
+	matchFinish(t, e) {
+		if (this.#r(t)) return;
+		if (!this.includeChildMatches && this.#s?.add) {
+			let r = `${t.relativePosix()}/**`;
+			this.#s.add(r);
+		}
+		let s = this.opts.absolute === void 0 ? e : this.opts.absolute;
+		this.seen.add(t);
+		let i = this.opts.mark && t.isDirectory() ? this.#n : "";
+		if (this.opts.withFileTypes) this.matchEmit(t);
+		else if (s) {
+			let r = this.opts.posix ? t.fullpathPosix() : t.fullpath();
+			this.matchEmit(r + i);
+		} else {
+			let r = this.opts.posix ? t.relativePosix() : t.relative(), o = this.opts.dotRelative && !r.startsWith(".." + this.#n) ? "." + this.#n : "";
+			this.matchEmit(r ? o + r + i : "." + i);
+		}
+	}
+	async match(t, e, s) {
+		let i = await this.matchCheck(t, s);
+		i && this.matchFinish(i, e);
+	}
+	matchSync(t, e, s) {
+		let i = this.matchCheckSync(t, s);
+		i && this.matchFinish(i, e);
+	}
+	walkCB(t, e, s) {
+		this.signal?.aborted && s(), this.walkCB2(t, e, new Et(this.opts), s);
+	}
+	walkCB2(t, e, s, i) {
+		if (this.#o(t)) return i();
+		if (this.signal?.aborted && i(), this.paused) {
+			this.onResume(() => this.walkCB2(t, e, s, i));
+			return;
+		}
+		s.processPatterns(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || (r++, this.match(h, a, l).then(() => o()));
+		for (let h of s.subwalkTargets()) {
+			if (this.maxDepth !== 1 / 0 && h.depth() >= this.maxDepth) continue;
+			r++;
+			let a = h.readdirCached();
+			h.calledReaddir() ? this.walkCB3(h, a, s, o) : h.readdirCB((l, u) => this.walkCB3(h, u, s, o), !0);
+		}
+		o();
+	}
+	walkCB3(t, e, s, i) {
+		s = s.filterEntries(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || (r++, this.match(h, a, l).then(() => o()));
+		for (let [h, a] of s.subwalks.entries()) r++, this.walkCB2(h, a, s.child(), o);
+		o();
+	}
+	walkCBSync(t, e, s) {
+		this.signal?.aborted && s(), this.walkCB2Sync(t, e, new Et(this.opts), s);
+	}
+	walkCB2Sync(t, e, s, i) {
+		if (this.#o(t)) return i();
+		if (this.signal?.aborted && i(), this.paused) {
+			this.onResume(() => this.walkCB2Sync(t, e, s, i));
+			return;
+		}
+		s.processPatterns(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || this.matchSync(h, a, l);
+		for (let h of s.subwalkTargets()) {
+			if (this.maxDepth !== 1 / 0 && h.depth() >= this.maxDepth) continue;
+			r++;
+			let a = h.readdirSync();
+			this.walkCB3Sync(h, a, s, o);
+		}
+		o();
+	}
+	walkCB3Sync(t, e, s, i) {
+		s = s.filterEntries(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || this.matchSync(h, a, l);
+		for (let [h, a] of s.subwalks.entries()) r++, this.walkCB2Sync(h, a, s.child(), o);
+		o();
+	}
+};
+var xt = class extends zt {
+	matches = /* @__PURE__ */ new Set();
+	constructor(t, e, s) {
+		super(t, e, s);
+	}
+	matchEmit(t) {
+		this.matches.add(t);
+	}
+	async walk() {
+		if (this.signal?.aborted) throw this.signal.reason;
+		return this.path.isUnknown() && await this.path.lstat(), await new Promise((t, e) => {
+			this.walkCB(this.path, this.patterns, () => {
+				this.signal?.aborted ? e(this.signal.reason) : t(this.matches);
+			});
+		}), this.matches;
+	}
+	walkSync() {
+		if (this.signal?.aborted) throw this.signal.reason;
+		return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => {
+			if (this.signal?.aborted) throw this.signal.reason;
+		}), this.matches;
+	}
+};
+var vt = class extends zt {
+	results;
+	constructor(t, e, s) {
+		super(t, e, s), this.results = new V({
+			signal: this.signal,
+			objectMode: !0
+		}), this.results.on("drain", () => this.resume()), this.results.on("resume", () => this.resume());
+	}
+	matchEmit(t) {
+		this.results.write(t), this.results.flowing || this.pause();
+	}
+	stream() {
+		let t = this.path;
+		return t.isUnknown() ? t.lstat().then(() => {
+			this.walkCB(t, this.patterns, () => this.results.end());
+		}) : this.walkCB(t, this.patterns, () => this.results.end()), this.results;
+	}
+	streamSync() {
+		return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => this.results.end()), this.results;
+	}
+};
+var Pi = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux";
+var I = class {
+	absolute;
+	cwd;
+	root;
+	dot;
+	dotRelative;
+	follow;
+	ignore;
+	magicalBraces;
+	mark;
+	matchBase;
+	maxDepth;
+	nobrace;
+	nocase;
+	nodir;
+	noext;
+	noglobstar;
+	pattern;
+	platform;
+	realpath;
+	scurry;
+	stat;
+	signal;
+	windowsPathsNoEscape;
+	withFileTypes;
+	includeChildMatches;
+	opts;
+	patterns;
+	constructor(t, e) {
+		if (!e) throw new TypeError("glob options required");
+		if (this.withFileTypes = !!e.withFileTypes, this.signal = e.signal, this.follow = !!e.follow, this.dot = !!e.dot, this.dotRelative = !!e.dotRelative, this.nodir = !!e.nodir, this.mark = !!e.mark, e.cwd ? (e.cwd instanceof URL || e.cwd.startsWith("file://")) && (e.cwd = fileURLToPath(e.cwd)) : this.cwd = "", this.cwd = e.cwd || "", this.root = e.root, this.magicalBraces = !!e.magicalBraces, this.nobrace = !!e.nobrace, this.noext = !!e.noext, this.realpath = !!e.realpath, this.absolute = e.absolute, this.includeChildMatches = e.includeChildMatches !== !1, this.noglobstar = !!e.noglobstar, this.matchBase = !!e.matchBase, this.maxDepth = typeof e.maxDepth == "number" ? e.maxDepth : 1 / 0, this.stat = !!e.stat, this.ignore = e.ignore, this.withFileTypes && this.absolute !== void 0) throw new Error("cannot set absolute and withFileTypes:true");
+		if (typeof t == "string" && (t = [t]), this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === !1, this.windowsPathsNoEscape && (t = t.map((a) => a.replace(/\\/g, "/"))), this.matchBase) {
+			if (e.noglobstar) throw new TypeError("base matching requires globstar");
+			t = t.map((a) => a.includes("/") ? a : `./**/${a}`);
+		}
+		if (this.pattern = t, this.platform = e.platform || Pi, this.opts = {
+			...e,
+			platform: this.platform
+		}, e.scurry) {
+			if (this.scurry = e.scurry, e.nocase !== void 0 && e.nocase !== e.scurry.nocase) throw new Error("nocase option contradicts provided scurry option");
+		} else {
+			let a = e.platform === "win32" ? it : e.platform === "darwin" ? St : e.platform ? rt : Xe;
+			this.scurry = new a(this.cwd, {
+				nocase: e.nocase,
+				fs: e.fs
 			});
-		} catch (err) {
-			logger.debug(`[luals] Failed to clean up temporary directory ${tempDir}: ${err instanceof Error ? err.message : String(err)}`);
 		}
+		this.nocase = this.scurry.nocase;
+		let s = this.platform === "darwin" || this.platform === "win32", i = {
+			braceExpandMax: 1e4,
+			...e,
+			dot: this.dot,
+			matchBase: this.matchBase,
+			nobrace: this.nobrace,
+			nocase: this.nocase,
+			nocaseMagicOnly: s,
+			nocomment: !0,
+			noext: this.noext,
+			nonegate: !0,
+			optimizationLevel: 2,
+			platform: this.platform,
+			windowsPathsNoEscape: this.windowsPathsNoEscape,
+			debug: !!this.opts.debug
+		}, [o, h] = this.pattern.map((a) => new D(a, i)).reduce((a, l) => (a[0].push(...l.set), a[1].push(...l.globParts), a), [[], []]);
+		this.patterns = o.map((a, l) => {
+			let u = h[l];
+			if (!u) throw new Error("invalid pattern object");
+			return new nt(a, u, 0, this.platform);
+		});
+	}
+	async walk() {
+		return [...await new xt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).walk()];
+	}
+	walkSync() {
+		return [...new xt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).walkSync()];
+	}
+	stream() {
+		return new vt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).stream();
+	}
+	streamSync() {
+		return new vt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).streamSync();
+	}
+	iterateSync() {
+		return this.streamSync()[Symbol.iterator]();
+	}
+	[Symbol.iterator]() {
+		return this.iterateSync();
+	}
+	iterate() {
+		return this.stream()[Symbol.asyncIterator]();
+	}
+	[Symbol.asyncIterator]() {
+		return this.iterate();
 	}
+};
+var le = (n, t = {}) => {
+	Array.isArray(n) || (n = [n]);
+	for (let e of n) if (new D(e, t).hasMagic()) return !0;
+	return !1;
+};
+function Bt(n, t = {}) {
+	return new I(n, t).streamSync();
 }
+function Qe(n, t = {}) {
+	return new I(n, t).stream();
+}
+function ts(n, t = {}) {
+	return new I(n, t).walkSync();
+}
+async function Je(n, t = {}) {
+	return new I(n, t).walk();
+}
+function Ut(n, t = {}) {
+	return new I(n, t).iterateSync();
+}
+function es(n, t = {}) {
+	return new I(n, t).iterate();
+}
+var ji = Bt;
+var Ii = Object.assign(Qe, { sync: Bt });
+var zi = Ut;
+var Bi = Object.assign(es, { sync: Ut });
+var Ui = Object.assign(ts, {
+	stream: Bt,
+	iterate: Ut
+});
+var Ze = Object.assign(Je, {
+	glob: Je,
+	globSync: ts,
+	sync: Ui,
+	globStream: Qe,
+	stream: Ii,
+	globStreamSync: Bt,
+	streamSync: ji,
+	globIterate: es,
+	iterate: Bi,
+	globIterateSync: Ut,
+	iterateSync: zi,
+	Glob: I,
+	hasMagic: le,
+	escape: tt,
+	unescape: W
+});
+Ze.glob = Ze;
 //#endregion
 //#region src/luals/files.ts
+/** Directories skipped unless the workspace config overrides `workspace.ignoreDir`. */
+const DEFAULT_IGNORE_DIRS = [
+	".git",
+	".vscode",
+	".nanos-lint",
+	"node_modules"
+];
+/** Candidate Lua files: LuaLS checks every `*.lua` file in the tree. */
+const LUA_FILE_PATTERN = "**/*.lua";
+/** `glob` rejects patterns longer than this, so they are dropped before matching. */
+const MAX_PATTERN_LENGTH = 65536;
+/**
+* Complexity budget per pattern. `minimatch` evaluates patterns through an AST
+* but still compiles them to regular expressions, so ambiguous wildcards inside
+* one path segment can backtrack, and brace groups expand combinatorially
+* (`{a,b}` repeated 16 times is 65 536 alternatives). A hostile or accidental
+* `.luarc.json` could otherwise stall the file walk, so patterns beyond the
+* budget are skipped with a warning instead of being matched.
+*
+* The ambiguity of one segment grows like `C(segment length, wildcards)`, so the
+* per-segment cap is what keeps matching cheap. `**\/*a*a*a*a\/*a*a*a*a\/*a*a*a*a\/*a*a*a*z.lua`
+* (4 wildcards per segment) stays within a 4-wildcard cap yet costs ~5 ms per
+* candidate file — ~100 s on a 20 000-file tree — while two wildcards per
+* segment cost `C(60, 2) = 1 770` splits, hundreds of times less. The budget is
+* deliberately far below what minimatch can parse: every realistic pattern
+* (`**\/*.{bak,tmp}`, `**\/node_modules\/**`, `**\/item-[0-9].lua`,
+* `**\/*.min.*`) needs at most two wildcards in any one segment.
+*/
+const MAX_WILDCARDS_PER_SEGMENT = 2;
+const MAX_TOTAL_WILDCARDS = 12;
+const MAX_BRACE_ALTERNATIVES = 256;
+/** Counts wildcard tokens (`*`, `?`, character classes and brace groups). */
+function countWildcards(value) {
+	let count = 0;
+	for (const char of value) if (char === "*" || char === "?" || char === "[" || char === "{") count += 1;
+	return count;
+}
+/**
+* Upper bound of the alternatives brace expansion would produce; `1` when the
+* pattern has no brace groups. Nested groups count towards their parent, which
+* over-estimates on purpose so the bound stays safe.
+*/
+function estimateBraceAlternatives(pattern) {
+	const pending = [];
+	let estimate = 1;
+	for (const char of pattern) if (char === "{") pending.push(0);
+	else if (char === "}" && pending.length > 0) {
+		const alternatives = (pending.pop() ?? 0) + 1;
+		estimate *= alternatives;
+		if (pending.length > 0) pending[pending.length - 1] = (pending[pending.length - 1] ?? 0) + alternatives - 1;
+	} else if (char === "," && pending.length > 0) pending[pending.length - 1] = (pending[pending.length - 1] ?? 0) + 1;
+	return estimate;
+}
+/** Returns `false` when matching the pattern could become pathologically slow. */
+function isPatternWithinBudget(pattern) {
+	if (estimateBraceAlternatives(pattern) > MAX_BRACE_ALTERNATIVES) return false;
+	if (countWildcards(pattern) > MAX_TOTAL_WILDCARDS) return false;
+	return pattern.split("/").every((segment) => countWildcards(segment) <= MAX_WILDCARDS_PER_SEGMENT);
+}
+/**
+* Normalizes one user-supplied pattern (`workspace.ignoreDir`, `files.exclude`
+* or a built-in default) into the slash-separated form `glob` expects.
+* Backslashes are accepted as separators so Windows-authored `.luarc.json`
+* files keep working, and trailing slashes are dropped so `vendor/` behaves
+* exactly like `vendor`. Patterns that cannot be matched (`""`, `"."`, NUL
+* bytes, oversized input, absolute paths, or non-string JSON values) are
+* rejected instead of being handed to `glob`.
+*/
+function normalizePattern(pattern) {
+	if (typeof pattern !== "string") return null;
+	const normalized = pattern.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+	if (!normalized || normalized === "." || normalized.length > MAX_PATTERN_LENGTH || normalized.includes("\0") || isAbsolutePattern(normalized)) return null;
+	return normalized;
+}
+/** Drive-letter prefixes, recognized on every platform (not just Windows). */
+const WINDOWS_ABSOLUTE_PATTERN = /^[A-Za-z]:\//;
+/**
+* `workspace.ignoreDir` / `files.exclude` entries are workspace-relative in
+* LuaLS, and `glob` matches ignore patterns against walk-relative paths. An
+* absolute entry is therefore unusable, and `glob` anchors it on some platforms
+* but not others (a macOS `/var` -> `/private/var` walk root or a Windows drive
+* letter behave differently again), so it is skipped to keep one `.luarc.json`
+* behaving identically on Linux, macOS and Windows.
+*/
+function isAbsolutePattern(normalized) {
+	return path.posix.isAbsolute(normalized) || WINDOWS_ABSOLUTE_PATTERN.test(normalized);
+}
+/**
+* Expands one LuaLS pattern into the equivalent `glob` ignore patterns:
+*
+* - basename-only patterns (`*.lua`, `vendor`) match at any depth, so the
+*   `**\/`-prefixed variants are added (mirrors LuaLS `matchBase` semantics);
+* - a pattern also excludes everything below a matching directory, which is
+*   what the trailing `/**` variant expresses;
+* - the pattern itself is always kept so an exact file or directory match
+*   works as written.
+*/
+function expandIgnorePattern(pattern) {
+	return pattern.includes("/") ? [pattern, `${pattern}/**`] : [`**/${pattern}`, `**/${pattern}/**`];
+}
+/** Normalizes and expands a list of LuaLS patterns into `glob` ignore patterns. */
+function toIgnorePatterns(patterns) {
+	const ignore = [];
+	for (const raw of patterns) {
+		const normalized = normalizePattern(raw);
+		if (!normalized) {
+			logger.debug(`[luals] Skipping unusable glob pattern "${String(raw)}" while counting checked files.`);
+			continue;
+		}
+		if (!isPatternWithinBudget(normalized)) {
+			logger.warn(`[luals] Skipping glob pattern "${raw}": it is too complex to match safely and would slow down file counting.`);
+			continue;
+		}
+		ignore.push(...expandIgnorePattern(normalized));
+	}
+	return ignore;
+}
 /**
-* Counts candidate Lua files within targetPath, taking ignoreDir and files.exclude into account.
+* Counts candidate Lua files within targetPath, taking `workspace.ignoreDir`
+* and `files.exclude` into account.
+*
+* Traversal and matching are delegated to the bundled `glob` package, whose
+* `minimatch` matcher understands the full glob syntax LuaLS accepts (brace
+* expansion, character classes, `**`, `?`) instead of the hand-rolled
+* glob-to-regex translation used before. Combined with the pattern budgets
+* above, this keeps the count predictable for adversarial configurations
+* while remaining consistent with LuaLS exclude semantics (#27).
 */
 function countCheckedFiles(targetPath, configPath) {
-	const absPath = path.resolve(targetPath);
+	let absPath = path.resolve(targetPath);
 	if (!fs.existsSync(absPath)) return 0;
+	try {
+		absPath = fs.realpathSync.native(absPath);
+	} catch {
+		try {
+			absPath = fs.realpathSync(absPath);
+		} catch (err) {}
+	}
 	if (fs.statSync(absPath).isFile()) return absPath.toLowerCase().endsWith(".lua") ? 1 : 0;
-	let ignoreDirs = [
-		".git",
-		".vscode",
-		".nanos-lint",
-		"node_modules"
-	];
+	let ignoreDirs = DEFAULT_IGNORE_DIRS;
 	let excludePatterns = [];
 	if (configPath && fs.existsSync(configPath)) try {
 		const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-		if (cfg.workspace?.ignoreDir) ignoreDirs = cfg.workspace.ignoreDir;
-		if (cfg.files?.exclude) excludePatterns = cfg.files.exclude;
+		if (Array.isArray(cfg.workspace?.ignoreDir)) ignoreDirs = cfg.workspace.ignoreDir;
+		if (Array.isArray(cfg.files?.exclude)) excludePatterns = cfg.files.exclude;
 	} catch (err) {
 		logger.warn(`[luals] Failed to parse config file for file counting at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
 	}
-	const normIgnoreDirs = new Set(ignoreDirs.map((d) => d.replace(/\\/g, "/").toLowerCase()));
-	function isExcluded(relPath) {
-		const norm = relPath.replace(/\\/g, "/");
-		const baseName = path.posix.basename(norm);
-		for (const pat of excludePatterns) {
-			const normPat = pat.replace(/\\/g, "/");
-			if (norm === normPat || baseName === normPat) return true;
-			if (normPat.endsWith("/**")) {
-				const dir = normPat.slice(0, -3);
-				if (norm === dir || norm.startsWith(`${dir}/`)) return true;
-			}
-			if (norm.startsWith(`${normPat}/`)) return true;
-			if (normPat.includes("*") || normPat.includes("?")) {
-				if (!normPat.includes("/")) {
-					const baseRegexStr = "^" + normPat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
-					try {
-						if (new RegExp(baseRegexStr, "i").test(baseName)) return true;
-					} catch (err) {
-						logger.debug(`[luals] Invalid regex for pattern "${normPat}": ${err instanceof Error ? err.message : String(err)}`);
-					}
-				}
-				let regexStr = normPat;
-				const hasLeadingDoubleStar = regexStr.startsWith("**/");
-				if (hasLeadingDoubleStar) regexStr = regexStr.slice(3);
-				const hasTrailingDoubleStar = regexStr.endsWith("/**");
-				if (hasTrailingDoubleStar) regexStr = regexStr.slice(0, -3);
-				let escaped = regexStr.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*\//g, "/(?:.*/)?").replace(/\*\*/g, ".*").replace(/(?<!\.)\*/g, "[^/]*").replace(/\?/g, "[^/]");
-				if (hasLeadingDoubleStar) escaped = `(?:^|.*/)${escaped}`;
-				if (hasTrailingDoubleStar) escaped = `${escaped}(?:/.*)?`;
-				try {
-					if (new RegExp(`^${escaped}$`, "i").test(norm)) return true;
-				} catch (err) {
-					logger.debug(`[luals] Invalid glob regex for pattern "${normPat}": ${err instanceof Error ? err.message : String(err)}`);
-				}
-			}
-		}
-		return false;
-	}
-	let count = 0;
-	function walk(currentDir, relDir = "") {
-		let entries;
-		try {
-			entries = fs.readdirSync(currentDir, { withFileTypes: true });
-		} catch (err) {
-			logger.debug(`[luals] Failed to read directory ${currentDir}: ${err instanceof Error ? err.message : String(err)}`);
-			return;
-		}
-		for (const entry of entries) {
-			const name = entry.name;
-			const relPath = relDir ? `${relDir}/${name}` : name;
-			const fullPath = path.join(currentDir, name);
-			if (entry.isDirectory() || entry.isSymbolicLink() && (() => {
-				try {
-					return fs.statSync(fullPath).isDirectory();
-				} catch (err) {
-					logger.debug(`[luals] Failed to stat symlink target ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
-					return false;
-				}
-			})()) {
-				const lowerName = name.toLowerCase();
-				if (normIgnoreDirs.has(lowerName) || normIgnoreDirs.has(relPath.toLowerCase())) continue;
-				if (isExcluded(relPath) || isExcluded(`${relPath}/**`)) continue;
-				walk(fullPath, relPath);
-			} else if (entry.isFile() && name.toLowerCase().endsWith(".lua")) {
-				if (!isExcluded(relPath)) count++;
-			}
-		}
+	const ignore = [...toIgnorePatterns(ignoreDirs), ...toIgnorePatterns(excludePatterns)];
+	try {
+		return ts(LUA_FILE_PATTERN, {
+			cwd: absPath,
+			ignore,
+			dot: true,
+			nocase: true,
+			follow: false,
+			withFileTypes: true
+		}).filter((entry) => entry.isFile()).length;
+	} catch (err) {
+		logger.warn(`[luals] Failed to walk ${absPath} while counting checked files: ${err instanceof Error ? err.message : String(err)}`);
+		return 0;
 	}
-	walk(absPath);
-	return count;
 }
 //#endregion
 //#region src/luals/runner.ts
@@ -1896,7 +5416,7 @@ function isOfflineError(err) {
 	return /offline|enotfound|eai_again|econnrefused|etimedout|fetch failed/i.test(msg);
 }
 async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
-	if (process.env.LUALS_BIN && fs.existsSync(process.env.LUALS_BIN)) return process.env.LUALS_BIN;
+	if (process.env.LUALS_BIN) return assertValidLuaLSBinary(process.env.LUALS_BIN, "LUALS_BIN");
 	if (options?.reuseExisting !== false && (!version || version === "latest")) {
 		const defaultInfo = getPlatformInfo(FALLBACK_LUALS_VERSION);
 		const defaultBundledPath = path.join(getPackageRoot(), defaultInfo.binaryRelativePath);
@@ -1985,10 +5505,15 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	}
 	const currentWeek = getIsoWeek();
 	const metadata = readLuaLSMetadata(baseCacheDir);
-	if (options?.reuseExisting !== false && metadata && metadata.lastCheckedWeek === currentWeek && metadata.latestVersion) {
-		const info = getPlatformInfo(metadata.latestVersion);
-		const cachedPath = path.join(getCacheDir(metadata.latestVersion, baseCacheDir), info.binaryRelativePath);
-		if (isBinaryValid(cachedPath)) return cachedPath;
+	const safeLatest = metadata?.latestVersion ? sanitizeLuaLSVersion(metadata.latestVersion) : null;
+	if (options?.reuseExisting !== false && metadata && metadata.lastCheckedWeek === currentWeek && safeLatest) {
+		const info = getPlatformInfo(safeLatest);
+		const targetDir = path.resolve(getCacheDir(safeLatest, baseCacheDir));
+		const resolvedBase = path.resolve(baseCacheDir);
+		if (targetDir.startsWith(resolvedBase + path.sep) || targetDir === resolvedBase) {
+			const cachedPath = path.join(targetDir, info.binaryRelativePath);
+			if (isBinaryValid(cachedPath)) return cachedPath;
+		}
 	}
 	const cachedVersions = options?.reuseExisting !== false ? listCachedLuaLSVersions(baseCacheDir) : [];
 	const firstCachedVersion = cachedVersions[0];
@@ -2055,7 +5580,7 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 		logger.debug(`[luals] Failed to resolve native realpath for target: ${err instanceof Error ? err.message : String(err)}`);
 	}
 	if (!fs.existsSync(absoluteTarget)) throw new LuaLSError(`Target path does not exist: ${targetPath}`, "ERR_TARGET_NOT_FOUND", "Verify that the target path exists and is accessible.");
-	const binary = options.lualsBin || await resolveLuaLSBinary(options.lualsVersion, { quiet: options.quiet });
+	const binary = options.lualsBin ? assertValidLuaLSBinary(options.lualsBin, "--luals-bin") : await resolveLuaLSBinary(options.lualsVersion, { quiet: options.quiet });
 	let checkDir = absoluteTarget;
 	let targetFileOnly = null;
 	if (fs.statSync(absoluteTarget).isFile()) {
@@ -5291,9 +8816,10 @@ function readAnnotationsMetadata(cacheDir = getAnnotationsCacheDir()) {
 	}
 	return null;
 }
+const MIN_ANNOTATIONS_SIZE_BYTES = 1e3;
 /**
-* Verifies that an annotations file exists, is a regular file, is of non-trivial size (>= 1000 bytes),
-* and begins with valid Lua comments or nanos world definitions.
+* Verifies that an annotations file exists, is a regular file, is of non-trivial size (>= MIN_ANNOTATIONS_SIZE_BYTES),
+* and begins with valid LuaLS metadata or nanos world definitions.
 */
 function isAnnotationsValid(filePath) {
 	if (!fs.existsSync(filePath)) return false;
@@ -5301,11 +8827,11 @@ function isAnnotationsValid(filePath) {
 		const stat = fs.statSync(filePath);
 		if (!stat.isFile() || stat.size < 1e3) return false;
 		const fd = fs.openSync(filePath, "r");
-		const buffer = Buffer.alloc(256);
-		const bytesRead = fs.readSync(fd, buffer, 0, 256, 0);
+		const buffer = Buffer.alloc(512);
+		const bytesRead = fs.readSync(fd, buffer, 0, 512, 0);
 		fs.closeSync(fd);
 		const header = buffer.toString("utf-8", 0, bytesRead).trimStart();
-		return header.startsWith("--") || header.includes("nanos world");
+		return header.startsWith("---@meta") || header.includes("nanos world") || header.includes("nanos-world");
 	} catch (err) {
 		logger.debug(`[annotations] Annotation validation failed for ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
 		return false;
@@ -5328,8 +8854,16 @@ async function fetchLatestCommitId() {
 	}
 	return null;
 }
-async function fetchRawAnnotationsContent() {
-	const res = await fetch(RAW_ANNOTATIONS_URL, {
+/**
+* Returns raw annotations URL, pinned to commit SHA if provided and valid.
+*/
+function getRawAnnotationsUrl(commitSha) {
+	if (commitSha && /^[0-9a-fA-F]{7,40}$/.test(commitSha)) return `https://raw.githubusercontent.com/${DOCGEN_REPO}/${commitSha}/annotations.lua`;
+	return RAW_ANNOTATIONS_URL;
+}
+async function fetchRawAnnotationsContent(commitSha) {
+	const url = getRawAnnotationsUrl(commitSha);
+	const res = await fetch(url, {
 		headers: { "User-Agent": "nanos-lint" },
 		signal: AbortSignal.timeout(15e3)
 	});
@@ -5393,7 +8927,7 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 			if (commitId && commitId !== "unknown") logger.info(`[annotations] Downloading nanos world API annotations (${commitId.slice(0, 7)})...`);
 			else logger.info("[annotations] Downloading nanos world API annotations...");
 		}
-		const content = await fetchRawAnnotationsContent();
+		const content = await fetchRawAnnotationsContent(commitId);
 		const tempAnnotationsPath = path.join(tempDir, ANNOTATIONS_FILENAME);
 		fs.writeFileSync(tempAnnotationsPath, content, "utf-8");
 		const { dateStr, dateObj } = getTodayDateString();
@@ -5405,7 +8939,7 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 		const tempMetaPath = path.join(tempDir, METADATA_FILENAME);
 		fs.writeFileSync(tempMetaPath, JSON.stringify(metadata, null, 2), "utf-8");
 		const existingMeta = readAnnotationsMetadata(cacheDir);
-		if (existingMeta && existingMeta.commitId === commitId && fs.existsSync(finalAnnotationsPath) && fs.statSync(finalAnnotationsPath).size >= 1e3) return finalAnnotationsPath;
+		if (existingMeta && existingMeta.commitId === commitId && fs.existsSync(finalAnnotationsPath) && isAnnotationsValid(finalAnnotationsPath)) return finalAnnotationsPath;
 		const oldAnnotationsExists = fs.existsSync(finalAnnotationsPath);
 		const oldMetaExists = fs.existsSync(finalMetaPath);
 		if (oldAnnotationsExists || oldMetaExists) {
@@ -5446,6 +8980,26 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 		}
 	}
 }
+function validateCustomAnnotationsPath(filePath, source) {
+	const resolved = path.resolve(filePath);
+	if (!fs.existsSync(resolved)) {
+		if (source === "custom") throw new AnnotationsError(`Custom annotations file not found: ${resolved}`, "ERR_ANNOTATIONS_NOT_FOUND", "Verify that the path specified in --annotations exists and is accessible.");
+		else throw new AnnotationsError(`Annotations file specified in environment not found: ${resolved}`, "ERR_ANNOTATIONS_ENV_NOT_FOUND", "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS exists.");
+	}
+	const stat = fs.statSync(resolved);
+	if (!stat.isFile()) throw new AnnotationsError(source === "custom" ? `Custom annotations path is not a file: ${resolved}` : `Annotations path specified in environment is not a file: ${resolved}`, "ERR_ANNOTATIONS_NOT_A_FILE", source === "custom" ? "Verify that the path specified in --annotations points to a regular file, not a directory." : "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS points to a regular file, not a directory.");
+	if (stat.size === 0) throw new AnnotationsError(source === "custom" ? `Custom annotations file is empty: ${resolved}` : `Annotations file specified in environment is empty: ${resolved}`, "ERR_ANNOTATIONS_INVALID", source === "custom" ? "Verify that the path specified in --annotations is a valid non-empty Lua annotations file." : "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS is a valid non-empty Lua annotations file.");
+	try {
+		const fd = fs.openSync(resolved, "r");
+		const buffer = Buffer.alloc(Math.min(stat.size, 512));
+		const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+		fs.closeSync(fd);
+		if (buffer.subarray(0, bytesRead).includes(0)) throw new AnnotationsError(source === "custom" ? `Custom annotations file appears to be a binary file: ${resolved}` : `Annotations file specified in environment appears to be a binary file: ${resolved}`, "ERR_ANNOTATIONS_INVALID", "Verify that the annotations file is a valid Lua text annotations file.");
+	} catch (err) {
+		if (err instanceof AnnotationsError) throw err;
+	}
+	return resolved;
+}
 /**
 * Resolves the nanos world annotations.lua definitions file path.
 * Resolution precedence:
@@ -5455,17 +9009,9 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 * 4. User cache (checked once per day from upstream GitHub)
 */
 async function resolveAnnotations(options = {}) {
-	if (options.customPath) {
-		const resolved = path.resolve(options.customPath);
-		if (!fs.existsSync(resolved)) throw new AnnotationsError(`Custom annotations file not found: ${resolved}`, "ERR_ANNOTATIONS_NOT_FOUND", "Verify that the path specified in --annotations exists and is accessible.");
-		return resolved;
-	}
+	if (options.customPath) return validateCustomAnnotationsPath(options.customPath, "custom");
 	const envPath = process.env.NANOS_ANNOTATIONS_PATH || process.env.NANOS_ANNOTATIONS;
-	if (envPath) {
-		const resolved = path.resolve(envPath);
-		if (!fs.existsSync(resolved)) throw new AnnotationsError(`Annotations file specified in environment not found: ${resolved}`, "ERR_ANNOTATIONS_ENV_NOT_FOUND", "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS exists.");
-		return resolved;
-	}
+	if (envPath) return validateCustomAnnotationsPath(envPath, "env");
 	const bundled = path.join(getPackageRoot(), "annotations.lua");
 	if (fs.existsSync(bundled) && isAnnotationsValid(bundled)) return bundled;
 	const cacheDir = options.cacheDir ?? getAnnotationsCacheDir();
@@ -5845,6 +9391,6 @@ if (isDirectExecution()) runCLI().then((code) => {
 	process.exit(1);
 });
 //#endregion
-export { fetchLatestLuaLSVersionFromGitHub as $, pluralize as A, logger as At, getBaseLuaLSCacheDir as B, updateLastCheckedDate as C, systemPaths as Ct, formatReport as D, LOG_LEVEL_PRIORITY as Dt, formatProblemSummary as E, LOG_LEVELS as Et, downloadAndExtractLuaLS as F, listCachedLuaLSVersionDirs as G, getIsoWeek as H, escapePowerShellSingleQuote as I, writeLuaLSMetadata as J, listCachedLuaLSVersions as K, LUALS_METADATA_FILENAME as L, resolveLuaLSBinary as M, runLuaLSCheck as N, formatSeverityBadge as O, Logger as Ot, countCheckedFiles as P, FALLBACK_LUALS_VERSION as Q, cleanupOldCachedLuaLSVersions as R, resolveAnnotations as S, getDirectorySize as St, formatPretty as T, DEFAULT_LOG_LEVEL as Tt, getLegacyCacheDir as U, getCacheDir as V, getLuaLSMetadataPath as W, getPlatformInfo as X, isBinaryValid as Y, DEFAULT_LUALS_VERSION as Z, getAnnotationsMetadataFilePath as _, ConfigError as _t, formatCacheStatusPretty as a, getDefaultTemplatePath as at, isAnnotationsValid as b, cleanCache as bt, DOCGEN_BRANCH as c, initWorkspace as ct, METADATA_FILENAME as d, parseJsonc as dt, resolveLatestLuaLSVersion as et, RAW_ANNOTATIONS_URL as f, resolveWorkspaceConfig as ft, getAnnotationsCacheDir as g, CacheError as gt, fetchRawAnnotationsContent as h, AnnotationsError as ht, runCLI as i, getDefaultAnnotationsPath as it, shouldEnableColor as j, parseLogLevel as jt, getColors as k, isValidLogLevel as kt, DOCGEN_REPO as l, loadConfigFile as lt, fetchLatestCommitId as m, stripTrailingSlashes as mt, createProgram as n, sanitizeLuaLSVersion as nt, getCacheStatus as o, getDefinitionsDir as ot, downloadAndCacheAnnotations as p, stripJsonComments as pt, readLuaLSMetadata as q, isDirectExecution as r, VALID_LUALS_DIAGNOSTIC_CODES as rt, ANNOTATIONS_FILENAME as s, getPackageRoot as st, collectIgnorePatterns as t, resolveLuaLSVersion as tt, GITHUB_COMMITS_API as u, mergeConfigs as ut, getCachedAnnotationsFilePath as v, LuaLSError as vt, formatGitHubAnnotations as w, fileUriToPath as wt, readAnnotationsMetadata as x, formatBytes as xt, getTodayDateString as y, NanosLintError as yt, findExistingLuaLSDir as z };
+export { listCachedLuaLSVersionDirs as $, formatSeverityBadge as A, NanosLintError as At, computeFileSha256 as B, isValidLogLevel as Bt, readAnnotationsMetadata as C, resolveWorkspaceConfig as Ct, formatPretty as D, CacheError as Dt, formatGitHubAnnotations as E, AnnotationsError as Et, runLuaLSCheck as F, fileUriToPath as Ft, LUALS_METADATA_FILENAME as G, escapePowerShellSingleQuote as H, parseLogLevel as Ht, countCheckedFiles as I, DEFAULT_LOG_LEVEL as It, getBaseLuaLSCacheDir as J, cleanupOldCachedLuaLSVersions as K, ALLOWED_DOWNLOAD_DOMAINS as L, LOG_LEVELS as Lt, pluralize as M, formatBytes as Mt, shouldEnableColor as N, getDirectorySize as Nt, formatProblemSummary as O, ConfigError as Ot, resolveLuaLSBinary as P, systemPaths as Pt, getLuaLSMetadataPath as Q, DOWNLOAD_TIMEOUT_MS as R, LOG_LEVEL_PRIORITY as Rt, isAnnotationsValid as S, parseJsonc as St, updateLastCheckedDate as T, stripTrailingSlashes as Tt, isAllowedDownloadUrl as U, downloadAndExtractLuaLS as V, logger as Vt, limitDownloadStream as W, getIsoWeek as X, getCacheDir as Y, getLegacyCacheDir as Z, getAnnotationsCacheDir as _, getDefinitionsDir as _t, formatCacheStatusPretty as a, isBinaryRunnable as at, getRawAnnotationsUrl as b, loadConfigFile as bt, DOCGEN_BRANCH as c, DEFAULT_LUALS_VERSION as ct, METADATA_FILENAME as d, resolveLatestLuaLSVersion as dt, listCachedLuaLSVersions as et, MIN_ANNOTATIONS_SIZE_BYTES as f, resolveLuaLSVersion as ft, fetchRawAnnotationsContent as g, getDefaultTemplatePath as gt, fetchLatestCommitId as h, getDefaultAnnotationsPath as ht, runCLI as i, assertValidLuaLSBinary as it, getColors as j, cleanCache as jt, formatReport as k, LuaLSError as kt, DOCGEN_REPO as l, FALLBACK_LUALS_VERSION as lt, downloadAndCacheAnnotations as m, VALID_LUALS_DIAGNOSTIC_CODES as mt, createProgram as n, writeLuaLSMetadata as nt, getCacheStatus as o, isBinaryValid as ot, RAW_ANNOTATIONS_URL as p, sanitizeLuaLSVersion as pt, findExistingLuaLSDir as q, isDirectExecution as r, MIN_DOWNLOADED_BINARY_SIZE_BYTES as rt, ANNOTATIONS_FILENAME as s, getPlatformInfo as st, collectIgnorePatterns as t, readLuaLSMetadata as tt, GITHUB_COMMITS_API as u, fetchLatestLuaLSVersionFromGitHub as ut, getAnnotationsMetadataFilePath as v, getPackageRoot as vt, resolveAnnotations as w, stripJsonComments as wt, getTodayDateString as x, mergeConfigs as xt, getCachedAnnotationsFilePath as y, initWorkspace as yt, MAX_ARCHIVE_SIZE_BYTES as z, Logger as zt };
 
-//# sourceMappingURL=cli-DGez8MSI.js.map
+//# sourceMappingURL=cli-BAy_Ztvh.js.map