eslint-plugin-unicorn 48.0.0 → 49.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "48.0.0",
+	"version": "49.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -26,6 +26,7 @@
 		"lint:md": "markdownlint \"**/*.md\"",
 		"lint:package-json": "npmPkgJsonLint .",
 		"run-rules-on-codebase": "node ./test/run-rules-on-codebase/lint.mjs",
+		"bundle-lodash": "echo \"export {defaultsDeep, camelCase, kebabCase, snakeCase, upperFirst, lowerFirst} from 'lodash-es';\" | npx esbuild --bundle --outfile=rules/utils/lodash.js --format=cjs",
 		"smoke": "eslint-remote-tester --config ./test/smoke/eslint-remote-tester.config.js",
 		"test": "npm-run-all --continue-on-error lint test:*",
 		"test:js": "c8 ava"
@@ -46,7 +47,7 @@
 		"xo"
 	],
 	"dependencies": {
-		"@babel/helper-validator-identifier": "^7.22.5",
+		"@babel/helper-validator-identifier": "^7.22.20",
 		"@eslint-community/eslint-utils": "^4.4.0",
 		"ci-info": "^3.8.0",
 		"clean-regexp": "^1.0.0",
@@ -54,7 +55,6 @@
 		"indent-string": "^4.0.0",
 		"is-builtin-module": "^3.2.1",
 		"jsesc": "^3.0.2",
-		"lodash": "^4.17.21",
 		"pluralize": "^8.0.0",
 		"read-pkg-up": "^7.0.1",
 		"regexp-tree": "^0.1.27",
@@ -63,37 +63,37 @@
 		"strip-indent": "^3.0.0"
 	},
 	"devDependencies": {
-		"@babel/code-frame": "^7.22.5",
-		"@babel/core": "^7.22.8",
-		"@babel/eslint-parser": "^7.22.7",
+		"@babel/code-frame": "^7.22.13",
+		"@babel/core": "^7.23.2",
+		"@babel/eslint-parser": "^7.22.15",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^5.61.0",
+		"@typescript-eslint/parser": "^6.9.0",
 		"ava": "^3.15.0",
-		"c8": "^8.0.0",
+		"c8": "^8.0.1",
 		"chalk": "^5.3.0",
-		"enquirer": "^2.3.6",
-		"eslint": "^8.44.0",
+		"enquirer": "^2.4.1",
+		"eslint": "^8.52.0",
 		"eslint-ava-rule-tester": "^4.0.0",
-		"eslint-doc-generator": "^1.4.3",
-		"eslint-plugin-eslint-plugin": "^5.1.0",
+		"eslint-doc-generator": "^1.5.2",
+		"eslint-plugin-eslint-plugin": "^5.1.1",
 		"eslint-plugin-internal-rules": "file:./scripts/internal-rules/",
-		"eslint-remote-tester": "^3.0.0",
+		"eslint-remote-tester": "^3.0.1",
 		"eslint-remote-tester-repositories": "^1.0.1",
-		"execa": "^7.1.1",
+		"execa": "^8.0.1",
 		"listr": "^0.14.3",
 		"lodash-es": "^4.17.21",
-		"markdownlint-cli": "^0.35.0",
+		"markdownlint-cli": "^0.37.0",
 		"mem": "^9.0.2",
 		"npm-package-json-lint": "^7.0.0",
-		"npm-run-all": "^4.1.5",
+		"npm-run-all2": "^6.1.1",
 		"outdent": "^0.8.0",
-		"typescript": "^5.1.6",
-		"vue-eslint-parser": "^9.3.1",
-		"xo": "^0.54.2",
-		"yaml": "^2.3.1"
+		"typescript": "^5.2.2",
+		"vue-eslint-parser": "^9.3.2",
+		"xo": "^0.56.0",
+		"yaml": "^2.3.3"
 	},
 	"peerDependencies": {
-		"eslint": ">=8.44.0"
+		"eslint": ">=8.52.0"
 	},
 	"ava": {
 		"files": [
@@ -114,6 +114,7 @@
 		"ignores": [
 			".cache-eslint-remote-tester",
 			"eslint-remote-tester-results",
+			"rules/utils/lodash.js",
 			"test/integration/{fixtures,fixtures-local}/**"
 		],
 		"rules": {

package/rules/ast/is-method-call.js

@@ -1,5 +1,4 @@
 'use strict';
-const {pick} = require('lodash');
 const isMemberExpression = require('./is-member-expression.js');
 const {isCallExpression} = require('./call-or-new-expression.js');
 
@@ -46,11 +45,16 @@ function isMethodCall(node, options) {
 
 	return (
 		isCallExpression(node, {
-			...pick(options, ['argumentsLength', 'minimumArguments', 'maximumArguments', 'allowSpreadElement']),
+			argumentsLength: options.argumentsLength,
+			minimumArguments: options.minimumArguments,
+			maximumArguments: options.maximumArguments,
+			allowSpreadElement: options.allowSpreadElement,
 			optional: optionalCall,
 		})
 		&& isMemberExpression(node.callee, {
-			...pick(options, ['object', 'objects', 'computed']),
+			object: options.object,
+			objects: options.objects,
+			computed: options.computed,
 			property: method,
 			properties: methods,
 			optional: optionalMember,

package/rules/ast/is-reference-identifier.js

@@ -115,6 +115,16 @@ function isNotReference(node) {
 			return parent.id === node;
 		}
 
+		// `type Foo = { [Identifier: string]: string }`
+		case 'TSIndexSignature': {
+			return parent.parameters.includes(node);
+		}
+
+		// `type Identifier = Foo`
+		case 'TSTypeAliasDeclaration': {
+			return parent.id === node;
+		}
+
 		case 'TSPropertySignature': {
 			return parent.key === node;
 		}

package/rules/better-regex.js

@@ -28,10 +28,9 @@ const create = context => {
 			}
 
 			const {raw: original, regex} = node;
-
-			// Regular Expressions with `u` flag are not well handled by `regexp-tree`
+			// Regular Expressions with `u` and `v` flag are not well handled by `regexp-tree`
 			// https://github.com/DmitrySoshnikov/regexp-tree/issues/162
-			if (regex.flags.includes('u')) {
+			if (regex.flags.includes('u') || regex.flags.includes('v')) {
 				return;
 			}
 

package/rules/catch-error-name.js

@@ -62,7 +62,7 @@ const create = context => {
 
 			if (
 				isNameAllowed(originalName)
-				|| isNameAllowed(originalName.replace(/_+$/g, ''))
+				|| isNameAllowed(originalName.replaceAll(/_+$/g, ''))
 			) {
 				return;
 			}

package/rules/consistent-destructuring.js

@@ -89,7 +89,7 @@ const create = context => {
 				&& property.key.type === 'Identifier'
 				&& property.value.type === 'Identifier',
 			);
-			const lastProperty = objectPattern.properties[objectPattern.properties.length - 1];
+			const lastProperty = objectPattern.properties.at(-1);
 
 			const hasRest = lastProperty && lastProperty.type === 'RestElement';
 
@@ -134,7 +134,7 @@ const create = context => {
 					},
 					* fix(fixer) {
 						const {properties} = objectPattern;
-						const lastProperty = properties[properties.length - 1];
+						const lastProperty = properties.at(-1);
 
 						yield fixer.replaceText(node, newMember);
 

package/rules/custom-error-definition.js

@@ -1,5 +1,5 @@
 'use strict';
-const {upperFirst} = require('lodash');
+const {upperFirst} = require('./utils/lodash.js');
 
 const MESSAGE_ID_INVALID_EXPORT = 'invalidExport';
 const messages = {

package/rules/expiring-todo-comments.js

@@ -1,4 +1,5 @@
 'use strict';
+const path = require('node:path');
 const readPkgUp = require('read-pkg-up');
 const semver = require('semver');
 const ci = require('ci-info');
@@ -47,146 +48,160 @@ const messages = {
 		'Unexpected \'{{matchedTerm}}\' comment without any conditions: \'{{comment}}\'.',
 };
 
-// We don't need to normalize the package.json data, because we are only using 2 properties and those 2 properties
-// aren't validated by the normalization. But when this plugin is used in a monorepo, the name field in the
-// package.json is invalid and would make this plugin throw an error. See also #1871
-const packageResult = readPkgUp.sync({normalize: false});
-const hasPackage = Boolean(packageResult);
-const packageJson = hasPackage ? packageResult.packageJson : {};
-
-const packageDependencies = {
-	...packageJson.dependencies,
-	...packageJson.devDependencies,
-};
-
-const DEPENDENCY_INCLUSION_RE = /^[+-]\s*@?\S+\/?\S+/;
-const VERSION_COMPARISON_RE = /^(?<name>@?\S\/?\S+)@(?<condition>>|>=)(?<version>\d+(?:\.\d+){0,2}(?:-[\da-z-]+(?:\.[\da-z-]+)*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?)/i;
-const PKG_VERSION_RE = /^(?<condition>>|>=)(?<version>\d+(?:\.\d+){0,2}(?:-[\da-z-]+(?:\.[\da-z-]+)*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?)\s*$/;
-const ISO8601_DATE = /\d{4}-\d{2}-\d{2}/;
-
-function parseTodoWithArguments(string, {terms}) {
-	const lowerCaseString = string.toLowerCase();
-	const lowerCaseTerms = terms.map(term => term.toLowerCase());
-	const hasTerm = lowerCaseTerms.some(term => lowerCaseString.includes(term));
-
-	if (!hasTerm) {
-		return false;
+/** @param {string} dirname */
+function getPackageHelpers(dirname) {
+	// We don't need to normalize the package.json data, because we are only using 2 properties and those 2 properties
+	// aren't validated by the normalization. But when this plugin is used in a monorepo, the name field in the
+	// package.json can be invalid and would make this plugin throw an error. See also #1871
+	/** @type {readPkgUp.ReadResult | undefined} */
+	let packageResult;
+	try {
+		packageResult = readPkgUp.sync({normalize: false, cwd: dirname});
+	} catch {
+		// This can happen if package.json files have comments in them etc.
+		packageResult = undefined;
 	}
 
-	const TODO_ARGUMENT_RE = /\[(?<rawArguments>[^}]+)]/i;
-	const result = TODO_ARGUMENT_RE.exec(string);
+	const hasPackage = Boolean(packageResult);
+	const packageJson = packageResult ? packageResult.packageJson : {};
 
-	if (!result) {
-		return false;
-	}
+	const packageDependencies = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+	};
 
-	const {rawArguments} = result.groups;
+	function parseTodoWithArguments(string, {terms}) {
+		const lowerCaseString = string.toLowerCase();
+		const lowerCaseTerms = terms.map(term => term.toLowerCase());
+		const hasTerm = lowerCaseTerms.some(term => lowerCaseString.includes(term));
 
-	const parsedArguments = rawArguments
-		.split(',')
-		.map(argument => parseArgument(argument.trim()));
+		if (!hasTerm) {
+			return false;
+		}
 
-	return createArgumentGroup(parsedArguments);
-}
+		const TODO_ARGUMENT_RE = /\[(?<rawArguments>[^}]+)]/i;
+		const result = TODO_ARGUMENT_RE.exec(string);
 
-function createArgumentGroup(arguments_) {
-	const groups = {};
-	for (const {value, type} of arguments_) {
-		groups[type] = groups[type] || [];
-		groups[type].push(value);
-	}
+		if (!result) {
+			return false;
+		}
 
-	return groups;
-}
+		const {rawArguments} = result.groups;
 
-function parseArgument(argumentString) {
-	if (ISO8601_DATE.test(argumentString)) {
-		return {
-			type: 'dates',
-			value: argumentString,
-		};
-	}
+		const parsedArguments = rawArguments
+			.split(',')
+			.map(argument => parseArgument(argument.trim()));
 
-	if (hasPackage && DEPENDENCY_INCLUSION_RE.test(argumentString)) {
-		const condition = argumentString[0] === '+' ? 'in' : 'out';
-		const name = argumentString.slice(1).trim();
-
-		return {
-			type: 'dependencies',
-			value: {
-				name,
-				condition,
-			},
-		};
+		return createArgumentGroup(parsedArguments);
 	}
 
-	if (hasPackage && VERSION_COMPARISON_RE.test(argumentString)) {
-		const {groups} = VERSION_COMPARISON_RE.exec(argumentString);
-		const name = groups.name.trim();
-		const condition = groups.condition.trim();
-		const version = groups.version.trim();
+	function parseArgument(argumentString, dirname) {
+		const {hasPackage} = getPackageHelpers(dirname);
+		if (ISO8601_DATE.test(argumentString)) {
+			return {
+				type: 'dates',
+				value: argumentString,
+			};
+		}
 
-		const hasEngineKeyword = name.indexOf('engine:') === 0;
-		const isNodeEngine = hasEngineKeyword && name === 'engine:node';
+		if (hasPackage && DEPENDENCY_INCLUSION_RE.test(argumentString)) {
+			const condition = argumentString[0] === '+' ? 'in' : 'out';
+			const name = argumentString.slice(1).trim();
 
-		if (hasEngineKeyword && isNodeEngine) {
 			return {
-				type: 'engines',
+				type: 'dependencies',
 				value: {
+					name,
 					condition,
-					version,
 				},
 			};
 		}
 
-		if (!hasEngineKeyword) {
+		if (hasPackage && VERSION_COMPARISON_RE.test(argumentString)) {
+			const {groups} = VERSION_COMPARISON_RE.exec(argumentString);
+			const name = groups.name.trim();
+			const condition = groups.condition.trim();
+			const version = groups.version.trim();
+
+			const hasEngineKeyword = name.indexOf('engine:') === 0;
+			const isNodeEngine = hasEngineKeyword && name === 'engine:node';
+
+			if (hasEngineKeyword && isNodeEngine) {
+				return {
+					type: 'engines',
+					value: {
+						condition,
+						version,
+					},
+				};
+			}
+
+			if (!hasEngineKeyword) {
+				return {
+					type: 'dependencies',
+					value: {
+						name,
+						condition,
+						version,
+					},
+				};
+			}
+		}
+
+		if (hasPackage && PKG_VERSION_RE.test(argumentString)) {
+			const result = PKG_VERSION_RE.exec(argumentString);
+			const {condition, version} = result.groups;
+
 			return {
-				type: 'dependencies',
+				type: 'packageVersions',
 				value: {
-					name,
-					condition,
-					version,
+					condition: condition.trim(),
+					version: version.trim(),
 				},
 			};
 		}
-	}
-
-	if (hasPackage && PKG_VERSION_RE.test(argumentString)) {
-		const result = PKG_VERSION_RE.exec(argumentString);
-		const {condition, version} = result.groups;
 
+		// Currently being ignored as integration tests pointed
+		// some TODO comments have `[random data like this]`
 		return {
-			type: 'packageVersions',
-			value: {
-				condition: condition.trim(),
-				version: version.trim(),
-			},
+			type: 'unknowns',
+			value: argumentString,
 		};
 	}
 
-	// Currently being ignored as integration tests pointed
-	// some TODO comments have `[random data like this]`
-	return {
-		type: 'unknowns',
-		value: argumentString,
-	};
-}
+	function parseTodoMessage(todoString) {
+		// @example "TODO [...]: message here"
+		// @example "TODO [...] message here"
+		const argumentsEnd = todoString.indexOf(']');
+
+		const afterArguments = todoString.slice(argumentsEnd + 1).trim();
 
-function parseTodoMessage(todoString) {
-	// @example "TODO [...]: message here"
-	// @example "TODO [...] message here"
-	const argumentsEnd = todoString.indexOf(']');
+		// Check if have to skip colon
+		// @example "TODO [...]: message here"
+		const dropColon = afterArguments[0] === ':';
+		if (dropColon) {
+			return afterArguments.slice(1).trim();
+		}
+
+		return afterArguments;
+	}
+
+	return {packageResult, hasPackage, packageJson, packageDependencies, parseArgument, parseTodoMessage, parseTodoWithArguments};
+}
 
-	const afterArguments = todoString.slice(argumentsEnd + 1).trim();
+const DEPENDENCY_INCLUSION_RE = /^[+-]\s*@?\S+\/?\S+/;
+const VERSION_COMPARISON_RE = /^(?<name>@?\S\/?\S+)@(?<condition>>|>=)(?<version>\d+(?:\.\d+){0,2}(?:-[\da-z-]+(?:\.[\da-z-]+)*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?)/i;
+const PKG_VERSION_RE = /^(?<condition>>|>=)(?<version>\d+(?:\.\d+){0,2}(?:-[\da-z-]+(?:\.[\da-z-]+)*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?)\s*$/;
+const ISO8601_DATE = /\d{4}-\d{2}-\d{2}/;
 
-	// Check if have to skip colon
-	// @example "TODO [...]: message here"
-	const dropColon = afterArguments[0] === ':';
-	if (dropColon) {
-		return afterArguments.slice(1).trim();
+function createArgumentGroup(arguments_) {
+	const groups = {};
+	for (const {value, type} of arguments_) {
+		groups[type] = groups[type] || [];
+		groups[type].push(value);
 	}
 
-	return afterArguments;
+	return groups;
 }
 
 function reachedDate(past, now) {
@@ -263,6 +278,9 @@ const create = context => {
 		pattern => pattern instanceof RegExp ? pattern : new RegExp(pattern, 'u'),
 	);
 
+	const dirname = path.dirname(context.filename);
+	const {packageJson, packageDependencies, parseArgument, parseTodoMessage, parseTodoWithArguments} = getPackageHelpers(dirname);
+
 	const {sourceCode} = context;
 	const comments = sourceCode.getAllComments();
 	const unusedComments = comments
@@ -284,13 +302,18 @@ const create = context => {
 	// This is highly dependable on ESLint's `no-warning-comments` implementation.
 	// What we do is patch the parts we know the rule will use, `getAllComments`.
 	// Since we have priority, we leave only the comments that we didn't use.
-	const fakeContext = {
-		...context,
-		sourceCode: {
-			...sourceCode,
-			getAllComments: () => options.allowWarningComments ? [] : unusedComments,
+	const fakeContext = new Proxy(context, {
+		get(target, property, receiver) {
+			if (property === 'sourceCode') {
+				return {
+					...sourceCode,
+					getAllComments: () => options.allowWarningComments ? [] : unusedComments,
+				};
+			}
+
+			return Reflect.get(target, property, receiver);
 		},
-	};
+	});
 	const rules = baseRule.create(fakeContext);
 
 	function processComment(comment) {
@@ -485,7 +508,7 @@ const create = context => {
 				}
 			}
 
-			const withoutWhitespace = unknown.replace(/ /g, '');
+			const withoutWhitespace = unknown.replaceAll(' ', '');
 
 			if (parseArgument(withoutWhitespace).type !== 'unknowns') {
 				uses++;

package/rules/filename-case.js

@@ -1,6 +1,6 @@
 'use strict';
 const path = require('node:path');
-const {camelCase, kebabCase, snakeCase, upperFirst} = require('lodash');
+const {camelCase, kebabCase, snakeCase, upperFirst} = require('./utils/lodash.js');
 const cartesianProductSamples = require('./utils/cartesian-product-samples.js');
 
 const MESSAGE_ID = 'filename-case';

package/rules/fix/remove-argument.js

@@ -7,7 +7,7 @@ function removeArgument(fixer, node, sourceCode) {
 	const index = callExpression.arguments.indexOf(node);
 	const parentheses = getParentheses(node, sourceCode);
 	const firstToken = parentheses[0] || node;
-	const lastToken = parentheses[parentheses.length - 1] || node;
+	const lastToken = parentheses.at(-1) || node;
 
 	let [start] = firstToken.range;
 	let [, end] = lastToken.range;

package/rules/import-style.js

@@ -1,5 +1,5 @@
 'use strict';
-const {defaultsDeep} = require('lodash');
+const {defaultsDeep} = require('./utils/lodash.js');
 const {getStringIfConstant} = require('@eslint-community/eslint-utils');
 const {isCallExpression} = require('./ast/index.js');
 

package/rules/no-array-for-each.js

@@ -400,7 +400,7 @@ const create = context => {
 	});
 
 	context.on('ReturnStatement', node => {
-		const currentFunction = functionStack[functionStack.length - 1];
+		const currentFunction = functionStack.at(-1);
 		if (!currentFunction) {
 			return;
 		}

package/rules/no-array-method-this-argument.js

@@ -83,7 +83,7 @@ function useBoundFunction(callExpression, sourceCode) {
 		const callbackParentheses = getParentheses(callback, sourceCode);
 		const isParenthesized = callbackParentheses.length > 0;
 		const callbackLastToken = isParenthesized
-			? callbackParentheses[callbackParentheses.length - 1]
+			? callbackParentheses.at(-1)
 			: callback;
 		if (
 			!isParenthesized

package/rules/no-console-spaces.js

@@ -11,7 +11,7 @@ const messages = {
 const hasLeadingSpace = value => value.length > 1 && value.charAt(0) === ' ' && value.charAt(1) !== ' ';
 
 // Find exactly one trailing space, allow exactly one space
-const hasTrailingSpace = value => value.length > 1 && value.charAt(value.length - 1) === ' ' && value.charAt(value.length - 2) !== ' ';
+const hasTrailingSpace = value => value.length > 1 && value.at(-1) === ' ' && value.at(-2) !== ' ';
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {

package/rules/no-empty-file.js

@@ -6,7 +6,7 @@ const messages = {
 	[MESSAGE_ID]: 'Empty files are not allowed.',
 };
 
-const isDirective = node => node.type === 'ExpressionStatement' && 'directive' in node;
+const isDirective = node => node.type === 'ExpressionStatement' && typeof node.directive === 'string';
 const isEmpty = node => isEmptyNode(node, isDirective);
 
 const isTripleSlashDirective = node =>

package/rules/no-hex-escape.js

@@ -8,7 +8,7 @@ const messages = {
 };
 
 function checkEscape(context, node, value) {
-	const fixedValue = value.replace(/(?<=(?:^|[^\\])(?:\\\\)*\\)x/g, 'u00');
+	const fixedValue = value.replaceAll(/(?<=(?:^|[^\\])(?:\\\\)*\\)x/g, 'u00');
 
 	if (value !== fixedValue) {
 		return {

package/rules/no-unnecessary-await.js

@@ -30,7 +30,7 @@ function notPromise(node) {
 		}
 
 		case 'SequenceExpression': {
-			return notPromise(node.expressions[node.expressions.length - 1]);
+			return notPromise(node.expressions.at(-1));
 		}
 
 		// No default

package/rules/no-useless-switch-case.js

@@ -25,7 +25,7 @@ const create = context => ({
 		const [defaultCase] = defaultCases;
 
 		// We only check cases where the last case is the `default` case
-		if (defaultCase !== cases[cases.length - 1]) {
+		if (defaultCase !== cases.at(-1)) {
 			return;
 		}
 

package/rules/no-useless-undefined.js

@@ -236,7 +236,7 @@ const create = context => {
 		}
 
 		const firstUndefined = undefinedArguments[0];
-		const lastUndefined = undefinedArguments[undefinedArguments.length - 1];
+		const lastUndefined = undefinedArguments.at(-1);
 
 		return {
 			messageId,

package/rules/no-zero-fractions.js

@@ -28,7 +28,7 @@ const create = context => ({
 		}
 
 		const {before, dotAndFractions, after} = match.groups;
-		const fixedDotAndFractions = dotAndFractions.replace(/[.0_]+$/g, '');
+		const fixedDotAndFractions = dotAndFractions.replaceAll(/[.0_]+$/g, '');
 		const formatted = ((before + fixedDotAndFractions) || '0') + after;
 
 		if (formatted === raw) {

package/rules/numeric-separators-style.js

@@ -111,7 +111,7 @@ const create = context => {
 				suffix = 'n';
 			}
 
-			const strippedNumber = number.replace(/_/g, '');
+			const strippedNumber = number.replaceAll('_', '');
 			const {prefix, data} = numeric.getPrefix(strippedNumber);
 
 			const {onlyIfContainsSeparator} = options[prefix.toLowerCase()];

package/rules/prefer-default-parameters.js

@@ -72,7 +72,7 @@ const hasExtraReferences = (assignment, references, left) => {
 };
 
 const isLastParameter = (parameters, parameter) => {
-	const lastParameter = parameters[parameters.length - 1];
+	const lastParameter = parameters.at(-1);
 
 	// See 'default-param-last' rule
 	return parameter && parameter === lastParameter;
@@ -122,7 +122,7 @@ const create = context => {
 	const functionStack = [];
 
 	const checkExpression = (node, left, right, assignment) => {
-		const currentFunction = functionStack[functionStack.length - 1];
+		const currentFunction = functionStack.at(-1);
 
 		if (!currentFunction || !isDefaultExpression(left, right)) {
 			return;