eslint-plugin-unicorn 70.0.0 → 71.1.0

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

@@ -24,13 +24,6 @@ const replacementMethod = new Map([
 ]);
 const methods = replacementMethod.keys().toArray();
 
-const predicateBodyTypesRequiringParentheses = new Set([
-	'TSAsExpression',
-	'TSNonNullExpression',
-	'TSSatisfiesExpression',
-	'TSTypeAssertion',
-]);
-
 const needsParenthesesInConciseArrowBody = (node, text) =>
 	node.parent.type === 'ArrowFunctionExpression'
 	&& node.parent.body === node
@@ -75,7 +68,7 @@ function getReplacementPredicateText(node, context) {
 	}
 
 	const text = context.sourceCode.getText(node);
-	const needsParentheses = predicateBodyTypesRequiringParentheses.has(node.type) || shouldAddParenthesesToUnaryExpressionArgument(node, '!');
+	const needsParentheses = shouldAddParenthesesToUnaryExpressionArgument(node, '!');
 
 	return {
 		node,
@@ -158,7 +151,7 @@ const create = context => {
 				replacement,
 			},
 			* fix(fixer) {
-				const needsReturnOrThrowParentheses = (
+				const isNeedsReturnOrThrowParentheses = (
 					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 					&& parent.argument === unaryExpression
 					&& !isOnSameLine(bangToken, tokenAfterBang, context)
@@ -171,12 +164,12 @@ const create = context => {
 
 				if (
 					tokenStore === sourceCode
-					&& !needsReturnOrThrowParentheses
+					&& !isNeedsReturnOrThrowParentheses
 				) {
 					yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 				}
 
-				if (needsReturnOrThrowParentheses) {
+				if (isNeedsReturnOrThrowParentheses) {
 					yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 					return;
 				}

package/rules/no-negated-comparison.js

@@ -98,14 +98,14 @@ function * fix({
 	const tokenAfterBangIncludingComments = sourceCode.getTokenAfter(bangToken, {includeComments: true});
 	const operatorToken = getPunctuatorBinaryExpressionOperatorToken(comparison, context);
 	const {parent} = unaryExpression;
-	const needsReturnOrThrowParentheses = (
+	const isNeedsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === unaryExpression
 		&& !isOnSameLine(bangToken, tokenAfterBang, context)
 		&& !isParenthesized(unaryExpression, context)
 	);
 
-	if (!needsReturnOrThrowParentheses) {
+	if (!isNeedsReturnOrThrowParentheses) {
 		yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 	}
 
@@ -117,16 +117,13 @@ function * fix({
 		yield fixer.insertTextAfter(tokenAfterBangIncludingComments, ' ');
 	}
 
-	if (!(
-		parentNeedsGroupedComparison(parent)
-		&& !isParenthesized(unaryExpression, context)
-	)) {
+	if (!parentNeedsGroupedComparison(parent) || isParenthesized(unaryExpression, context)) {
 		yield removeParentheses(comparison, fixer, context);
 	}
 
 	yield fixer.replaceText(operatorToken, replacementOperator);
 
-	if (needsReturnOrThrowParentheses) {
+	if (isNeedsReturnOrThrowParentheses) {
 		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
@@ -178,21 +175,21 @@ function * fixLogical({
 	const bangToken = sourceCode.getFirstToken(unaryExpression);
 	const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
 	const {parent} = unaryExpression;
-	const needsReturnOrThrowParentheses = (
+	const isNeedsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === unaryExpression
 		&& !isOnSameLine(bangToken, tokenAfterBang, context)
 		&& !isParenthesized(unaryExpression, context)
 	);
 
-	if (!needsReturnOrThrowParentheses) {
+	if (!isNeedsReturnOrThrowParentheses) {
 		yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 	}
 
 	yield fixer.remove(bangToken);
 	yield fixer.replaceText(logicalExpression, getFixedLogicalExpressionText(logicalExpression, context));
 
-	if (needsReturnOrThrowParentheses) {
+	if (isNeedsReturnOrThrowParentheses) {
 		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}

package/rules/no-negation-in-equality-check.js

@@ -23,11 +23,8 @@ const create = context => {
 	context.on('BinaryExpression', binaryExpression => {
 		const {operator, left} = binaryExpression;
 
-		if (!(
-			isEqualityCheck(binaryExpression)
-			&& isNegatedExpression(left)
-			&& !isNegatedExpression(left.argument)
-		)) {
+		if (!(isEqualityCheck(binaryExpression)
+			&& isNegatedExpression(left)) || isNegatedExpression(left.argument)) {
 			return;
 		}
 

package/rules/no-process-exit.js

@@ -11,9 +11,9 @@ const isWorkerThreads = node =>
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const startsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
+	const isStartsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
 
-	if (startsWithHashBang) {
+	if (isStartsWithHashBang) {
 		return;
 	}
 
@@ -22,7 +22,7 @@ const create = context => {
 	let processEventHandlerDepth = 0;
 
 	// Only report if it's outside a worker thread context. See #328.
-	let requiredWorkerThreadsModule = false;
+	let isRequiredWorkerThreadsModule = false;
 	const problemNodes = [];
 
 	const isProcessEventHandler = node => isMethodCall(node, {
@@ -39,7 +39,7 @@ const create = context => {
 			isStaticRequire(callExpression)
 			&& isWorkerThreads(callExpression.arguments[0])
 		) {
-			requiredWorkerThreadsModule = true;
+			isRequiredWorkerThreadsModule = true;
 		}
 	});
 
@@ -49,7 +49,7 @@ const create = context => {
 			importDeclaration.source.type === 'Literal'
 			&& isWorkerThreads(importDeclaration.source)
 		) {
-			requiredWorkerThreadsModule = true;
+			isRequiredWorkerThreadsModule = true;
 		}
 	});
 
@@ -81,7 +81,7 @@ const create = context => {
 	});
 
 	context.onExit('Program', function * () {
-		if (requiredWorkerThreadsModule) {
+		if (isRequiredWorkerThreadsModule) {
 			return;
 		}
 

package/rules/no-static-only-class.js

@@ -38,16 +38,10 @@ function isStaticMember(node) {
 	}
 
 	// TypeScript class
-	if (
-		isDeclare
+	return !(isDeclare
 		|| isReadonly
 		|| accessibility !== undefined
-		|| (Array.isArray(decorators) && decorators.length > 0)
-	) {
-		return false;
-	}
-
-	return true;
+		|| (Array.isArray(decorators) && decorators.length > 0));
 }
 
 function * switchClassMemberToObjectProperty(node, context, fixer) {

package/rules/no-thenable.js

@@ -79,16 +79,13 @@ const cases = [
 	{
 		selector: 'CallExpression',
 		* getNodes(node, context) {
-			if (!(
-				isMethodCall(node, {
-					objects: ['Object', 'Reflect'],
-					method: 'defineProperty',
-					minimumArguments: 3,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				&& node.arguments[0].type !== 'SpreadElement'
-			)) {
+			if (!isMethodCall(node, {
+				objects: ['Object', 'Reflect'],
+				method: 'defineProperty',
+				minimumArguments: 3,
+				optionalCall: false,
+				optionalMember: false,
+			}) || node.arguments[0].type === 'SpreadElement') {
 				return;
 			}
 
@@ -117,11 +114,8 @@ const cases = [
 			}
 
 			for (const pairs of node.arguments[0].elements) {
-				if (!(
-					pairs?.type === 'ArrayExpression'
-					&& pairs.elements[0]
-					&& pairs.elements[0].type !== 'SpreadElement'
-				)) {
+				if (!(pairs?.type === 'ArrayExpression'
+					&& pairs.elements[0]) || pairs.elements[0].type === 'SpreadElement') {
 					continue;
 				}
 

package/rules/no-undeclared-class-members.js

@@ -179,11 +179,7 @@ const getDeclaredClassMemberNames = (classBody, sourceCode) => {
 	const names = new Set(['constructor']);
 
 	for (const member of classBody.body) {
-		if (!(
-			classMemberTypes.has(member.type)
-			&& member.static !== true
-			&& member.kind !== 'constructor'
-		)) {
+		if (!classMemberTypes.has(member.type) || member.static === true || member.kind === 'constructor') {
 			continue;
 		}
 

package/rules/no-unnecessary-array-flat-map.js

@@ -1,10 +1,11 @@
 import {hasSideEffect} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
+import {isEmptyArrayExpression, isMethodCall} from './ast/index.js';
 import {
 	getParenthesizedText,
 	isKnownNonArray,
 	isParenthesized,
 	isSameIdentifier,
+	isTypeScriptFile,
 	shouldAddParenthesesToMemberExpressionObject,
 	wouldRemoveComments,
 } from './utils/index.js';
@@ -49,10 +50,6 @@ const isSimpleSingleParameterArrowCallback = node =>
 	&& !node.params[0].optional
 	&& node.body.type !== 'BlockStatement';
 
-const isEmptyArrayExpression = node =>
-	node.type === 'ArrayExpression'
-	&& node.elements.length === 0;
-
 const getSingleArrayElement = node => {
 	if (
 		node.type !== 'ArrayExpression'
@@ -195,6 +192,10 @@ function getProblemForFilterFlatMap(flatMapCallExpression, callbackResult, conte
 }
 
 function getProblemForConditionalFlatMap(flatMapCallExpression, callback, callbackResult, context) {
+	if (isTypeScriptFile(context.physicalFilename)) {
+		return;
+	}
+
 	const method = isSameIdentifier(callbackResult.element, callback.params[0]) ? 'filter' : 'filter().map';
 	const problem = {
 		node: flatMapCallExpression.callee.property,

package/rules/no-unnecessary-global-this.js

@@ -1,9 +1,4 @@
-import {
-	isIdentifierName,
-	isKeyword,
-	isReservedWord,
-	isStrictReservedWord,
-} from '@babel/helper-validator-identifier';
+import reservedIdentifiers from 'reserved-identifiers';
 import {findVariable} from '@eslint-community/eslint-utils';
 import {isStringLiteral} from './ast/index.js';
 import {
@@ -12,6 +7,7 @@ import {
 	isLeftHandSide,
 	isControlFlowTest,
 	isBooleanExpression,
+	isIdentifierName,
 } from './utils/index.js';
 
 const MESSAGE_ID = 'no-unnecessary-global-this';
@@ -53,11 +49,11 @@ function isActiveGlobal(name, node, context) {
 		&& variable.defs.length === 0;
 }
 
+const reserved = reservedIdentifiers();
+
 function canUseBareIdentifier(name) {
 	return isIdentifierName(name)
-		&& !isKeyword(name)
-		&& !isReservedWord(name, true)
-		&& !isStrictReservedWord(name, true);
+		&& (!reserved.has(name) || name === 'eval' || name === 'arguments');
 }
 
 function getStaticPropertyName(node) {

package/rules/no-unused-properties.js

@@ -65,7 +65,6 @@ const getReferenceParent = referenceNode => {
 	return referenceNode.parent;
 };
 
-// eslint-disable-next-line unicorn/name-replacements
 const specialProtoPropertyKey = {
 	type: 'Identifier',
 	name: '__proto__',

package/rules/no-useless-coercion.js

@@ -1,3 +1,4 @@
+import {isEmptyStringLiteral} from './ast/index.js';
 import {
 	isBoolean,
 	isString,
@@ -25,8 +26,6 @@ const coercions = new Map([
 	['Number', {type: 'number', isType: (node, context) => isNumber(node, context.sourceCode.getScope(node))}],
 ]);
 
-const isEmptyStringLiteral = node => node.type === 'Literal' && node.value === '';
-
 /** @param {ESLint.Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;

package/rules/no-useless-undefined.js

@@ -410,10 +410,10 @@ const create = context => {
 			return;
 		}
 
-		const accessWhenTestPasses = !isConsequentUndefined;
+		const isAccessWhenTestPasses = !isConsequentUndefined;
 		const testValidity = getIndexedAccessTestValidity(node.test, indexedAccess);
 
-		if (testValidity !== accessWhenTestPasses) {
+		if (testValidity !== isAccessWhenTestPasses) {
 			return;
 		}
 

package/rules/prefer-array-find.js

@@ -204,13 +204,10 @@ const create = context => {
 	// `array.filter()[0]`
 	// `array?.filter()[0]`
 	context.on('MemberExpression', node => {
-		if (!(
-			node.computed
+		if (!(node.computed
 			&& node.property.type === 'Literal'
 			&& node.property.raw === '0'
-			&& isArrayFilterCall(node.object, context)
-			&& !isLeftHandSide(node)
-		)) {
+			&& isArrayFilterCall(node.object, context)) || isLeftHandSide(node)) {
 			return;
 		}
 

package/rules/prefer-bigint-literals.js

@@ -75,6 +75,7 @@ function getReplacement(valueNode) {
 	const {value, raw} = valueNode;
 
 	// Intentionally `Number.isInteger`, not `Number.isSafeInteger`: large integers beyond the safe range are exactly what bigint literals are for.
+	// eslint-disable-next-line unicorn/prefer-number-is-safe-integer
 	if (!Number.isInteger(value)) {
 		return;
 	}

package/rules/prefer-boolean-return.js

@@ -3,6 +3,7 @@ import {
 	getLastTrailingCommentOnSameLine,
 	getNextNode,
 	getParenthesizedText,
+	getPreviousNode,
 	isGlobalBooleanCall,
 	shouldAddParenthesesToUnaryExpressionArgument,
 } from './utils/index.js';
@@ -143,11 +144,11 @@ const create = context => {
 		const hasComments = sourceCode.getCommentsInside(node).length > 0
 			|| sourceCode.getCommentsInside(alternate).length > 0
 			|| getLastTrailingCommentOnSameLine(context, alternate);
-		const needsGlobalBoolean = !shouldNegateTest
+		const isNeedsGlobalBoolean = !shouldNegateTest
 			&& !isRuntimeBooleanExpression(node.test, context)
 			&& !canUseGlobalBoolean(node);
 
-		if (hasComments || needsGlobalBoolean) {
+		if (hasComments || isNeedsGlobalBoolean) {
 			return problem;
 		}
 
@@ -160,6 +161,13 @@ const create = context => {
 		};
 	}
 
+	function isPrecededByFlatIfReturningSameBoolean(node, returnValue) {
+		const previousNode = getPreviousNode(node, context);
+		return previousNode?.type === 'IfStatement'
+			&& !previousNode.alternate
+			&& getBooleanReturnValue(getNodeBody(previousNode.consequent)) === returnValue;
+	}
+
 	function getFlatProblem(node) {
 		const alternate = getNextNode(node, context);
 		if (
@@ -169,9 +177,18 @@ const create = context => {
 			return;
 		}
 
+		const consequent = getNodeBody(node.consequent);
+		const consequentValue = getBooleanReturnValue(consequent);
+		if (
+			consequentValue !== undefined
+			&& isPrecededByFlatIfReturningSameBoolean(node, consequentValue)
+		) {
+			return;
+		}
+
 		const problem = getProblem(
 			node,
-			getNodeBody(node.consequent),
+			consequent,
 			alternate,
 			[
 				sourceCode.getRange(node)[0],

package/rules/prefer-default-parameters.js

@@ -108,8 +108,8 @@ const fixDefaultExpression = (fixer, sourceCode, node) => {
 		]);
 	}
 
-	const endsWithWhitespace = lineText[column] === ' ';
-	if (endsWithWhitespace) {
+	const isEndsWithWhitespace = lineText[column] === ' ';
+	if (isEndsWithWhitespace) {
 		const [start, end] = sourceCode.getRange(node);
 		return fixer.removeRange([start, end + 1]);
 	}

package/rules/prefer-else-if.js

@@ -148,13 +148,13 @@ function getEqualityComparisons(node) {
 */
 function getBooleanComparisonInfo(node, context) {
 	node = unwrapExpression(node);
-	let value = true;
+	let isValue = true;
 
 	while (
 		node.type === 'UnaryExpression'
 		&& node.operator === '!'
 	) {
-		value = !value;
+		isValue = !isValue;
 		node = unwrapExpression(node.argument);
 	}
 
@@ -178,7 +178,7 @@ function getBooleanComparisonInfo(node, context) {
 
 	return {
 		discriminant: node,
-		valueKeys: new Set([getStaticEqualityValueKey(value)]),
+		valueKeys: new Set([getStaticEqualityValueKey(isValue)]),
 	};
 }
 
@@ -444,13 +444,9 @@ function getProblem(previousIfStatement, ifStatement, context, branchAlwaysExits
 	const previous = getComparisonInfo(previousIfStatement.test, context);
 	const current = getComparisonInfo(ifStatement.test, context);
 
-	if (!(
-		previous
+	if (!(previous
 		&& current
-		&& isSame(previous.discriminant, current.discriminant)
-		&& !hasOverlappingValues(previous.valueKeys, current.valueKeys)
-		&& !hasDirectDiscriminantMutation(previousIfStatement.consequent, previous.discriminant, context)
-	)) {
+		&& isSame(previous.discriminant, current.discriminant)) || hasOverlappingValues(previous.valueKeys, current.valueKeys) || hasDirectDiscriminantMutation(previousIfStatement.consequent, previous.discriminant, context)) {
 		return;
 	}
 

package/rules/prefer-has-check.js

@@ -1,5 +1,10 @@
 import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
-import {isMethodCall, isNewExpression, isUndefined} from './ast/index.js';
+import {
+	isMethodCall,
+	isNewExpression,
+	isNullLiteral,
+	isUndefined,
+} from './ast/index.js';
 import {
 	getParenthesizedText,
 	getTypeSymbol,
@@ -823,8 +828,6 @@ const getCallKind = (callExpression, comparison, context) => {
 	}
 };
 
-const isNullLiteral = node => node.type === 'Literal' && node.value === null;
-
 const getComparison = callExpression => {
 	const comparisonTarget = getTransparentExpressionAncestor(callExpression);
 	const {parent} = comparisonTarget;

package/rules/prefer-https.js

@@ -82,14 +82,14 @@ function isWellKnownXmlNamespace(text, matchIndex) {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	let checked = false;
+	let isChecked = false;
 
 	onRoot(context, node => {
-		if (checked) {
+		if (isChecked) {
 			return;
 		}
 
-		checked = true;
+		isChecked = true;
 
 		const {sourceCode} = context;
 		const {text} = sourceCode;

package/rules/prefer-identifier-import-export-specifiers.js

@@ -1,6 +1,4 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
-
-const {isIdentifierName} = helperValidatorIdentifier;
+import {isIdentifierName} from './utils/index.js';
 
 const MESSAGE_ID = 'prefer-identifier-import-export-specifiers';
 const messages = {

package/rules/prefer-minimal-ternary.js

@@ -166,14 +166,14 @@ function isMinimalBinaryExpression(left, right, context) {
 		return false;
 	}
 
-	const leftSidesAreSame = isSameSourceText(left.left, right.left, context.sourceCode);
-	const rightSidesAreSame = isSameSourceText(left.right, right.right, context.sourceCode);
+	const isLeftSidesAreSame = isSameSourceText(left.left, right.left, context.sourceCode);
+	const isRightSidesAreSame = isSameSourceText(left.right, right.right, context.sourceCode);
 
-	if (leftSidesAreSame === rightSidesAreSame) {
+	if (isLeftSidesAreSame === isRightSidesAreSame) {
 		return false;
 	}
 
-	return rightSidesAreSame || isSafeSharedExpression(left.left);
+	return isRightSidesAreSame || isSafeSharedExpression(left.left);
 }
 
 function hasSameObjectWithDifferentDynamicKey(left, right, context) {

package/rules/prefer-object-define-properties.js

@@ -1,15 +1,13 @@
 import {getStaticValue} from '@eslint-community/eslint-utils';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {isMethodCall} from './ast/index.js';
 import {
 	getIndentString,
 	getNextNode,
 	getPreviousNode,
 	isSameReference,
+	isIdentifierName,
 } from './utils/index.js';
 
-const {isIdentifierName} = helperValidatorIdentifier;
-
 const MESSAGE_ID = 'prefer-object-define-properties';
 const messages = {
 	[MESSAGE_ID]: 'Prefer `Object.defineProperties()` over multiple `Object.defineProperty()` calls.',

package/rules/prefer-observer-apis.js

@@ -231,11 +231,8 @@ const isGlobalObject = (node, context) =>
 const isWriteOnlyLeftHandSide = node =>
 	isLeftHandSide(node)
 	&& node.parent.type !== 'UpdateExpression'
-	&& !(
-		node.parent.type === 'AssignmentExpression'
-		&& node.parent.left === node
-		&& node.parent.operator !== '='
-	);
+	&& (!(node.parent.type === 'AssignmentExpression'
+		&& node.parent.left === node) || node.parent.operator === '=');
 
 const isGlobalDocument = (node, context) => {
 	node = unwrapTypeScriptExpression(node);

package/rules/prefer-private-class-fields.js

@@ -1,7 +1,5 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {getStaticStringValue} from './ast/index.js';
-
-const {isIdentifierName} = helperValidatorIdentifier;
+import {isIdentifierName} from './utils/index.js';
 
 const MESSAGE_ID = 'prefer-private-class-fields';
 const messages = {

package/rules/prefer-simple-sort-comparator.js

@@ -138,14 +138,14 @@ function trueBranchSign(branch) {
 }
 
 function expectedSignForTest(test, minuend, subtrahend) {
-	const greaterThan = test.operator === '>' || test.operator === '>=';
+	const isGreaterThan = test.operator === '>' || test.operator === '>=';
 	const testLeftIsMinuend = isSameReference(test.left, minuend) && isSameReference(test.right, subtrahend);
 
 	if (testLeftIsMinuend) {
-		return greaterThan ? 1 : -1;
+		return isGreaterThan ? 1 : -1;
 	}
 
-	return greaterThan ? -1 : 1;
+	return isGreaterThan ? -1 : 1;
 }
 
 function branchSignsMatchSubtraction(branch, minuend, subtrahend) {
@@ -220,9 +220,9 @@ const create = context => {
 
 		// Orient the subtraction so it matches the comparator's sort direction.
 		const {test} = tree;
-		const greaterThan = test.operator === '>' || test.operator === '>=';
-		const leftIsMinuend = greaterThan ? sign > 0 : sign < 0;
-		const [minuend, subtrahend] = leftIsMinuend ? [test.left, test.right] : [test.right, test.left];
+		const isGreaterThan = test.operator === '>' || test.operator === '>=';
+		const isLeftIsMinuend = isGreaterThan ? sign > 0 : sign < 0;
+		const [minuend, subtrahend] = isLeftIsMinuend ? [test.left, test.right] : [test.right, test.left];
 
 		if (!branchSignsMatchSubtraction(tree, minuend, subtrahend)) {
 			return;

package/rules/prefer-single-object-destructuring.js

@@ -68,15 +68,12 @@ const getProblem = (sourceCode, firstNode, secondNode) => {
 	const first = getSupportedDeclaration(sourceCode, firstNode);
 	const second = getSupportedDeclaration(sourceCode, secondNode);
 
-	if (!(
-		first
+	if (!(first
 		&& second
 		&& first.node.kind === second.node.kind
 		&& first.source === second.source
 		&& sourceCode.getCommentsInside(first.node).length === 0
-		&& sourceCode.getCommentsInside(second.node).length === 0
-		&& !hasCommentsBetween(sourceCode, first.node, second.node)
-	)) {
+		&& sourceCode.getCommentsInside(second.node).length === 0) || hasCommentsBetween(sourceCode, first.node, second.node)) {
 		return;
 	}
 

package/rules/prefer-single-replace.js

@@ -21,8 +21,8 @@ const characterClassEscapes = new Map([
 	['\t', String.raw`\t`],
 	['\f', String.raw`\f`],
 	['\v', String.raw`\v`],
-	['\u2028', String.raw`\u2028`],
-	['\u2029', String.raw`\u2029`],
+	['\u{2028}', String.raw`\u2028`],
+	['\u{2029}', String.raw`\u2029`],
 ]);
 
 // Escapes a single character for use inside a character class. `^` and `-` are only special depending on position, so they are escaped only when necessary (avoids tripping `no-useless-escape` on the output).