eslint-plugin-unicorn 69.0.0 → 70.0.0

package/rules/expiring-todo-comments.js

@@ -23,6 +23,7 @@ const MESSAGE_ID_HAVE_PACKAGE = 'unicorn/havePackage';
 const MESSAGE_ID_DONT_HAVE_PACKAGE = 'unicorn/dontHavePackage';
 const MESSAGE_ID_VERSION_MATCHES = 'unicorn/versionMatches';
 const MESSAGE_ID_PEER_VERSION_MATCHES = 'unicorn/peerVersionMatches';
+const MESSAGE_ID_UNSUPPORTED_CATALOG_PROTOCOL = 'unicorn/unsupportedCatalogProtocol';
 const MESSAGE_ID_ENGINE_MATCHES = 'unicorn/engineMatches';
 const MESSAGE_ID_REMOVE_WHITESPACE = 'unicorn/removeWhitespaces';
 const MESSAGE_ID_MISSING_AT_SYMBOL = 'unicorn/missingAtSymbol';
@@ -46,6 +47,8 @@ const messages = {
 		'Due since package version matched: {{comparison}}. {{message}}',
 	[MESSAGE_ID_PEER_VERSION_MATCHES]:
 		'Due since peer dependency version matched: {{comparison}}. {{message}}',
+	[MESSAGE_ID_UNSUPPORTED_CATALOG_PROTOCOL]:
+		'Cannot check {{dependencyType}} version because {{package}} uses the unsupported `catalog:` protocol. {{message}}',
 	[MESSAGE_ID_ENGINE_MATCHES]:
 		'Due since Node.js version matched: {{comparison}}. {{message}}',
 	[MESSAGE_ID_REMOVE_WHITESPACE]:
@@ -284,6 +287,10 @@ function getRangeFloor(range) {
 	return semver.validRange(range) ? semver.minVersion(range) : undefined;
 }
 
+function isCatalogProtocol(rawVersion) {
+	return typeof rawVersion === 'string' && rawVersion.startsWith('catalog:');
+}
+
 const DEFAULT_OPTIONS = {
 	terms: ['todo', 'fixme', 'xxx'],
 	ignore: [],
@@ -480,6 +487,14 @@ const create = context => {
 				continue;
 			}
 
+			if (isCatalogProtocol(targetPackageRawVersion)) {
+				report(MESSAGE_ID_UNSUPPORTED_CATALOG_PROTOCOL, {
+					dependencyType: 'dependency',
+					package: dependency.name,
+				});
+				continue;
+			}
+
 			const targetPackageVersion = tryToCoerceVersion(targetPackageRawVersion);
 
 			/* c8 ignore start */
@@ -505,6 +520,14 @@ const create = context => {
 				continue;
 			}
 
+			if (isCatalogProtocol(targetPeerRawVersion)) {
+				report(MESSAGE_ID_UNSUPPORTED_CATALOG_PROTOCOL, {
+					dependencyType: 'peer dependency',
+					package: peerDependency.name,
+				});
+				continue;
+			}
+
 			const targetPeerVersion = getRangeFloor(targetPeerRawVersion);
 
 			if (targetPeerVersion && satisfiesRange(targetPeerVersion, peerDependency.condition, peerDependency.version)) {

package/rules/fix/{add-parenthesizes-to-return-or-throw-expression.js → add-parentheses-to-return-or-throw-expression.js}

@@ -11,7 +11,7 @@ import {isSemicolonToken} from '@eslint-community/eslint-utils';
 @param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
 @returns {ESLint.Rule.ReportFixer}
 */
-export default function * addParenthesizesToReturnOrThrowExpression(fixer, node, context) {
+export default function * addParenthesesToReturnOrThrowExpression(fixer, node, context) {
 	if (node.type !== 'ReturnStatement' && node.type !== 'ThrowStatement') {
 		return;
 	}

package/rules/fix/index.js

@@ -21,4 +21,4 @@ export {default as replaceReferenceIdentifier} from './replace-reference-identif
 export {default as replaceNodeOrTokenAndSpacesBefore} from './replace-node-or-token-and-spaces-before.js';
 export {default as fixSpaceAroundKeyword} from './fix-space-around-keywords.js';
 export {default as replaceStringRaw} from './replace-string-raw.js';
-export {default as addParenthesizesToReturnOrThrowExpression} from './add-parenthesizes-to-return-or-throw-expression.js';
+export {default as addParenthesesToReturnOrThrowExpression} from './add-parentheses-to-return-or-throw-expression.js';

package/rules/fix/switch-new-expression-to-call-expression.js

@@ -3,7 +3,7 @@ import {
 	isParenthesized,
 	isOnSameLine,
 } from '../utils/index.js';
-import addParenthesizesToReturnOrThrowExpression from './add-parenthesizes-to-return-or-throw-expression.js';
+import addParenthesesToReturnOrThrowExpression from './add-parentheses-to-return-or-throw-expression.js';
 import removeSpaceAfter from './remove-spaces-after.js';
 
 /**
@@ -39,6 +39,6 @@ export default function * switchNewExpressionToCallExpression(newExpression, con
 	if (!isOnSameLine(newToken, newExpression.callee, context) && !isParenthesized(newExpression, context)) {
 		// Ideally, we should use first parenthesis of the `callee`, and should check spaces after the `new` token
 		// But adding extra parentheses is harmless, no need to be too complicated
-		yield addParenthesizesToReturnOrThrowExpression(fixer, newExpression.parent, context);
+		yield addParenthesesToReturnOrThrowExpression(fixer, newExpression.parent, context);
 	}
 }

package/rules/index.js

@@ -53,6 +53,7 @@ export {default as 'no-array-sort-for-min-max'} from './no-array-sort-for-min-ma
 export {default as 'no-array-sort'} from './no-array-sort.js';
 export {default as 'no-array-splice'} from './no-array-splice.js';
 export {default as 'no-asterisk-prefix-in-documentation-comments'} from './no-asterisk-prefix-in-documentation-comments.js';
+export {default as 'no-async-promise-finally'} from './no-async-promise-finally.js';
 export {default as 'no-await-expression-member'} from './no-await-expression-member.js';
 export {default as 'no-await-in-promise-methods'} from './no-await-in-promise-methods.js';
 export {default as 'no-blob-to-file'} from './no-blob-to-file.js';
@@ -129,9 +130,11 @@ export {default as 'no-typeof-undefined'} from './no-typeof-undefined.js';
 export {default as 'no-uncalled-method'} from './no-uncalled-method.js';
 export {default as 'no-undeclared-class-members'} from './no-undeclared-class-members.js';
 export {default as 'no-unnecessary-array-flat-depth'} from './no-unnecessary-array-flat-depth.js';
+export {default as 'no-unnecessary-array-flat-map'} from './no-unnecessary-array-flat-map.js';
 export {default as 'no-unnecessary-array-splice-count'} from './no-unnecessary-array-splice-count.js';
 export {default as 'no-unnecessary-await'} from './no-unnecessary-await.js';
 export {default as 'no-unnecessary-boolean-comparison'} from './no-unnecessary-boolean-comparison.js';
+export {default as 'no-unnecessary-fetch-options'} from './no-unnecessary-fetch-options.js';
 export {default as 'no-unnecessary-global-this'} from './no-unnecessary-global-this.js';
 export {default as 'no-unnecessary-nested-ternary'} from './no-unnecessary-nested-ternary.js';
 export {default as 'no-unnecessary-polyfills'} from './no-unnecessary-polyfills.js';
@@ -144,6 +147,7 @@ export {default as 'no-unreadable-new-expression'} from './no-unreadable-new-exp
 export {default as 'no-unreadable-object-destructuring'} from './no-unreadable-object-destructuring.js';
 export {default as 'no-unsafe-buffer-conversion'} from './no-unsafe-buffer-conversion.js';
 export {default as 'no-unsafe-dom-html'} from './no-unsafe-dom-html.js';
+export {default as 'no-unsafe-promise-all-settled-values'} from './no-unsafe-promise-all-settled-values.js';
 export {default as 'no-unsafe-property-key'} from './no-unsafe-property-key.js';
 export {default as 'no-unsafe-string-replacement'} from './no-unsafe-string-replacement.js';
 export {default as 'no-unused-array-method-return'} from './no-unused-array-method-return.js';
@@ -173,6 +177,7 @@ 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-any'} from './prefer-abort-signal-any.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';
@@ -182,6 +187,7 @@ export {default as 'prefer-array-flat-map'} from './prefer-array-flat-map.js';
 export {default as 'prefer-array-flat'} from './prefer-array-flat.js';
 export {default as 'prefer-array-from-async'} from './prefer-array-from-async.js';
 export {default as 'prefer-array-from-map'} from './prefer-array-from-map.js';
+export {default as 'prefer-array-from-range'} from './prefer-array-from-range.js';
 export {default as 'prefer-array-index-of'} from './prefer-array-index-of.js';
 export {default as 'prefer-array-iterable-methods'} from './prefer-array-iterable-methods.js';
 export {default as 'prefer-array-last-methods'} from './prefer-array-last-methods.js';
@@ -191,6 +197,7 @@ export {default as 'prefer-at'} from './prefer-at.js';
 export {default as 'prefer-await'} from './prefer-await.js';
 export {default as 'prefer-bigint-literals'} from './prefer-bigint-literals.js';
 export {default as 'prefer-blob-reading-methods'} from './prefer-blob-reading-methods.js';
+export {default as 'prefer-block-statement-over-iife'} from './prefer-block-statement-over-iife.js';
 export {default as 'prefer-boolean-return'} from './prefer-boolean-return.js';
 export {default as 'prefer-class-fields'} from './prefer-class-fields.js';
 export {default as 'prefer-classlist-toggle'} from './prefer-classlist-toggle.js';
@@ -214,6 +221,7 @@ export {default as 'prefer-flat-math-min-max'} from './prefer-flat-math-min-max.
 export {default as 'prefer-get-or-insert-computed'} from './prefer-get-or-insert-computed.js';
 export {default as 'prefer-global-number-constants'} from './prefer-global-number-constants.js';
 export {default as 'prefer-global-this'} from './prefer-global-this.js';
+export {default as 'prefer-group-by'} from './prefer-group-by.js';
 export {default as 'prefer-has-check'} from './prefer-has-check.js';
 export {default as 'prefer-hoisting-branch-code'} from './prefer-hoisting-branch-code.js';
 export {default as 'prefer-https'} from './prefer-https.js';
@@ -223,6 +231,7 @@ export {default as 'prefer-includes-over-repeated-comparisons'} from './prefer-i
 export {default as 'prefer-includes'} from './prefer-includes.js';
 export {default as 'prefer-iterable-in-constructor'} from './prefer-iterable-in-constructor.js';
 export {default as 'prefer-iterator-concat'} from './prefer-iterator-concat.js';
+export {default as 'prefer-iterator-helpers'} from './prefer-iterator-helpers.js';
 export {default as 'prefer-iterator-to-array-at-end'} from './prefer-iterator-to-array-at-end.js';
 export {default as 'prefer-iterator-to-array'} from './prefer-iterator-to-array.js';
 export {default as 'prefer-keyboard-event-key'} from './prefer-keyboard-event-key.js';
@@ -267,6 +276,7 @@ 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';
 export {default as 'prefer-simple-sort-comparator'} from './prefer-simple-sort-comparator.js';
+export {default as 'prefer-simplified-conditions'} from './prefer-simplified-conditions.js';
 export {default as 'prefer-single-array-predicate'} from './prefer-single-array-predicate.js';
 export {default as 'prefer-single-call'} from './prefer-single-call.js';
 export {default as 'prefer-single-object-destructuring'} from './prefer-single-object-destructuring.js';

package/rules/isolated-functions.js

@@ -1,19 +1,95 @@
 import globals from 'globals';
-import {functionTypes} from './ast/index.js';
+import {functionTypes, isMemberExpression, isMethodCall} from './ast/index.js';
 
 const MESSAGE_ID_EXTERNALLY_SCOPED_VARIABLE = 'externally-scoped-variable';
+const MESSAGE_ID_SUPER = 'super';
+const MESSAGE_ID_THIS_EXPRESSION = 'this-expression';
+const functionContextReferenceMessageIds = new Map([
+	['Super', MESSAGE_ID_SUPER],
+	['ThisExpression', MESSAGE_ID_THIS_EXPRESSION],
+]);
+
 const messages = {
 	[MESSAGE_ID_EXTERNALLY_SCOPED_VARIABLE]: 'Variable {{name}} not defined in scope of isolated function. Function is isolated because: {{reason}}.',
+	[MESSAGE_ID_SUPER]: 'Unexpected `super` in isolated function. Function is isolated because: {{reason}}.',
+	[MESSAGE_ID_THIS_EXPRESSION]: 'Unexpected `this` in isolated function. Function is isolated because: {{reason}}.',
 };
 
 /** @type {{functions: string[], selectors: string[], comments: string[], overrideGlobals?: import('eslint').Linter.Globals}} */
 const defaultOptions = {
-	functions: ['makeSynchronous'],
+	functions: ['makeSynchronous', 'workerize'],
 	selectors: [],
 	comments: ['@isolated'],
 	overrideGlobals: {},
 };
 
+const scriptingObjects = ['browser', 'chrome'];
+
+const getObjectPropertyName = node => {
+	if (node.computed && node.key.type !== 'Literal') {
+		return;
+	}
+
+	if (node.key.type === 'Identifier') {
+		return node.key.name;
+	}
+
+	if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
+		return node.key.value;
+	}
+};
+
+const getDefaultArgumentCallReason = node => {
+	if (
+		node.parent.type !== 'CallExpression'
+		|| node.parent.arguments[0] !== node
+	) {
+		return;
+	}
+
+	if (isMethodCall(node.parent, {object: 'browser', method: 'execute'})) {
+		return 'callee of method named "browser.execute"';
+	}
+
+	if (isMethodCall(node.parent, {object: 'page', method: 'evaluate'})) {
+		return 'callee of method named "page.evaluate"';
+	}
+};
+
+const getScriptingExecuteScriptObjectName = node => {
+	if (
+		!isMethodCall(node, {method: 'executeScript'})
+		|| !isMemberExpression(node.callee.object, {
+			objects: scriptingObjects,
+			property: 'scripting',
+		})
+	) {
+		return;
+	}
+
+	return node.callee.object.object.name;
+};
+
+const getExecuteScriptPropertyReason = node => {
+	if (
+		node.parent.type !== 'Property'
+		|| node.parent.kind !== 'init'
+		|| getObjectPropertyName(node.parent) !== 'func'
+		|| node.parent.parent.type !== 'ObjectExpression'
+		|| node.parent.parent.parent.type !== 'CallExpression'
+		|| node.parent.parent.parent.arguments[0] !== node.parent.parent
+	) {
+		return;
+	}
+
+	const scriptingObjectName = getScriptingExecuteScriptObjectName(node.parent.parent.parent);
+	if (!scriptingObjectName) {
+		return;
+	}
+
+	return `property "func" passed to "${scriptingObjectName}.scripting.executeScript"`;
+};
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
@@ -29,8 +105,58 @@ const create = context => {
 	};
 	const checked = new WeakSet();
 
+	function * getFunctionContextProblems(node, reason, root = node) {
+		const messageId = functionContextReferenceMessageIds.get(node.type);
+		if (messageId) {
+			yield {
+				node,
+				messageId,
+				data: {reason},
+			};
+			return;
+		}
+
+		if (node !== root) {
+			if (functionTypes.includes(node.type) && node.type !== 'ArrowFunctionExpression') {
+				return;
+			}
+
+			if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+				if (node.superClass) {
+					yield * getFunctionContextProblems(node.superClass, reason, root);
+				}
+
+				for (const classElement of node.body.body) {
+					if (classElement.computed) {
+						yield * getFunctionContextProblems(classElement.key, reason, root);
+					}
+				}
+
+				return;
+			}
+		}
+
+		for (const key of sourceCode.visitorKeys[node.type] ?? []) {
+			const value = node[key];
+
+			if (Array.isArray(value)) {
+				for (const childNode of value) {
+					if (childNode?.type) {
+						yield * getFunctionContextProblems(childNode, reason, root);
+					}
+				}
+
+				continue;
+			}
+
+			if (value?.type) {
+				yield * getFunctionContextProblems(value, reason, root);
+			}
+		}
+	}
+
 	/** @param {import('estree').Node} node */
-	const reportExternallyScopedVariables = (node, reason) => {
+	const reportIsolatedFunctionProblems = (node, reason) => {
 		if (checked.has(node) || !functionTypes.includes(node.type)) {
 			return;
 		}
@@ -69,12 +195,33 @@ const create = context => {
 				data: {name: identifier.name, reason},
 			});
 		}
+
+		for (const problem of getFunctionContextProblems(node, reason)) {
+			context.report(problem);
+		}
 	};
 
 	const isComment = token => token?.type === 'Block' || token?.type === 'Line';
 
+	const canCommentApplyToParent = (node, parent) =>
+		parent && (
+			[
+				'VariableDeclarator',
+				'VariableDeclaration',
+				'ExportNamedDeclaration',
+				'ExportDefaultDeclaration',
+			].includes(parent.type)
+			|| (
+				(
+					parent.type === 'Property'
+					|| parent.type === 'MethodDefinition'
+				)
+				&& parent.value === node
+			)
+		);
+
 	/**
-	 Find a comment on this node or its parent, in cases where the node passed is part of a variable or export declaration.
+	 Find a comment on this node or its parent, in cases where the node passed is part of a variable, export, property, or method declaration.
 	 @param {import('estree').Node} node
 	 */
 	const findComment = node => {
@@ -82,12 +229,7 @@ const create = context => {
 		let commentableNode = node;
 		while (
 			!isComment(previousToken)
-			&& [
-				'VariableDeclarator',
-				'VariableDeclaration',
-				'ExportNamedDeclaration',
-				'ExportDefaultDeclaration',
-			].includes(commentableNode.parent.type)
+			&& canCommentApplyToParent(commentableNode, commentableNode.parent)
 		) {
 			commentableNode = commentableNode.parent;
 			previousToken = sourceCode.getTokenBefore(commentableNode, {includeComments: true});
@@ -127,6 +269,8 @@ const create = context => {
 		) {
 			return `callee of function named ${JSON.stringify(node.parent.callee.name)}`;
 		}
+
+		return getDefaultArgumentCallReason(node) ?? getExecuteScriptPropertyReason(node);
 	};
 
 	context.onExit(
@@ -137,7 +281,7 @@ const create = context => {
 				return;
 			}
 
-			return reportExternallyScopedVariables(node, reason);
+			return reportIsolatedFunctionProblems(node, reason);
 		},
 	);
 
@@ -146,7 +290,7 @@ const create = context => {
 			selector,
 			node => {
 				const reason = `matches selector ${JSON.stringify(selector)}`;
-				return reportExternallyScopedVariables(node, reason);
+				return reportIsolatedFunctionProblems(node, reason);
 			},
 		);
 	}

package/rules/no-async-promise-finally.js

@@ -0,0 +1,111 @@
+import {findVariable, getPropertyName} from '@eslint-community/eslint-utils';
+import {isFunction} from './ast/index.js';
+import {
+	getConstVariableInitializer,
+	isPromiseType,
+	unwrapTypeScriptExpression,
+} from './utils/index.js';
+
+const MESSAGE_ID = 'no-async-promise-finally';
+const messages = {
+	[MESSAGE_ID]: 'Do not pass an async function to `Promise#finally()`.',
+};
+
+const isAsyncNonGeneratorFunction = node =>
+	isFunction(node)
+	&& node.async
+	&& !node.generator;
+
+function isPromiseObject(node, context) {
+	const {parserServices} = context.sourceCode;
+	if (!parserServices?.program) {
+		return;
+	}
+
+	try {
+		return isPromiseType(
+			parserServices.getTypeAtLocation(node),
+			parserServices.program.getTypeChecker(),
+		);
+	} catch {
+		// TypeScript can throw while resolving incomplete projects; keep this rule best-effort.
+	}
+}
+
+function isAsyncFunctionDeclarationReference(node, context) {
+	if (node.type !== 'Identifier') {
+		return false;
+	}
+
+	const variable = findVariable(context.sourceCode.getScope(node), node);
+	if (variable?.defs.length !== 1) {
+		return false;
+	}
+
+	const [definition] = variable.defs;
+	return definition.type === 'FunctionName'
+		&& isAsyncNonGeneratorFunction(definition.node);
+}
+
+function isAsyncFinallyCallback(node, context) {
+	node = unwrapTypeScriptExpression(node);
+
+	if (isAsyncNonGeneratorFunction(node)) {
+		return true;
+	}
+
+	const initializer = getConstVariableInitializer(node, context);
+	if (initializer && isAsyncNonGeneratorFunction(unwrapTypeScriptExpression(initializer))) {
+		return true;
+	}
+
+	return isAsyncFunctionDeclarationReference(node, context);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('CallExpression', callExpression => {
+		const {callee} = callExpression;
+		if (callee.type !== 'MemberExpression') {
+			return;
+		}
+
+		const method = getPropertyName(callee, context.sourceCode.getScope(callExpression));
+		if (method !== 'finally') {
+			return;
+		}
+
+		const promiseObject = isPromiseObject(callee.object, context);
+		if (promiseObject === false) {
+			return;
+		}
+
+		const [callback] = callExpression.arguments;
+		if (!callback || !isAsyncFinallyCallback(callback, context)) {
+			return;
+		}
+
+		return {
+			node: callback,
+			messageId: MESSAGE_ID,
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow async functions as `Promise#finally()` callbacks.',
+			recommended: 'unopinionated',
+		},
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-collection-bracket-access.js

@@ -56,6 +56,28 @@ const collectionTypes = [
 // `.method(…)` without parentheses, so suggestions are limited to them.
 const simpleObjectTypes = new Set(['Identifier', 'ThisExpression', 'MemberExpression']);
 
+function getStaticPropertyValues(node, sourceCode) {
+	const staticResult = getStaticValue(node, sourceCode.getScope(node));
+	if (staticResult) {
+		return [staticResult.value];
+	}
+
+	if (node.type !== 'ConditionalExpression') {
+		return;
+	}
+
+	const consequentValues = getStaticPropertyValues(node.consequent, sourceCode);
+	const alternateValues = getStaticPropertyValues(node.alternate, sourceCode);
+	if (!consequentValues || !alternateValues) {
+		return;
+	}
+
+	return [
+		...consequentValues,
+		...alternateValues,
+	];
+}
+
 function getProblem(node, collection, context) {
 	const {sourceCode} = context;
 	const {name: type} = collection;
@@ -132,11 +154,12 @@ const create = context => {
 		}
 
 		// Allow accessing a real member, including `Symbol` ones like `map[Symbol.iterator]`.
-		const staticResult = getStaticValue(node.property, context.sourceCode.getScope(node.property));
+		const staticPropertyValues = getStaticPropertyValues(node.property, context.sourceCode);
 		if (
-			staticResult
-			&& (typeof staticResult.value === 'string' || typeof staticResult.value === 'symbol')
-			&& Reflect.has(collection.prototype, staticResult.value)
+			staticPropertyValues?.every(value =>
+				(typeof value === 'string' || typeof value === 'symbol')
+				&& Reflect.has(collection.prototype, value),
+			)
 		) {
 			return;
 		}

package/rules/no-manually-wrapped-comments.js

@@ -11,12 +11,14 @@ const messages = {
 };
 
 // Trailing `:` marks a complete line (heading, label, list intro), not a wrapped sentence.
-const sentenceEndPattern = /[!.:?]$/v;
+const sentenceEndPattern = /(?:[\p{Extended_Pictographic}!.:?]\p{Variation_Selector}?|\p{RGI_Emoji})$/v;
 const directiveCommentPattern = /^(?:[#\/@]|eslint(?:$|\s|-)|globals?\b|exported\b|no default$|noinspection\b|(?:c8|istanbul|v8)\s+ignore\b|(?:biome|deno|dprint|oxlint|prettier)-|(?:cspell|spell-checker):)/v;
+const annotationCommentPattern = /^[A-Z]{2,}(?:\([^\)]+\))?:/v;
 const spdxCommentPattern = /^SPDX-/v;
 const copyrightCommentPattern = /^(?:©|copyright\b)/iv;
 // Editor modelines: vim (`vim:`, `vi:`) and Emacs (`-*- … -*-`).
 const modelineCommentPattern = /^(?:vim?:|-\*-)/v;
+const structuredCommentPattern = /^(?:language=\S+|(?:end)?region(?:$|\s)|<\/?editor-fold\b)/v;
 const listCommentPattern = /^(?:[*+\-]\s|\d+(?:\.|\))\s)/v;
 const separatorCommentPattern = /^[#*\-=_~]{3,}$/v;
 const urlPattern = /\bhttps?:\/\/|www\./v;
@@ -28,9 +30,11 @@ const endsWithSentencePunctuation = comment => sentenceEndPattern.test(getCommen
 
 const isIgnoredCommentText = text =>
 	directiveCommentPattern.test(text)
+	|| annotationCommentPattern.test(text)
 	|| spdxCommentPattern.test(text)
 	|| copyrightCommentPattern.test(text)
 	|| modelineCommentPattern.test(text)
+	|| structuredCommentPattern.test(text)
 	|| listCommentPattern.test(text)
 	|| separatorCommentPattern.test(text)
 	|| urlPattern.test(text)

package/rules/no-negated-array-predicate.js

@@ -8,7 +8,7 @@ import {
 	shouldAddParenthesesToUnaryExpressionArgument,
 } from './utils/index.js';
 import {
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 	fixSpaceAroundKeyword,
 } from './fix/index.js';
 import {isFunction, isMethodCall} from './ast/index.js';
@@ -177,7 +177,7 @@ const create = context => {
 				}
 
 				if (needsReturnOrThrowParentheses) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+					yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 					return;
 				}