eslint-linter-browserify 10.0.3 → 10.2.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.0.3";
+var version = "10.2.0";
 var require$$3$1 = {
 	version: version};
 
@@ -8346,7 +8346,6 @@ function requireUtils$1 () {
 		for (
 			let minIndex = 0, maxIndex = tokens.length - 1;
 			minIndex <= maxIndex;
-
 		) {
 			/*
 			 * Calculate the index in the middle between minIndex and maxIndex.
@@ -10013,6 +10012,7 @@ function requireGlobals () {
 		AsyncDisposableStack: false,
 		DisposableStack: false,
 		SuppressedError: false,
+		Temporal: false,
 	};
 
 	//-----------------------------------------------------------------------------
@@ -22914,7 +22914,9 @@ function requireCommonjs$1 () {
 		            const x = numeric(n[0]);
 		            const y = numeric(n[1]);
 		            const width = Math.max(n[0].length, n[1].length);
-		            let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
+		            let incr = n.length === 3 && n[2] !== undefined ?
+		                Math.max(Math.abs(numeric(n[2])), 1)
+		                : 1;
 		            let test = lte;
 		            const reverse = y < x;
 		            if (reverse) {
@@ -23186,16 +23188,16 @@ function require_unescape () {
 	const unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true, } = {}) => {
 	    if (magicalBraces) {
 	        return windowsPathsNoEscape ?
-	            s.replace(/\[([^\/\\])\]/g, '$1')
+	            s.replace(/\[([^/\\])\]/g, '$1')
 	            : s
-	                .replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2')
-	                .replace(/\\([^\/])/g, '$1');
+	                .replace(/((?!\\).|^)\[([^/\\])\]/g, '$1$2')
+	                .replace(/\\([^/])/g, '$1');
 	    }
 	    return windowsPathsNoEscape ?
-	        s.replace(/\[([^\/\\{}])\]/g, '$1')
+	        s.replace(/\[([^/\\{}])\]/g, '$1')
 	        : s
-	            .replace(/((?!\\).|^)\[([^\/\\{}])\]/g, '$1$2')
-	            .replace(/\\([^\/{}])/g, '$1');
+	            .replace(/((?!\\).|^)\[([^/\\{}])\]/g, '$1$2')
+	            .replace(/\\([^/{}])/g, '$1');
 	};
 	_unescape.unescape = unescape;
 	
@@ -23400,15 +23402,14 @@ function requireAst$1 () {
 	    }
 	    // reconstructs the pattern
 	    toString() {
-	        if (this.#toString !== undefined)
-	            return this.#toString;
-	        if (!this.type) {
-	            return (this.#toString = this.#parts.map(p => String(p)).join(''));
-	        }
-	        else {
-	            return (this.#toString =
-	                this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');
-	        }
+	        return (this.#toString !== undefined ? this.#toString
+	            : !this.type ?
+	                (this.#toString = this.#parts.map(p => String(p)).join(''))
+	                : (this.#toString =
+	                    this.type +
+	                        '(' +
+	                        this.#parts.map(p => String(p)).join('|') +
+	                        ')'));
 	    }
 	    #fillNegs() {
 	        /* c8 ignore start */
@@ -23688,7 +23689,7 @@ function requireAst$1 () {
 	    }
 	    #canUsurpType(c) {
 	        const m = usurpMap.get(this.type);
-	        return !!(m?.has(c));
+	        return !!m?.has(c);
 	    }
 	    #canUsurp(child) {
 	        if (!child ||
@@ -24117,7 +24118,7 @@ function requireCommonjs () {
 		};
 		exports$1.minimatch = minimatch;
 		// Optimized checking for the most common glob patterns.
-		const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+		const starDotExtRE = /^\*+([^+@!?*[(]*)$/;
 		const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);
 		const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
 		const starDotExtTestNocase = (ext) => {
@@ -24136,7 +24137,7 @@ function requireCommonjs () {
 		const starRE = /^\*+$/;
 		const starTest = (f) => f.length !== 0 && !f.startsWith('.');
 		const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';
-		const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+		const qmarksRE = /^\?+([^+@!?*[(]*)?$/;
 		const qmarksTestNocase = ([$0, ext = '']) => {
 		    const noext = qmarksTestNoExt([$0]);
 		    if (!ext)
@@ -24368,6 +24369,7 @@ function requireCommonjs () {
 		        // step 2: expand braces
 		        this.globSet = [...new Set(this.braceExpand())];
 		        if (options.debug) {
+		            //oxlint-disable-next-line no-console
 		            this.debug = (...args) => console.error(...args);
 		        }
 		        this.debug(this.pattern, this.globSet);
@@ -24430,10 +24432,10 @@ function requireCommonjs () {
 		    preprocess(globParts) {
 		        // if we're not in globstar mode, then turn ** into *
 		        if (this.options.noglobstar) {
-		            for (let i = 0; i < globParts.length; i++) {
-		                for (let j = 0; j < globParts[i].length; j++) {
-		                    if (globParts[i][j] === '**') {
-		                        globParts[i][j] = '*';
+		            for (const partset of globParts) {
+		                for (let j = 0; j < partset.length; j++) {
+		                    if (partset[j] === '**') {
+		                        partset[j] = '*';
 		                    }
 		                }
 		            }
@@ -24521,7 +24523,11 @@ function requireCommonjs () {
 		            let dd = 0;
 		            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
 		                const p = parts[dd - 1];
-		                if (p && p !== '.' && p !== '..' && p !== '**') {
+		                if (p &&
+		                    p !== '.' &&
+		                    p !== '..' &&
+		                    p !== '**' &&
+		                    !(this.isWindows && /^[a-z]:$/i.test(p))) {
 		                    didSomething = true;
 		                    parts.splice(dd - 1, 2);
 		                    dd -= 2;
@@ -24770,15 +24776,17 @@ function requireCommonjs () {
 		        // split the pattern up into globstar-delimited sections
 		        // the tail has to be at the end, and the others just have
 		        // to be found in order from the head.
-		        const [head, body, tail] = partial ? [
-		            pattern.slice(patternIndex, firstgs),
-		            pattern.slice(firstgs + 1),
-		            [],
-		        ] : [
-		            pattern.slice(patternIndex, firstgs),
-		            pattern.slice(firstgs + 1, lastgs),
-		            pattern.slice(lastgs + 1),
-		        ];
+		        const [head, body, tail] = partial ?
+		            [
+		                pattern.slice(patternIndex, firstgs),
+		                pattern.slice(firstgs + 1),
+		                [],
+		            ]
+		            : [
+		                pattern.slice(patternIndex, firstgs),
+		                pattern.slice(firstgs + 1, lastgs),
+		                pattern.slice(lastgs + 1),
+		            ];
 		        // check the head, from the current file/pattern index.
 		        if (head.length) {
 		            const fileHead = file.slice(fileIndex, fileIndex + head.length);
@@ -25124,7 +25132,7 @@ function requireCommonjs () {
 		            this.regexp = new RegExp(re, [...flags].join(''));
 		            /* c8 ignore start */
 		        }
-		        catch (ex) {
+		        catch {
 		            // should be impossible
 		            this.regexp = false;
 		        }
@@ -25139,7 +25147,7 @@ function requireCommonjs () {
 		        if (this.preserveMultipleSlashes) {
 		            return p.split('/');
 		        }
-		        else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+		        else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
 		            // add an extra '' for the one we lose
 		            return ['', ...p.split(/\/+/)];
 		        }
@@ -25181,8 +25189,7 @@ function requireCommonjs () {
 		                filename = ff[i];
 		            }
 		        }
-		        for (let i = 0; i < set.length; i++) {
-		            const pattern = set[i];
+		        for (const pattern of set) {
 		            let file = ff;
 		            if (options.matchBase && pattern.length === 1) {
 		                file = [filename];
@@ -25301,7 +25308,7 @@ function requireCjs$1 () {
 	class ValidationStrategy {
 		/**
 		 * Validates that a value is an array.
-		 * @param {*} value The value to validate.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
@@ -25313,19 +25320,19 @@ function requireCjs$1 () {
 
 		/**
 		 * Validates that a value is a boolean.
-		 * @param {*} value The value to validate.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
 		static boolean(value) {
 			if (typeof value !== "boolean") {
-				throw new TypeError("Expected a Boolean.");
+				throw new TypeError("Expected a boolean.");
 			}
 		}
 
 		/**
 		 * Validates that a value is a number.
-		 * @param {*} value The value to validate.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
@@ -25336,8 +25343,8 @@ function requireCjs$1 () {
 		}
 
 		/**
-		 * Validates that a value is a object.
-		 * @param {*} value The value to validate.
+		 * Validates that a value is an object.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
@@ -25348,8 +25355,8 @@ function requireCjs$1 () {
 		}
 
 		/**
-		 * Validates that a value is a object or null.
-		 * @param {*} value The value to validate.
+		 * Validates that a value is an object or null.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
@@ -25361,7 +25368,7 @@ function requireCjs$1 () {
 
 		/**
 		 * Validates that a value is a string.
-		 * @param {*} value The value to validate.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
@@ -25373,7 +25380,7 @@ function requireCjs$1 () {
 
 		/**
 		 * Validates that a value is a non-empty string.
-		 * @param {*} value The value to validate.
+		 * @param {unknown} value The value to validate.
 		 * @returns {void}
 		 * @throws {TypeError} If the value is invalid.
 		 */
@@ -25548,13 +25555,17 @@ function requireCjs$1 () {
 
 			// add in all strategies
 			for (const key of Object.keys(definitions)) {
-				validateDefinition(key, definitions[key]);
+				const definition = definitions[key];
+
+				validateDefinition(key, definition);
+
+				let normalizedDefinition = definition;
 
 				// normalize merge and validate methods if subschema is present
-				if (typeof definitions[key].schema === "object") {
-					const schema = new ObjectSchema(definitions[key].schema);
-					definitions[key] = {
-						...definitions[key],
+				if (typeof normalizedDefinition.schema === "object") {
+					const schema = new ObjectSchema(normalizedDefinition.schema);
+					normalizedDefinition = {
+						...normalizedDefinition,
 						merge(first = {}, second = {}) {
 							return schema.merge(first, second);
 						},
@@ -25566,30 +25577,25 @@ function requireCjs$1 () {
 				}
 
 				// normalize the merge method in case there's a string
-				if (typeof definitions[key].merge === "string") {
-					definitions[key] = {
-						...definitions[key],
-						merge: MergeStrategy[
-							/** @type {string} */ (definitions[key].merge)
-						],
+				if (typeof normalizedDefinition.merge === "string") {
+					normalizedDefinition = {
+						...normalizedDefinition,
+						merge: MergeStrategy[normalizedDefinition.merge],
 					};
 				}
 
 				// normalize the validate method in case there's a string
-				if (typeof definitions[key].validate === "string") {
-					definitions[key] = {
-						...definitions[key],
-						validate:
-							ValidationStrategy[
-								/** @type {string} */ (definitions[key].validate)
-							],
+				if (typeof normalizedDefinition.validate === "string") {
+					normalizedDefinition = {
+						...normalizedDefinition,
+						validate: ValidationStrategy[normalizedDefinition.validate],
 					};
 				}
 
-				this.#definitions.set(key, definitions[key]);
+				this.#definitions.set(key, normalizedDefinition);
 
-				if (definitions[key].required) {
-					this.#requiredKeys.set(key, definitions[key]);
+				if (normalizedDefinition.required) {
+					this.#requiredKeys.set(key, normalizedDefinition);
 				}
 			}
 		}
@@ -35344,6 +35350,76 @@ function requireConfig () {
 		};
 	}
 
+	/**
+	 * Normalizes a language name by replacing the built-in `@/` plugin prefix with `js/`.
+	 * @param {string} languageName The language name to normalize.
+	 * @returns {string} The normalized language name.
+	 */
+	function normalizeLanguageName(languageName) {
+		return languageName.startsWith("@/")
+			? `js/${languageName.slice(2)}`
+			: languageName;
+	}
+
+	/**
+	 * Checks if a rule's `meta.languages` supports the given language.
+	 * @param {Array<string>|undefined} ruleLangs The rule's `meta.languages` array.
+	 * @param {string} configLanguageName The normalized language name from the config (e.g., "js/js").
+	 * @param {Array<string>} validPluginNames The valid plugin name aliases for the config's plugin
+	 *   (normalized plugin name plus its `meta.namespace` if defined).
+	 * @returns {boolean} True if the rule supports the language, false otherwise.
+	 */
+	function doesRuleSupportLanguage(
+		ruleLangs,
+		configLanguageName,
+		validPluginNames,
+	) {
+		// If no languages specified, works with all languages (backward compatible)
+		if (!ruleLangs) {
+			return true;
+		}
+
+		const { objectName: configLangPart } =
+			splitPluginIdentifier(configLanguageName);
+
+		for (const langEntry of ruleLangs) {
+			// Skip non-string entries
+			if (typeof langEntry !== "string") {
+				continue;
+			}
+
+			// "*" matches any language
+			if (langEntry === "*") {
+				return true;
+			}
+
+			// Direct match
+			if (langEntry === configLanguageName) {
+				return true;
+			}
+
+			const { pluginName: rulePluginPart, objectName: ruleLangPart } =
+				splitPluginIdentifier(langEntry);
+
+			// "plugin/*" wildcard - matches any language from that plugin (by name or namespace)
+			if (ruleLangPart === "*") {
+				if (validPluginNames.includes(rulePluginPart)) {
+					return true;
+				}
+			} else {
+				// Match by plugin name or namespace, with exact language part
+				if (
+					validPluginNames.includes(rulePluginPart) &&
+					ruleLangPart === configLangPart
+				) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
 	/**
 	 * Returns the name of an object in the config by reading its `meta` key.
 	 * @param {Object} object The object to check.
@@ -35688,12 +35764,30 @@ function requireConfig () {
 		 * @throws {TypeError} If the rulesConfig is not provided or is invalid.
 		 * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid.
 		 * @throws {TypeError} If a rule is not found in the plugins.
+		 * @throws {TypeError} If a rule does not support the current language.
 		 */
 		validateRulesConfig(rulesConfig) {
 			if (!rulesConfig) {
 				throw new TypeError("Config is required for validation.");
 			}
 
+			// Normalize "@/" prefix to "js/" for matching and user-facing messages
+			const normalizedLanguageName = normalizeLanguageName(
+				this.#languageName,
+			);
+
+			// Compute valid plugin name aliases for the config's language plugin once
+			const { pluginName: configPluginName } = splitPluginIdentifier(
+				normalizedLanguageName,
+			);
+			const configPlugin =
+				this.plugins[configPluginName] ??
+				(configPluginName === "js" ? this.plugins["@"] : void 0);
+			const validPluginNames = configPlugin?.meta?.namespace
+				? [configPluginName, configPlugin.meta.namespace]
+				: [configPluginName];
+			const unsupportedLanguageRules = [];
+
 			for (const [ruleId, ruleOptions] of Object.entries(rulesConfig)) {
 				// check for edge case
 				if (ruleId === "__proto__") {
@@ -35719,6 +35813,34 @@ function requireConfig () {
 					throwRuleNotFoundError(parseRuleId(ruleId), this);
 				}
 
+				// Validate meta.languages structure if present (only for enabled rules)
+				if (rule.meta?.languages !== void 0) {
+					if (!Array.isArray(rule.meta.languages)) {
+						throw new TypeError(
+							`Key "rules": Key "${ruleId}": Key "meta": Key "languages": Expected an array.`,
+						);
+					}
+
+					for (const lang of rule.meta.languages) {
+						if (typeof lang !== "string") {
+							throw new TypeError(
+								`Key "rules": Key "${ruleId}": Key "meta": Key "languages": Expected each element to be a string.`,
+							);
+						}
+					}
+				}
+
+				// Check if the rule supports the current language
+				if (
+					!doesRuleSupportLanguage(
+						rule.meta?.languages,
+						normalizedLanguageName,
+						validPluginNames,
+					)
+				) {
+					unsupportedLanguageRules.push(ruleId);
+				}
+
 				const validateRule = getOrCreateValidator(rule, ruleId);
 
 				if (validateRule) {
@@ -35750,6 +35872,19 @@ function requireConfig () {
 					}
 				}
 			}
+
+			if (unsupportedLanguageRules.length > 0) {
+				const error = new TypeError(
+					`Key "rules": The following rules do not support the language "${normalizedLanguageName}":\n${unsupportedLanguageRules.map(ruleId => `\t- "${ruleId}"`).join("\n")}`,
+				);
+
+				error.messageTemplate = "rule-unsupported-language";
+				error.messageData = {
+					ruleIds: unsupportedLanguageRules,
+					language: normalizedLanguageName,
+				};
+				throw error;
+			}
 		}
 
 		/**
@@ -45111,24 +45246,24 @@ function requireEspree () {
 		 * Normalize sourceType from the initial config
 		 * @param {string} sourceType to normalize
 		 * @throws {Error} throw an error if sourceType is invalid
-		 * @returns {"script"|"module"} normalized sourceType
+		 * @returns {"script"|"module"|"commonjs"} normalized sourceType
 		 */
 		function normalizeSourceType(sourceType = "script") {
-			if (sourceType === "script" || sourceType === "module") {
+			if (
+				sourceType === "script" ||
+				sourceType === "module" ||
+				sourceType === "commonjs"
+			) {
 				return sourceType;
 			}
 
-			if (sourceType === "commonjs") {
-				return "script";
-			}
-
 			throw new Error("Invalid sourceType.");
 		}
 
 		/**
 		 * @typedef {{
 		 *   ecmaVersion: NormalizedEcmaVersion,
-		 *   sourceType: "script"|"module",
+		 *   sourceType: "script"|"module"|"commonjs",
 		 *   range?: boolean,
 		 *   loc?: boolean,
 		 *   allowReserved: boolean | "never",
@@ -45933,7 +46068,7 @@ function requireEspree () {
 		//------------------------------------------------------------------------------
 
 		/** @type {string} */
-		const version = "11.1.1"; // x-release-please-version
+		const version = "11.2.0"; // x-release-please-version
 		const name = "espree";
 
 		// Derive node types from VisitorKeys
@@ -46419,9 +46554,9 @@ function requireAstUtils () {
 			if (left.regex || right.regex) {
 				return Boolean(
 					left.regex &&
-						right.regex &&
-						left.regex.pattern === right.regex.pattern &&
-						left.regex.flags === right.regex.flags,
+					right.regex &&
+					left.regex.pattern === right.regex.pattern &&
+					left.regex.flags === right.regex.flags,
 				);
 			}
 
@@ -47062,9 +47197,9 @@ function requireAstUtils () {
 
 			return Boolean(
 				reference &&
-					reference.resolved &&
-					reference.resolved.scope.type === "global" &&
-					reference.resolved.defs.length === 0,
+				reference.resolved &&
+				reference.resolved.scope.type === "global" &&
+				reference.resolved.defs.length === 0,
 			);
 		}
 
@@ -53154,9 +53289,9 @@ function requireCapitalizedComments () {
 
 				return Boolean(
 					previousToken &&
-						nextToken &&
-						comment.loc.start.line === previousToken.loc.end.line &&
-						comment.loc.end.line === nextToken.loc.start.line,
+					nextToken &&
+					comment.loc.start.line === previousToken.loc.end.line &&
+					comment.loc.end.line === nextToken.loc.start.line,
 				);
 			}
 
@@ -53172,7 +53307,7 @@ function requireCapitalizedComments () {
 
 				return Boolean(
 					previousTokenOrComment &&
-						["Block", "Line"].includes(previousTokenOrComment.type),
+					["Block", "Line"].includes(previousTokenOrComment.type),
 				);
 			}
 
@@ -82358,11 +82493,11 @@ function requireNoExtendNative () {
 			function isPrototypePropertyAccessed(identifierNode) {
 				return Boolean(
 					identifierNode &&
-						identifierNode.parent &&
-						identifierNode.parent.type === "MemberExpression" &&
-						identifierNode.parent.object === identifierNode &&
-						astUtils.getStaticPropertyName(identifierNode.parent) ===
-							"prototype",
+					identifierNode.parent &&
+					identifierNode.parent.type === "MemberExpression" &&
+					identifierNode.parent.object === identifierNode &&
+					astUtils.getStaticPropertyName(identifierNode.parent) ===
+						"prototype",
 				);
 			}
 
@@ -92704,7 +92839,14 @@ function requireNoObjCalls () {
 	// Helpers
 	//------------------------------------------------------------------------------
 
-	const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
+	const nonCallableGlobals = [
+		"Atomics",
+		"JSON",
+		"Math",
+		"Reflect",
+		"Intl",
+		"Temporal",
+	];
 
 	/**
 	 * Returns the name of the node to report
@@ -99723,9 +99865,7 @@ function requireNoThisBeforeSuper () {
 							isConstructor: true,
 							hasExtends: Boolean(
 								classNode.superClass &&
-									!astUtils.isNullOrUndefined(
-										classNode.superClass,
-									),
+								!astUtils.isNullOrUndefined(classNode.superClass),
 							),
 							codePath,
 							currentSegments: new Set(),
@@ -101254,6 +101394,35 @@ function requireNoUnmodifiedLoopCondition () {
 		return null;
 	}
 
+	/**
+	 * Checks whether a given modifier is in a loop.
+	 *
+	 * Besides checking for the condition being in the loop, this also checks
+	 * whether the function that this modifier is belonging to is called
+	 * in the loop.
+	 * @param {LoopConditionInfo} condition The condition to check.
+	 * @param {Reference} modifier The modifier to check.
+	 * @returns {boolean} `true` if the modifier is in a loop.
+	 */
+	function hasModifierInLoop(condition, modifier) {
+		if (condition.isInLoop(modifier)) {
+			return true;
+		}
+
+		const funcNode = getEncloseFunctionDeclaration(modifier);
+
+		if (!funcNode) {
+			return false;
+		}
+
+		const funcVar = astUtils.getVariableByName(
+			modifier.from.upper,
+			funcNode.id.name,
+		);
+
+		return Boolean(funcVar && funcVar.references.some(condition.isInLoop));
+	}
+
 	/**
 	 * Updates the "modified" flags of given loop conditions with given modifiers.
 	 * @param {LoopConditionInfo[]} conditions The loop conditions to be updated.
@@ -101266,26 +101435,8 @@ function requireNoUnmodifiedLoopCondition () {
 
 			for (let j = 0; !condition.modified && j < modifiers.length; ++j) {
 				const modifier = modifiers[j];
-				let funcNode, funcVar;
-
-				/*
-				 * Besides checking for the condition being in the loop, we want to
-				 * check the function that this modifier is belonging to is called
-				 * in the loop.
-				 * FIXME: This should probably be extracted to a function.
-				 */
-				const inLoop =
-					condition.isInLoop(modifier) ||
-					Boolean(
-						(funcNode = getEncloseFunctionDeclaration(modifier)) &&
-							(funcVar = astUtils.getVariableByName(
-								modifier.from.upper,
-								funcNode.id.name,
-							)) &&
-							funcVar.references.some(condition.isInLoop),
-					);
 
-				condition.modified = inLoop;
+				condition.modified = hasModifierInLoop(condition, modifier);
 			}
 		}
 	}
@@ -108558,6 +108709,28 @@ function requireNoVar () {
 		return variable.name === "let";
 	}
 
+	/**
+	 * Checks whether a given variable has any references before its declaration.
+	 * This is important because var allows hoisting, but let/const do not.
+	 * @param {Variable} variable The variable to check.
+	 * @returns {boolean} `true` if the variable is referenced before its declaration.
+	 */
+	function hasReferenceBeforeDeclaration(variable) {
+		const declarationStart = variable.defs[0].node.range[0];
+
+		return variable.references.some(reference => {
+			const referenceStart = reference.identifier.range[0];
+
+			/*
+			 * Check if the reference occurs before the declaration.
+			 * We don't need to check scopes because all references to this variable
+			 * are already in variable.references (which only includes references
+			 * that resolve to this specific variable binding).
+			 */
+			return !reference.init && referenceStart < declarationStart;
+		});
+	}
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -108611,6 +108784,7 @@ function requireNoVar () {
 			 * - A variable is used from a closure within a loop.
 			 * - A variable might be used before it is assigned within a loop.
 			 * - A variable might be used in TDZ.
+			 * - A variable is referenced before its declaration.
 			 * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
 			 * - A variable has name that is disallowed for `let` declarations.
 			 *
@@ -108655,6 +108829,10 @@ function requireNoVar () {
 			function canFix(node) {
 				const variables = sourceCode.getDeclaredVariables(node);
 				const scopeNode = getScopeNode(node);
+				const parentStatementList = new Set([
+					...astUtils.STATEMENT_LIST_PARENTS,
+					"TSModuleBlock",
+				]);
 
 				if (
 					node.parent.type === "SwitchCase" ||
@@ -108662,7 +108840,8 @@ function requireNoVar () {
 					variables.some(isGlobal) ||
 					variables.some(isRedeclared) ||
 					variables.some(isUsedFromOutsideOf(scopeNode)) ||
-					variables.some(hasNameDisallowedForLetDeclarations)
+					variables.some(hasNameDisallowedForLetDeclarations) ||
+					variables.some(hasReferenceBeforeDeclaration)
 				) {
 					return false;
 				}
@@ -108682,7 +108861,7 @@ function requireNoVar () {
 						node.parent.type === "ForStatement" &&
 						node.parent.init === node
 					) &&
-					!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)
+					!parentStatementList.has(node.parent.type)
 				) {
 					// If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed.
 					return false;
@@ -112985,11 +113164,11 @@ function requirePaddingLineBetweenStatements () {
 		const nextToken = sourceCode.getTokenAfter(semiToken);
 		const isSemicolonLessStyle = Boolean(
 			prevToken &&
-				nextToken &&
-				prevToken.range[0] >= node.range[0] &&
-				astUtils.isSemicolonToken(semiToken) &&
-				semiToken.loc.start.line !== prevToken.loc.end.line &&
-				semiToken.loc.end.line === nextToken.loc.start.line,
+			nextToken &&
+			prevToken.range[0] >= node.range[0] &&
+			astUtils.isSemicolonToken(semiToken) &&
+			semiToken.loc.start.line !== prevToken.loc.end.line &&
+			semiToken.loc.end.line === nextToken.loc.start.line,
 		);
 
 		return isSemicolonLessStyle ? prevToken : semiToken;
@@ -131019,6 +131198,22 @@ function requireLinter () {
 										throw err;
 									}
 
+									/*
+									 * If the rule does not support the current language, report a
+									 * specific, actionable error message.
+									 */
+									if (
+										err.messageTemplate ===
+										"rule-unsupported-language"
+									) {
+										report.addError({
+											ruleId,
+											message: `Inline configuration for rule "${ruleId}" is invalid:\n\tRule does not support the language "${err.messageData.language}". Use a config block with "files" to apply the rule only to supported files, or disable it.\n`,
+											loc,
+										});
+										return;
+									}
+
 									let baseMessage = err.message
 										.slice(
 											err.message.startsWith('Key "rules":')