eslint-plugin-unicorn 58.0.0 → 59.0.0

package/index.js

@@ -9,6 +9,14 @@ const deprecatedRules = createDeprecatedRules({
 		message: 'Replaced by `unicorn/no-instanceof-builtins` which covers more cases.',
 		replacedBy: ['unicorn/no-instanceof-builtins'],
 	},
+	'no-length-as-slice-end': {
+		message: 'Replaced by `unicorn/no-unnecessary-slice-end` which covers more cases.',
+		replacedBy: ['unicorn/no-unnecessary-slice-end'],
+	},
+	'no-array-push-push': {
+		message: 'Replaced by `unicorn/prefer-single-call` which covers more cases.',
+		replacedBy: ['unicorn/prefer-single-call'],
+	},
 });
 
 const externalRules = {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "58.0.0",
+	"version": "59.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -64,12 +64,12 @@
 		"clean-regexp": "^1.0.0",
 		"core-js-compat": "^3.41.0",
 		"esquery": "^1.6.0",
+		"find-up-simple": "^1.0.1",
 		"globals": "^16.0.0",
 		"indent-string": "^5.0.0",
 		"is-builtin-module": "^5.0.0",
 		"jsesc": "^3.1.0",
 		"pluralize": "^8.0.0",
-		"read-package-up": "^11.0.0",
 		"regexp-tree": "^0.1.27",
 		"regjsparser": "^0.12.0",
 		"semver": "^7.7.1",

package/readme.md

@@ -79,7 +79,6 @@ export default [
 | [no-array-callback-reference](docs/rules/no-array-callback-reference.md)                         | Prevent passing a function reference directly to iterator methods.                                                                                                                                                | ✅  |    | 💡 |
 | [no-array-for-each](docs/rules/no-array-for-each.md)                                             | Prefer `for…of` over the `forEach` method.                                                                                                                                                                        | ✅  | 🔧 | 💡 |
 | [no-array-method-this-argument](docs/rules/no-array-method-this-argument.md)                     | Disallow using the `this` argument in array methods.                                                                                                                                                              | ✅  | 🔧 | 💡 |
-| [no-array-push-push](docs/rules/no-array-push-push.md)                                           | Enforce combining multiple `Array#push()` into one call.                                                                                                                                                          | ✅  | 🔧 | 💡 |
 | [no-array-reduce](docs/rules/no-array-reduce.md)                                                 | Disallow `Array#reduce()` and `Array#reduceRight()`.                                                                                                                                                              | ✅  |    |    |
 | [no-await-expression-member](docs/rules/no-await-expression-member.md)                           | Disallow member access from await expression.                                                                                                                                                                     | ✅  | 🔧 |    |
 | [no-await-in-promise-methods](docs/rules/no-await-in-promise-methods.md)                         | Disallow using `await` in `Promise` method parameters.                                                                                                                                                            | ✅  |    | 💡 |
@@ -92,7 +91,6 @@ export default [
 | [no-invalid-fetch-options](docs/rules/no-invalid-fetch-options.md)                               | Disallow invalid options in `fetch()` and `new Request()`.                                                                                                                                                        | ✅  |    |    |
 | [no-invalid-remove-event-listener](docs/rules/no-invalid-remove-event-listener.md)               | Prevent calling `EventTarget#removeEventListener()` with the result of an expression.                                                                                                                             | ✅  |    |    |
 | [no-keyword-prefix](docs/rules/no-keyword-prefix.md)                                             | Disallow identifiers starting with `new` or `class`.                                                                                                                                                              |    |    |    |
-| [no-length-as-slice-end](docs/rules/no-length-as-slice-end.md)                                   | Disallow using `.length` as the `end` argument of `{Array,String,TypedArray}#slice()`.                                                                                                                            | ✅  | 🔧 |    |
 | [no-lonely-if](docs/rules/no-lonely-if.md)                                                       | Disallow `if` statements as the only statement in `if` blocks without `else`.                                                                                                                                     | ✅  | 🔧 |    |
 | [no-magic-array-flat-depth](docs/rules/no-magic-array-flat-depth.md)                             | Disallow a magic number as the `depth` argument in `Array#flat(…).`                                                                                                                                               | ✅  |    |    |
 | [no-named-default](docs/rules/no-named-default.md)                                               | Disallow named usage of default import and export.                                                                                                                                                                | ✅  | 🔧 |    |
@@ -109,8 +107,11 @@ export default [
 | [no-thenable](docs/rules/no-thenable.md)                                                         | Disallow `then` property.                                                                                                                                                                                         | ✅  |    |    |
 | [no-this-assignment](docs/rules/no-this-assignment.md)                                           | Disallow assigning `this` to a variable.                                                                                                                                                                          | ✅  |    |    |
 | [no-typeof-undefined](docs/rules/no-typeof-undefined.md)                                         | Disallow comparing `undefined` using `typeof`.                                                                                                                                                                    | ✅  | 🔧 | 💡 |
+| [no-unnecessary-array-flat-depth](docs/rules/no-unnecessary-array-flat-depth.md)                 | Disallow using `1` as the `depth` argument of `Array#flat()`.                                                                                                                                                     | ✅  | 🔧 |    |
+| [no-unnecessary-array-splice-count](docs/rules/no-unnecessary-array-splice-count.md)             | Disallow using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#{splice,toSpliced}()`.                                                                                              | ✅  | 🔧 |    |
 | [no-unnecessary-await](docs/rules/no-unnecessary-await.md)                                       | Disallow awaiting non-promise values.                                                                                                                                                                             | ✅  | 🔧 |    |
 | [no-unnecessary-polyfills](docs/rules/no-unnecessary-polyfills.md)                               | Enforce the use of built-in methods instead of unnecessary polyfills.                                                                                                                                             | ✅  |    |    |
+| [no-unnecessary-slice-end](docs/rules/no-unnecessary-slice-end.md)                               | Disallow using `.length` or `Infinity` as the `end` argument of `{Array,String,TypedArray}#slice()`.                                                                                                              | ✅  | 🔧 |    |
 | [no-unreadable-array-destructuring](docs/rules/no-unreadable-array-destructuring.md)             | Disallow unreadable array destructuring.                                                                                                                                                                          | ✅  | 🔧 |    |
 | [no-unreadable-iife](docs/rules/no-unreadable-iife.md)                                           | Disallow unreadable IIFEs.                                                                                                                                                                                        | ✅  |    |    |
 | [no-unused-properties](docs/rules/no-unused-properties.md)                                       | Disallow unused object properties.                                                                                                                                                                                |    |    |    |
@@ -141,6 +142,7 @@ export default [
 | [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-global-this](docs/rules/prefer-global-this.md)                                           | Prefer `globalThis` over `window`, `self`, and `global`.                                                                                                                                                          | ✅  | 🔧 |    |
+| [prefer-import-meta-properties](docs/rules/prefer-import-meta-properties.md)                     | Prefer `import.meta.{dirname,filename}` over legacy techniques for getting file paths.                                                                                                                            |    | 🔧 |    |
 | [prefer-includes](docs/rules/prefer-includes.md)                                                 | Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence.                                                                                        | ✅  | 🔧 | 💡 |
 | [prefer-json-parse-buffer](docs/rules/prefer-json-parse-buffer.md)                               | Prefer reading a JSON file as a buffer.                                                                                                                                                                           |    | 🔧 |    |
 | [prefer-keyboard-event-key](docs/rules/prefer-keyboard-event-key.md)                             | Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.                                                                                                                                                          | ✅  | 🔧 |    |
@@ -162,6 +164,7 @@ export default [
 | [prefer-regexp-test](docs/rules/prefer-regexp-test.md)                                           | Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`.                                                                                                                                                 | ✅  | 🔧 | 💡 |
 | [prefer-set-has](docs/rules/prefer-set-has.md)                                                   | Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.                                                                                                                          | ✅  | 🔧 | 💡 |
 | [prefer-set-size](docs/rules/prefer-set-size.md)                                                 | Prefer using `Set#size` instead of `Array#length`.                                                                                                                                                                | ✅  | 🔧 |    |
+| [prefer-single-call](docs/rules/prefer-single-call.md)                                           | Enforce combining multiple `Array#push()`, `Element#classList.{add,remove}()`, and `importScripts()` into one call.                                                                                               | ✅  | 🔧 | 💡 |
 | [prefer-spread](docs/rules/prefer-spread.md)                                                     | Prefer the spread operator over `Array.from(…)`, `Array#concat(…)`, `Array#{slice,toSpliced}()` and `String#split('')`.                                                                                           | ✅  | 🔧 | 💡 |
 | [prefer-string-raw](docs/rules/prefer-string-raw.md)                                             | Prefer using the `String.raw` tag to avoid escaping `\`.                                                                                                                                                          | ✅  | 🔧 |    |
 | [prefer-string-replace-all](docs/rules/prefer-string-replace-all.md)                             | Prefer `String#replaceAll()` over regex searches with the global flag.                                                                                                                                            | ✅  | 🔧 |    |
@@ -186,9 +189,9 @@ export default [
 
 <!-- end auto-generated rules list -->
 
-### Deprecated Rules
+### Deleted and deprecated rules
 
-See [docs/deprecated-rules.md](docs/deprecated-rules.md)
+See [the list](docs/deleted-and-deprecated-rules.md).
 
 ## Preset configs
 

package/rules/empty-brace-spaces.js

@@ -7,10 +7,7 @@ const messages = {
 
 const getProblem = (node, context) => {
 	const {sourceCode} = context;
-	const filter = node.type === 'RecordExpression'
-		? token => token.type === 'Punctuator' && (token.value === '#{' || token.value === '{|')
-		: isOpeningBraceToken;
-	const openingBrace = sourceCode.getFirstToken(node, {filter});
+	const openingBrace = sourceCode.getFirstToken(node, {filter: isOpeningBraceToken});
 	const closingBrace = sourceCode.getLastToken(node);
 	const [, start] = sourceCode.getRange(openingBrace);
 	const [end] = sourceCode.getRange(closingBrace);
@@ -36,20 +33,11 @@ const create = context => {
 		'BlockStatement',
 		'ClassBody',
 		'StaticBlock',
-	], node => {
-		if (node.body.length > 0) {
-			return;
-		}
-
-		return getProblem(node, context);
-	});
-
-	context.on([
 		'ObjectExpression',
-		// Experimental https://github.com/tc39/proposal-record-tuple
-		'RecordExpression',
 	], node => {
-		if (node.properties.length > 0) {
+		const children = node.type === 'ObjectExpression' ? node.properties : node.body;
+
+		if (children.length > 0) {
 			return;
 		}
 

package/rules/expiring-todo-comments.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
 import {isRegExp} from 'node:util/types';
-import {readPackageUpSync} from 'read-package-up';
 import semver from 'semver';
 import * as ci from 'ci-info';
 import getBuiltinRule from './utils/get-builtin-rule.js';
+import {readPackageJson} from './shared/package-json.js';
 
 const baseRule = getBuiltinRule('no-warning-comments');
 
@@ -50,20 +50,9 @@ const messages = {
 
 /** @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 = readPackageUpSync({normalize: false, cwd: dirname});
-	} catch {
-		// This can happen if package.json files have comments in them etc.
-		packageResult = undefined;
-	}
-
-	const hasPackage = Boolean(packageResult);
-	const packageJson = packageResult ? packageResult.packageJson : {};
+	const packageJsonResult = readPackageJson(dirname);
+	const packageJson = packageJsonResult?.packageJson ?? {};
+	const hasPackage = Boolean(packageJsonResult);
 
 	const packageDependencies = {
 		...packageJson.dependencies,
@@ -187,7 +176,7 @@ function getPackageHelpers(dirname) {
 	}
 
 	return {
-		packageResult,
+		packageResult: packageJsonResult,
 		hasPackage,
 		packageJson,
 		packageDependencies,

package/rules/index.js

@@ -24,7 +24,6 @@ import noAnonymousDefaultExport from './no-anonymous-default-export.js';
 import noArrayCallbackReference from './no-array-callback-reference.js';
 import noArrayForEach from './no-array-for-each.js';
 import noArrayMethodThisArgument from './no-array-method-this-argument.js';
-import noArrayPushPush from './no-array-push-push.js';
 import noArrayReduce from './no-array-reduce.js';
 import noAwaitExpressionMember from './no-await-expression-member.js';
 import noAwaitInPromiseMethods from './no-await-in-promise-methods.js';
@@ -37,7 +36,6 @@ import noInstanceofBuiltins from './no-instanceof-builtins.js';
 import noInvalidFetchOptions from './no-invalid-fetch-options.js';
 import noInvalidRemoveEventListener from './no-invalid-remove-event-listener.js';
 import noKeywordPrefix from './no-keyword-prefix.js';
-import noLengthAsSliceEnd from './no-length-as-slice-end.js';
 import noLonelyIf from './no-lonely-if.js';
 import noMagicArrayFlatDepth from './no-magic-array-flat-depth.js';
 import noNamedDefault from './no-named-default.js';
@@ -54,8 +52,11 @@ import noStaticOnlyClass from './no-static-only-class.js';
 import noThenable from './no-thenable.js';
 import noThisAssignment from './no-this-assignment.js';
 import noTypeofUndefined from './no-typeof-undefined.js';
+import noUnnecessaryArrayFlatDepth from './no-unnecessary-array-flat-depth.js';
+import noUnnecessaryArraySpliceCount from './no-unnecessary-array-splice-count.js';
 import noUnnecessaryAwait from './no-unnecessary-await.js';
 import noUnnecessaryPolyfills from './no-unnecessary-polyfills.js';
+import noUnnecessarySliceEnd from './no-unnecessary-slice-end.js';
 import noUnreadableArrayDestructuring from './no-unreadable-array-destructuring.js';
 import noUnreadableIife from './no-unreadable-iife.js';
 import noUnusedProperties from './no-unused-properties.js';
@@ -86,6 +87,7 @@ import preferDomNodeTextContent from './prefer-dom-node-text-content.js';
 import preferEventTarget from './prefer-event-target.js';
 import preferExportFrom from './prefer-export-from.js';
 import preferGlobalThis from './prefer-global-this.js';
+import preferImportMetaProperties from './prefer-import-meta-properties.js';
 import preferIncludes from './prefer-includes.js';
 import preferJsonParseBuffer from './prefer-json-parse-buffer.js';
 import preferKeyboardEventKey from './prefer-keyboard-event-key.js';
@@ -107,6 +109,7 @@ import preferReflectApply from './prefer-reflect-apply.js';
 import preferRegexpTest from './prefer-regexp-test.js';
 import preferSetHas from './prefer-set-has.js';
 import preferSetSize from './prefer-set-size.js';
+import preferSingleCall from './prefer-single-call.js';
 import preferSpread from './prefer-spread.js';
 import preferStringRaw from './prefer-string-raw.js';
 import preferStringReplaceAll from './prefer-string-replace-all.js';
@@ -153,7 +156,6 @@ const rules = {
 	'no-array-callback-reference': createRule(noArrayCallbackReference, 'no-array-callback-reference'),
 	'no-array-for-each': createRule(noArrayForEach, 'no-array-for-each'),
 	'no-array-method-this-argument': createRule(noArrayMethodThisArgument, 'no-array-method-this-argument'),
-	'no-array-push-push': createRule(noArrayPushPush, 'no-array-push-push'),
 	'no-array-reduce': createRule(noArrayReduce, 'no-array-reduce'),
 	'no-await-expression-member': createRule(noAwaitExpressionMember, 'no-await-expression-member'),
 	'no-await-in-promise-methods': createRule(noAwaitInPromiseMethods, 'no-await-in-promise-methods'),
@@ -166,7 +168,6 @@ const rules = {
 	'no-invalid-fetch-options': createRule(noInvalidFetchOptions, 'no-invalid-fetch-options'),
 	'no-invalid-remove-event-listener': createRule(noInvalidRemoveEventListener, 'no-invalid-remove-event-listener'),
 	'no-keyword-prefix': createRule(noKeywordPrefix, 'no-keyword-prefix'),
-	'no-length-as-slice-end': createRule(noLengthAsSliceEnd, 'no-length-as-slice-end'),
 	'no-lonely-if': createRule(noLonelyIf, 'no-lonely-if'),
 	'no-magic-array-flat-depth': createRule(noMagicArrayFlatDepth, 'no-magic-array-flat-depth'),
 	'no-named-default': createRule(noNamedDefault, 'no-named-default'),
@@ -183,8 +184,11 @@ const rules = {
 	'no-thenable': createRule(noThenable, 'no-thenable'),
 	'no-this-assignment': createRule(noThisAssignment, 'no-this-assignment'),
 	'no-typeof-undefined': createRule(noTypeofUndefined, 'no-typeof-undefined'),
+	'no-unnecessary-array-flat-depth': createRule(noUnnecessaryArrayFlatDepth, 'no-unnecessary-array-flat-depth'),
+	'no-unnecessary-array-splice-count': createRule(noUnnecessaryArraySpliceCount, 'no-unnecessary-array-splice-count'),
 	'no-unnecessary-await': createRule(noUnnecessaryAwait, 'no-unnecessary-await'),
 	'no-unnecessary-polyfills': createRule(noUnnecessaryPolyfills, 'no-unnecessary-polyfills'),
+	'no-unnecessary-slice-end': createRule(noUnnecessarySliceEnd, 'no-unnecessary-slice-end'),
 	'no-unreadable-array-destructuring': createRule(noUnreadableArrayDestructuring, 'no-unreadable-array-destructuring'),
 	'no-unreadable-iife': createRule(noUnreadableIife, 'no-unreadable-iife'),
 	'no-unused-properties': createRule(noUnusedProperties, 'no-unused-properties'),
@@ -215,6 +219,7 @@ const rules = {
 	'prefer-event-target': createRule(preferEventTarget, 'prefer-event-target'),
 	'prefer-export-from': createRule(preferExportFrom, 'prefer-export-from'),
 	'prefer-global-this': createRule(preferGlobalThis, 'prefer-global-this'),
+	'prefer-import-meta-properties': createRule(preferImportMetaProperties, 'prefer-import-meta-properties'),
 	'prefer-includes': createRule(preferIncludes, 'prefer-includes'),
 	'prefer-json-parse-buffer': createRule(preferJsonParseBuffer, 'prefer-json-parse-buffer'),
 	'prefer-keyboard-event-key': createRule(preferKeyboardEventKey, 'prefer-keyboard-event-key'),
@@ -236,6 +241,7 @@ const rules = {
 	'prefer-regexp-test': createRule(preferRegexpTest, 'prefer-regexp-test'),
 	'prefer-set-has': createRule(preferSetHas, 'prefer-set-has'),
 	'prefer-set-size': createRule(preferSetSize, 'prefer-set-size'),
+	'prefer-single-call': createRule(preferSingleCall, 'prefer-single-call'),
 	'prefer-spread': createRule(preferSpread, 'prefer-spread'),
 	'prefer-string-raw': createRule(preferStringRaw, 'prefer-string-raw'),
 	'prefer-string-replace-all': createRule(preferStringReplaceAll, 'prefer-string-replace-all'),

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

@@ -0,0 +1,50 @@
+import {isMethodCall, isLiteral} from './ast/index.js';
+import {removeArgument} from './fix/index.js';
+import {} from './utils/index.js';
+
+const MESSAGE_ID = 'no-unnecessary-array-flat-depth';
+const messages = {
+	[MESSAGE_ID]: 'Passing `1` as the `depth` argument is unnecessary.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('CallExpression', callExpression => {
+		if (!(
+			isMethodCall(callExpression, {
+				method: 'flat',
+				argumentsLength: 1,
+				optionalCall: false,
+			})
+			&& isLiteral(callExpression.arguments[0], 1)
+		)) {
+			return;
+		}
+
+		const [numberOne] = callExpression.arguments;
+
+		return {
+			node: numberOne,
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => removeArgument(fixer, numberOne, context.sourceCode),
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow using `1` as the `depth` argument of `Array#flat()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+
+		messages,
+	},
+};
+
+export default config;

package/rules/no-unnecessary-array-splice-count.js

@@ -0,0 +1,23 @@
+import {listen} from './shared/no-unnecessary-length-or-infinity-rule.js';
+
+const MESSAGE_ID = 'no-unnecessary-array-splice-count';
+const messages = {
+	[MESSAGE_ID]: 'Passing `{{description}}` as the `{{argumentName}}` argument is unnecessary.',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create: context => listen(context, {methods: ['splice', 'toSpliced'], messageId: MESSAGE_ID}),
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#{splice,toSpliced}()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+
+		messages,
+	},
+};
+
+export default config;

package/rules/no-unnecessary-polyfills.js

@@ -1,8 +1,8 @@
 import path from 'node:path';
-import {readPackageUpSync} from 'read-package-up';
 import coreJsCompat from 'core-js-compat';
 import {camelCase} from './utils/lodash.js';
 import isStaticRequire from './ast/is-static-require.js';
+import {readPackageJson} from './shared/package-json.js';
 
 const {data: compatData, entries: coreJsEntries} = coreJsCompat;
 
@@ -57,18 +57,13 @@ function getTargets(options, dirname) {
 		return options.targets;
 	}
 
-	/** @type {readPkgUp.ReadResult | undefined} */
-	let packageResult;
-	try {
-		// It can fail if, for example, the package.json file has comments.
-		packageResult = readPackageUpSync({normalize: false, cwd: dirname});
-	} catch {}
+	const packageJsonResult = readPackageJson(dirname);
 
-	if (!packageResult) {
+	if (!packageJsonResult) {
 		return;
 	}
 
-	const {browserslist, engines} = packageResult.packageJson;
+	const {browserslist, engines} = packageJsonResult.packageJson;
 	return browserslist ?? engines;
 }
 

package/rules/no-unnecessary-slice-end.js

@@ -0,0 +1,22 @@
+import {listen} from './shared/no-unnecessary-length-or-infinity-rule.js';
+
+const MESSAGE_ID = 'no-unnecessary-slice-end';
+const messages = {
+	[MESSAGE_ID]: 'Passing `{{description}}` as the `end` argument is unnecessary.',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create: context => listen(context, {methods: ['slice'], messageId: MESSAGE_ID}),
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow using `.length` or `Infinity` as the `end` argument of `{Array,String,TypedArray}#slice()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/rules/prefer-import-meta-properties.js

@@ -0,0 +1,320 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	isMemberExpression,
+	isCallExpression,
+	isNewExpression,
+	isMethodCall,
+} from './ast/index.js';
+
+const ERROR_DIRNAME = 'error/calculate-dirname';
+const ERROR_FILENAME = 'error/calculate-filename';
+const messages = {
+	[ERROR_DIRNAME]: 'Do not construct dirname.',
+	[ERROR_FILENAME]: 'Do not construct filename using `fileURLToPath()`.',
+};
+
+const isParentLiteral = node => {
+	if (node?.type !== 'Literal') {
+		return false;
+	}
+
+	return node.value === '.' || node.value === './';
+};
+
+const isImportMeta = node =>
+	node.type === 'MetaProperty'
+	&& node.meta.name === 'import'
+	&& node.property.name === 'meta';
+
+function isNodeBuiltinModuleFunctionCall(node, {modules, functionName, sourceCode}) {
+	if (!isCallExpression(node, {optional: false, argumentsLength: 1})) {
+		return false;
+	}
+
+	const visited = new Set();
+
+	return checkExpression(node.callee, 'property');
+
+	/** @param {import('estree').Expression} node */
+	function checkExpression(node, checkKind) {
+		if (node.type === 'MemberExpression') {
+			if (!(
+				checkKind === 'property'
+				&& isMemberExpression(node, {property: functionName, computed: false, optional: false})
+			)) {
+				return false;
+			}
+
+			return checkExpression(node.object, 'module');
+		}
+
+		if (node.type === 'CallExpression') {
+			if (checkKind !== 'module') {
+				return false;
+			}
+
+			// `process.getBuiltinModule('x')`
+			return (
+				isMethodCall(node, {
+					object: 'process',
+					method: 'getBuiltinModule',
+					argumentsLength: 1,
+					optionalMember: false,
+					optionalCall: false,
+				})
+				&& isModuleLiteral(node.arguments[0])
+			);
+		}
+
+		if (node.type !== 'Identifier') {
+			return false;
+		}
+
+		if (visited.has(node)) {
+			return false;
+		}
+
+		visited.add(node);
+
+		const variable = findVariable(sourceCode.getScope(node), node);
+		if (!variable || variable.defs.length !== 1) {
+			return;
+		}
+
+		return checkDefinition(variable.defs[0], checkKind);
+	}
+
+	/** @param {import('eslint').Scope.Definition} define */
+	function checkDefinition(define, checkKind) {
+		if (define.type === 'ImportBinding') {
+			if (!isModuleLiteral(define.parent.source)) {
+				return false;
+			}
+
+			const specifier = define.node;
+			return checkKind === 'module'
+				? (specifier?.type === 'ImportDefaultSpecifier' || specifier?.type === 'ImportNamespaceSpecifier')
+				: (specifier?.type === 'ImportSpecifier' && specifier.imported.name === functionName);
+		}
+
+		return define.type === 'Variable' && checkPattern(define.name, checkKind);
+	}
+
+	/** @param {import('estree').Identifier | import('estree').ObjectPattern} node */
+	function checkPattern(node, checkKind) {
+		/** @type {{parent?: import('estree').Node}} */
+		const {parent} = node;
+		if (parent.type === 'VariableDeclarator') {
+			if (
+				!parent.init
+				|| parent.id !== node
+				|| parent.parent.type !== 'VariableDeclaration'
+				|| parent.parent.kind !== 'const'
+			) {
+				return false;
+			}
+
+			return checkExpression(parent.init, checkKind);
+		}
+
+		if (parent.type === 'Property') {
+			if (!(
+				checkKind === 'property'
+				&& parent.value === node
+				&& !parent.computed
+				&& parent.key.type === 'Identifier'
+				&& parent.key.name === functionName
+			)) {
+				return false;
+			}
+
+			// Check for ObjectPattern
+			return checkPattern(parent.parent, 'module');
+		}
+
+		return false;
+	}
+
+	function isModuleLiteral(node) {
+		return node?.type === 'Literal' && modules.has(node.value);
+	}
+}
+
+/**
+@returns {node is import('estree').SimpleCallExpression}
+*/
+function isUrlFileURLToPathCall(node, sourceCode) {
+	return isNodeBuiltinModuleFunctionCall(node, {
+		modules: new Set(['url', 'node:url']),
+		functionName: 'fileURLToPath',
+		sourceCode,
+	});
+}
+
+/**
+@returns {node is import('estree').SimpleCallExpression}
+*/
+function isPathDirnameCall(node, sourceCode) {
+	return isNodeBuiltinModuleFunctionCall(node, {
+		modules: new Set(['path', 'node:path']),
+		functionName: 'dirname',
+		sourceCode,
+	});
+}
+
+function create(context) {
+	const {sourceCode} = context;
+
+	context.on('MetaProperty', function * (node) {
+		if (!isImportMeta(node)) {
+			return;
+		}
+
+		/** @type {import('estree').Node} */
+		const memberExpression = node.parent;
+		if (!isMemberExpression(memberExpression, {
+			properties: ['url', 'filename'],
+			computed: false,
+			optional: false,
+		})) {
+			return;
+		}
+
+		const propertyName = memberExpression.property.name;
+		if (propertyName === 'url') {
+			// `url.fileURLToPath(import.meta.url)`
+			if (
+				isUrlFileURLToPathCall(memberExpression.parent, sourceCode)
+				&& memberExpression.parent.arguments[0] === memberExpression
+			) {
+				yield * iterateProblemsFromFilename(memberExpression.parent, {
+					reportFilenameNode: true,
+				});
+				return;
+			}
+
+			// `new URL(import.meta.url)`
+			// `new URL('.', import.meta.url)`
+			// `new URL('./', import.meta.url)`
+			if (isNewExpression(memberExpression.parent, {name: 'URL', minimumArguments: 1, maximumArguments: 2})) {
+				const newUrl = memberExpression.parent;
+				const urlParent = newUrl.parent;
+
+				// `new URL(import.meta.url)`
+				if (
+					newUrl.arguments.length === 1
+					&& newUrl.arguments[0] === memberExpression
+					// `url.fileURLToPath(new URL(import.meta.url))`
+					&& isUrlFileURLToPathCall(urlParent, sourceCode)
+					&& urlParent.arguments[0] === newUrl
+				) {
+					yield * iterateProblemsFromFilename(urlParent, {
+						reportFilenameNode: true,
+					});
+					return;
+				}
+
+				// `url.fileURLToPath(new URL(".", import.meta.url))`
+				// `url.fileURLToPath(new URL("./", import.meta.url))`
+				if (
+					newUrl.arguments.length === 2
+					&& isParentLiteral(newUrl.arguments[0])
+					&& newUrl.arguments[1] === memberExpression
+					&& isUrlFileURLToPathCall(urlParent, sourceCode)
+					&& urlParent.arguments[0] === newUrl
+				) {
+					yield getProblem(urlParent, 'dirname');
+				}
+			}
+
+			return;
+		}
+
+		if (propertyName === 'filename') {
+			yield * iterateProblemsFromFilename(memberExpression);
+		}
+
+		/**
+		Iterates over reports where a given filename expression node
+		would be used to convert it to a dirname.
+		@param { import('estree').Expression} node
+		*/
+		function * iterateProblemsFromFilename(node, {reportFilenameNode = false} = {}) {
+			/** @type {{parent: import('estree').Node}} */
+			const {parent} = node;
+
+			// `path.dirname(filename)`
+			if (
+				isPathDirnameCall(parent, sourceCode)
+				&& parent.arguments[0] === node
+			) {
+				yield getProblem(parent, 'dirname');
+				return;
+			}
+
+			if (reportFilenameNode) {
+				yield getProblem(node, 'filename');
+			}
+
+			if (
+				parent.type !== 'VariableDeclarator'
+				|| parent.init !== node
+				|| parent.id.type !== 'Identifier'
+				|| parent.parent.type !== 'VariableDeclaration'
+				|| parent.parent.kind !== 'const'
+			) {
+				return;
+			}
+
+			/** @type {import('eslint').Scope.Variable|null} */
+			const variable = findVariable(sourceCode.getScope(parent.id), parent.id);
+			if (!variable) {
+				return;
+			}
+
+			for (const reference of variable.references) {
+				if (!reference.isReadOnly()) {
+					continue;
+				}
+
+				/** @type {{parent: import('estree').Node}} */
+				const {parent} = reference.identifier;
+				if (
+					isPathDirnameCall(parent, sourceCode)
+					&& parent.arguments[0] === reference.identifier
+				) {
+					// Report `path.dirname(identifier)`
+					yield getProblem(parent, 'dirname');
+				}
+			}
+		}
+
+		/**
+		@param { import('estree').Node} node
+		@param {'dirname' | 'filename'} name
+		*/
+		function getProblem(node, name) {
+			return {
+				node,
+				messageId: name === 'dirname' ? ERROR_DIRNAME : ERROR_FILENAME,
+				fix: fixer => fixer.replaceText(node, `import.meta.${name}`),
+			};
+		}
+	});
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `import.meta.{dirname,filename}` over legacy techniques for getting file paths.',
+			recommended: false,
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/rules/prefer-node-protocol.js

@@ -1,5 +1,8 @@
 import isBuiltinModule from 'is-builtin-module';
-import isStaticRequire from './ast/is-static-require.js';
+import {
+	isStaticRequire,
+	isMethodCall,
+} from './ast/index.js';
 
 const MESSAGE_ID = 'prefer-node-protocol';
 const messages = {
@@ -19,7 +22,16 @@ const create = context => ({
 				&& node.parent.source === node
 			)
 			|| (
-				isStaticRequire(node.parent)
+				(
+					isMethodCall(node.parent, {
+						object: 'process',
+						method: 'getBuiltinModule',
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+					|| isStaticRequire(node.parent)
+				)
 				&& node.parent.arguments[0] === node
 			)
 		)) {

package/rules/prefer-single-call.js

@@ -0,0 +1,179 @@
+import {hasSideEffect, isSemicolonToken} from '@eslint-community/eslint-utils';
+import {getCallExpressionTokens, getCallExpressionArgumentsText} from './utils/index.js';
+import isSameReference from './utils/is-same-reference.js';
+import {isNodeMatches} from './utils/is-node-matches.js';
+import getPreviousNode from './utils/get-previous-node.js';
+import {isMethodCall, isMemberExpression, isCallExpression} from './ast/index.js';
+
+const ERROR = 'error/array-push';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[ERROR]: 'Do not call `{{description}}` multiple times.',
+	[SUGGESTION]: 'Merge with previous one.',
+};
+
+const isExpressionStatement = node =>
+	node?.parent.type === 'ExpressionStatement'
+	&& node.parent.expression === node;
+const isClassList = node => isMemberExpression(node, {
+	property: 'classList',
+	optional: false,
+	computed: false,
+});
+
+const cases = [
+	{
+		description: 'Array#push()',
+		test: callExpression => isMethodCall(callExpression, {
+			method: 'push',
+			optionalCall: false,
+			optionalMember: false,
+		}),
+		ignore: [
+			'stream.push',
+			'this.push',
+			'this.stream.push',
+			'process.stdin.push',
+			'process.stdout.push',
+			'process.stderr.push',
+		],
+	},
+	{
+		description: 'Element#classList.add()',
+		test: callExpression =>
+			isMethodCall(callExpression, {
+				method: 'add',
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& isClassList(callExpression.callee.object),
+	},
+	{
+		description: 'Element#classList.remove()',
+		test: callExpression =>
+			isMethodCall(callExpression, {
+				method: 'remove',
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& isClassList(callExpression.callee.object),
+	},
+	{
+		description: 'importScripts()',
+		test: callExpression => isCallExpression(callExpression, {
+			name: 'importScripts',
+			optional: false,
+		}),
+	},
+].map(problematicalCase => ({
+	...problematicalCase,
+	test: callExpression => isExpressionStatement(callExpression) && problematicalCase.test(callExpression),
+}));
+
+function create(context) {
+	const {
+		ignore: ignoredCalleeInOptions,
+	} = {
+		ignore: [],
+		...context.options[0],
+	};
+	const {sourceCode} = context;
+
+	return {
+		* CallExpression(secondCall) {
+			for (const {description, test, ignore = []} of cases) {
+				if (!test(secondCall)) {
+					continue;
+				}
+
+				const ignoredCallee = [...ignore, ...ignoredCalleeInOptions];
+				if (isNodeMatches(secondCall.callee, ignoredCallee)) {
+					continue;
+				}
+
+				const firstCall = getPreviousNode(secondCall.parent, sourceCode)?.expression;
+				if (!test(firstCall) || !isSameReference(firstCall.callee, secondCall.callee)) {
+					continue;
+				}
+
+				const secondCallArguments = secondCall.arguments;
+				const problem = {
+					node: secondCall.callee.type === 'Identifier' ? secondCall.callee : secondCall.callee.property,
+					messageId: ERROR,
+					data: {description},
+				};
+
+				const fix = function * (fixer) {
+					if (secondCallArguments.length > 0) {
+						const text = getCallExpressionArgumentsText(sourceCode, secondCall);
+
+						const {
+							trailingCommaToken,
+							closingParenthesisToken,
+						} = getCallExpressionTokens(sourceCode, firstCall);
+
+						yield (
+							trailingCommaToken
+								? fixer.insertTextAfter(trailingCommaToken, ` ${text}`)
+								: fixer.insertTextBefore(closingParenthesisToken, firstCall.arguments.length > 0 ? `, ${text}` : text)
+						);
+					}
+
+					const firstExpression = firstCall.parent;
+					const secondExpression = secondCall.parent;
+					const shouldKeepSemicolon = !isSemicolonToken(sourceCode.getLastToken(firstExpression))
+						&& isSemicolonToken(sourceCode.getLastToken(secondExpression));
+					const [, start] = sourceCode.getRange(firstExpression);
+					const [, end] = sourceCode.getRange(secondExpression);
+
+					yield fixer.replaceTextRange([start, end], shouldKeepSemicolon ? ';' : '');
+				};
+
+				if (secondCallArguments.some(element => hasSideEffect(element, sourceCode))) {
+					problem.suggest = [
+						{
+							messageId: SUGGESTION,
+							fix,
+						},
+					];
+				} else {
+					problem.fix = fix;
+				}
+
+				yield problem;
+			}
+		},
+	};
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			ignore: {
+				type: 'array',
+				uniqueItems: true,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce combining multiple `Array#push()`, `Element#classList.{add,remove}()`, and `importScripts()` into one call.',
+			recommended: true,
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		defaultOptions: [{}],
+		messages,
+	},
+};
+
+export default config;

package/rules/shared/no-unnecessary-length-or-infinity-rule.js

@@ -0,0 +1,80 @@
+import {isMethodCall, isMemberExpression} from '../ast/index.js';
+import {isSameReference} from '../utils/index.js';
+import {removeArgument} from '../fix/index.js';
+
+function getObjectLengthOrInfinityDescription(node, object) {
+	// `Infinity`
+	if (node.type === 'Identifier' && node.name === 'Infinity') {
+		return 'Infinity';
+	}
+
+	// `Number.POSITIVE_INFINITY`
+	if (isMemberExpression(node, {
+		object: 'Number',
+		property: 'POSITIVE_INFINITY',
+		computed: false,
+		optional: false,
+	})) {
+		return 'Number.POSITIVE_INFINITY';
+	}
+
+	// `object?.length`
+	const isOptional = node.type === 'ChainExpression';
+	if (isOptional) {
+		node = node.expression;
+	}
+
+	// `object.length`
+	if (!(
+		isMemberExpression(node, {property: 'length', computed: false})
+		&& isSameReference(object, node.object)
+	)) {
+		return;
+	}
+
+	return `${object.type === 'Identifier' ? object.name : '…'}${isOptional ? '?.' : '.'}length`;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function listen(context, {methods, messageId}) {
+	context.on('CallExpression', callExpression => {
+		if (!isMethodCall(callExpression, {
+			methods,
+			argumentsLength: 2,
+			optionalCall: false,
+		})) {
+			return;
+		}
+
+		const secondArgument = callExpression.arguments[1];
+		const description = getObjectLengthOrInfinityDescription(
+			secondArgument,
+			callExpression.callee.object,
+		);
+
+		if (!description) {
+			return;
+		}
+
+		const methodName = callExpression.callee.property.name;
+		const messageData = {
+			description,
+		};
+
+		if (methodName === 'splice') {
+			messageData.argumentName = 'deleteCount';
+		} else if (methodName === 'toSpliced') {
+			messageData.argumentName = 'skipCount';
+		}
+
+		return {
+			node: secondArgument,
+			messageId,
+			data: messageData,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => removeArgument(fixer, secondArgument, context.sourceCode),
+		};
+	});
+}
+
+export {listen};

package/rules/shared/package-json.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import {findUpSync} from 'find-up-simple';
+
+const directoryCache = new Map();
+const dataCache = new Map();
+
+/**
+Finds the closest package.json file to the given directory and returns its path and contents.
+
+Caches the result for future lookups.
+
+@param dirname {string}
+@return {{ path: string, packageJson: Record<string, unknown> } | undefined}
+*/
+export function readPackageJson(dirname) {
+	let packageJsonPath;
+	if (directoryCache.has(dirname)) {
+		packageJsonPath = directoryCache.get(dirname);
+	} else {
+		packageJsonPath = findUpSync('package.json', {cwd: dirname, type: 'file'});
+		directoryCache.set(dirname, packageJsonPath);
+	}
+
+	if (!packageJsonPath) {
+		return;
+	}
+
+	let packageJson;
+	if (dataCache.has(packageJsonPath)) {
+		packageJson = dataCache.get(packageJsonPath);
+	} else {
+		try {
+			packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+			dataCache.set(packageJsonPath, packageJson);
+		} catch {
+			// This can happen if package.json files have comments in them etc.
+			return;
+		}
+	}
+
+	return {path: packageJsonPath, packageJson};
+}

package/rules/shared/typed-array.js

@@ -7,6 +7,7 @@ const typedArrayTypes = [
 	'Uint16Array',
 	'Int32Array',
 	'Uint32Array',
+	'Float16Array',
 	'Float32Array',
 	'Float64Array',
 	'BigInt64Array',

package/rules/no-array-push-push.js

@@ -1,150 +0,0 @@
-import {hasSideEffect, isSemicolonToken} from '@eslint-community/eslint-utils';
-import {getCallExpressionTokens, getCallExpressionArgumentsText} from './utils/index.js';
-import isSameReference from './utils/is-same-reference.js';
-import {isNodeMatches} from './utils/is-node-matches.js';
-import getPreviousNode from './utils/get-previous-node.js';
-import {isMethodCall} from './ast/index.js';
-
-const ERROR = 'error';
-const SUGGESTION = 'suggestion';
-const messages = {
-	[ERROR]: 'Do not call `Array#push()` multiple times.',
-	[SUGGESTION]: 'Merge with previous one.',
-};
-
-const isArrayPushCall = node =>
-	node
-	&& node.parent.type === 'ExpressionStatement'
-	&& node.parent.expression === node
-	&& isMethodCall(node, {
-		method: 'push',
-		optionalCall: false,
-		optionalMember: false,
-	});
-
-function getFirstArrayPushCall(secondCall, sourceCode) {
-	const firstCall = getPreviousNode(secondCall.parent, sourceCode)?.expression;
-	if (isArrayPushCall(firstCall)) {
-		return firstCall;
-	}
-}
-
-function create(context) {
-	const {ignore} = {
-		ignore: [],
-		...context.options[0],
-	};
-	const ignoredObjects = [
-		'stream',
-		'this',
-		'this.stream',
-		'process.stdin',
-		'process.stdout',
-		'process.stderr',
-		...ignore,
-	];
-	const {sourceCode} = context;
-
-	return {
-		CallExpression(secondCall) {
-			if (!isArrayPushCall(secondCall)) {
-				return;
-			}
-
-			const secondCallArray = secondCall.callee.object;
-
-			if (isNodeMatches(secondCallArray, ignoredObjects)) {
-				return;
-			}
-
-			const firstCall = getFirstArrayPushCall(secondCall, sourceCode);
-			if (!firstCall) {
-				return;
-			}
-
-			const firstCallArray = firstCall.callee.object;
-
-			// Not same array
-			if (!isSameReference(firstCallArray, secondCallArray)) {
-				return;
-			}
-
-			const secondCallArguments = secondCall.arguments;
-			const problem = {
-				node: secondCall.callee.property,
-				messageId: ERROR,
-			};
-
-			const fix = function * (fixer) {
-				if (secondCallArguments.length > 0) {
-					const text = getCallExpressionArgumentsText(sourceCode, secondCall);
-
-					const {
-						trailingCommaToken,
-						closingParenthesisToken,
-					} = getCallExpressionTokens(sourceCode, firstCall);
-
-					yield (
-						trailingCommaToken
-							? fixer.insertTextAfter(trailingCommaToken, ` ${text}`)
-							: fixer.insertTextBefore(closingParenthesisToken, firstCall.arguments.length > 0 ? `, ${text}` : text)
-					);
-				}
-
-				const firstExpression = firstCall.parent;
-				const secondExpression = secondCall.parent;
-				const shouldKeepSemicolon = !isSemicolonToken(sourceCode.getLastToken(firstExpression))
-					&& isSemicolonToken(sourceCode.getLastToken(secondExpression));
-				const [, start] = sourceCode.getRange(firstExpression);
-				const [, end] = sourceCode.getRange(secondExpression);
-
-				yield fixer.replaceTextRange([start, end], shouldKeepSemicolon ? ';' : '');
-			};
-
-			if (secondCallArguments.some(element => hasSideEffect(element, sourceCode))) {
-				problem.suggest = [
-					{
-						messageId: SUGGESTION,
-						fix,
-					},
-				];
-			} else {
-				problem.fix = fix;
-			}
-
-			return problem;
-		},
-	};
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			ignore: {
-				type: 'array',
-				uniqueItems: true,
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce combining multiple `Array#push()` into one call.',
-			recommended: true,
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;

package/rules/no-length-as-slice-end.js

@@ -1,54 +0,0 @@
-import {isMethodCall, isMemberExpression} from './ast/index.js';
-import {removeArgument} from './fix/index.js';
-import {isSameReference} from './utils/index.js';
-
-const MESSAGE_ID = 'no-length-as-slice-end';
-const messages = {
-	[MESSAGE_ID]: 'Passing `….length` as the `end` argument is unnecessary.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('CallExpression', callExpression => {
-		if (!isMethodCall(callExpression, {
-			method: 'slice',
-			argumentsLength: 2,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		const secondArgument = callExpression.arguments[1];
-		const node = secondArgument.type === 'ChainExpression' ? secondArgument.expression : secondArgument;
-
-		if (
-			!isMemberExpression(node, {property: 'length', computed: false})
-			|| !isSameReference(callExpression.callee.object, node.object)
-		) {
-			return;
-		}
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			fix: fixer => removeArgument(fixer, secondArgument, context.sourceCode),
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow using `.length` as the `end` argument of `{Array,String,TypedArray}#slice()`.',
-			recommended: true,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;