nanos-lint 2.8.0 → 2.8.2

package/dist/{cli-DGez8MSI.js → cli-BTHx4yp_.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 { promisify, stripVTControlCharacters } from "node:util";
+import crypto from "node:crypto";
+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",
@@ -22,9 +29,11 @@ const LOG_LEVEL_PRIORITY = {
 	debug: 4
 };
 const DEFAULT_LOG_LEVEL = "warn";
+/** Validates whether a string corresponds to a recognized log level. */
 function isValidLogLevel(level) {
 	return level in LOG_LEVEL_PRIORITY;
 }
+/** Parses a string into a valid LogLevel, defaulting to 'warn'. */
 function parseLogLevel(raw) {
 	if (!raw) return DEFAULT_LOG_LEVEL;
 	const lower = raw.trim().toLowerCase();
@@ -39,12 +48,15 @@ var Logger = class {
 			if (envLevel && isValidLogLevel(envLevel.trim().toLowerCase())) this.level = envLevel.trim().toLowerCase();
 		}
 	}
+	/** Sets the active minimum logging level. */
 	setLevel(level) {
 		if (isValidLogLevel(level)) this.level = level;
 	}
+	/** Returns the current active log level. */
 	getLevel() {
 		return this.level;
 	}
+	/** Checks if a message at the specified level should be emitted. */
 	isEnabledFor(level) {
 		return LOG_LEVEL_PRIORITY[this.level] >= LOG_LEVEL_PRIORITY[level];
 	}
@@ -52,15 +64,19 @@ var Logger = class {
 	isOutputEnabled() {
 		return this.level !== "silent";
 	}
+	/** Logs an error-level message to stderr. */
 	error(...args) {
 		if (this.isEnabledFor("error")) console.error(...args);
 	}
+	/** Logs a warning-level message to stderr. */
 	warn(...args) {
 		if (this.isEnabledFor("warn")) console.warn(...args);
 	}
+	/** Logs an informational message to stdout. */
 	info(...args) {
 		if (this.isEnabledFor("info")) console.log(...args);
 	}
+	/** Logs a debug-level diagnostic message to stdout. */
 	debug(...args) {
 		if (this.isEnabledFor("debug")) console.debug(...args);
 	}
@@ -1015,6 +1031,7 @@ function getPackageRoot() {
 	}
 	return path.resolve(__dirname, "..");
 }
+/** Resolves the default annotations path from environment variable, bundled file, or user cache. */
 function getDefaultAnnotationsPath() {
 	const envPath = process.env.NANOS_ANNOTATIONS_PATH || process.env.NANOS_ANNOTATIONS;
 	if (envPath && fs.existsSync(envPath)) return path.resolve(envPath);
@@ -1029,6 +1046,7 @@ function getDefaultAnnotationsPath() {
 function getDefinitionsDir() {
 	return path.dirname(getDefaultAnnotationsPath());
 }
+/** Resolves the absolute path to the default .luarc.json template shipped with the package. */
 function getDefaultTemplatePath() {
 	const root = getPackageRoot();
 	return path.join(root, "templates", ".luarc.json");
@@ -1040,6 +1058,7 @@ function stripJsonComments(text) {
 	const cleanText = text.replace(/^\uFEFF/, "");
 	return stripComments(cleanText);
 }
+/** Parses JSONC text with support for comments and trailing commas. */
 function parseJsonc(text) {
 	const cleanText = text.replace(/^\uFEFF/, "");
 	const errors = [];
@@ -1050,6 +1069,7 @@ function parseJsonc(text) {
 	}
 	return result;
 }
+/** Reads and parses a .luarc.json configuration file from disk. */
 function loadConfigFile(filePath) {
 	if (!fs.existsSync(filePath)) throw new ConfigError(`Configuration file not found: ${filePath}`, "ERR_CONFIG_NOT_FOUND", "Ensure the configuration file path is correct or run 'nanos-lint init' to generate a default config.");
 	const content = fs.readFileSync(filePath, "utf-8");
@@ -1345,25 +1365,12 @@ function initWorkspace(workspacePath, options) {
 //#region src/luals/version.ts
 const FALLBACK_LUALS_VERSION = "3.19.1";
 const DEFAULT_LUALS_VERSION = "latest";
-/**
-* Characters accepted in a LuaLS version/tag. Only ASCII letters, digits, dots,
-* dashes and underscores are allowed, so a version can never contain a path
-* separator, a drive letter or a traversal segment.
-*/
+/** Characters accepted in a safe LuaLS version tag. */
 const SAFE_VERSION_CHARS = new Map([..."0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._-"].map((ch) => [ch, ch]));
 const MAX_VERSION_LENGTH = 64;
 /**
-* Validates a LuaLS version/tag and rebuilds it from the allow-list above.
-*
-* Version strings originate from untrusted sources: the GitHub releases API
-* response and user supplied `--luals-version` arguments. They are interpolated
-* into cache directory paths, download URLs, and the path of the binary that is
-* eventually executed, so they must be constrained to a single safe path
-* segment. Rebuilding the value character by character guarantees the returned
-* string only ever contains allow-listed characters (CodeQL: js/command-line-injection).
-*
-* @returns the normalized version (a single leading `v` is dropped), or `null`
-*          when the input cannot be used as a version tag.
+* Validates and normalizes a LuaLS version string to prevent path traversal or injection.
+* Drops a single leading 'v' and returns null on invalid characters.
 */
 function sanitizeLuaLSVersion(raw) {
 	const trimmed = raw.trim();
@@ -1420,6 +1427,7 @@ async function resolveLuaLSVersion(version) {
 }
 //#endregion
 //#region src/luals/platform.ts
+/** Resolves platform-specific binary naming and relative paths for the host operating system. */
 function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 	const platform = process.platform;
 	const arch = process.arch;
@@ -1457,14 +1465,172 @@ function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 }
 //#endregion
 //#region src/luals/validation.ts
+const execFileAsync$2 = promisify(execFile);
 /**
-* Verifies that a LuaLS binary exists, has non-trivial size, and is executable.
+* Escapes single quotes for safe PowerShell single-quoted string interpolation.
 */
-function isBinaryValid(binaryPath) {
-	if (!fs.existsSync(binaryPath)) return false;
+function escapePowerShellSingleQuote(str) {
+	return str.replace(/'/g, "''");
+}
+/**
+* Maximum total decompressed size of a LuaLS release archive (500 MB).
+* Protects against zip bombs and maliciously inflated archives (#31).
+*/
+const MAX_DECOMPRESSED_SIZE_BYTES = 524288e3;
+/**
+* Maximum number of members allowed in a LuaLS release archive (10,000).
+* Protects against inode exhaustion and archive recursion attacks (#31).
+*/
+const MAX_ARCHIVE_MEMBER_COUNT = 1e4;
+/** Parses the file size column from a 'tar -tvf' listing output line. */
+function parseTarTvSize(line) {
+	const parts = line.trim().split(/\s+/);
+	if (parts.length < 5) return 0;
+	const p1 = parts[1];
+	const p2 = parts[2];
+	const p4 = parts[4];
+	if (p1 && p2 && p1.includes("/") && /^\d+$/.test(p2)) return parseInt(p2, 10) || 0;
+	if (p4 && /^\d+$/.test(p4)) return parseInt(p4, 10) || 0;
+	for (let i = 2; i < Math.min(parts.length - 1, 6); i++) {
+		const p = parts[i];
+		if (p && /^\d+$/.test(p)) return parseInt(p, 10) || 0;
+	}
+	return 0;
+}
+/** Asserts that an archive entry name does not escape the destination directory. */
+function checkEscapedMember(member) {
+	if (member.startsWith("/") || member.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(member) || member.split(/[/\\]/).includes("..")) throw new LuaLSError(`Archive member path escapes extraction directory: ${member}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+}
+/** Validates that archive entry count and decompressed size do not exceed safety limits. */
+function checkArchiveLimits(count, size) {
+	if (count > 1e4) throw new LuaLSError(`Archive member count (${count}) exceeds maximum limit (${MAX_ARCHIVE_MEMBER_COUNT})`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+	if (size > 524288e3) throw new LuaLSError(`Archive declared decompressed size (${size} bytes) exceeds maximum limit (${MAX_DECOMPRESSED_SIZE_BYTES} bytes)`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
+}
+/** Locates the platform tar executable path, checking System32 on Windows. */
+function getTarBinary() {
+	if (process.platform === "win32") {
+		const sysTar = path.join(process.env.SystemRoot || "C:\\Windows", "System32", "tar.exe");
+		if (fs.existsSync(sysTar)) return sysTar;
+	}
+	return "tar";
+}
+/** Pre-inspects a ZIP archive's central directory to enforce extraction safety constraints (#31). */
+function inspectZipMembers(archivePath) {
+	const buf = fs.readFileSync(archivePath);
+	if (buf.length < 22) throw new LuaLSError("Failed to inspect release archive before extraction: archive is too small to be a valid zip", "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+	let eocdOffset = -1;
+	const minOffset = Math.max(0, buf.length - 22 - 65535);
+	for (let i = buf.length - 22; i >= minOffset; i--) if (buf.readUInt32LE(i) === 101010256) {
+		const commentLen = buf.readUInt16LE(i + 20);
+		if (i + 22 + commentLen === buf.length) {
+			eocdOffset = i;
+			break;
+		}
+	}
+	if (eocdOffset === -1) {
+		for (let i = buf.length - 22; i >= minOffset; i--) if (buf.readUInt32LE(i) === 101010256) {
+			eocdOffset = i;
+			break;
+		}
+	}
+	if (eocdOffset === -1) throw new LuaLSError("Failed to inspect release archive before extraction: corrupt or invalid zip archive (missing EOCD)", "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+	const entryCount = buf.readUInt16LE(eocdOffset + 10);
+	let offset = buf.readUInt32LE(eocdOffset + 16);
+	let memberCount = 0;
+	let totalDeclaredSize = 0;
+	for (let i = 0; i < entryCount && offset + 46 <= buf.length; i++) {
+		if (buf.readUInt32LE(offset) !== 33639248) throw new LuaLSError("Failed to inspect release archive before extraction: invalid central directory header", "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		const uncompressedSize = buf.readUInt32LE(offset + 24);
+		const fileNameLen = buf.readUInt16LE(offset + 28);
+		const extraLen = buf.readUInt16LE(offset + 30);
+		const commentLen = buf.readUInt16LE(offset + 32);
+		if ((buf.readUInt32LE(offset + 38) >>> 16 & 61440) === 40960) throw new LuaLSError("Archive member is a symbolic or hard link. Refusing to extract archive-planted links.", "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		const fileNameStart = offset + 46;
+		const fileNameEnd = fileNameStart + fileNameLen;
+		if (fileNameEnd > buf.length) throw new LuaLSError("Failed to inspect release archive before extraction: corrupt file name length in zip", "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		const fileName = buf.toString("utf-8", fileNameStart, fileNameEnd);
+		memberCount++;
+		totalDeclaredSize += uncompressedSize;
+		checkEscapedMember(fileName);
+		offset += 46 + fileNameLen + extraLen + commentLen;
+	}
+	checkArchiveLimits(memberCount, totalDeclaredSize);
+	return {
+		memberCount,
+		totalDeclaredSize
+	};
+}
+/** Detects whether an archive file starts with ZIP magic bytes. */
+function isZipArchive(archivePath) {
+	try {
+		const fd = fs.openSync(archivePath, "r");
+		const buf = Buffer.alloc(4);
+		const bytesRead = fs.readSync(fd, buf, 0, 4, 0);
+		fs.closeSync(fd);
+		if (bytesRead < 4) return false;
+		return buf[0] === 80 && buf[1] === 75 && (buf[2] === 3 && buf[3] === 4 || buf[2] === 5 && buf[3] === 6 || buf[2] === 7 && buf[3] === 8);
+	} catch {
+		return false;
+	}
+}
+/** Detects whether an archive file starts with GZIP magic bytes. */
+function isGzipArchive(archivePath) {
+	try {
+		const fd = fs.openSync(archivePath, "r");
+		const buf = Buffer.alloc(2);
+		const bytesRead = fs.readSync(fd, buf, 0, 2, 0);
+		fs.closeSync(fd);
+		return bytesRead >= 2 && buf[0] === 31 && buf[1] === 139;
+	} catch {
+		return false;
+	}
+}
+/** Pre-inspects archive members using tar listing or zip directory parsing to enforce extraction safety constraints (#31). */
+async function validateArchiveMembers(archivePath) {
+	if (isZipArchive(archivePath) || archivePath.toLowerCase().endsWith(".zip") && !isGzipArchive(archivePath)) return inspectZipMembers(archivePath);
+	let memberCount = 0;
+	let totalDeclaredSize = 0;
+	const tarBin = getTarBinary();
+	const archiveDir = path.dirname(archivePath);
+	const archiveFile = path.basename(archivePath);
+	try {
+		const [namesOutput, verboseOutput] = await Promise.all([execFileAsync$2(tarBin, ["-tf", archiveFile], { cwd: archiveDir }), execFileAsync$2(tarBin, ["-tvf", archiveFile], { cwd: archiveDir })]);
+		for (const rawName of namesOutput.stdout.split(/\r?\n/)) {
+			const member = rawName.trim();
+			if (!member) continue;
+			memberCount++;
+			checkEscapedMember(member);
+		}
+		for (const rawLine of verboseOutput.stdout.split(/\r?\n/)) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			if (/^[lh]/.test(line) || line.includes(" -> ") || line.includes(" link to ")) throw new LuaLSError("Archive member is a symbolic or hard link. Refusing to extract archive-planted links.", "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+			totalDeclaredSize += parseTarTvSize(line);
+		}
+		checkArchiveLimits(memberCount, totalDeclaredSize);
+	} catch (err) {
+		if (err instanceof LuaLSError) throw err;
+		throw new LuaLSError(`Failed to inspect release archive before extraction: ${err instanceof Error ? err.message : String(err)}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.", { cause: err });
+	}
+	return {
+		memberCount,
+		totalDeclaredSize
+	};
+}
+/**
+* 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.
+*/
+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,8 +1642,63 @@ 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
+/** Returns the base directory in the system cache where LuaLS versions and metadata are stored. */
 function getBaseLuaLSCacheDir() {
 	return path.join(systemPaths.cache, "luals");
 }
@@ -1507,16 +1728,23 @@ function getIsoWeek(d = /* @__PURE__ */ new Date()) {
 	const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
 	return `${date.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
 }
+/** Returns the path to the LuaLS metadata.json file within the specified cache directory. */
 function getLuaLSMetadataPath(baseCacheDir = getBaseLuaLSCacheDir()) {
 	return path.join(baseCacheDir, LUALS_METADATA_FILENAME);
 }
+/** Reads and parses the LuaLS metadata.json file, purging corrupted or invalid files automatically. */
 function readLuaLSMetadata(baseCacheDir = getBaseLuaLSCacheDir()) {
 	const metaPath = getLuaLSMetadataPath(baseCacheDir);
 	if (!fs.existsSync(metaPath)) return null;
 	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.`);
@@ -1534,6 +1762,7 @@ function readLuaLSMetadata(baseCacheDir = getBaseLuaLSCacheDir()) {
 	}
 	return null;
 }
+/** Writes metadata.json containing the latest checked version and timestamp. */
 function writeLuaLSMetadata(metadata, baseCacheDir = getBaseLuaLSCacheDir()) {
 	try {
 		fs.mkdirSync(baseCacheDir, { recursive: true });
@@ -1656,13 +1885,57 @@ 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.
+* Enforces a maximum byte count on an asynchronous download stream.
 */
-function escapePowerShellSingleQuote(str) {
-	return str.replace(/'/g, "''");
+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;
+	}
 }
+/** Downloads, verifies, and extracts the LuaLS release archive for the current platform. */
 async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDir, options) {
 	const resolvedVersion = await resolveLuaLSVersion(version);
 	const info = getPlatformInfo(resolvedVersion);
@@ -1697,12 +1970,17 @@ 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;
@@ -1718,16 +1996,44 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 				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));
+			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}...`);
+			await validateArchiveMembers(archivePath);
 			try {
-				await execFileAsync$1("tar", [
+				const tarArgs = process.platform === "win32" ? [
 					"-xf",
-					archivePath,
+					path.basename(archivePath),
 					"-C",
 					tempDir
-				]);
+				] : [
+					"-xf",
+					path.basename(archivePath),
+					"--no-same-owner",
+					"--no-same-permissions",
+					"-C",
+					tempDir
+				];
+				await execFileAsync$1(getTarBinary(), tarArgs, { cwd: path.dirname(archivePath) });
 			} catch (tarErr) {
 				if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync$1("powershell.exe", [
 					"-NoProfile",
@@ -1736,6 +2042,8 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 				]);
 				else throw tarErr;
 			}
+			const extractedSize = getDirectorySize(tempDir);
+			if (extractedSize > 524288e3) throw new LuaLSError(`Extracted archive size (${extractedSize} bytes) exceeds maximum limit (${MAX_DECOMPRESSED_SIZE_BYTES} bytes)`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
 			try {
 				fs.unlinkSync(archivePath);
 			} catch (err) {
@@ -1743,12 +2051,19 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 			}
 		}
 		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 (!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 (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 {
@@ -1764,139 +2079,3454 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 				} 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 (!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);
+				}
+			}
+			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;
+			}
+		}
+	}
+	[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));
+		}
+	}
+	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 (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;
 /**
-* Counts candidate Lua files within targetPath, taking ignoreDir and files.exclude into account.
+* Complexity budget per pattern to bound backtracking and combinatorial brace expansion.
+* Patterns exceeding limits are skipped with a warning to protect against ReDoS (#27).
 */
+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 a user pattern to slash-separated form, dropping trailing slashes and invalid inputs. */
+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]:\//;
+/** Rejects absolute patterns to maintain cross-platform consistency with LuaLS relative paths. */
+function isAbsolutePattern(normalized) {
+	return path.posix.isAbsolute(normalized) || WINDOWS_ABSOLUTE_PATTERN.test(normalized);
+}
+/** Expands a LuaLS pattern to include basename and sub-directory variants for glob matching. */
+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 workspace ignoreDir and files.exclude into account (#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
 const execFileAsync = promisify(execFile);
+/** Determines if an error represents an offline network condition. */
 function isOfflineError(err) {
 	if (!err) return false;
 	const msg = err instanceof Error ? err.message : String(err);
 	return /offline|enotfound|eai_again|econnrefused|etimedout|fetch failed/i.test(msg);
 }
+/** Resolves the executable path of a LuaLS binary from env, bundle, cache, or network download. */
 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 +5615,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];
@@ -2047,6 +5682,7 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	cleanupOldCachedLuaLSVersions(targetVersion, baseCacheDir);
 	return downloadedBinary;
 }
+/** Executes the LuaLS diagnostics check on the target path using merged configurations. */
 async function runLuaLSCheck(targetPath, configPath, options) {
 	let absoluteTarget = path.resolve(targetPath);
 	try {
@@ -2055,7 +5691,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()) {
@@ -2155,6 +5791,7 @@ function shouldEnableColor() {
 	if (process.env.FORCE_COLOR !== void 0 && process.env.FORCE_COLOR !== "0") return true;
 	return process.stdout ? Boolean(process.stdout.isTTY) : true;
 }
+/** Returns ANSI color escape code helpers or empty strings when colors are disabled. */
 function getColors(useColor = shouldEnableColor()) {
 	if (!useColor) return {
 		reset: "",
@@ -2181,6 +5818,7 @@ function getColors(useColor = shouldEnableColor()) {
 		gray: "\x1B[90m"
 	};
 }
+/** Formats a numeric diagnostic severity level into a colored badge. */
 function formatSeverityBadge(severity, useColor = shouldEnableColor()) {
 	const c = getColors(useColor);
 	const name = SEVERITY_NAMES[severity] || "Warning";
@@ -2191,9 +5829,11 @@ function formatSeverityBadge(severity, useColor = shouldEnableColor()) {
 		default: return `${c.gray}[${name}]${c.reset}`;
 	}
 }
+/** Formats a noun with its count and pluralizes if necessary. */
 function pluralize(count, singular, plural = `${singular}s`) {
 	return `${count} ${count === 1 ? singular : plural}`;
 }
+/** Formats the summary text detailing diagnostic counts and affected files. */
 function formatProblemSummary(totalProblems, errors, warnings, files) {
 	const parts = [];
 	if (errors > 0) parts.push(pluralize(errors, "error"));
@@ -2203,6 +5843,7 @@ function formatProblemSummary(totalProblems, errors, warnings, files) {
 	const breakdown = parts.length > 0 ? ` (${parts.join(", ")})` : "";
 	return `Diagnosis complete: ${pluralize(totalProblems, "problem")}${breakdown} found across ${pluralize(files, "file")}.`;
 }
+/** Formats check results into pretty human-readable terminal output. */
 function formatPretty(result, cwd = process.cwd(), useColor = shouldEnableColor()) {
 	const c = getColors(useColor);
 	const symCross = "✖  ";
@@ -2252,6 +5893,7 @@ function formatPretty(result, cwd = process.cwd(), useColor = shouldEnableColor(
 	lines.push(`${c.red}${c.bold}${symCross}${summary}${c.reset}`);
 	return lines.join("\n");
 }
+/** Formats check diagnostics into GitHub Actions workflow annotation commands. */
 function formatGitHubAnnotations(result, cwd = process.cwd()) {
 	const commands = [];
 	for (const [rawUri, diags] of Object.entries(result.diagnostics)) {
@@ -2271,6 +5913,7 @@ function formatGitHubAnnotations(result, cwd = process.cwd()) {
 	}
 	return commands.join("\n");
 }
+/** Formats check results according to the chosen format (pretty, json, github). */
 function formatReport(result, format = "pretty", cwd = process.cwd(), useColor = shouldEnableColor()) {
 	switch (format) {
 		case "json": return JSON.stringify(result, null, 2);
@@ -5238,13 +8881,13 @@ function useColor() {
 }
 new Command();
 //#endregion
-//#region src/annotations.ts
-const DOCGEN_REPO = "nanos-world/vscode-extension";
-const DOCGEN_BRANCH = "docgen-output";
-const RAW_ANNOTATIONS_URL = "https://raw.githubusercontent.com/nanos-world/vscode-extension/refs/heads/docgen-output/annotations.lua";
-const GITHUB_COMMITS_API = "https://api.github.com/repos/nanos-world/vscode-extension/commits/docgen-output";
+//#region src/annotations-metadata.ts
 const ANNOTATIONS_FILENAME = "annotations.lua";
 const METADATA_FILENAME = "metadata.json";
+const MIN_ANNOTATIONS_SIZE_BYTES = 1e3;
+const MAX_ANNOTATIONS_SIZE_BYTES = 10485760;
+const MAX_COMMIT_JSON_SIZE_BYTES = 1048576;
+/** Returns current date string formatted as YYYY-MM-DD alongside a date components object. */
 function getTodayDateString(d = /* @__PURE__ */ new Date()) {
 	const year = d.getFullYear();
 	const month = d.getMonth() + 1;
@@ -5258,59 +8901,127 @@ function getTodayDateString(d = /* @__PURE__ */ new Date()) {
 		}
 	};
 }
+/** Returns the system cache directory used for nanos world annotations. */
 function getAnnotationsCacheDir() {
 	return path.join(systemPaths.cache, "annotations");
 }
+/** Returns the full path to the cached annotations.lua file. */
 function getCachedAnnotationsFilePath() {
 	return path.join(getAnnotationsCacheDir(), ANNOTATIONS_FILENAME);
 }
+/** Returns the full path to the annotations metadata.json file. */
 function getAnnotationsMetadataFilePath() {
 	return path.join(getAnnotationsCacheDir(), METADATA_FILENAME);
 }
+/** Reads and parses annotations metadata.json, purging corrupt files automatically. */
 function readAnnotationsMetadata(cacheDir = getAnnotationsCacheDir()) {
 	const metaPath = path.join(cacheDir, "metadata.json");
 	if (!fs.existsSync(metaPath)) return null;
-	try {
-		const content = fs.readFileSync(metaPath, "utf-8");
-		const parsed = JSON.parse(content);
-		if (typeof parsed?.commitId === "string" && typeof parsed?.lastChecked === "string") return parsed;
+	const purge = (reason) => {
 		try {
 			fs.unlinkSync(metaPath);
-			logger.warn(`[annotations] Stale or invalid annotations metadata at ${metaPath} purged.`);
-		} catch (unlinkErr) {
-			logger.debug(`[annotations] Failed to unlink invalid metadata: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
+			logger.warn(`[annotations] ${reason} annotations metadata at ${metaPath} purged.`);
+		} catch (err) {
+			logger.debug(`[annotations] Failed to unlink metadata: ${err instanceof Error ? err.message : String(err)}`);
 		}
+	};
+	try {
+		const parsed = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+		if (typeof parsed?.commitId === "string" && typeof parsed?.lastChecked === "string") return parsed;
+		purge("Stale or invalid");
 	} catch (err) {
 		logger.debug(`Failed to parse annotations metadata: ${err instanceof Error ? err.message : String(err)}`);
-		try {
-			fs.unlinkSync(metaPath);
-			logger.warn(`[annotations] Corrupted annotations metadata at ${metaPath} purged.`);
-		} catch (unlinkErr) {
-			logger.debug(`[annotations] Failed to unlink corrupted metadata: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
-		}
+		purge("Corrupted");
 	}
 	return null;
 }
-/**
-* 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 non-trivial in size, and contains valid header. */
 function isAnnotationsValid(filePath) {
 	if (!fs.existsSync(filePath)) return false;
 	try {
 		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);
-		fs.closeSync(fd);
-		const header = buffer.toString("utf-8", 0, bytesRead).trimStart();
-		return header.startsWith("--") || header.includes("nanos world");
+		try {
+			const buffer = Buffer.alloc(512);
+			const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+			const header = buffer.toString("utf-8", 0, bytesRead).trimStart();
+			return header.startsWith("---@meta") || header.includes("nanos world") || header.includes("nanos-world");
+		} finally {
+			fs.closeSync(fd);
+		}
 	} catch (err) {
 		logger.debug(`[annotations] Annotation validation failed for ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
 		return false;
 	}
 }
+/** Updates metadata lastChecked date atomically without modifying annotations.lua. */
+function updateLastCheckedDate(commitId, cacheDir = getAnnotationsCacheDir()) {
+	const { dateStr, dateObj } = getTodayDateString();
+	const metadata = {
+		commitId,
+		lastChecked: dateStr,
+		date: dateObj
+	};
+	fs.mkdirSync(cacheDir, { recursive: true });
+	const metaPath = path.join(cacheDir, METADATA_FILENAME);
+	const tempMetaPath = path.join(os.tmpdir(), `.metadata-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`);
+	try {
+		fs.writeFileSync(tempMetaPath, JSON.stringify(metadata, null, 2), "utf-8");
+		fs.copyFileSync(tempMetaPath, metaPath);
+	} finally {
+		try {
+			if (fs.existsSync(tempMetaPath)) fs.unlinkSync(tempMetaPath);
+		} catch (err) {
+			logger.warn(`Failed to clean up temporary metadata file ${tempMetaPath}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	return metadata;
+}
+//#endregion
+//#region src/annotations-download.ts
+const DOCGEN_REPO = "nanos-world/vscode-extension";
+const DOCGEN_BRANCH = "docgen-output";
+const RAW_ANNOTATIONS_URL = "https://raw.githubusercontent.com/nanos-world/vscode-extension/refs/heads/docgen-output/annotations.lua";
+const GITHUB_COMMITS_API = "https://api.github.com/repos/nanos-world/vscode-extension/commits/docgen-output";
+/** Reads an HTTP response body with an upper byte limit to guard against memory exhaustion. */
+async function readBoundedResponseBody(res, maxBytes, onExceeded) {
+	const lengthHeader = res.headers?.get?.("content-length");
+	if (lengthHeader) {
+		const declared = parseInt(lengthHeader, 10);
+		if (!isNaN(declared) && declared > maxBytes) {
+			if (typeof res.body?.cancel === "function") await res.body.cancel().catch(() => {});
+			onExceeded(declared, "header");
+			return null;
+		}
+	}
+	if (res.body && typeof res.body[Symbol.asyncIterator] === "function") {
+		let total = 0;
+		const chunks = [];
+		for await (const chunk of res.body) {
+			const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			total += buf.length;
+			if (total > maxBytes) {
+				if (typeof res.body.cancel === "function") await res.body.cancel().catch(() => {});
+				onExceeded(total, "stream");
+				return null;
+			}
+			chunks.push(buf);
+		}
+		return Buffer.concat(chunks).toString("utf-8");
+	}
+	if (typeof res.text === "function") {
+		const text = await res.text();
+		const len = Buffer.byteLength(text, "utf-8");
+		if (len > maxBytes) {
+			onExceeded(len, "stream");
+			return null;
+		}
+		return text;
+	}
+	return "";
+}
+/** Fetches the latest commit SHA for the annotations branch from the GitHub API. */
 async function fetchLatestCommitId() {
 	try {
 		const headers = { "User-Agent": "nanos-lint" };
@@ -5320,7 +9031,17 @@ async function fetchLatestCommitId() {
 			signal: AbortSignal.timeout(5e3)
 		});
 		if (res.ok) {
-			const data = await res.json();
+			const rawJson = await readBoundedResponseBody(res, MAX_COMMIT_JSON_SIZE_BYTES, (bytes) => {
+				logger.warn(`GitHub commits response exceeded size limit of ${MAX_COMMIT_JSON_SIZE_BYTES} bytes (${bytes} bytes)`);
+			});
+			if (rawJson === null) return null;
+			if (!rawJson && !res.bodyUsed && typeof res.json === "function") {
+				const data = await res.json();
+				if (typeof data.sha === "string" && /^[0-9a-fA-F]{7,40}$/.test(data.sha)) return data.sha;
+				return null;
+			}
+			if (!rawJson) return null;
+			const data = JSON.parse(rawJson);
 			if (typeof data.sha === "string" && /^[0-9a-fA-F]{7,40}$/.test(data.sha)) return data.sha;
 		}
 	} catch (err) {
@@ -5328,16 +9049,26 @@ 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;
+}
+/** Downloads raw annotations.lua content from GitHub raw content endpoints. */
+async function fetchRawAnnotationsContent(commitSha) {
+	const url = getRawAnnotationsUrl(commitSha);
+	const res = await fetch(url, {
 		headers: { "User-Agent": "nanos-lint" },
 		signal: AbortSignal.timeout(15e3)
 	});
 	if (!res.ok) throw new AnnotationsError(`Failed to download annotations.lua: ${res.status} ${res.statusText}`, "ERR_ANNOTATIONS_DOWNLOAD", "Verify your internet connection and that GitHub raw endpoints are accessible.");
-	const text = await res.text();
+	const text = await readBoundedResponseBody(res, MAX_ANNOTATIONS_SIZE_BYTES, (bytes, reason) => {
+		throw new AnnotationsError(reason === "header" ? `Annotations file size (${bytes} bytes) exceeds maximum limit (${MAX_ANNOTATIONS_SIZE_BYTES} bytes)` : `Annotations file download exceeded maximum allowed size of ${MAX_ANNOTATIONS_SIZE_BYTES} bytes`, "ERR_ANNOTATIONS_TOO_LARGE", "Specify a local annotations file via --annotations <path>.");
+	});
 	if (!text || text.length < 1e3) throw new AnnotationsError("Downloaded annotations.lua appears truncated or invalid", "ERR_ANNOTATIONS_INVALID", "Retry downloading or pass a local annotations file via --annotations <path>.");
 	return text;
 }
+/** Copies a file with exponential backoff retries to handle transient file lock contention. */
 async function copyFileWithRetry(src, dest, maxRetries = 10) {
 	for (let attempt = 0; attempt < maxRetries; attempt++) try {
 		fs.copyFileSync(src, dest);
@@ -5351,35 +9082,7 @@ async function copyFileWithRetry(src, dest, maxRetries = 10) {
 		throw err;
 	}
 }
-/**
-* Updates the metadata lastChecked date atomically without modifying annotations.lua.
-*/
-function updateLastCheckedDate(commitId, cacheDir = getAnnotationsCacheDir()) {
-	const { dateStr, dateObj } = getTodayDateString();
-	const metadata = {
-		commitId,
-		lastChecked: dateStr,
-		date: dateObj
-	};
-	fs.mkdirSync(cacheDir, { recursive: true });
-	const metaPath = path.join(cacheDir, METADATA_FILENAME);
-	const tempMetaPath = path.join(os.tmpdir(), `.metadata-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`);
-	try {
-		fs.writeFileSync(tempMetaPath, JSON.stringify(metadata, null, 2), "utf-8");
-		fs.copyFileSync(tempMetaPath, metaPath);
-	} finally {
-		try {
-			if (fs.existsSync(tempMetaPath)) fs.unlinkSync(tempMetaPath);
-		} catch (err) {
-			logger.warn(`Failed to clean up temporary metadata file ${tempMetaPath}: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-	return metadata;
-}
-/**
-* Downloads annotations.lua, writes it and the new metadata in a chained atomic transaction.
-* If any step fails, the previous cache state is reverted.
-*/
+/** Downloads annotations.lua and writes metadata in a chained atomic transaction with rollback. */
 async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCacheDir(), options) {
 	fs.mkdirSync(cacheDir, { recursive: true });
 	const finalAnnotationsPath = path.join(cacheDir, ANNOTATIONS_FILENAME);
@@ -5390,10 +9093,10 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 	try {
 		fs.mkdirSync(tempDir, { recursive: true });
 		if (!options?.quiet) {
-			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 label = commitId && commitId !== "unknown" ? ` (${commitId.slice(0, 7)})` : "";
+			logger.info(`[annotations] Downloading nanos world API annotations${label}...`);
 		}
-		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 +9108,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) {
@@ -5417,16 +9120,16 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 		await copyFileWithRetry(tempAnnotationsPath, finalAnnotationsPath);
 		await copyFileWithRetry(tempMetaPath, finalMetaPath);
 		if (!options?.quiet) {
-			if (commitId && commitId !== "unknown") logger.info(`[annotations] Updated annotations.lua to commit ${commitId.slice(0, 7)}.`);
-			else logger.info("[annotations] Updated annotations.lua.");
+			const label = commitId && commitId !== "unknown" ? ` to commit ${commitId.slice(0, 7)}` : "";
+			logger.info(`[annotations] Updated annotations.lua${label}.`);
 		}
 		return finalAnnotationsPath;
 	} catch (err) {
 		if (hasBackup && fs.existsSync(backupDir)) try {
-			const backupAnnotations = path.join(backupDir, ANNOTATIONS_FILENAME);
-			const backupMeta = path.join(backupDir, METADATA_FILENAME);
-			if (fs.existsSync(backupAnnotations)) await copyFileWithRetry(backupAnnotations, finalAnnotationsPath);
-			if (fs.existsSync(backupMeta)) await copyFileWithRetry(backupMeta, finalMetaPath);
+			const bAnn = path.join(backupDir, ANNOTATIONS_FILENAME);
+			const bMeta = path.join(backupDir, METADATA_FILENAME);
+			if (fs.existsSync(bAnn)) await copyFileWithRetry(bAnn, finalAnnotationsPath);
+			if (fs.existsSync(bMeta)) await copyFileWithRetry(bMeta, finalMetaPath);
 		} catch (rollbackErr) {
 			logger.error(`Failed to restore annotations from backup during rollback: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`);
 		}
@@ -5446,6 +9149,33 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 		}
 	}
 }
+//#endregion
+//#region src/annotations.ts
+/** Validates that a user-supplied or environment-specified annotations path exists and is a valid file. */
+function validateCustomAnnotationsPath(filePath, source) {
+	const resolved = path.resolve(filePath);
+	const isCustom = source === "custom";
+	const targetDesc = isCustom ? "path specified in --annotations" : "path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS";
+	if (!fs.existsSync(resolved)) throw new AnnotationsError(isCustom ? `Custom annotations file not found: ${resolved}` : `Annotations file specified in environment not found: ${resolved}`, isCustom ? "ERR_ANNOTATIONS_NOT_FOUND" : "ERR_ANNOTATIONS_ENV_NOT_FOUND", `Verify that the ${targetDesc} exists and is accessible.`);
+	const stat = fs.statSync(resolved);
+	if (!stat.isFile()) throw new AnnotationsError(isCustom ? `Custom annotations path is not a file: ${resolved}` : `Annotations path specified in environment is not a file: ${resolved}`, "ERR_ANNOTATIONS_NOT_A_FILE", `Verify that the ${targetDesc} points to a regular file, not a directory.`);
+	if (stat.size === 0) throw new AnnotationsError(isCustom ? `Custom annotations file is empty: ${resolved}` : `Annotations file specified in environment is empty: ${resolved}`, "ERR_ANNOTATIONS_INVALID", `Verify that the ${targetDesc} is a valid non-empty Lua annotations file.`);
+	try {
+		const fd = fs.openSync(resolved, "r");
+		let isBinary = false;
+		try {
+			const buffer = Buffer.alloc(Math.min(stat.size, 512));
+			const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+			isBinary = buffer.subarray(0, bytesRead).includes(0);
+		} finally {
+			fs.closeSync(fd);
+		}
+		if (isBinary) throw new AnnotationsError(isCustom ? `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 +9185,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();
@@ -5517,6 +9239,7 @@ async function resolveAnnotations(options = {}) {
 }
 //#endregion
 //#region src/cache-status.ts
+/** Collects detailed status and disk usage information for LuaLS and annotations caches. */
 function getCacheStatus(baseCacheDir = systemPaths.cache) {
 	const totalSize = getDirectorySize(baseCacheDir);
 	const totalSizeFormatted = formatBytes(totalSize);
@@ -5574,6 +9297,7 @@ function getCacheStatus(baseCacheDir = systemPaths.cache) {
 		}
 	};
 }
+/** Formats a cache status report into human-readable terminal output. */
 function formatCacheStatusPretty(report) {
 	const lines = [];
 	lines.push("nanos-lint Cache Status");
@@ -5608,6 +9332,7 @@ function formatCacheStatusPretty(report) {
 }
 //#endregion
 //#region src/cli.ts
+/** Retrieves the formatted package name and version string from package.json. */
 function getVersionString() {
 	const root = getPackageRoot();
 	try {
@@ -5621,10 +9346,12 @@ function getVersionString() {
 function writeOutput(message) {
 	if (logger.isOutputEnabled()) console.log(message);
 }
+/** Accumulates repeatable --ignore pattern arguments, splitting by comma and newline. */
 function collectIgnorePatterns(val, prev) {
 	const parts = val.split(/[\r\n,]+/).map((s) => s.trim()).filter(Boolean);
 	return (prev ?? []).concat(parts);
 }
+/** Constructs and configures the top-level Commander program and its CLI subcommands. */
 function createProgram(options) {
 	const setExitCode = options?.setExitCode ?? (() => {});
 	const program = new Command("nanos-lint");
@@ -5773,6 +9500,7 @@ Examples:
 `);
 	return program;
 }
+/** Parses command-line arguments and executes the requested CLI action. */
 async function runCLI(args = process.argv.slice(2)) {
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
@@ -5809,6 +9537,7 @@ async function runCLI(args = process.argv.slice(2)) {
 		return 1;
 	}
 }
+/** Determines whether the current module is being directly executed as an application entrypoint. */
 function isDirectExecution(importMetaUrl = import.meta.url, argv1 = process.argv[1]) {
 	if (!argv1) return false;
 	const toPath = (urlStr) => {
@@ -5845,6 +9574,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 { getLuaLSMetadataPath as $, formatProblemSummary as A, loadConfigFile as At, DOWNLOAD_TIMEOUT_MS as B, NanosLintError as Bt, getCachedAnnotationsFilePath as C, sanitizeLuaLSVersion as Ct, updateLastCheckedDate as D, getDefinitionsDir as Dt, readAnnotationsMetadata as E, getDefaultTemplatePath as Et, shouldEnableColor as F, stripTrailingSlashes as Ft, limitDownloadStream as G, fileUriToPath as Gt, computeFileSha256 as H, formatBytes as Ht, resolveLuaLSBinary as I, AnnotationsError as It, findExistingLuaLSDir as J, LOG_LEVEL_PRIORITY as Jt, LUALS_METADATA_FILENAME as K, DEFAULT_LOG_LEVEL as Kt, runLuaLSCheck as L, CacheError as Lt, formatSeverityBadge as M, parseJsonc as Mt, getColors as N, resolveWorkspaceConfig as Nt, formatGitHubAnnotations as O, getPackageRoot as Ot, pluralize as P, stripJsonComments as Pt, getLegacyCacheDir as Q, parseLogLevel as Qt, countCheckedFiles as R, ConfigError as Rt, getAnnotationsMetadataFilePath as S, resolveLuaLSVersion as St, isAnnotationsValid as T, getDefaultAnnotationsPath as Tt, downloadAndExtractLuaLS as U, getDirectorySize as Ut, MAX_ARCHIVE_SIZE_BYTES as V, cleanCache as Vt, isAllowedDownloadUrl as W, systemPaths as Wt, getCacheDir as X, isValidLogLevel as Xt, getBaseLuaLSCacheDir as Y, Logger as Yt, getIsoWeek as Z, logger as Zt, MAX_ANNOTATIONS_SIZE_BYTES as _, getPlatformInfo as _t, formatCacheStatusPretty as a, MAX_DECOMPRESSED_SIZE_BYTES as at, MIN_ANNOTATIONS_SIZE_BYTES as b, fetchLatestLuaLSVersionFromGitHub as bt, DOCGEN_BRANCH as c, escapePowerShellSingleQuote as ct, RAW_ANNOTATIONS_URL as d, isBinaryRunnable as dt, listCachedLuaLSVersionDirs as et, downloadAndCacheAnnotations as f, isBinaryValid as ft, ANNOTATIONS_FILENAME as g, validateArchiveMembers as gt, getRawAnnotationsUrl as h, parseTarTvSize as ht, runCLI as i, MAX_ARCHIVE_MEMBER_COUNT as it, formatReport as j, mergeConfigs as jt, formatPretty as k, initWorkspace as kt, DOCGEN_REPO as l, getTarBinary as lt, fetchRawAnnotationsContent as m, isZipArchive as mt, createProgram as n, readLuaLSMetadata as nt, getCacheStatus as o, MIN_DOWNLOADED_BINARY_SIZE_BYTES as ot, fetchLatestCommitId as p, isGzipArchive as pt, cleanupOldCachedLuaLSVersions as q, LOG_LEVELS as qt, isDirectExecution as r, writeLuaLSMetadata as rt, resolveAnnotations as s, assertValidLuaLSBinary as st, collectIgnorePatterns as t, listCachedLuaLSVersions as tt, GITHUB_COMMITS_API as u, inspectZipMembers as ut, MAX_COMMIT_JSON_SIZE_BYTES as v, DEFAULT_LUALS_VERSION as vt, getTodayDateString as w, VALID_LUALS_DIAGNOSTIC_CODES as wt, getAnnotationsCacheDir as x, resolveLatestLuaLSVersion as xt, METADATA_FILENAME as y, FALLBACK_LUALS_VERSION as yt, ALLOWED_DOWNLOAD_DOMAINS as z, LuaLSError as zt };
 
-//# sourceMappingURL=cli-DGez8MSI.js.map
+//# sourceMappingURL=cli-BTHx4yp_.js.map