nanos-lint 2.2.1 → 2.4.0

package/dist/{cli-Dx-1zSOk.js → cli-kmHD4epr.js}

@@ -2,7 +2,7 @@ import { fileURLToPath } from "node:url";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import childProcess, { execFile } from "node:child_process";
+import childProcess, { execFile, execFileSync } from "node:child_process";
 import { promisify, stripVTControlCharacters } from "node:util";
 import { EventEmitter } from "node:events";
 import process$1 from "node:process";
@@ -31,6 +31,754 @@ function fileUriToPath(uri) {
 	}
 }
 //#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/scanner.js
+/**
+* Creates a JSON scanner on the given text.
+* If ignoreTrivia is set, whitespaces or comments are ignored.
+*/
+function createScanner(text, ignoreTrivia = false) {
+	const len = text.length;
+	let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+	function scanHexDigits(count, exact) {
+		let digits = 0;
+		let value = 0;
+		while (digits < count || !exact) {
+			let ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value = value * 16 + ch - 48;
+			else if (ch >= 65 && ch <= 70) value = value * 16 + ch - 65 + 10;
+			else if (ch >= 97 && ch <= 102) value = value * 16 + ch - 97 + 10;
+			else break;
+			pos++;
+			digits++;
+		}
+		if (digits < count) value = -1;
+		return value;
+	}
+	function setPosition(newPosition) {
+		pos = newPosition;
+		value = "";
+		tokenOffset = 0;
+		token = 16;
+		scanError = 0;
+	}
+	function scanNumber() {
+		let start = pos;
+		if (text.charCodeAt(pos) === 48) pos++;
+		else {
+			pos++;
+			while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+		}
+		if (pos < text.length && text.charCodeAt(pos) === 46) {
+			pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+			} else {
+				scanError = 3;
+				return text.substring(start, pos);
+			}
+		}
+		let end = pos;
+		if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+			pos++;
+			if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+				end = pos;
+			} else scanError = 3;
+		}
+		return text.substring(start, end);
+	}
+	function scanString() {
+		let result = "", start = pos;
+		while (true) {
+			if (pos >= len) {
+				result += text.substring(start, pos);
+				scanError = 2;
+				break;
+			}
+			const ch = text.charCodeAt(pos);
+			if (ch === 34) {
+				result += text.substring(start, pos);
+				pos++;
+				break;
+			}
+			if (ch === 92) {
+				result += text.substring(start, pos);
+				pos++;
+				if (pos >= len) {
+					scanError = 2;
+					break;
+				}
+				switch (text.charCodeAt(pos++)) {
+					case 34:
+						result += "\"";
+						break;
+					case 92:
+						result += "\\";
+						break;
+					case 47:
+						result += "/";
+						break;
+					case 98:
+						result += "\b";
+						break;
+					case 102:
+						result += "\f";
+						break;
+					case 110:
+						result += "\n";
+						break;
+					case 114:
+						result += "\r";
+						break;
+					case 116:
+						result += "	";
+						break;
+					case 117:
+						const ch3 = scanHexDigits(4, true);
+						if (ch3 >= 0) result += String.fromCharCode(ch3);
+						else scanError = 4;
+						break;
+					default: scanError = 5;
+				}
+				start = pos;
+				continue;
+			}
+			if (ch >= 0 && ch <= 31) {
+				if (isLineBreak(ch)) {
+					result += text.substring(start, pos);
+					scanError = 2;
+					break;
+				} else scanError = 6;
+			}
+			pos++;
+		}
+		return result;
+	}
+	function scanNext() {
+		value = "";
+		scanError = 0;
+		tokenOffset = pos;
+		lineStartOffset = lineNumber;
+		prevTokenLineStartOffset = tokenLineStartOffset;
+		if (pos >= len) {
+			tokenOffset = len;
+			return token = 17;
+		}
+		let code = text.charCodeAt(pos);
+		if (isWhiteSpace(code)) {
+			do {
+				pos++;
+				value += String.fromCharCode(code);
+				code = text.charCodeAt(pos);
+			} while (isWhiteSpace(code));
+			return token = 15;
+		}
+		if (isLineBreak(code)) {
+			pos++;
+			value += String.fromCharCode(code);
+			if (code === 13 && text.charCodeAt(pos) === 10) {
+				pos++;
+				value += "\n";
+			}
+			lineNumber++;
+			tokenLineStartOffset = pos;
+			return token = 14;
+		}
+		switch (code) {
+			case 123:
+				pos++;
+				return token = 1;
+			case 125:
+				pos++;
+				return token = 2;
+			case 91:
+				pos++;
+				return token = 3;
+			case 93:
+				pos++;
+				return token = 4;
+			case 58:
+				pos++;
+				return token = 6;
+			case 44:
+				pos++;
+				return token = 5;
+			case 34:
+				pos++;
+				value = scanString();
+				return token = 10;
+			case 47:
+				const start = pos - 1;
+				if (text.charCodeAt(pos + 1) === 47) {
+					pos += 2;
+					while (pos < len) {
+						if (isLineBreak(text.charCodeAt(pos))) break;
+						pos++;
+					}
+					value = text.substring(start, pos);
+					return token = 12;
+				}
+				if (text.charCodeAt(pos + 1) === 42) {
+					pos += 2;
+					const safeLength = len - 1;
+					let commentClosed = false;
+					while (pos < safeLength) {
+						const ch = text.charCodeAt(pos);
+						if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+							pos += 2;
+							commentClosed = true;
+							break;
+						}
+						pos++;
+						if (isLineBreak(ch)) {
+							if (ch === 13 && text.charCodeAt(pos) === 10) pos++;
+							lineNumber++;
+							tokenLineStartOffset = pos;
+						}
+					}
+					if (!commentClosed) {
+						pos++;
+						scanError = 1;
+					}
+					value = text.substring(start, pos);
+					return token = 13;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+			case 45:
+				value += String.fromCharCode(code);
+				pos++;
+				if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
+			case 48:
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57:
+				value += scanNumber();
+				return token = 11;
+			default:
+				while (pos < len && isUnknownContentCharacter(code)) {
+					pos++;
+					code = text.charCodeAt(pos);
+				}
+				if (tokenOffset !== pos) {
+					value = text.substring(tokenOffset, pos);
+					switch (value) {
+						case "true": return token = 8;
+						case "false": return token = 9;
+						case "null": return token = 7;
+					}
+					return token = 16;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+		}
+	}
+	function isUnknownContentCharacter(code) {
+		if (isWhiteSpace(code) || isLineBreak(code)) return false;
+		switch (code) {
+			case 125:
+			case 93:
+			case 123:
+			case 91:
+			case 34:
+			case 58:
+			case 44:
+			case 47: return false;
+		}
+		return true;
+	}
+	function scanNextNonTrivia() {
+		let result;
+		do
+			result = scanNext();
+		while (result >= 12 && result <= 15);
+		return result;
+	}
+	return {
+		setPosition,
+		getPosition: () => pos,
+		scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+		getToken: () => token,
+		getTokenValue: () => value,
+		getTokenOffset: () => tokenOffset,
+		getTokenLength: () => pos - tokenOffset,
+		getTokenStartLine: () => lineStartOffset,
+		getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+		getTokenError: () => scanError
+	};
+}
+function isWhiteSpace(ch) {
+	return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+	return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+	return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes) {
+	CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+	CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+	CharacterCodes[CharacterCodes["space"] = 32] = "space";
+	CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+	CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+	CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+	CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+	CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+	CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+	CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+	CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+	CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+	CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+	CharacterCodes[CharacterCodes["a"] = 97] = "a";
+	CharacterCodes[CharacterCodes["b"] = 98] = "b";
+	CharacterCodes[CharacterCodes["c"] = 99] = "c";
+	CharacterCodes[CharacterCodes["d"] = 100] = "d";
+	CharacterCodes[CharacterCodes["e"] = 101] = "e";
+	CharacterCodes[CharacterCodes["f"] = 102] = "f";
+	CharacterCodes[CharacterCodes["g"] = 103] = "g";
+	CharacterCodes[CharacterCodes["h"] = 104] = "h";
+	CharacterCodes[CharacterCodes["i"] = 105] = "i";
+	CharacterCodes[CharacterCodes["j"] = 106] = "j";
+	CharacterCodes[CharacterCodes["k"] = 107] = "k";
+	CharacterCodes[CharacterCodes["l"] = 108] = "l";
+	CharacterCodes[CharacterCodes["m"] = 109] = "m";
+	CharacterCodes[CharacterCodes["n"] = 110] = "n";
+	CharacterCodes[CharacterCodes["o"] = 111] = "o";
+	CharacterCodes[CharacterCodes["p"] = 112] = "p";
+	CharacterCodes[CharacterCodes["q"] = 113] = "q";
+	CharacterCodes[CharacterCodes["r"] = 114] = "r";
+	CharacterCodes[CharacterCodes["s"] = 115] = "s";
+	CharacterCodes[CharacterCodes["t"] = 116] = "t";
+	CharacterCodes[CharacterCodes["u"] = 117] = "u";
+	CharacterCodes[CharacterCodes["v"] = 118] = "v";
+	CharacterCodes[CharacterCodes["w"] = 119] = "w";
+	CharacterCodes[CharacterCodes["x"] = 120] = "x";
+	CharacterCodes[CharacterCodes["y"] = 121] = "y";
+	CharacterCodes[CharacterCodes["z"] = 122] = "z";
+	CharacterCodes[CharacterCodes["A"] = 65] = "A";
+	CharacterCodes[CharacterCodes["B"] = 66] = "B";
+	CharacterCodes[CharacterCodes["C"] = 67] = "C";
+	CharacterCodes[CharacterCodes["D"] = 68] = "D";
+	CharacterCodes[CharacterCodes["E"] = 69] = "E";
+	CharacterCodes[CharacterCodes["F"] = 70] = "F";
+	CharacterCodes[CharacterCodes["G"] = 71] = "G";
+	CharacterCodes[CharacterCodes["H"] = 72] = "H";
+	CharacterCodes[CharacterCodes["I"] = 73] = "I";
+	CharacterCodes[CharacterCodes["J"] = 74] = "J";
+	CharacterCodes[CharacterCodes["K"] = 75] = "K";
+	CharacterCodes[CharacterCodes["L"] = 76] = "L";
+	CharacterCodes[CharacterCodes["M"] = 77] = "M";
+	CharacterCodes[CharacterCodes["N"] = 78] = "N";
+	CharacterCodes[CharacterCodes["O"] = 79] = "O";
+	CharacterCodes[CharacterCodes["P"] = 80] = "P";
+	CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+	CharacterCodes[CharacterCodes["R"] = 82] = "R";
+	CharacterCodes[CharacterCodes["S"] = 83] = "S";
+	CharacterCodes[CharacterCodes["T"] = 84] = "T";
+	CharacterCodes[CharacterCodes["U"] = 85] = "U";
+	CharacterCodes[CharacterCodes["V"] = 86] = "V";
+	CharacterCodes[CharacterCodes["W"] = 87] = "W";
+	CharacterCodes[CharacterCodes["X"] = 88] = "X";
+	CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+	CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+	CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+	CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+	CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+	CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+	CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+	CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+	CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+	CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+	CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+	CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+	CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+	CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+	CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+	CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+	CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+new Array(20).fill(0).map((_, index) => {
+	return " ".repeat(index);
+});
+const maxCachedValues = 200;
+new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\n" + " ".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r" + " ".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r\n" + " ".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\n" + "	".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r" + "	".repeat(index);
+}), new Array(maxCachedValues).fill(0).map((_, index) => {
+	return "\r\n" + "	".repeat(index);
+});
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions) {
+	ParseOptions.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore always check the errors list to find out if the input was valid.
+*/
+function parse$1(text, errors = [], options = ParseOptions.DEFAULT) {
+	let currentProperty = null;
+	let currentParent = [];
+	const previousParents = [];
+	function onValue(value) {
+		if (Array.isArray(currentParent)) currentParent.push(value);
+		else if (currentProperty !== null) currentParent[currentProperty] = value;
+	}
+	visit(text, {
+		onObjectBegin: () => {
+			const object = {};
+			onValue(object);
+			previousParents.push(currentParent);
+			currentParent = object;
+			currentProperty = null;
+		},
+		onObjectProperty: (name) => {
+			currentProperty = name;
+		},
+		onObjectEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onArrayBegin: () => {
+			const array = [];
+			onValue(array);
+			previousParents.push(currentParent);
+			currentParent = array;
+			currentProperty = null;
+		},
+		onArrayEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onLiteralValue: onValue,
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}
+	}, options);
+	return currentParent[0];
+}
+/**
+* Parses the given text and invokes the visitor functions for each object, array and literal reached.
+*/
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+	const _scanner = createScanner(text, false);
+	const _jsonPath = [];
+	let suppressedCallbacks = 0;
+	function toNoArgVisit(visitFunction) {
+		return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisit(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisitWithPath(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+	}
+	function toBeginVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks++;
+			else if (visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) === false) suppressedCallbacks = 1;
+		} : () => true;
+	}
+	function toEndVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks--;
+			if (suppressedCallbacks === 0) visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+		} : () => true;
+	}
+	const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+	const disallowComments = options && options.disallowComments;
+	const allowTrailingComma = options && options.allowTrailingComma;
+	function scanNext() {
+		while (true) {
+			const token = _scanner.scan();
+			switch (_scanner.getTokenError()) {
+				case 4:
+					handleError(14);
+					break;
+				case 5:
+					handleError(15);
+					break;
+				case 3:
+					handleError(13);
+					break;
+				case 1:
+					if (!disallowComments) handleError(11);
+					break;
+				case 2:
+					handleError(12);
+					break;
+				case 6: handleError(16);
+			}
+			switch (token) {
+				case 12:
+				case 13:
+					if (disallowComments) handleError(10);
+					else onComment();
+					break;
+				case 16:
+					handleError(1);
+					break;
+				case 15:
+				case 14: break;
+				default: return token;
+			}
+		}
+	}
+	function handleError(error, skipUntilAfter = [], skipUntil = []) {
+		onError(error);
+		if (skipUntilAfter.length + skipUntil.length > 0) {
+			let token = _scanner.getToken();
+			while (token !== 17) {
+				if (skipUntilAfter.indexOf(token) !== -1) {
+					scanNext();
+					break;
+				} else if (skipUntil.indexOf(token) !== -1) break;
+				token = scanNext();
+			}
+		}
+	}
+	function parseString(isValue) {
+		const value = _scanner.getTokenValue();
+		if (isValue) onLiteralValue(value);
+		else {
+			onObjectProperty(value);
+			_jsonPath.push(value);
+		}
+		scanNext();
+		return true;
+	}
+	function parseLiteral() {
+		switch (_scanner.getToken()) {
+			case 11:
+				const tokenValue = _scanner.getTokenValue();
+				let value = Number(tokenValue);
+				if (isNaN(value)) {
+					handleError(2);
+					value = 0;
+				}
+				onLiteralValue(value);
+				break;
+			case 7:
+				onLiteralValue(null);
+				break;
+			case 8:
+				onLiteralValue(true);
+				break;
+			case 9:
+				onLiteralValue(false);
+				break;
+			default: return false;
+		}
+		scanNext();
+		return true;
+	}
+	function parseProperty() {
+		if (_scanner.getToken() !== 10) {
+			handleError(3, [], [2, 5]);
+			return false;
+		}
+		parseString(false);
+		if (_scanner.getToken() === 6) {
+			onSeparator(":");
+			scanNext();
+			if (!parseValue()) handleError(4, [], [2, 5]);
+		} else handleError(5, [], [2, 5]);
+		_jsonPath.pop();
+		return true;
+	}
+	function parseObject() {
+		onObjectBegin();
+		scanNext();
+		let needsComma = false;
+		while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 2 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (!parseProperty()) handleError(4, [], [2, 5]);
+			needsComma = true;
+		}
+		onObjectEnd();
+		if (_scanner.getToken() !== 2) handleError(7, [2], []);
+		else scanNext();
+		return true;
+	}
+	function parseArray() {
+		onArrayBegin();
+		scanNext();
+		let isFirstElement = true;
+		let needsComma = false;
+		while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 4 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (isFirstElement) {
+				_jsonPath.push(0);
+				isFirstElement = false;
+			} else _jsonPath[_jsonPath.length - 1]++;
+			if (!parseValue()) handleError(4, [], [4, 5]);
+			needsComma = true;
+		}
+		onArrayEnd();
+		if (!isFirstElement) _jsonPath.pop();
+		if (_scanner.getToken() !== 4) handleError(8, [4], []);
+		else scanNext();
+		return true;
+	}
+	function parseValue() {
+		switch (_scanner.getToken()) {
+			case 3: return parseArray();
+			case 1: return parseObject();
+			case 10: return parseString(true);
+			default: return parseLiteral();
+		}
+	}
+	scanNext();
+	if (_scanner.getToken() === 17) {
+		if (options.allowEmptyContent) return true;
+		handleError(4, [], []);
+		return false;
+	}
+	if (!parseValue()) {
+		handleError(4, [], []);
+		return false;
+	}
+	if (_scanner.getToken() !== 17) handleError(9, [], []);
+	return true;
+}
+/**
+* Takes JSON with JavaScript-style comments and remove
+* them. Optionally replaces every none-newline character
+* of comments with a replaceCharacter
+*/
+function stripComments$1(text, replaceCh) {
+	let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
+	do {
+		pos = _scanner.getPosition();
+		kind = _scanner.scan();
+		switch (kind) {
+			case 12:
+			case 13:
+			case 17:
+				if (offset !== pos) parts.push(text.substring(offset, pos));
+				if (replaceCh !== void 0) parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
+				offset = _scanner.getPosition();
+		}
+	} while (kind !== 17);
+	return parts.join("");
+}
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError) {
+	ScanError[ScanError["None"] = 0] = "None";
+	ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+	ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+	ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+	ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+	ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+	ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind) {
+	SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+	SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+	SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+	SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+	SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+	SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+	SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+	SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+	SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+	SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+	SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+	SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+	SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+	SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+	SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+	SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+	SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore, always check the errors list to find out if the input was valid.
+*/
+const parse = parse$1;
+/**
+* Takes JSON with JavaScript-style comments and remove
+* them. Optionally replaces every none-newline character
+* of comments with a replaceCharacter
+*/
+const stripComments = stripComments$1;
+var ParseErrorCode;
+(function(ParseErrorCode) {
+	ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+	ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+	ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+	ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+	ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+	ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+	ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+	ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+	ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+	ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+	ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+	ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+	ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+	switch (code) {
+		case 1: return "InvalidSymbol";
+		case 2: return "InvalidNumberFormat";
+		case 3: return "PropertyNameExpected";
+		case 4: return "ValueExpected";
+		case 5: return "ColonExpected";
+		case 6: return "CommaExpected";
+		case 7: return "CloseBraceExpected";
+		case 8: return "CloseBracketExpected";
+		case 9: return "EndOfFileExpected";
+		case 10: return "InvalidCommentToken";
+		case 11: return "UnexpectedEndOfComment";
+		case 12: return "UnexpectedEndOfString";
+		case 13: return "UnexpectedEndOfNumber";
+		case 14: return "InvalidUnicode";
+		case 15: return "InvalidEscapeCharacter";
+		case 16: return "InvalidCharacter";
+	}
+	return "<unknown ParseErrorCode>";
+}
+//#endregion
 //#region src/config.ts
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -54,79 +802,21 @@ function getDefaultTemplatePath() {
 	return path.join(root, "templates", ".luarc.json");
 }
 /**
-* Strips single-line comments (//), multi-line comments (/* ... *\/),
-* and trailing commas before '}' or ']' from JSONC text while preserving string literals.
+* Strips single-line and multi-line comments from JSONC text using jsonc-parser.
 */
 function stripJsonComments(text) {
 	const cleanText = text.replace(/^\uFEFF/, "");
-	let result = "";
-	let i = 0;
-	const len = cleanText.length;
-	while (i < len) {
-		const ch = cleanText[i];
-		if (ch === "\"") {
-			result += ch;
-			i++;
-			while (i < len) {
-				const c = cleanText[i];
-				result += c;
-				if (c === "\\") {
-					i++;
-					if (i < len) result += cleanText[i];
-				} else if (c === "\"") break;
-				i++;
-			}
-			i++;
-			continue;
-		}
-		if (ch === "/" && i + 1 < len && cleanText[i + 1] === "/") {
-			i += 2;
-			while (i < len && cleanText[i] !== "\n" && cleanText[i] !== "\r") i++;
-			continue;
-		}
-		if (ch === "/" && i + 1 < len && cleanText[i + 1] === "*") {
-			i += 2;
-			while (i + 1 < len && !(cleanText[i] === "*" && cleanText[i + 1] === "/")) i++;
-			i += 2;
-			continue;
-		}
-		if (ch === ",") {
-			let j = i + 1;
-			let isTrailing = false;
-			while (j < len) {
-				const nextChar = cleanText[j];
-				if (nextChar === " " || nextChar === "	" || nextChar === "\n" || nextChar === "\r") {
-					j++;
-					continue;
-				}
-				if (nextChar === "/" && j + 1 < len && cleanText[j + 1] === "/") {
-					j += 2;
-					while (j < len && cleanText[j] !== "\n" && cleanText[j] !== "\r") j++;
-					continue;
-				}
-				if (nextChar === "/" && j + 1 < len && cleanText[j + 1] === "*") {
-					j += 2;
-					while (j + 1 < len && !(cleanText[j] === "*" && cleanText[j + 1] === "/")) j++;
-					j += 2;
-					continue;
-				}
-				if (nextChar === "}" || nextChar === "]") isTrailing = true;
-				break;
-			}
-			if (isTrailing) {
-				result += " ";
-				i++;
-				continue;
-			}
-		}
-		result += ch;
-		i++;
-	}
-	return result;
+	return stripComments(cleanText);
 }
 function parseJsonc(text) {
-	const stripped = stripJsonComments(text);
-	return JSON.parse(stripped);
+	const cleanText = text.replace(/^\uFEFF/, "");
+	const errors = [];
+	const result = parse(cleanText, errors, { allowTrailingComma: true });
+	if (errors.length > 0) {
+		const errorDetails = errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
+		throw new SyntaxError(`Invalid JSONC: ${errorDetails}`);
+	}
+	return result;
 }
 function loadConfigFile(filePath) {
 	if (!fs.existsSync(filePath)) throw new Error(`Configuration file not found: ${filePath}`);
@@ -161,6 +851,7 @@ function mergeConfigs(base, override = {}, definitionsDir = getDefinitionsDir(),
 	const defaultIgnore = [
 		".git",
 		".vscode",
+		".nanos-lint",
 		"node_modules",
 		"dist",
 		"bin",
@@ -290,12 +981,18 @@ function initWorkspace(workspacePath, options) {
 	const template = loadConfigFile(getDefaultTemplatePath());
 	const definitionsDir = getDefinitionsDir();
 	const sourceAnnotations = path.join(definitionsDir, "annotations.lua");
+	if (!fs.existsSync(sourceAnnotations)) throw new Error(`Definitions file not found at ${sourceAnnotations}. Make sure submodules are initialized.`);
 	const targetNanosDir = path.join(workspacePath, ".nanos-lint");
 	fs.mkdirSync(targetNanosDir, { recursive: true });
 	const targetAnnotations = path.join(targetNanosDir, "annotations.lua");
-	if (fs.existsSync(sourceAnnotations)) fs.copyFileSync(sourceAnnotations, targetAnnotations);
+	fs.copyFileSync(sourceAnnotations, targetAnnotations);
 	template.workspace = template.workspace ?? {};
 	template.workspace.library = [".nanos-lint/annotations.lua"];
+	const existingIgnore = template.workspace.ignoreDir ?? [];
+	if (!existingIgnore.includes(".nanos-lint")) template.workspace.ignoreDir = [".nanos-lint", ...existingIgnore];
+	template.files = template.files ?? {};
+	const existingExclude = template.files.exclude ?? [];
+	if (!existingExclude.includes(".nanos-lint/**")) template.files.exclude = [".nanos-lint/**", ...existingExclude];
 	fs.writeFileSync(targetFile, JSON.stringify(template, null, 2), "utf-8");
 	return targetFile;
 }
@@ -374,15 +1071,50 @@ function getCacheDir(version = FALLBACK_LUALS_VERSION) {
 	const base = process.platform === "win32" ? process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local") : process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
 	return path.join(base, "nanos-lint", "luals", version);
 }
+/**
+* Verifies that a 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;
+		const output = execFileSync(binaryPath, ["--version"], {
+			timeout: 5e3,
+			stdio: "pipe",
+			encoding: "utf-8"
+		});
+		return /^\d+\.\d+\.\d+/.test(output.trim());
+	} catch {
+		return false;
+	}
+}
 async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDir, options) {
 	const resolvedVersion = await resolveLuaLSVersion(version);
 	const info = getPlatformInfo(resolvedVersion);
 	const destDir = targetDir || getCacheDir(resolvedVersion);
 	const binaryPath = path.join(destDir, info.binaryRelativePath);
-	if (fs.existsSync(binaryPath)) return binaryPath;
-	fs.mkdirSync(destDir, { recursive: true });
+	const completeMarker = path.join(destDir, ".complete");
+	if (fs.existsSync(destDir)) {
+		if (fs.existsSync(binaryPath) && isBinaryValid(binaryPath)) {
+			if (!fs.existsSync(completeMarker)) try {
+				fs.writeFileSync(completeMarker, resolvedVersion, "utf-8");
+			} catch {}
+			return binaryPath;
+		}
+		try {
+			fs.rmSync(destDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+	const parentDir = path.dirname(destDir);
+	fs.mkdirSync(parentDir, { recursive: true });
+	const tempDir = path.join(parentDir, `.${path.basename(destDir)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+	fs.mkdirSync(tempDir, { recursive: true });
 	const url = `https://github.com/LuaLS/lua-language-server/releases/download/${resolvedVersion}/${info.assetName}`;
-	const archivePath = path.join(destDir, info.assetName);
+	const archivePath = path.join(tempDir, info.assetName);
 	if (!options?.quiet) console.log(`[luals] Downloading LuaLS ${resolvedVersion} from ${url}...`);
 	let response = null;
 	let lastErr = null;
@@ -393,54 +1125,108 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 				response = res;
 				break;
 			}
+			await res.body?.cancel();
 			lastErr = /* @__PURE__ */ new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
 		} catch (err) {
 			lastErr = err;
 		}
 		if (attempt < 3) await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
 	}
-	if (!response || !response.body) throw lastErr || /* @__PURE__ */ new Error(`Failed to download ${url}`);
-	const arrayBuffer = await response.arrayBuffer();
-	fs.writeFileSync(archivePath, Buffer.from(arrayBuffer));
-	if (!options?.quiet) console.log(`[luals] Extracting to ${destDir}...`);
-	try {
-		await execFileAsync("tar", [
-			"-xf",
-			archivePath,
-			"-C",
-			destDir
-		]);
-	} catch (tarErr) {
-		if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync("powershell.exe", [
-			"-NoProfile",
-			"-Command",
-			`Expand-Archive -Path '${escapePowerShellSingleQuote(archivePath)}' -DestinationPath '${escapePowerShellSingleQuote(destDir)}' -Force`
-		]);
-		else throw tarErr;
+	if (!response || !response.body) {
+		try {
+			fs.rmSync(tempDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		throw lastErr || /* @__PURE__ */ new Error(`Failed to download ${url}`);
 	}
 	try {
-		fs.unlinkSync(archivePath);
-	} catch {}
-	if (process.platform !== "win32") try {
-		fs.chmodSync(binaryPath, 493);
-	} catch {}
-	if (!fs.existsSync(binaryPath)) throw new Error(`Failed to extract LuaLS binary to expected path: ${binaryPath}`);
-	if (!options?.quiet) console.log(`[luals] Ready: ${binaryPath}`);
-	return binaryPath;
+		const arrayBuffer = await response.arrayBuffer();
+		fs.writeFileSync(archivePath, Buffer.from(arrayBuffer));
+		if (!options?.quiet) console.log(`[luals] Extracting to ${destDir}...`);
+		try {
+			await execFileAsync("tar", [
+				"-xf",
+				archivePath,
+				"-C",
+				tempDir
+			]);
+		} catch (tarErr) {
+			if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync("powershell.exe", [
+				"-NoProfile",
+				"-Command",
+				`Expand-Archive -Path '${escapePowerShellSingleQuote(archivePath)}' -DestinationPath '${escapePowerShellSingleQuote(tempDir)}' -Force`
+			]);
+			else throw tarErr;
+		}
+		try {
+			fs.unlinkSync(archivePath);
+		} catch {}
+		const tempBinaryPath = path.join(tempDir, info.binaryRelativePath);
+		if (process.platform !== "win32") try {
+			fs.chmodSync(tempBinaryPath, 493);
+		} catch {}
+		if (!fs.existsSync(tempBinaryPath) || fs.statSync(tempBinaryPath).size < 1e5) throw new Error(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`);
+		fs.writeFileSync(path.join(tempDir, ".complete"), resolvedVersion, "utf-8");
+		for (let attempt = 0; attempt < 5; attempt++) try {
+			fs.renameSync(tempDir, destDir);
+			break;
+		} catch (renameErr) {
+			if (fs.existsSync(binaryPath) && isBinaryValid(binaryPath)) {
+				try {
+					fs.rmSync(tempDir, {
+						recursive: true,
+						force: true
+					});
+				} catch {}
+				if (!options?.quiet) console.log(`[luals] Ready: ${binaryPath}`);
+				return binaryPath;
+			}
+			if (attempt < 4) await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+			else throw renameErr;
+		}
+		if (!isBinaryValid(binaryPath)) throw new Error(`Extracted LuaLS binary at ${binaryPath} is invalid or non-functional.`);
+		if (!options?.quiet) console.log(`[luals] Ready: ${binaryPath}`);
+		return binaryPath;
+	} finally {
+		if (fs.existsSync(tempDir)) try {
+			fs.rmSync(tempDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
 }
 async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	if (process.env.LUALS_BIN && fs.existsSync(process.env.LUALS_BIN)) return process.env.LUALS_BIN;
 	const resolvedVersion = await resolveLuaLSVersion(version);
 	const info = getPlatformInfo(resolvedVersion);
 	const bundledPath = path.join(getPackageRoot(), info.binaryRelativePath);
-	if (fs.existsSync(bundledPath)) return bundledPath;
-	const cachedPath = path.join(getCacheDir(resolvedVersion), info.binaryRelativePath);
-	if (fs.existsSync(cachedPath)) return cachedPath;
+	if (fs.existsSync(bundledPath) && isBinaryValid(bundledPath)) return bundledPath;
+	const cachedDir = getCacheDir(resolvedVersion);
+	const cachedPath = path.join(cachedDir, info.binaryRelativePath);
+	const completeMarker = path.join(cachedDir, ".complete");
+	if (fs.existsSync(cachedPath)) {
+		if (isBinaryValid(cachedPath)) {
+			if (!fs.existsSync(completeMarker)) try {
+				fs.writeFileSync(completeMarker, resolvedVersion, "utf-8");
+			} catch {}
+			return cachedPath;
+		}
+		if (!options?.quiet) console.warn(`[luals] Cached LuaLS binary at ${cachedPath} is corrupted or incomplete. Repairing...`);
+		try {
+			fs.rmSync(cachedDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
 	try {
 		const cmd = process.platform === "win32" ? "where.exe" : "which";
 		const { stdout } = await execFileAsync(cmd, ["lua-language-server"]);
 		const found = stdout.trim().split(/\r?\n/)[0];
-		if (found && fs.existsSync(found)) return found;
+		if (found && fs.existsSync(found) && isBinaryValid(found)) return found;
 	} catch {}
 	return await downloadAndExtractLuaLS(resolvedVersion, void 0, options);
 }
@@ -485,8 +1271,9 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 		} catch {}
 	}
 	if (!parseSucceeded) {
-		if (execError) throw new Error(`LuaLS check failed to execute or produce diagnostic output: ${execError instanceof Error ? execError.message : String(execError)}`);
-		throw new Error(`LuaLS check failed to produce diagnostic output at: ${checkOutPath}`);
+		const cacheHint = `(Cache location: ${getCacheDir()})`;
+		if (execError) throw new Error(`LuaLS check failed to execute or produce diagnostic output: ${execError instanceof Error ? execError.message : String(execError)}. ${cacheHint}`);
+		throw new Error(`LuaLS check failed to produce diagnostic output at: ${checkOutPath}. ${cacheHint}`);
 	}
 	if (targetFileOnly) {
 		const filtered = {};
@@ -529,6 +1316,7 @@ function countCheckedFiles(targetPath, configPath) {
 	let ignoreDirs = [
 		".git",
 		".vscode",
+		".nanos-lint",
 		"node_modules"
 	];
 	let excludePatterns = [];
@@ -3832,6 +4620,6 @@ if (isDirectExecution()) runCLI().then((code) => {
 	process.exit(1);
 });
 //#endregion
-export { parseJsonc as A, runLuaLSCheck as C, initWorkspace as D, getPackageRoot as E, stripJsonComments as M, fileUriToPath as N, loadConfigFile as O, resolveLuaLSVersion as S, getDefinitionsDir as T, escapePowerShellSingleQuote as _, formatGitHubAnnotations as a, resolveLatestLuaLSVersion as b, formatReport as c, pluralize as d, shouldEnableColor as f, downloadAndExtractLuaLS as g, countCheckedFiles as h, runCLI as i, resolveWorkspaceConfig as j, mergeConfigs as k, formatSeverityBadge as l, FALLBACK_LUALS_VERSION as m, createProgram as n, formatPretty as o, DEFAULT_LUALS_VERSION as p, isDirectExecution as r, formatProblemSummary as s, collectIgnorePatterns as t, getColors as u, getCacheDir as v, getDefaultTemplatePath as w, resolveLuaLSBinary as x, getPlatformInfo as y };
+export { mergeConfigs as A, resolveLuaLSVersion as C, getPackageRoot as D, getDefinitionsDir as E, resolveWorkspaceConfig as M, stripJsonComments as N, initWorkspace as O, fileUriToPath as P, resolveLuaLSBinary as S, getDefaultTemplatePath as T, escapePowerShellSingleQuote as _, formatGitHubAnnotations as a, isBinaryValid as b, formatReport as c, pluralize as d, shouldEnableColor as f, downloadAndExtractLuaLS as g, countCheckedFiles as h, runCLI as i, parseJsonc as j, loadConfigFile as k, formatSeverityBadge as l, FALLBACK_LUALS_VERSION as m, createProgram as n, formatPretty as o, DEFAULT_LUALS_VERSION as p, isDirectExecution as r, formatProblemSummary as s, collectIgnorePatterns as t, getColors as u, getCacheDir as v, runLuaLSCheck as w, resolveLatestLuaLSVersion as x, getPlatformInfo as y };
 
-//# sourceMappingURL=cli-Dx-1zSOk.js.map
+//# sourceMappingURL=cli-kmHD4epr.js.map