eslint-plugin-unicorn 69.0.0 → 71.0.0

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;
@@ -22,15 +98,103 @@ const create = context => {
 
 	options.comments = options.comments.map(comment => comment.toLowerCase());
 
-	const allowedGlobals = {
+	const configuredGlobals = {
 		...(globals[`es${context.languageOptions.ecmaVersion}`] ?? globals.builtins),
 		...context.languageOptions.globals,
-		...options.overrideGlobals,
 	};
 	const checked = new WeakSet();
 
+	const getAllowedGlobalValue = reference => {
+		const {identifier, resolved} = reference;
+		const {name} = identifier;
+
+		if (Object.hasOwn(options.overrideGlobals, name)) {
+			const overrideGlobalValue = options.overrideGlobals[name];
+
+			if (overrideGlobalValue === 'off') {
+				return 'off';
+			}
+
+			if (resolved && !sourceCode.isGlobalReference(identifier)) {
+				return;
+			}
+
+			return overrideGlobalValue;
+		}
+
+		if (
+			Object.hasOwn(configuredGlobals, name)
+			&& configuredGlobals[name] === 'off'
+		) {
+			return 'off';
+		}
+
+		if (!sourceCode.isGlobalReference(identifier)) {
+			return;
+		}
+
+		if (
+			!Object.hasOwn(configuredGlobals, name)
+			&& !resolved?.eslintExplicitGlobal
+		) {
+			return;
+		}
+
+		return resolved?.writeable ? 'writable' : 'readonly';
+	};
+
+	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;
 		}
@@ -47,18 +211,20 @@ const create = context => {
 				continue;
 			}
 
-			if (Object.hasOwn(allowedGlobals, identifier.name) && allowedGlobals[identifier.name] !== 'off') {
+			const allowedGlobalValue = getAllowedGlobalValue(reference);
+			let problemReason = reason;
+
+			if (allowedGlobalValue !== undefined && allowedGlobalValue !== 'off') {
 				if (reference.isReadOnly()) {
 					continue;
 				}
 
-				const globalsValue = allowedGlobals[identifier.name];
-				const isGlobalWritable = [true, 'writable', 'writeable'].includes(globalsValue);
+				const isGlobalWritable = [true, 'writable', 'writeable'].includes(allowedGlobalValue);
 				if (isGlobalWritable) {
 					continue;
 				}
 
-				reason += ' (global variable is not writable)';
+				problemReason += ' (global variable is not writable)';
 			}
 
 			// Could consider checking for typeof operator here, like in no-undef?
@@ -66,15 +232,36 @@ const create = context => {
 			context.report({
 				node: identifier,
 				messageId: MESSAGE_ID_EXTERNALLY_SCOPED_VARIABLE,
-				data: {name: identifier.name, reason},
+				data: {name: identifier.name, reason: problemReason},
 			});
 		}
+
+		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 +269,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 +309,8 @@ const create = context => {
 		) {
 			return `callee of function named ${JSON.stringify(node.parent.callee.name)}`;
 		}
+
+		return getDefaultArgumentCallReason(node) ?? getExecuteScriptPropertyReason(node);
 	};
 
 	context.onExit(
@@ -137,7 +321,7 @@ const create = context => {
 				return;
 			}
 
-			return reportExternallyScopedVariables(node, reason);
+			return reportIsolatedFunctionProblems(node, reason);
 		},
 	);
 
@@ -146,7 +330,7 @@ const create = context => {
 			selector,
 			node => {
 				const reason = `matches selector ${JSON.stringify(selector)}`;
-				return reportExternallyScopedVariables(node, reason);
+				return reportIsolatedFunctionProblems(node, reason);
 			},
 		);
 	}

