eslint 9.22.0 → 9.24.0

package/lib/rules/utils/keywords.js

@@ -5,63 +5,63 @@
 "use strict";
 
 module.exports = [
-    "abstract",
-    "boolean",
-    "break",
-    "byte",
-    "case",
-    "catch",
-    "char",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "double",
-    "else",
-    "enum",
-    "export",
-    "extends",
-    "false",
-    "final",
-    "finally",
-    "float",
-    "for",
-    "function",
-    "goto",
-    "if",
-    "implements",
-    "import",
-    "in",
-    "instanceof",
-    "int",
-    "interface",
-    "long",
-    "native",
-    "new",
-    "null",
-    "package",
-    "private",
-    "protected",
-    "public",
-    "return",
-    "short",
-    "static",
-    "super",
-    "switch",
-    "synchronized",
-    "this",
-    "throw",
-    "throws",
-    "transient",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "volatile",
-    "while",
-    "with"
+	"abstract",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
 ];

package/lib/rules/utils/lazy-loading-rule-map.js

@@ -22,94 +22,97 @@ const debug = require("debug")("eslint:rules");
  * @extends {Map<string, () => Rule>}
  */
 class LazyLoadingRuleMap extends Map {
+	/**
+	 * Initialize this map.
+	 * @param {Array<[string, function(): Rule]>} loaders The rule loaders.
+	 */
+	constructor(loaders) {
+		let remaining = loaders.length;
 
-    /**
-     * Initialize this map.
-     * @param {Array<[string, function(): Rule]>} loaders The rule loaders.
-     */
-    constructor(loaders) {
-        let remaining = loaders.length;
+		super(
+			debug.enabled
+				? loaders.map(([ruleId, load]) => {
+						let cache = null;
 
-        super(
-            debug.enabled
-                ? loaders.map(([ruleId, load]) => {
-                    let cache = null;
+						return [
+							ruleId,
+							() => {
+								if (!cache) {
+									debug(
+										"Loading rule %o (remaining=%d)",
+										ruleId,
+										--remaining,
+									);
+									cache = load();
+								}
+								return cache;
+							},
+						];
+					})
+				: loaders,
+		);
 
-                    return [
-                        ruleId,
-                        () => {
-                            if (!cache) {
-                                debug("Loading rule %o (remaining=%d)", ruleId, --remaining);
-                                cache = load();
-                            }
-                            return cache;
-                        }
-                    ];
-                })
-                : loaders
-        );
+		// `super(...iterable)` uses `this.set()`, so disable it here.
+		Object.defineProperty(LazyLoadingRuleMap.prototype, "set", {
+			configurable: true,
+			value: void 0,
+		});
+	}
 
-        // `super(...iterable)` uses `this.set()`, so disable it here.
-        Object.defineProperty(LazyLoadingRuleMap.prototype, "set", {
-            configurable: true,
-            value: void 0
-        });
-    }
+	/**
+	 * Get a rule.
+	 * Each rule will be loaded on the first access.
+	 * @param {string} ruleId The rule ID to get.
+	 * @returns {Rule|undefined} The rule.
+	 */
+	get(ruleId) {
+		const load = super.get(ruleId);
 
-    /**
-     * Get a rule.
-     * Each rule will be loaded on the first access.
-     * @param {string} ruleId The rule ID to get.
-     * @returns {Rule|undefined} The rule.
-     */
-    get(ruleId) {
-        const load = super.get(ruleId);
+		return load && load();
+	}
 
-        return load && load();
-    }
+	/**
+	 * Iterate rules.
+	 * @returns {IterableIterator<Rule>} Rules.
+	 */
+	*values() {
+		for (const load of super.values()) {
+			yield load();
+		}
+	}
 
-    /**
-     * Iterate rules.
-     * @returns {IterableIterator<Rule>} Rules.
-     */
-    *values() {
-        for (const load of super.values()) {
-            yield load();
-        }
-    }
+	/**
+	 * Iterate rules.
+	 * @returns {IterableIterator<[string, Rule]>} Rules.
+	 */
+	*entries() {
+		for (const [ruleId, load] of super.entries()) {
+			yield [ruleId, load()];
+		}
+	}
 
-    /**
-     * Iterate rules.
-     * @returns {IterableIterator<[string, Rule]>} Rules.
-     */
-    *entries() {
-        for (const [ruleId, load] of super.entries()) {
-            yield [ruleId, load()];
-        }
-    }
-
-    /**
-     * Call a function with each rule.
-     * @param {Function} callbackFn The callback function.
-     * @param {any} [thisArg] The object to pass to `this` of the callback function.
-     * @returns {void}
-     */
-    forEach(callbackFn, thisArg) {
-        for (const [ruleId, load] of super.entries()) {
-            callbackFn.call(thisArg, load(), ruleId, this);
-        }
-    }
+	/**
+	 * Call a function with each rule.
+	 * @param {Function} callbackFn The callback function.
+	 * @param {any} [thisArg] The object to pass to `this` of the callback function.
+	 * @returns {void}
+	 */
+	forEach(callbackFn, thisArg) {
+		for (const [ruleId, load] of super.entries()) {
+			callbackFn.call(thisArg, load(), ruleId, this);
+		}
+	}
 }
 
 // Forbid mutation.
 Object.defineProperties(LazyLoadingRuleMap.prototype, {
-    clear: { configurable: true, value: void 0 },
-    delete: { configurable: true, value: void 0 },
-    [Symbol.iterator]: {
-        configurable: true,
-        writable: true,
-        value: LazyLoadingRuleMap.prototype.entries
-    }
+	clear: { configurable: true, value: void 0 },
+	delete: { configurable: true, value: void 0 },
+	[Symbol.iterator]: {
+		configurable: true,
+		writable: true,
+		value: LazyLoadingRuleMap.prototype.entries,
+	},
 });
 
 module.exports = { LazyLoadingRuleMap };

