eslint-linter-browserify 10.1.0 → 10.2.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.1.0";
+var version = "10.2.0";
 var require$$3$1 = {
 	version: version};
 
@@ -10012,6 +10012,7 @@ function requireGlobals () {
 		AsyncDisposableStack: false,
 		DisposableStack: false,
 		SuppressedError: false,
+		Temporal: false,
 	};
 
 	//-----------------------------------------------------------------------------
@@ -22913,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) {
@@ -23185,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;
 	
@@ -23399,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 */
@@ -23687,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 ||
@@ -24116,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) => {
@@ -24135,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)
@@ -24367,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);
@@ -24429,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] = '*';
 		                    }
 		                }
 		            }
@@ -24520,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;
@@ -24769,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);
@@ -25123,7 +25132,7 @@ function requireCommonjs () {
 		            this.regexp = new RegExp(re, [...flags].join(''));
 		            /* c8 ignore start */
 		        }
-		        catch (ex) {
+		        catch {
 		            // should be impossible
 		            this.regexp = false;
 		        }
@@ -25138,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(/\/+/)];
 		        }
@@ -25180,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];
@@ -25300,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.
 		 */
@@ -25312,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.
 		 */
@@ -25335,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.
 		 */
@@ -25347,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.
 		 */
@@ -25360,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.
 		 */
@@ -25372,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.
 		 */
@@ -25547,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);
 						},
@@ -25565,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);
 				}
 			}
 		}
@@ -35343,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.
@@ -35687,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__") {
@@ -35718,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) {
@@ -35749,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;
+			}
 		}
 
 		/**
@@ -92703,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
@@ -101251,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.
@@ -101263,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);
 			}
 		}
 	}
@@ -131044,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":')