package/rules/name-replacements.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
 import {isRegExp} from 'node:util/types';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {
 	getAvailableVariableName,
 	cartesianProductSamples,
@@ -9,6 +8,7 @@ import {
 	upperFirst,
 	lowerFirst,
 	isVirtualFilename,
+	isIdentifierName,
 } from './utils/index.js';
 import {defaultReplacements, defaultAllowList, defaultIgnore} from './shared/name-replacements.js';
 import {
@@ -24,7 +24,6 @@ import {functionTypes} from './ast/index.js';
 const MESSAGE_ID_REPLACE = 'replace';
 const MESSAGE_ID_SUGGESTION = 'suggestion';
 const MESSAGE_ID_RENAME = 'rename';
-const {isIdentifierName} = helperValidatorIdentifier;
 const anotherNameMessage = 'A more descriptive name will do too.';
 const messages = {
 	[MESSAGE_ID_REPLACE]: `The {{nameTypeText}} \`{{discouragedName}}\` should be named \`{{replacement}}\`. ${anotherNameMessage}`,

package/rules/no-anonymous-default-export.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
 import {getFunctionHeadLocation, getFunctionNameWithKind, isOpeningParenToken} from '@eslint-community/eslint-utils';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {camelCase} from 'change-case';
 import {
 	getClassHeadLocation,
@@ -9,11 +8,10 @@ import {
 	getAvailableVariableName,
 	upperFirst,
 	isVirtualFilename,
+	isIdentifierName,
 } from './utils/index.js';
 import {isMemberExpression} from './ast/index.js';
 
-const {isIdentifierName} = helperValidatorIdentifier;
-
 const MESSAGE_ID_ERROR = 'no-anonymous-default-export/error';
 const MESSAGE_ID_SUGGESTION = 'no-anonymous-default-export/suggestion';
 const messages = {

package/rules/no-array-callback-reference.js

@@ -1,4 +1,4 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
+import isIdentifier from 'is-identifier';
 import {findVariable} from '@eslint-community/eslint-utils';
 import typedArray from './shared/typed-array.js';
 import {isMethodCall, isUndefined} from './ast/index.js';
@@ -22,11 +22,6 @@ const ERROR_WITH_NAME_MESSAGE_ID = 'error-with-name';
 const ERROR_WITHOUT_NAME_MESSAGE_ID = 'error-without-name';
 const REPLACE_WITH_NAME_MESSAGE_ID = 'replace-with-name';
 const REPLACE_WITHOUT_NAME_MESSAGE_ID = 'replace-without-name';
-const {
-	isIdentifierName,
-	isKeyword,
-	isStrictBindReservedWord,
-} = helperValidatorIdentifier;
 const messages = {
 	[ERROR_WITH_NAME_MESSAGE_ID]: 'Do not pass function `{{name}}` directly to `.{{method}}(…)`.',
 	[ERROR_WITHOUT_NAME_MESSAGE_ID]: 'Do not pass function directly to `.{{method}}(…)`.',
@@ -301,10 +296,7 @@ function isDefinitelyNotFunctionValue(node, context, visitedVariables = new Set(
 		: false;
 }
 
-const isValidParameterName = name =>
-	isIdentifierName(name)
-	&& !isKeyword(name)
-	&& !isStrictBindReservedWord(name, true);
+const isValidParameterName = isIdentifier;
 
 function getSuggestionParameters(callExpression, callback, parameters) {
 	if (callback.type !== 'Identifier') {

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-chained-comparison.js

@@ -1,4 +1,5 @@
 import {hasSideEffect} from '@eslint-community/eslint-utils';
+import {isBooleanLiteral} from './ast/index.js';
 import {getParenthesizedText, isParenthesized, isBoolean} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-chained-comparison/error';
@@ -13,7 +14,6 @@ const equalityOperators = new Set(['===', '!==', '==', '!=']);
 const comparisonOperators = orderingOperators.union(equalityOperators);
 
 const isComparison = node => node.type === 'BinaryExpression' && comparisonOperators.has(node.operator);
-const isBooleanLiteral = node => node.type === 'Literal' && typeof node.value === 'boolean';
 
 // The `&&` rewrite is a `LogicalExpression`, which binds looser than any comparison. It can only
 // replace `node` where a surrounding operator won't recapture it: at the top of an expression or

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-computed-property-existence-check.js

@@ -134,10 +134,7 @@ const create = context => {
 	});
 
 	context.on('BinaryExpression', node => {
-		if (!(
-			node.operator === 'in'
-			&& !isStaticPropertyKey(node.left)
-		)) {
+		if (node.operator !== 'in' || isStaticPropertyKey(node.left)) {
 			return;
 		}
 

package/rules/no-declarations-before-early-exit.js

@@ -1,5 +1,10 @@
 import {isCommentToken, hasSideEffect} from '@eslint-community/eslint-utils';
-import {containsSuspensionPoint, getReferences, trackBranchExits} from './utils/index.js';
+import {
+	containsSuspensionPoint,
+	getReferences,
+	isReactHookName,
+	trackBranchExits,
+} from './utils/index.js';
 
 const MESSAGE_ID = 'no-declarations-before-early-exit';
 const messages = {
@@ -23,10 +28,6 @@ function isGuardStatement(node, branchAlwaysExits) {
 	return consequentExits !== alternateExits;
 }
 
-// https://github.com/facebook/react/blob/main/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts
-const isReactHookName = name =>
-	name === 'use' || /^use[\dA-Z]/.test(name);
-
 // Matches `useFoo(…)` and `Namespace.useFoo(…)` (for example, `React.useMemo(…)`).
 const isReactHookCall = node => {
 	if (node?.type !== 'CallExpression') {

package/rules/no-error-property-assignment.js

@@ -142,7 +142,7 @@ const getLocalUpdateFrame = knownErrorVariableFrames =>
 	?? knownErrorVariableFrames.at(-1);
 
 const updateExistingKnownErrorVariable = (knownErrorVariableFrames, variable, constructorName) => {
-	let crossesFunctionBoundary = false;
+	let isCrossesFunctionBoundary = false;
 
 	for (const frame of knownErrorVariableFrames.toReversed()) {
 		if (frame.knownErrorVariables.has(variable)) {
@@ -151,7 +151,7 @@ const updateExistingKnownErrorVariable = (knownErrorVariableFrames, variable, co
 				return true;
 			}
 
-			if (!crossesFunctionBoundary) {
+			if (!isCrossesFunctionBoundary) {
 				frame.knownErrorVariables.set(variable, undefined);
 			}
 
@@ -160,7 +160,7 @@ const updateExistingKnownErrorVariable = (knownErrorVariableFrames, variable, co
 		}
 
 		if (frame.isFunctionBoundary) {
-			crossesFunctionBoundary = true;
+			isCrossesFunctionBoundary = true;
 		}
 	}
 

package/rules/no-for-loop.js

@@ -876,14 +876,14 @@ const create = context => {
 
 				let declarationElement = element;
 				let declarationType = 'const';
-				let removeDeclaration = true;
+				let isRemoveDeclaration = true;
 
 				if (elementNode) {
 					if (elementNode.id.type === 'ObjectPattern' || elementNode.id.type === 'ArrayPattern') {
-						removeDeclaration = arrayReferences.length === 1;
+						isRemoveDeclaration = arrayReferences.length === 1;
 					}
 
-					if (removeDeclaration) {
+					if (isRemoveDeclaration) {
 						declarationType = elementNode.parent.kind;
 						declarationElement = sourceCode.getText(elementNode.id);
 					}
@@ -911,7 +911,7 @@ const create = context => {
 				}
 
 				if (elementNode) {
-					yield removeDeclaration
+					yield isRemoveDeclaration
 						? fixer.removeRange(getRemovalRange(elementNode, sourceCode))
 						: fixer.replaceText(elementNode.init, element);
 				}

package/rules/no-keyword-prefix.js

@@ -90,12 +90,12 @@ function reportObjectPatternAndShouldSkipPropertyCheck(report, node, options) {
 		return true;
 	}
 
-	const assignmentKeyEqualsValue = parent.key.name === parent.value.name;
+	const isAssignmentKeyEqualsValue = parent.key.name === parent.value.name;
 
 	const valueIsInvalid = parent.value.name && Boolean(keyword);
 
 	// Ignore destructuring if the option is set, unless a new identifier is created
-	if (valueIsInvalid && !assignmentKeyEqualsValue) {
+	if (valueIsInvalid && !isAssignmentKeyEqualsValue) {
 		report(node, keyword);
 	}
 

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)