package/lib/rules/utils/regular-expressions.js

@@ -20,31 +20,39 @@ const REGEXPP_LATEST_ECMA_VERSION = 2025;
  * ecmaVersion doesn't support the `u` flag.
  */
 function isValidWithUnicodeFlag(ecmaVersion, pattern, flag = "u") {
-    if (flag === "u" && ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
-        return false;
-    }
-    if (flag === "v" && ecmaVersion <= 2023) {
-        return false;
-    }
-
-    const validator = new RegExpValidator({
-        ecmaVersion: Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION)
-    });
-
-    try {
-        validator.validatePattern(pattern, void 0, void 0, flag === "u" ? {
-            unicode: /* uFlag = */ true
-        } : {
-            unicodeSets: true
-        });
-    } catch {
-        return false;
-    }
-
-    return true;
+	if (flag === "u" && ecmaVersion <= 5) {
+		// ecmaVersion <= 5 doesn't support the 'u' flag
+		return false;
+	}
+	if (flag === "v" && ecmaVersion <= 2023) {
+		return false;
+	}
+
+	const validator = new RegExpValidator({
+		ecmaVersion: Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION),
+	});
+
+	try {
+		validator.validatePattern(
+			pattern,
+			void 0,
+			void 0,
+			flag === "u"
+				? {
+						unicode: /* uFlag = */ true,
+					}
+				: {
+						unicodeSets: true,
+					},
+		);
+	} catch {
+		return false;
+	}
+
+	return true;
 }
 
 module.exports = {
-    isValidWithUnicodeFlag,
-    REGEXPP_LATEST_ECMA_VERSION
+	isValidWithUnicodeFlag,
+	REGEXPP_LATEST_ECMA_VERSION,
 };

package/lib/rules/utils/unicode/index.js

@@ -9,8 +9,8 @@ const isRegionalIndicatorSymbol = require("./is-regional-indicator-symbol");
 const isSurrogatePair = require("./is-surrogate-pair");
 
 module.exports = {
-    isCombiningCharacter,
-    isEmojiModifier,
-    isRegionalIndicatorSymbol,
-    isSurrogatePair
+	isCombiningCharacter,
+	isEmojiModifier,
+	isRegionalIndicatorSymbol,
+	isSurrogatePair,
 };

package/lib/rules/utils/unicode/is-combining-character.js

@@ -9,5 +9,5 @@
  * @returns {boolean} `true` if the character belongs to the category, any of `Mc`, `Me`, and `Mn`.
  */
 module.exports = function isCombiningCharacter(codePoint) {
-    return /^[\p{Mc}\p{Me}\p{Mn}]$/u.test(String.fromCodePoint(codePoint));
+	return /^[\p{Mc}\p{Me}\p{Mn}]$/u.test(String.fromCodePoint(codePoint));
 };

package/lib/rules/utils/unicode/is-emoji-modifier.js

@@ -9,5 +9,5 @@
  * @returns {boolean} `true` if the character is an emoji modifier.
  */
 module.exports = function isEmojiModifier(code) {
-    return code >= 0x1F3FB && code <= 0x1F3FF;
+	return code >= 0x1f3fb && code <= 0x1f3ff;
 };

package/lib/rules/utils/unicode/is-regional-indicator-symbol.js

@@ -9,5 +9,5 @@
  * @returns {boolean} `true` if the character is a regional indicator symbol.
  */
 module.exports = function isRegionalIndicatorSymbol(code) {
-    return code >= 0x1F1E6 && code <= 0x1F1FF;
+	return code >= 0x1f1e6 && code <= 0x1f1ff;
 };

package/lib/rules/utils/unicode/is-surrogate-pair.js

@@ -10,5 +10,5 @@
  * @returns {boolean} `true` if the character pair is a surrogate pair.
  */
 module.exports = function isSurrogatePair(lead, tail) {
-    return lead >= 0xD800 && lead < 0xDC00 && tail >= 0xDC00 && tail < 0xE000;
+	return lead >= 0xd800 && lead < 0xdc00 && tail >= 0xdc00 && tail < 0xe000;
 };