eslint-plugin-unicorn 68.0.0 → 69.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "68.0.0",
+	"version": "69.0.0",
 	"description": "More than 300 powerful ESLint rules",
 	"license": "MIT",
 	"repository": {
@@ -113,6 +113,8 @@
 		"open-editor": "^6.0.0",
 		"outdent": "^0.8.0",
 		"pretty-ms": "^9.3.0",
+		"svelte": "^5.56.3",
+		"svelte-eslint-parser": "^1.8.0",
 		"typescript": "^6.0.3",
 		"vue-eslint-parser": "^10.4.1",
 		"yaml": "^2.9.0"

package/readme.md

@@ -110,6 +110,7 @@ export default defineConfig([
 | [consistent-json-file-read](docs/rules/consistent-json-file-read.md)                                       | Enforce consistent JSON file reads before `JSON.parse()`.                                                                      | ✅    | 🔧 |    |    |
 | [consistent-optional-chaining](docs/rules/consistent-optional-chaining.md)                                 | Enforce consistent optional chaining for same-base member access.                                                              | ✅ ☑️ |    | 💡 |    |
 | [consistent-template-literal-escape](docs/rules/consistent-template-literal-escape.md)                     | Enforce consistent style for escaping `${` in template literals.                                                               | ✅    | 🔧 |    |    |
+| [consistent-tuple-labels](docs/rules/consistent-tuple-labels.md)                                           | Enforce consistent labels on tuple type elements.                                                                              | ✅    |    |    |    |
 | [custom-error-definition](docs/rules/custom-error-definition.md)                                           | Enforce correct `Error` subclassing.                                                                                           |      | 🔧 |    |    |
 | [default-export-style](docs/rules/default-export-style.md)                                                 | Enforce consistent default export declarations.                                                                                | ✅    | 🔧 | 💡 |    |
 | [dom-node-dataset](docs/rules/dom-node-dataset.md)                                                         | Enforce consistent style for DOM element dataset access.                                                                       | ✅ ☑️ | 🔧 |    |    |
@@ -179,8 +180,10 @@ export default defineConfig([
 | [no-invalid-fetch-options](docs/rules/no-invalid-fetch-options.md)                                         | Disallow invalid options in `fetch()` and `new Request()`.                                                                     | ✅ ☑️ |    |    |    |
 | [no-invalid-file-input-accept](docs/rules/no-invalid-file-input-accept.md)                                 | Disallow invalid `accept` values on file inputs.                                                                               |      | 🔧 |    |    |
 | [no-invalid-remove-event-listener](docs/rules/no-invalid-remove-event-listener.md)                         | Prevent calling `EventTarget#removeEventListener()` with the result of an expression.                                          | ✅ ☑️ |    |    |    |
+| [no-invalid-well-known-symbol-methods](docs/rules/no-invalid-well-known-symbol-methods.md)                 | Disallow invalid implementations of well-known symbol methods.                                                                 | ✅ ☑️ | 🔧 | 💡 |    |
 | [no-keyword-prefix](docs/rules/no-keyword-prefix.md)                                                       | Disallow identifiers starting with `new` or `class`.                                                                           |      |    |    |    |
 | [no-late-current-target-access](docs/rules/no-late-current-target-access.md)                               | Disallow accessing `event.currentTarget` after the synchronous event dispatch has finished.                                    | ✅    |    |    |    |
+| [no-late-event-control](docs/rules/no-late-event-control.md)                                               | Disallow event-control method calls after the synchronous event dispatch has finished.                                         | ✅    |    |    |    |
 | [no-lonely-if](docs/rules/no-lonely-if.md)                                                                 | Disallow `if` statements as the only statement in `if` blocks without `else`.                                                  | ✅ ☑️ | 🔧 |    |    |
 | [no-loop-iterable-mutation](docs/rules/no-loop-iterable-mutation.md)                                       | Disallow mutating a loop iterable during iteration.                                                                            | ✅    |    |    |    |
 | [no-magic-array-flat-depth](docs/rules/no-magic-array-flat-depth.md)                                       | Disallow a magic number as the `depth` argument in `Array#flat(…).`                                                            | ✅ ☑️ |    |    |    |
@@ -261,8 +264,10 @@ export default defineConfig([
 | [number-literal-case](docs/rules/number-literal-case.md)                                                   | Enforce proper case for numeric literals.                                                                                      | ✅ ☑️ | 🔧 |    |    |
 | [numeric-separators-style](docs/rules/numeric-separators-style.md)                                         | Enforce the style of numeric separators by correctly grouping digits.                                                          | ✅ ☑️ | 🔧 |    |    |
 | [operator-assignment](docs/rules/operator-assignment.md)                                                   | Require assignment operator shorthand where possible.                                                                          | ✅    | 🔧 | 💡 |    |
+| [prefer-abort-signal-timeout](docs/rules/prefer-abort-signal-timeout.md)                                   | Prefer `AbortSignal.timeout()` over manually aborting an `AbortController` with `setTimeout()`.                                | ✅    |    | 💡 |    |
 | [prefer-add-event-listener](docs/rules/prefer-add-event-listener.md)                                       | Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions.                                                 | ✅ ☑️ | 🔧 |    |    |
 | [prefer-add-event-listener-options](docs/rules/prefer-add-event-listener-options.md)                       | Prefer an options object over a boolean in `.addEventListener()`.                                                              | ✅ ☑️ | 🔧 |    |    |
+| [prefer-aggregate-error](docs/rules/prefer-aggregate-error.md)                                             | Prefer `AggregateError` when throwing collected errors.                                                                        | ✅ ☑️ | 🔧 |    |    |
 | [prefer-array-find](docs/rules/prefer-array-find.md)                                                       | Prefer `.find(…)` and `.findLast(…)` over the first or last element from `.filter(…)`.                                         | ✅ ☑️ | 🔧 | 💡 |    |
 | [prefer-array-flat](docs/rules/prefer-array-flat.md)                                                       | Prefer `Array#flat()` over legacy techniques to flatten arrays.                                                                | ✅ ☑️ | 🔧 |    |    |
 | [prefer-array-flat-map](docs/rules/prefer-array-flat-map.md)                                               | Prefer `.flatMap(…)` over `.map(…).flat()` and `.filter(…).flatMap(…)`.                                                        | ✅ ☑️ | 🔧 | 💡 |    |
@@ -289,9 +294,11 @@ export default defineConfig([
 | [prefer-dom-node-append](docs/rules/prefer-dom-node-append.md)                                             | Prefer `Element#append()` over `Node#appendChild()`.                                                                           | ✅ ☑️ | 🔧 |    |    |
 | [prefer-dom-node-html-methods](docs/rules/prefer-dom-node-html-methods.md)                                 | Prefer `.getHTML()` and `.setHTML()` over `.innerHTML`.                                                                        |      | 🔧 | 💡 |    |
 | [prefer-dom-node-remove](docs/rules/prefer-dom-node-remove.md)                                             | Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.                                                          | ✅ ☑️ | 🔧 | 💡 |    |
+| [prefer-dom-node-replace-children](docs/rules/prefer-dom-node-replace-children.md)                         | Prefer `.replaceChildren()` when emptying DOM children.                                                                        | ✅ ☑️ | 🔧 |    |    |
 | [prefer-dom-node-text-content](docs/rules/prefer-dom-node-text-content.md)                                 | Prefer `.textContent` over `.innerText`.                                                                                       | ✅ ☑️ |    | 💡 |    |
 | [prefer-early-return](docs/rules/prefer-early-return.md)                                                   | Prefer early returns over full-function conditional wrapping.                                                                  | ✅ ☑️ | 🔧 | 💡 |    |
 | [prefer-else-if](docs/rules/prefer-else-if.md)                                                             | Prefer `else if` over adjacent `if` statements with related conditions.                                                        | ✅    | 🔧 | 💡 |    |
+| [prefer-error-is-error](docs/rules/prefer-error-is-error.md)                                               | Prefer `Error.isError()` when checking for errors.                                                                             |      | 🔧 |    |    |
 | [prefer-event-target](docs/rules/prefer-event-target.md)                                                   | Prefer `EventTarget` over `EventEmitter`.                                                                                      | ✅ ☑️ |    |    |    |
 | [prefer-export-from](docs/rules/prefer-export-from.md)                                                     | Prefer `export…from` when re-exporting.                                                                                        | ✅    | 🔧 | 💡 |    |
 | [prefer-flat-math-min-max](docs/rules/prefer-flat-math-min-max.md)                                         | Prefer flat `Math.min()` and `Math.max()` calls over nested calls.                                                             | ✅ ☑️ | 🔧 |    |    |
@@ -331,9 +338,11 @@ export default defineConfig([
 | [prefer-object-destructuring-defaults](docs/rules/prefer-object-destructuring-defaults.md)                 | Prefer object destructuring defaults over default object literals with spread.                                                 | ✅    |    | 💡 |    |
 | [prefer-object-from-entries](docs/rules/prefer-object-from-entries.md)                                     | Prefer using `Object.fromEntries(…)` to transform a list of key-value pairs into an object.                                    | ✅ ☑️ | 🔧 |    |    |
 | [prefer-object-iterable-methods](docs/rules/prefer-object-iterable-methods.md)                             | Prefer the most specific `Object` iterable method.                                                                             | ✅ ☑️ | 🔧 |    |    |
+| [prefer-observer-apis](docs/rules/prefer-observer-apis.md)                                                 | Prefer observer APIs over resize and scroll listeners with layout reads.                                                       | ✅    |    |    |    |
 | [prefer-optional-catch-binding](docs/rules/prefer-optional-catch-binding.md)                               | Prefer omitting the `catch` binding parameter.                                                                                 | ✅ ☑️ | 🔧 |    |    |
 | [prefer-path2d](docs/rules/prefer-path2d.md)                                                               | Prefer `Path2D` for repeatedly drawn canvas paths.                                                                             | ✅ ☑️ |    |    |    |
 | [prefer-private-class-fields](docs/rules/prefer-private-class-fields.md)                                   | Prefer private class fields over the underscore-prefix convention.                                                             | ✅    | 🔧 |    |    |
+| [prefer-promise-try](docs/rules/prefer-promise-try.md)                                                     | Prefer `Promise.try()` over promise-wrapping boilerplate.                                                                      | ✅    | 🔧 |    |    |
 | [prefer-promise-with-resolvers](docs/rules/prefer-promise-with-resolvers.md)                               | Prefer `Promise.withResolvers()` when extracting resolver functions from `new Promise()`.                                      | ✅ ☑️ | 🔧 |    |    |
 | [prefer-prototype-methods](docs/rules/prefer-prototype-methods.md)                                         | Prefer borrowing methods from the prototype instead of the instance.                                                           | ✅ ☑️ | 🔧 |    |    |
 | [prefer-query-selector](docs/rules/prefer-query-selector.md)                                               | Prefer `.querySelector()` and `.querySelectorAll()` over older DOM query methods.                                              | ✅    | 🔧 |    |    |
@@ -344,6 +353,7 @@ export default defineConfig([
 | [prefer-response-static-json](docs/rules/prefer-response-static-json.md)                                   | Prefer `Response.json()` over `new Response(JSON.stringify())`.                                                                | ✅ ☑️ | 🔧 |    |    |
 | [prefer-scoped-selector](docs/rules/prefer-scoped-selector.md)                                             | Prefer `:scope` when using element query selector methods.                                                                     | ✅    |    | 💡 |    |
 | [prefer-set-has](docs/rules/prefer-set-has.md)                                                             | Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.                                       | ✅ ☑️ | 🔧 | 💡 |    |
+| [prefer-set-methods](docs/rules/prefer-set-methods.md)                                                     | Prefer `Set` methods for Set operations.                                                                                       | ✅    | 🔧 | 💡 |    |
 | [prefer-set-size](docs/rules/prefer-set-size.md)                                                           | Prefer using `Set#size` instead of `Array#length`.                                                                             | ✅ ☑️ | 🔧 |    |    |
 | [prefer-short-arrow-method](docs/rules/prefer-short-arrow-method.md)                                       | Prefer arrow function properties over methods with a single return.                                                            |      | 🔧 |    |    |
 | [prefer-simple-condition-first](docs/rules/prefer-simple-condition-first.md)                               | Prefer simple conditions first in logical expressions.                                                                         | ✅ ☑️ | 🔧 | 💡 |    |
@@ -367,6 +377,7 @@ export default defineConfig([
 | [prefer-switch](docs/rules/prefer-switch.md)                                                               | Prefer `switch` over multiple `else-if`.                                                                                       | ✅ ☑️ | 🔧 |    |    |
 | [prefer-temporal](docs/rules/prefer-temporal.md)                                                           | Prefer `Temporal` over `Date`.                                                                                                 |      | 🔧 | 💡 |    |
 | [prefer-ternary](docs/rules/prefer-ternary.md)                                                             | Prefer ternary expressions over simple `if` statements that return or assign values.                                           | ✅ ☑️ | 🔧 | 💡 |    |
+| [prefer-toggle-attribute](docs/rules/prefer-toggle-attribute.md)                                           | Prefer using `Element#toggleAttribute()` to toggle attributes.                                                                 | ✅ ☑️ | 🔧 | 💡 |    |
 | [prefer-top-level-await](docs/rules/prefer-top-level-await.md)                                             | Prefer top-level await over top-level promises and async function calls.                                                       | ✅ ☑️ |    | 💡 |    |
 | [prefer-type-error](docs/rules/prefer-type-error.md)                                                       | Enforce throwing `TypeError` in type checking conditions.                                                                      | ✅ ☑️ | 🔧 |    |    |
 | [prefer-type-literal-last](docs/rules/prefer-type-literal-last.md)                                         | Require type literals to be last in union types.                                                                               | ✅    | 🔧 |    |    |
@@ -375,6 +386,7 @@ export default defineConfig([
 | [prefer-unicode-code-point-escapes](docs/rules/prefer-unicode-code-point-escapes.md)                       | Prefer Unicode code point escapes over legacy escape sequences.                                                                | ✅ ☑️ | 🔧 | 💡 |    |
 | [prefer-url-can-parse](docs/rules/prefer-url-can-parse.md)                                                 | Prefer `URL.canParse()` over constructing a `URL` in a try/catch for validation.                                               | ✅ ☑️ | 🔧 |    |    |
 | [prefer-url-href](docs/rules/prefer-url-href.md)                                                           | Prefer `URL#href` over stringifying a `URL`.                                                                                   | ✅ ☑️ | 🔧 |    |    |
+| [prefer-url-search-parameters](docs/rules/prefer-url-search-parameters.md)                                 | Prefer `URLSearchParams` over manually splitting query strings.                                                                | ✅ ☑️ |    | 💡 |    |
 | [prefer-while-loop-condition](docs/rules/prefer-while-loop-condition.md)                                   | Prefer putting the condition in the while statement.                                                                           | ✅ ☑️ | 🔧 |    |    |
 | [relative-url-style](docs/rules/relative-url-style.md)                                                     | Enforce consistent relative URL style.                                                                                         | ✅ ☑️ | 🔧 | 💡 |    |
 | [require-array-join-separator](docs/rules/require-array-join-separator.md)                                 | Enforce using the separator argument with `Array#join()`.                                                                      | ✅ ☑️ | 🔧 |    |    |

package/rules/ast/is-empty-object-expression.js

@@ -1,5 +1,5 @@
-const isEmptyArrayExpression = node =>
+const isEmptyObjectExpression = node =>
 	node.type === 'ObjectExpression'
 	&& node.properties.length === 0;
 
-export default isEmptyArrayExpression;
+export default isEmptyObjectExpression;

package/rules/comment-content.js

@@ -285,8 +285,11 @@ const listMarkerPatternSource = String.raw`(?:[*+\-]|\d+\.)`;
 const optionalListMarkerPrefixPatternSource = String.raw`${listMarkerPatternSource}?\s*`;
 const optionalLabelPrefixPatternSource = String.raw`(?:${identifierPatternSource}:\s*)?`;
 const bracketPropertyPatternSource = String.raw`\[[^\]]+\]`;
-const optionalAssignmentPrefixPatternSource = String.raw`(?:${identifierPatternSource}(?::|\s*=)\s*)?`;
 const memberCallPropertyPatternSource = String.raw`(?:(?:\?\.|\.)\s*${identifierPatternSource}|\??\.\s*${bracketPropertyPatternSource})`;
+const memberAssignmentTargetPatternSource = String.raw`${identifierPatternSource}(?:\s*${memberCallPropertyPatternSource}|\s*${bracketPropertyPatternSource})+`;
+const optionalDeclarationPrefixPatternSource = String.raw`(?:(?:const|let|var)\s+)?`;
+const assignmentTargetPatternSource = `(?:${identifierPatternSource}|${memberAssignmentTargetPatternSource})`;
+const optionalAssignmentPrefixPatternSource = String.raw`(?:(?:${identifierPatternSource}:|${optionalDeclarationPrefixPatternSource}${assignmentTargetPatternSource}\s*=)\s*)?`;
 const markdownLinkDestinationStartPatternSource = String.raw`(?:[A-Za-z][\d+\-.A-Za-z]*:\/\/|www\.|[\u{2D}0-9A-Za-z]+\.|[\w\-.]+\/|\/|#)`;
 const callArgumentsPatternSource = String.raw`\((?!\s*${markdownLinkDestinationStartPatternSource})[^\)]*\)`;
 const bracketMemberAccessLinePattern = new RegExp([
@@ -325,6 +328,14 @@ const memberCallLinePattern = new RegExp([
 	String.raw`\s*${memberCallPropertyPatternSource}\s*(?:\?\.\s*)?\(`,
 	String.raw`|${bracketPropertyPatternSource}\()`,
 ].join(''), 'v');
+const bareCallLinePattern = new RegExp([
+	`^${optionalListMarkerPrefixPatternSource}`,
+	String.raw`(?:\(\s*)?`,
+	optionalAssignmentPrefixPatternSource,
+	String.raw`(?:new\s+)?`,
+	codeIdentifierPatternSource,
+	String.raw`(?:\(|\s+\(\s*$)`,
+].join(''), 'v');
 const shellPromptLinePattern = new RegExp(String.raw`^${optionalListMarkerPrefixPatternSource}\$\s+\S+`, 'v');
 const secondaryShellPromptLinePattern = new RegExp(String.raw`^${optionalListMarkerPrefixPatternSource}>\s*(?:bun|curl|deno|docker|git|node(?:js)?|npm|npx|pnpm|yarn)\b`, 'v');
 const listMarkerPattern = new RegExp(String.raw`^${listMarkerPatternSource}\s*`, 'v');
@@ -336,6 +347,55 @@ const packageSpecifierTerminatorCharacters = '"\'`()[]{}<>,';
 const domainLeadingPunctuation = '([{<';
 const domainTrailingPunctuation = '.,;:!?)]}>';
 const maskCharacter = '\uFFFF';
+const openBrackets = '([{';
+const closeBrackets = ')]}';
+const quoteCharacters = '"\'`';
+
+// Count the net change in unbalanced brackets across a line, ignoring brackets inside string literals so they do not miscount. Operates on raw text so it is independent of mask ordering.
+function getBracketDepthDelta(text) {
+	let delta = 0;
+	let quote;
+
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+
+		if (quote) {
+			if (character === '\\') {
+				index++;
+				continue;
+			}
+
+			if (character === quote) {
+				quote = undefined;
+			}
+
+			continue;
+		}
+
+		if (character === '/' && text[index + 1] === '/') {
+			break;
+		}
+
+		if (character === '/' && text[index + 1] === '*') {
+			const endIndex = text.indexOf('*/', index + 2);
+			index = endIndex === -1 ? text.length : endIndex + 1;
+			continue;
+		}
+
+		if (quoteCharacters.includes(character)) {
+			quote = character;
+			continue;
+		}
+
+		if (openBrackets.includes(character)) {
+			delta++;
+		} else if (closeBrackets.includes(character)) {
+			delta--;
+		}
+	}
+
+	return delta;
+}
 
 function isIdentifierLikeCharacter(character) {
 	return Boolean(character) && /[\p{Letter}\p{Number}_]/v.test(character);
@@ -716,14 +776,48 @@ function isIgnoredCommentLine(line) {
 		|| memberCallLinePattern.test(removeMarkdownInlineLinks(line));
 }
 
+function getBracketContinuationOpeningDepth(line) {
+	line = cleanCommentLine(line);
+	line = removeMarkdownInlineLinks(line);
+
+	if (!bareCallLinePattern.test(line) && !memberCallLinePattern.test(line)) {
+		return 0;
+	}
+
+	return Math.max(0, getBracketDepthDelta(line));
+}
+
+// Advance the running bracket depth for one line. A line counts as code if depth is already open (a continuation line) or it looks like code on its own; otherwise depth resets to zero.
+function getNextBracketDepth(depth, line) {
+	if (depth > 0) {
+		return Math.max(0, depth + getBracketDepthDelta(line));
+	}
+
+	return getBracketContinuationOpeningDepth(line);
+}
+
 function maskIgnoredLines(characters, text) {
 	let start = 0;
+	let depth = 0;
 
 	while (start < text.length) {
 		const end = getLineEndIndex(text, start);
+		const line = text.slice(start, end);
+
+		if (characters.slice(start, end).includes(maskCharacter)) {
+			depth = 0;
+			start = end + 1;
+			continue;
+		}
 
-		if (isIgnoredCommentLine(text.slice(start, end))) {
+		const openingDepth = getBracketContinuationOpeningDepth(line);
+
+		// A line is masked if it looks like code on its own, or if it is a continuation line inside brackets opened by an earlier code-like line.
+		if (depth > 0 || isIgnoredCommentLine(line) || openingDepth > 0) {
 			maskRange(characters, start, end);
+			depth = depth > 0
+				? Math.max(0, depth + getBracketDepthDelta(line))
+				: openingDepth;
 		}
 
 		start = end + 1;
@@ -980,29 +1074,53 @@ const create = context => {
 		const {sourceCode} = context;
 		const comments = getRuleComments(context);
 
+		// Carry bracket depth across adjacent line comments so that a commented-out multi-line code construct spanning several `//` comments is not rewritten on its continuation lines.
+		let continuationDepth = 0;
+		let previousLineCommentRangeEnd;
+
 		for (const comment of comments) {
 			if (comment.type === 'Shebang' || isEslintDirective(context, comment)) {
+				continuationDepth = 0;
+				previousLineCommentRangeEnd = undefined;
 				continue;
 			}
 
-			const problem = getReplacementProblem(comment, sourceCode, replacements, checkUniformCase);
-			if (!problem) {
-				continue;
+			const range = sourceCode.getRange(comment);
+			const isAdjacentLineComment = comment.type === 'Line'
+				&& previousLineCommentRangeEnd !== undefined
+				&& /^[^\S\n]*\n[^\S\n]*$/v.test(sourceCode.text.slice(previousLineCommentRangeEnd, range[0]));
+
+			if (!isAdjacentLineComment) {
+				continuationDepth = 0;
 			}
 
-			yield {
-				node,
-				loc: {
-					start: sourceCode.getLocFromIndex(problem.replacementRange[0]),
-					end: sourceCode.getLocFromIndex(problem.replacementRange[1]),
-				},
-				messageId: MESSAGE_ID,
-				data: {
-					value: problem.value,
-					replacement: problem.replacement,
-				},
-				fix: fixer => fixer.replaceTextRange(problem.replacementRange, problem.replacement),
-			};
+			if (continuationDepth <= 0) {
+				const problem = getReplacementProblem(comment, sourceCode, replacements, checkUniformCase);
+				if (problem) {
+					yield {
+						node,
+						loc: {
+							start: sourceCode.getLocFromIndex(problem.replacementRange[0]),
+							end: sourceCode.getLocFromIndex(problem.replacementRange[1]),
+						},
+						messageId: MESSAGE_ID,
+						data: {
+							value: problem.value,
+							replacement: problem.replacement,
+						},
+						fix: fixer => fixer.replaceTextRange(problem.replacementRange, problem.replacement),
+					};
+				}
+			}
+
+			// Update continuation state for the next adjacent line comment.
+			if (comment.type === 'Line') {
+				continuationDepth = getNextBracketDepth(continuationDepth, comment.value);
+				previousLineCommentRangeEnd = range[1];
+			} else {
+				continuationDepth = 0;
+				previousLineCommentRangeEnd = undefined;
+			}
 		}
 	});
 };

package/rules/consistent-boolean-name.js

@@ -1,3 +1,4 @@
+import {isRegExp} from 'node:util/types';
 import {getPropertyName} from '@eslint-community/eslint-utils';
 import {renameVariable} from './fix/index.js';
 import {
@@ -23,10 +24,13 @@ const messages = {
 
 const defaultPrefixes = {
 	is: true,
+	are: true,
 	has: true,
+	have: true,
 	can: true,
 	should: true,
 	was: true,
+	were: true,
 	did: true,
 	will: true,
 };
@@ -83,11 +87,22 @@ function findParameter(parameters, identifier) {
 const prepareOptions = ({
 	checkProperties = false,
 	prefixes = {},
+	ignore = [],
 } = {}) => ({
 	checkProperties,
 	prefixes: getEnabledPrefixes({prefixes}),
+	ignore: ignore.map(pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u')),
 });
 
+function isIgnoredName(name, ignore) {
+	return ignore.some(regexp => {
+		regexp.lastIndex = 0;
+		const isIgnored = regexp.test(name);
+		regexp.lastIndex = 0;
+		return isIgnored;
+	});
+}
+
 function hasBooleanPrefix(name, prefixes) {
 	name = stripLeadingUnderscores(name);
 
@@ -216,6 +231,11 @@ const isBooleanVariable = (variable, context) => {
 	}
 
 	if (definition.type === 'Parameter') {
+		// Some parsers (such as Svelte's `{#each}` bindings) create `Parameter` definitions whose owner is not a function and has no `params` list.
+		if (!isFunction(definition.node)) {
+			return false;
+		}
+
 		const parameter = findParameter(definition.node.params, name);
 
 		return parameter?.type === 'AssignmentPattern'
@@ -387,17 +407,18 @@ function getAutofix(variable, prefixes, context, suggestions) {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {checkProperties, prefixes} = prepareOptions(context.options[0]);
+	const {checkProperties, prefixes, ignore} = prepareOptions(context.options[0]);
 
 	if (prefixes.length === 0) {
 		return;
 	}
 
 	const checkVariable = variable => {
-		// `hasBooleanPrefix` is a cheap string check, so run it before the expensive
-		// `isBooleanVariable` analysis.
+		// `hasBooleanPrefix` and `ignore` are cheap string checks, so run them before
+		// the expensive `isBooleanVariable` analysis.
 		if (
 			hasBooleanPrefix(variable.name, prefixes)
+			|| isIgnoredName(variable.name, ignore)
 			|| !isBooleanVariable(variable, context)
 		) {
 			return;
@@ -436,6 +457,7 @@ const create = context => {
 		if (
 			!name
 			|| hasBooleanPrefix(name, prefixes)
+			|| isIgnoredName(name, ignore)
 			|| !isBooleanProperty(node, context)
 		) {
 			return;
@@ -494,10 +516,15 @@ const config = {
 							pattern: '^[a-z][a-zA-Z0-9]*$',
 						},
 					},
+					ignore: {
+						type: 'array',
+						uniqueItems: true,
+						description: 'Patterns to ignore.',
+					},
 				},
 			},
 		],
-		defaultOptions: [{}],
+		defaultOptions: [{ignore: []}],
 		messages,
 	},
 };

package/rules/consistent-conditional-object-spread.js

@@ -22,6 +22,12 @@ const messages = {
 const nullishOperators = new Set(['==', '===']);
 const nonNullishOperators = new Set(['!=', '!==']);
 
+// `{...{}}`, `{...undefined}`, and `{...null}` all spread nothing.
+const isEmptySpreadBranch = node =>
+	isEmptyObjectExpression(node)
+	|| isUndefined(node)
+	|| isNullLiteral(node);
+
 const isObjectSpreadArgument = node => (
 	node.parent.type === 'SpreadElement'
 	&& node.parent.argument === node
@@ -203,8 +209,8 @@ function getConditionalExpressionChildText(node, context) {
 
 function getConditionalExpressionProblem(conditionalExpression, context) {
 	const {test, consequent, alternate} = conditionalExpression;
-	const isAlternateEmpty = isEmptyObjectExpression(alternate);
-	const isConsequentEmpty = isEmptyObjectExpression(consequent);
+	const isAlternateEmpty = isEmptySpreadBranch(alternate);
+	const isConsequentEmpty = isEmptySpreadBranch(consequent);
 
 	if (isAlternateEmpty === isConsequentEmpty) {
 		return;
@@ -260,7 +266,7 @@ function getConditionalExpressionProblem(conditionalExpression, context) {
 function getLogicalExpressionProblem(logicalExpression, context) {
 	if (
 		logicalExpression.operator !== '&&'
-		|| isEmptyObjectExpression(logicalExpression.right)
+		|| isEmptySpreadBranch(logicalExpression.right)
 	) {
 		return;
 	}

package/rules/consistent-tuple-labels.js

@@ -0,0 +1,49 @@
+const MESSAGE_ID = 'consistent-tuple-labels';
+const messages = {
+	[MESSAGE_ID]: 'This tuple element should have a label, just like the other elements.',
+};
+
+// A rest element keeps its label inside the `TSRestType` wrapper, e.g. `[...rest: number[]]`.
+const isLabeledElement = element =>
+	element.type === 'TSNamedTupleMember'
+	|| (element.type === 'TSRestType' && element.typeAnnotation.type === 'TSNamedTupleMember');
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('TSTupleType', node => {
+		const elements = node.elementTypes;
+
+		// A tuple with fewer than two elements can't be inconsistent.
+		if (elements.length < 2) {
+			return;
+		}
+
+		const unlabeledElements = elements.filter(element => !isLabeledElement(element));
+
+		// All labeled or all unlabeled is consistent.
+		if (unlabeledElements.length === 0 || unlabeledElements.length === elements.length) {
+			return;
+		}
+
+		// At least one element is labeled, so flag every unlabeled element.
+		return unlabeledElements.map(element => ({node: element, messageId: MESSAGE_ID}));
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent labels on tuple type elements.',
+			recommended: true,
+		},
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/custom-error-definition.js

@@ -1,9 +1,13 @@
+import {getPropertyName} from '@eslint-community/eslint-utils';
 import {
 	upperFirst,
 	getParenthesizedText,
 	isNodeMatchesNameOrPath,
 } from './utils/index.js';
-import {isUndefined} from './ast/index.js';
+import {
+	getStaticStringValue,
+	isUndefined,
+} from './ast/index.js';
 
 const MESSAGE_ID_INVALID_EXPORT = 'invalidExport';
 const MESSAGE_ID_DO_NOT_PASS_MESSAGE_TO_SUPER = 'doNotPassMessageToSuper';
@@ -73,8 +77,7 @@ const isPropertyDefinition = (node, name) =>
 	&& node.key.name === name;
 
 const isValidNameProperty = (nameProperty, className) =>
-	nameProperty?.value
-	&& nameProperty.value.value === className;
+	getStaticStringValue(nameProperty?.value) === className;
 
 const isMessageAccessor = (node, kind) =>
 	node.type === 'MethodDefinition'
@@ -200,6 +203,20 @@ const isSameIdentifier = (node, identifier) =>
 	node?.type === 'Identifier'
 	&& node.name === identifier.name;
 
+// Whether `super()` already forwards the error options inline, e.g. `super('Fixed message', {cause})`.
+const hasInlineErrorOptions = (superCallExpression, shouldPassMessageToSuper) => {
+	if (shouldPassMessageToSuper) {
+		return false;
+	}
+
+	const [messageArgument, optionsArgument] = superCallExpression.arguments;
+	return superCallExpression.arguments.length === 2
+		&& getStaticStringValue(messageArgument) !== undefined
+		&& optionsArgument.type === 'ObjectExpression'
+		&& optionsArgument.properties.length === 1
+		&& getPropertyName(optionsArgument.properties[0]) === 'cause';
+};
+
 const getErrorOptionsProblem = (context, constructor, superExpression, hasMessageAccessor) => {
 	const parameters = constructor.value.params;
 	const firstParameter = parameters[0];
@@ -236,6 +253,11 @@ const getErrorOptionsProblem = (context, constructor, superExpression, hasMessag
 	const messageArgumentText = shouldPassMessageToSuper ? firstParameterIdentifier.name : 'undefined';
 
 	if (!optionsParameter) {
+		// When `options` is already forwarded to `super()` (e.g. `super('Fixed message', {cause})`), a dedicated `options` parameter isn't needed.
+		if (hasInlineErrorOptions(superCallExpression, shouldPassMessageToSuper)) {
+			return;
+		}
+
 		return {
 			node: firstParameter,
 			messageId: MESSAGE_ID_MISSING_OPTIONS_PARAMETER,
@@ -282,10 +304,7 @@ function getInvalidErrorNameProblem(constructorBodyNode, constructorBody, errorD
 		return;
 	}
 
-	if (
-		nameExpression.expression.right.type !== 'Literal'
-		|| nameExpression.expression.right.value !== name
-	) {
+	if (getStaticStringValue(nameExpression.expression.right) !== name) {
 		return createInvalidNameError(nameExpression.expression.right ?? constructorBodyNode, name);
 	}
 }

package/rules/index.js

@@ -19,6 +19,7 @@ export {default as 'consistent-function-style'} from './consistent-function-styl
 export {default as 'consistent-json-file-read'} from './consistent-json-file-read.js';
 export {default as 'consistent-optional-chaining'} from './consistent-optional-chaining.js';
 export {default as 'consistent-template-literal-escape'} from './consistent-template-literal-escape.js';
+export {default as 'consistent-tuple-labels'} from './consistent-tuple-labels.js';
 export {default as 'custom-error-definition'} from './custom-error-definition.js';
 export {default as 'default-export-style'} from './default-export-style.js';
 export {default as 'dom-node-dataset'} from './dom-node-dataset.js';
@@ -88,8 +89,10 @@ export {default as 'no-invalid-character-comparison'} from './no-invalid-charact
 export {default as 'no-invalid-fetch-options'} from './no-invalid-fetch-options.js';
 export {default as 'no-invalid-file-input-accept'} from './no-invalid-file-input-accept.js';
 export {default as 'no-invalid-remove-event-listener'} from './no-invalid-remove-event-listener.js';
+export {default as 'no-invalid-well-known-symbol-methods'} from './no-invalid-well-known-symbol-methods.js';
 export {default as 'no-keyword-prefix'} from './no-keyword-prefix.js';
 export {default as 'no-late-current-target-access'} from './no-late-current-target-access.js';
+export {default as 'no-late-event-control'} from './no-late-event-control.js';
 export {default as 'no-lonely-if'} from './no-lonely-if.js';
 export {default as 'no-loop-iterable-mutation'} from './no-loop-iterable-mutation.js';
 export {default as 'no-magic-array-flat-depth'} from './no-magic-array-flat-depth.js';
@@ -170,8 +173,10 @@ export {default as 'no-zero-fractions'} from './no-zero-fractions.js';
 export {default as 'number-literal-case'} from './number-literal-case.js';
 export {default as 'numeric-separators-style'} from './numeric-separators-style.js';
 export {default as 'operator-assignment'} from './operator-assignment.js';
+export {default as 'prefer-abort-signal-timeout'} from './prefer-abort-signal-timeout.js';
 export {default as 'prefer-add-event-listener-options'} from './prefer-add-event-listener-options.js';
 export {default as 'prefer-add-event-listener'} from './prefer-add-event-listener.js';
+export {default as 'prefer-aggregate-error'} from './prefer-aggregate-error.js';
 export {default as 'prefer-array-find'} from './prefer-array-find.js';
 export {default as 'prefer-array-flat-map'} from './prefer-array-flat-map.js';
 export {default as 'prefer-array-flat'} from './prefer-array-flat.js';
@@ -198,9 +203,11 @@ export {default as 'prefer-dispose'} from './prefer-dispose.js';
 export {default as 'prefer-dom-node-append'} from './prefer-dom-node-append.js';
 export {default as 'prefer-dom-node-html-methods'} from './prefer-dom-node-html-methods.js';
 export {default as 'prefer-dom-node-remove'} from './prefer-dom-node-remove.js';
+export {default as 'prefer-dom-node-replace-children'} from './prefer-dom-node-replace-children.js';
 export {default as 'prefer-dom-node-text-content'} from './prefer-dom-node-text-content.js';
 export {default as 'prefer-early-return'} from './prefer-early-return.js';
 export {default as 'prefer-else-if'} from './prefer-else-if.js';
+export {default as 'prefer-error-is-error'} from './prefer-error-is-error.js';
 export {default as 'prefer-event-target'} from './prefer-event-target.js';
 export {default as 'prefer-export-from'} from './prefer-export-from.js';
 export {default as 'prefer-flat-math-min-max'} from './prefer-flat-math-min-max.js';
@@ -240,9 +247,11 @@ export {default as 'prefer-object-define-properties'} from './prefer-object-defi
 export {default as 'prefer-object-destructuring-defaults'} from './prefer-object-destructuring-defaults.js';
 export {default as 'prefer-object-from-entries'} from './prefer-object-from-entries.js';
 export {default as 'prefer-object-iterable-methods'} from './prefer-object-iterable-methods.js';
+export {default as 'prefer-observer-apis'} from './prefer-observer-apis.js';
 export {default as 'prefer-optional-catch-binding'} from './prefer-optional-catch-binding.js';
 export {default as 'prefer-path2d'} from './prefer-path2d.js';
 export {default as 'prefer-private-class-fields'} from './prefer-private-class-fields.js';
+export {default as 'prefer-promise-try'} from './prefer-promise-try.js';
 export {default as 'prefer-promise-with-resolvers'} from './prefer-promise-with-resolvers.js';
 export {default as 'prefer-prototype-methods'} from './prefer-prototype-methods.js';
 export {default as 'prefer-query-selector'} from './prefer-query-selector.js';
@@ -253,6 +262,7 @@ export {default as 'prefer-regexp-test'} from './prefer-regexp-test.js';
 export {default as 'prefer-response-static-json'} from './prefer-response-static-json.js';
 export {default as 'prefer-scoped-selector'} from './prefer-scoped-selector.js';
 export {default as 'prefer-set-has'} from './prefer-set-has.js';
+export {default as 'prefer-set-methods'} from './prefer-set-methods.js';
 export {default as 'prefer-set-size'} from './prefer-set-size.js';
 export {default as 'prefer-short-arrow-method'} from './prefer-short-arrow-method.js';
 export {default as 'prefer-simple-condition-first'} from './prefer-simple-condition-first.js';
@@ -276,6 +286,7 @@ export {default as 'prefer-structured-clone'} from './prefer-structured-clone.js
 export {default as 'prefer-switch'} from './prefer-switch.js';
 export {default as 'prefer-temporal'} from './prefer-temporal.js';
 export {default as 'prefer-ternary'} from './prefer-ternary.js';
+export {default as 'prefer-toggle-attribute'} from './prefer-toggle-attribute.js';
 export {default as 'prefer-top-level-await'} from './prefer-top-level-await.js';
 export {default as 'prefer-type-error'} from './prefer-type-error.js';
 export {default as 'prefer-type-literal-last'} from './prefer-type-literal-last.js';
@@ -284,6 +295,7 @@ export {default as 'prefer-unary-minus'} from './prefer-unary-minus.js';
 export {default as 'prefer-unicode-code-point-escapes'} from './prefer-unicode-code-point-escapes.js';
 export {default as 'prefer-url-can-parse'} from './prefer-url-can-parse.js';
 export {default as 'prefer-url-href'} from './prefer-url-href.js';
+export {default as 'prefer-url-search-parameters'} from './prefer-url-search-parameters.js';
 export {default as 'prefer-while-loop-condition'} from './prefer-while-loop-condition.js';
 export {default as 'relative-url-style'} from './relative-url-style.js';
 export {default as 'require-array-join-separator'} from './require-array-join-separator.js';