Enforce return statements in callbacks of array methods

Require `super()` calls in constructors

Enforce "for" loop update clause moving the counter in the right direction

Enforce `return` statements in getters

Disallow using an async function as a Promise executor

Disallow `await` inside of loops

Disallow reassigning class members

Disallow comparing against -0

Disallow assignment operators in conditional expressions

Disallow reassigning `const` variables

Disallow expressions where the operation doesn't affect the value

Disallow constant expressions in conditions

Disallow returning value from constructor

Disallow control characters in regular expressions

Disallow the use of `debugger`

Disallow duplicate arguments in `function` definitions

Disallow duplicate class members

Disallow duplicate conditions in if-else-if chains

Disallow duplicate keys in object literals

Disallow duplicate case labels

Disallow duplicate module imports

Disallow empty character classes in regular expressions

Disallow empty destructuring patterns

Disallow reassigning exceptions in `catch` clauses

Disallow fallthrough of `case` statements

Disallow reassigning `function` declarations

Disallow assigning to imported bindings

Disallow variable or `function` declarations in nested blocks

Disallow invalid regular expression strings in `RegExp` constructors

Disallow irregular whitespace

Disallow literal numbers that lose precision

Disallow characters which are made with multiple code points in character class syntax

Disallow `new` operators with global non-constructor functions

Disallow `new` operators with the `Symbol` object

Disallow calling global object properties as functions

Disallow returning values from Promise executor functions

Disallow calling some `Object.prototype` methods directly on objects

Disallow assignments where both sides are exactly the same

Disallow comparisons where both sides are exactly the same

Disallow returning values from setters

Disallow sparse arrays

Disallow template literal placeholder syntax in regular strings

Disallow `this`/`super` before calling `super()` in constructors

Disallow the use of undeclared variables unless mentioned in `/*global */` comments

Disallow confusing multiline expressions

Disallow unmodified loop conditions

Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements

Disallow loops with a body that allows only one iteration

Disallow control flow statements in `finally` blocks

Disallow negating the left operand of relational operators

Disallow use of optional chaining in contexts where the `undefined` value is not allowed

Disallow unused private class members

Disallow unused variables

Disallow the use of variables before they are defined

Disallow useless backreferences in regular expressions

Disallow assignments that can lead to race conditions due to usage of `await` or `yield`

Require calls to `isNaN()` when checking for `NaN`

Enforce comparing `typeof` expressions against valid strings

Enforce getter and setter pairs in objects and classes

Require braces around arrow function bodies

Enforce the use of variables within the scope they are defined

Enforce camelcase naming convention

Enforce or disallow capitalization of the first letter of a comment

Enforce that class methods utilize `this`

Enforce a maximum cyclomatic complexity allowed in a program

Require `return` statements to either always or never specify values

Enforce consistent naming when capturing the current execution context

Enforce consistent brace style for all control statements

Require `default` cases in `switch` statements

Enforce default clauses in switch statements to be last

Enforce default parameters to be last

Enforce dot notation whenever possible

Require the use of `===` and `!==`

Require function names to match the name of the variable or property to which they are assigned

Require or disallow named `function` expressions

Enforce the consistent use of either `function` declarations or expressions

Require grouped accessor pairs in object literals and classes

Require `for-in` loops to include an `if` statement

Disallow specified identifiers

Enforce minimum and maximum identifier lengths

Require identifiers to match a specified regular expression

Require or disallow initialization in variable declarations

Require or disallow logical assignment logical operator shorthand

Enforce a maximum number of classes per file

Enforce a maximum depth that blocks can be nested

Enforce a maximum number of lines per file

Enforce a maximum number of lines of code in a function

Enforce a maximum depth that callbacks can be nested

Enforce a maximum number of parameters in function definitions

Enforce a maximum number of statements allowed in function blocks

Enforce a particular style for multiline comments

Require constructor names to begin with a capital letter

Disallow the use of `alert`, `confirm`, and `prompt`

Disallow `Array` constructors

Disallow bitwise operators

Disallow the use of `arguments.caller` or `arguments.callee`

Disallow lexical declarations in case clauses

Disallow arrow functions where they could be confused with comparisons

Disallow the use of `console`

Disallow `continue` statements

Disallow deleting variables

Disallow division operators explicitly at the beginning of regular expressions

Disallow `else` blocks after `return` statements in `if` statements

Disallow empty block statements

Disallow empty functions

Disallow empty static blocks

Disallow `null` comparisons without type-checking operators

Disallow the use of `eval()`

Disallow extending native types

Disallow unnecessary calls to `.bind()`

Disallow unnecessary boolean casts

Disallow unnecessary labels

Disallow unnecessary semicolons

Disallow leading or trailing decimal points in numeric literals

Disallow assignments to native objects or read-only global variables

Disallow shorthand type conversions

Disallow declarations in the global scope

Disallow the use of `eval()`-like methods

Disallow inline comments after code

Disallow use of `this` in contexts where the value of `this` is `undefined`

Disallow the use of the `__iterator__` property

Disallow labels that share a name with a variable

Disallow labeled statements

Disallow unnecessary nested blocks

Disallow `if` statements as the only statement in `else` blocks

Disallow function declarations that contain unsafe references inside loop statements

Disallow magic numbers

Disallow mixed binary operators

Disallow use of chained assignment expressions

Disallow multiline strings

Disallow negated conditions

Disallow nested ternary expressions

Disallow `new` operators outside of assignments or comparisons

Disallow `new` operators with the `Function` object

Disallow `Object` constructors

Disallow `new` operators with the `String`, `Number`, and `Boolean` objects

Disallow `\8` and `\9` escape sequences in string literals

Disallow octal literals

Disallow octal escape sequences in string literals

Disallow reassigning `function` parameters

Disallow the unary operators `++` and `--`

Disallow the use of the `__proto__` property

Disallow variable redeclaration

Disallow multiple spaces in regular expressions

Disallow specified names in exports

Disallow specified global variables

Disallow specified modules when loaded by `import`

Disallow certain properties on certain objects

Disallow specified syntax

Disallow assignment operators in `return` statements

Disallow unnecessary `return await`

Disallow `javascript:` urls

Disallow comma operators

Disallow variable declarations from shadowing variables declared in the outer scope

Disallow identifiers from shadowing restricted names

Disallow ternary operators

Disallow throwing literals as exceptions

Disallow initializing variables to `undefined`

Disallow the use of `undefined` as an identifier

Disallow dangling underscores in identifiers

Disallow ternary operators when simpler alternatives exist

Disallow unused expressions

Disallow unused labels

Disallow unnecessary calls to `.call()` and `.apply()`

Disallow unnecessary `catch` clauses

Disallow unnecessary computed property keys in objects and classes

Disallow unnecessary concatenation of literals or template literals

Disallow unnecessary constructors

Disallow unnecessary escape characters

Disallow renaming import, export, and destructured assignments to the same name

Disallow redundant return statements

Require `let` or `const` instead of `var`

Disallow `void` operators

Disallow specified warning terms in comments

Disallow `with` statements

Require or disallow method and property shorthand syntax for object literals

Enforce variables to be declared either together or separately in functions

Require or disallow newlines around variable declarations

Require or disallow assignment operator shorthand where possible

Require using arrow functions for callbacks

Require `const` declarations for variables that are never reassigned after declared

Require destructuring from arrays and/or objects

Disallow the use of `Math.pow` in favor of the `**` operator

Enforce using named capture group in regular expression

Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals

Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`

Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead

Require using Error objects as Promise rejection reasons

Disallow use of the `RegExp` constructor in favor of regular expression literals

Require rest parameters instead of `arguments`

Require spread operators instead of `.apply()`

Require template literals instead of string concatenation

Require quotes around object literal property names

Enforce the consistent use of the radix argument when using `parseInt()`

Disallow async functions which have no `await` expression

Enforce the use of `u` flag on RegExp

Require generator functions to contain `yield`

Enforce sorted import declarations within modules

Require object keys to be sorted

Require variables within the same declaration block to be sorted

Enforce consistent spacing after the `//` or `/*` in a comment

Require or disallow strict mode directives

Require symbol descriptions

Require `var` declarations be placed at the top of their containing scope

Require or disallow "Yoda" conditions

Enforce linebreaks after opening and before closing array brackets

Enforce consistent spacing inside array brackets

Enforce line breaks after each array element

Require parentheses around arrow function arguments

Enforce consistent spacing before and after the arrow in arrow functions

Disallow or enforce spaces inside of blocks after opening block and before closing block

Enforce consistent brace style for blocks

Require or disallow trailing commas

Enforce consistent spacing before and after commas

Enforce consistent comma style

Enforce consistent spacing inside computed property brackets

Enforce consistent newlines before and after dots

Require or disallow newline at the end of files

Require or disallow spacing between function identifiers and their invocations

Enforce line breaks between arguments of a function call

Enforce consistent line breaks inside function parentheses

Enforce consistent spacing around `*` operators in generator functions

Enforce the location of arrow function bodies

Enforce consistent indentation

Enforce the consistent use of either double or single quotes in JSX attributes

Enforce consistent spacing between keys and values in object literal properties

Enforce consistent spacing before and after keywords

Enforce position of line comments

Enforce consistent linebreak style

Require empty lines around comments

Require or disallow an empty line between class members

Enforce a maximum line length

Enforce a maximum number of statements allowed per line

Enforce newlines between operands of ternary expressions

Enforce or disallow parentheses when invoking a constructor with no arguments

Require a newline after each call in a method chain

Disallow unnecessary parentheses

Disallow mixed spaces and tabs for indentation

Disallow multiple spaces

Disallow multiple empty lines

Disallow all tabs

Disallow trailing whitespace at the end of lines

Disallow whitespace before properties

Enforce the location of single-line statements

Enforce consistent line breaks after opening and before closing braces

Enforce consistent spacing inside braces

Enforce placing object properties on separate lines

Enforce consistent linebreak style for operators

Require or disallow padding within blocks

Require or disallow padding lines between statements

Enforce the consistent use of either backticks, double, or single quotes

Enforce spacing between rest and spread operators and their expressions

Require or disallow semicolons instead of ASI

Enforce consistent spacing before and after semicolons

Enforce location of semicolons

Enforce consistent spacing before blocks

Enforce consistent spacing before `function` definition opening parenthesis

Enforce consistent spacing inside parentheses

Require spacing around infix operators

Enforce consistent spacing before or after unary operators

Enforce spacing around colons of switch statements

Require or disallow spacing around embedded expressions of template strings

Require or disallow spacing between template tags and their literals

Require or disallow Unicode byte order mark (BOM)

Require parentheses around immediate `function` invocations

Require parenthesis around regex literals

Require or disallow spacing around the `*` in `yield*` expressions