repoburg 1.1.0 → 1.1.1

package/backend/node_modules/eslint/lib/rules/indent.js

@@ -0,0 +1,1803 @@
+/**
+ * @fileoverview This rule sets a specific indentation style and width for your code
+ *
+ * @author Teddy Katz
+ * @author Vitaly Puzrin
+ * @author Gyandeep Singh
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const KNOWN_NODES = new Set([
+    "AssignmentExpression",
+    "AssignmentPattern",
+    "ArrayExpression",
+    "ArrayPattern",
+    "ArrowFunctionExpression",
+    "AwaitExpression",
+    "BlockStatement",
+    "BinaryExpression",
+    "BreakStatement",
+    "CallExpression",
+    "CatchClause",
+    "ChainExpression",
+    "ClassBody",
+    "ClassDeclaration",
+    "ClassExpression",
+    "ConditionalExpression",
+    "ContinueStatement",
+    "DoWhileStatement",
+    "DebuggerStatement",
+    "EmptyStatement",
+    "ExperimentalRestProperty",
+    "ExperimentalSpreadProperty",
+    "ExpressionStatement",
+    "ForStatement",
+    "ForInStatement",
+    "ForOfStatement",
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "Identifier",
+    "IfStatement",
+    "Literal",
+    "LabeledStatement",
+    "LogicalExpression",
+    "MemberExpression",
+    "MetaProperty",
+    "MethodDefinition",
+    "NewExpression",
+    "ObjectExpression",
+    "ObjectPattern",
+    "PrivateIdentifier",
+    "Program",
+    "Property",
+    "PropertyDefinition",
+    "RestElement",
+    "ReturnStatement",
+    "SequenceExpression",
+    "SpreadElement",
+    "StaticBlock",
+    "Super",
+    "SwitchCase",
+    "SwitchStatement",
+    "TaggedTemplateExpression",
+    "TemplateElement",
+    "TemplateLiteral",
+    "ThisExpression",
+    "ThrowStatement",
+    "TryStatement",
+    "UnaryExpression",
+    "UpdateExpression",
+    "VariableDeclaration",
+    "VariableDeclarator",
+    "WhileStatement",
+    "WithStatement",
+    "YieldExpression",
+    "JSXFragment",
+    "JSXOpeningFragment",
+    "JSXClosingFragment",
+    "JSXIdentifier",
+    "JSXNamespacedName",
+    "JSXMemberExpression",
+    "JSXEmptyExpression",
+    "JSXExpressionContainer",
+    "JSXElement",
+    "JSXClosingElement",
+    "JSXOpeningElement",
+    "JSXAttribute",
+    "JSXSpreadAttribute",
+    "JSXText",
+    "ExportDefaultDeclaration",
+    "ExportNamedDeclaration",
+    "ExportAllDeclaration",
+    "ExportSpecifier",
+    "ImportDeclaration",
+    "ImportSpecifier",
+    "ImportDefaultSpecifier",
+    "ImportNamespaceSpecifier",
+    "ImportExpression"
+]);
+
+/*
+ * General rule strategy:
+ * 1. An OffsetStorage instance stores a map of desired offsets, where each token has a specified offset from another
+ *    specified token or to the first column.
+ * 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For example, when entering a
+ *    BlockStatement, offset all of the tokens in the BlockStatement by 1 indent level from the opening curly
+ *    brace of the BlockStatement.
+ * 3. After traversing the AST, calculate the expected indentation levels of every token according to the
+ *    OffsetStorage container.
+ * 4. For each line, compare the expected indentation of the first token to the actual indentation in the file,
+ *    and report the token if the two values are not equal.
+ */
+
+
+/**
+ * A mutable map that stores (key, value) pairs. The keys are numeric indices, and must be unique.
+ * This is intended to be a generic wrapper around a map with non-negative integer keys, so that the underlying implementation
+ * can easily be swapped out.
+ */
+class IndexMap {
+
+    /**
+     * Creates an empty map
+     * @param {number} maxKey The maximum key
+     */
+    constructor(maxKey) {
+
+        // Initializing the array with the maximum expected size avoids dynamic reallocations that could degrade performance.
+        this._values = Array(maxKey + 1);
+    }
+
+    /**
+     * Inserts an entry into the map.
+     * @param {number} key The entry's key
+     * @param {any} value The entry's value
+     * @returns {void}
+     */
+    insert(key, value) {
+        this._values[key] = value;
+    }
+
+    /**
+     * Finds the value of the entry with the largest key less than or equal to the provided key
+     * @param {number} key The provided key
+     * @returns {*|undefined} The value of the found entry, or undefined if no such entry exists.
+     */
+    findLastNotAfter(key) {
+        const values = this._values;
+
+        for (let index = key; index >= 0; index--) {
+            const value = values[index];
+
+            if (value) {
+                return value;
+            }
+        }
+        return void 0;
+    }
+
+    /**
+     * Deletes all of the keys in the interval [start, end)
+     * @param {number} start The start of the range
+     * @param {number} end The end of the range
+     * @returns {void}
+     */
+    deleteRange(start, end) {
+        this._values.fill(void 0, start, end);
+    }
+}
+
+/**
+ * A helper class to get token-based info related to indentation
+ */
+class TokenInfo {
+
+    /**
+     * @param {SourceCode} sourceCode A SourceCode object
+     */
+    constructor(sourceCode) {
+        this.sourceCode = sourceCode;
+        this.firstTokensByLineNumber = new Map();
+        const tokens = sourceCode.tokensAndComments;
+
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+
+            if (!this.firstTokensByLineNumber.has(token.loc.start.line)) {
+                this.firstTokensByLineNumber.set(token.loc.start.line, token);
+            }
+            if (!this.firstTokensByLineNumber.has(token.loc.end.line) && sourceCode.text.slice(token.range[1] - token.loc.end.column, token.range[1]).trim()) {
+                this.firstTokensByLineNumber.set(token.loc.end.line, token);
+            }
+        }
+    }
+
+    /**
+     * Gets the first token on a given token's line
+     * @param {Token|ASTNode} token a node or token
+     * @returns {Token} The first token on the given line
+     */
+    getFirstTokenOfLine(token) {
+        return this.firstTokensByLineNumber.get(token.loc.start.line);
+    }
+
+    /**
+     * Determines whether a token is the first token in its line
+     * @param {Token} token The token
+     * @returns {boolean} `true` if the token is the first on its line
+     */
+    isFirstTokenOfLine(token) {
+        return this.getFirstTokenOfLine(token) === token;
+    }
+
+    /**
+     * Get the actual indent of a token
+     * @param {Token} token Token to examine. This should be the first token on its line.
+     * @returns {string} The indentation characters that precede the token
+     */
+    getTokenIndent(token) {
+        return this.sourceCode.text.slice(token.range[0] - token.loc.start.column, token.range[0]);
+    }
+}
+
+/**
+ * A class to store information on desired offsets of tokens from each other
+ */
+class OffsetStorage {
+
+    /**
+     * @param {TokenInfo} tokenInfo a TokenInfo instance
+     * @param {number} indentSize The desired size of each indentation level
+     * @param {string} indentType The indentation character
+     * @param {number} maxIndex The maximum end index of any token
+     */
+    constructor(tokenInfo, indentSize, indentType, maxIndex) {
+        this._tokenInfo = tokenInfo;
+        this._indentSize = indentSize;
+        this._indentType = indentType;
+
+        this._indexMap = new IndexMap(maxIndex);
+        this._indexMap.insert(0, { offset: 0, from: null, force: false });
+
+        this._lockedFirstTokens = new WeakMap();
+        this._desiredIndentCache = new WeakMap();
+        this._ignoredTokens = new WeakSet();
+    }
+
+    _getOffsetDescriptor(token) {
+        return this._indexMap.findLastNotAfter(token.range[0]);
+    }
+
+    /**
+     * Sets the offset column of token B to match the offset column of token A.
+     * - **WARNING**: This matches a *column*, even if baseToken is not the first token on its line. In
+     * most cases, `setDesiredOffset` should be used instead.
+     * @param {Token} baseToken The first token
+     * @param {Token} offsetToken The second token, whose offset should be matched to the first token
+     * @returns {void}
+     */
+    matchOffsetOf(baseToken, offsetToken) {
+
+        /*
+         * lockedFirstTokens is a map from a token whose indentation is controlled by the "first" option to
+         * the token that it depends on. For example, with the `ArrayExpression: first` option, the first
+         * token of each element in the array after the first will be mapped to the first token of the first
+         * element. The desired indentation of each of these tokens is computed based on the desired indentation
+         * of the "first" element, rather than through the normal offset mechanism.
+         */
+        this._lockedFirstTokens.set(offsetToken, baseToken);
+    }
+
+    /**
+     * Sets the desired offset of a token.
+     *
+     * This uses a line-based offset collapsing behavior to handle tokens on the same line.
+     * For example, consider the following two cases:
+     *
+     * (
+     *     [
+     *         bar
+     *     ]
+     * )
+     *
+     * ([
+     *     bar
+     * ])
+     *
+     * Based on the first case, it's clear that the `bar` token needs to have an offset of 1 indent level (4 spaces) from
+     * the `[` token, and the `[` token has to have an offset of 1 indent level from the `(` token. Since the `(` token is
+     * the first on its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 indent levels (8 spaces)
+     * from the start of its line.
+     *
+     * However, in the second case `bar` should only be indented by 4 spaces. This is because the offset of 1 indent level
+     * between the `(` and the `[` tokens gets "collapsed" because the two tokens are on the same line. As a result, the
+     * `(` token is mapped to the `[` token with an offset of 0, and the rule correctly decides that `bar` should be indented
+     * by 1 indent level from the start of the line.
+     *
+     * This is useful because rule listeners can usually just call `setDesiredOffset` for all the tokens in the node,
+     * without needing to check which lines those tokens are on.
+     *
+     * Note that since collapsing only occurs when two tokens are on the same line, there are a few cases where non-intuitive
+     * behavior can occur. For example, consider the following cases:
+     *
+     * foo(
+     * ).
+     *     bar(
+     *         baz
+     *     )
+     *
+     * foo(
+     * ).bar(
+     *     baz
+     * )
+     *
+     * Based on the first example, it would seem that `bar` should be offset by 1 indent level from `foo`, and `baz`
+     * should be offset by 1 indent level from `bar`. However, this is not correct, because it would result in `baz`
+     * being indented by 2 indent levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, no
+     * collapsing would occur).
+     *
+     * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset `bar` by 1 level from the `)`, and
+     * offset the `)` by 0 levels from `foo`. This ensures that the offset between `bar` and the `)` are correctly collapsed
+     * in the second case.
+     * @param {Token} token The token
+     * @param {Token} fromToken The token that `token` should be offset from
+     * @param {number} offset The desired indent level
+     * @returns {void}
+     */
+    setDesiredOffset(token, fromToken, offset) {
+        return this.setDesiredOffsets(token.range, fromToken, offset);
+    }
+
+    /**
+     * Sets the desired offset of all tokens in a range
+     * It's common for node listeners in this file to need to apply the same offset to a large, contiguous range of tokens.
+     * Moreover, the offset of any given token is usually updated multiple times (roughly once for each node that contains
+     * it). This means that the offset of each token is updated O(AST depth) times.
+     * It would not be performant to store and update the offsets for each token independently, because the rule would end
+     * up having a time complexity of O(number of tokens * AST depth), which is quite slow for large files.
+     *
+     * Instead, the offset tree is represented as a collection of contiguous offset ranges in a file. For example, the following
+     * list could represent the state of the offset tree at a given point:
+     *
+     * - Tokens starting in the interval [0, 15) are aligned with the beginning of the file
+     * - Tokens starting in the interval [15, 30) are offset by 1 indent level from the `bar` token
+     * - Tokens starting in the interval [30, 43) are offset by 1 indent level from the `foo` token
+     * - Tokens starting in the interval [43, 820) are offset by 2 indent levels from the `bar` token
+     * - Tokens starting in the interval [820, ∞) are offset by 1 indent level from the `baz` token
+     *
+     * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line above would be inserted by using:
+     * `setDesiredOffsets([30, 43], fooToken, 1);`
+     * @param {[number, number]} range A [start, end] pair. All tokens with range[0] <= token.start < range[1] will have the offset applied.
+     * @param {Token} fromToken The token that this is offset from
+     * @param {number} offset The desired indent level
+     * @param {boolean} force `true` if this offset should not use the normal collapsing behavior. This should almost always be false.
+     * @returns {void}
+     */
+    setDesiredOffsets(range, fromToken, offset, force) {
+
+        /*
+         * Offset ranges are stored as a collection of nodes, where each node maps a numeric key to an offset
+         * descriptor. The tree for the example above would have the following nodes:
+         *
+         * * key: 0, value: { offset: 0, from: null }
+         * * key: 15, value: { offset: 1, from: barToken }
+         * * key: 30, value: { offset: 1, from: fooToken }
+         * * key: 43, value: { offset: 2, from: barToken }
+         * * key: 820, value: { offset: 1, from: bazToken }
+         *
+         * To find the offset descriptor for any given token, one needs to find the node with the largest key
+         * which is <= token.start. To make this operation fast, the nodes are stored in a map indexed by key.
+         */
+
+        const descriptorToInsert = { offset, from: fromToken, force };
+
+        const descriptorAfterRange = this._indexMap.findLastNotAfter(range[1]);
+
+        const fromTokenIsInRange = fromToken && fromToken.range[0] >= range[0] && fromToken.range[1] <= range[1];
+        const fromTokenDescriptor = fromTokenIsInRange && this._getOffsetDescriptor(fromToken);
+
+        // First, remove any existing nodes in the range from the map.
+        this._indexMap.deleteRange(range[0] + 1, range[1]);
+
+        // Insert a new node into the map for this range
+        this._indexMap.insert(range[0], descriptorToInsert);
+
+        /*
+         * To avoid circular offset dependencies, keep the `fromToken` token mapped to whatever it was mapped to previously,
+         * even if it's in the current range.
+         */
+        if (fromTokenIsInRange) {
+            this._indexMap.insert(fromToken.range[0], fromTokenDescriptor);
+            this._indexMap.insert(fromToken.range[1], descriptorToInsert);
+        }
+
+        /*
+         * To avoid modifying the offset of tokens after the range, insert another node to keep the offset of the following
+         * tokens the same as it was before.
+         */
+        this._indexMap.insert(range[1], descriptorAfterRange);
+    }
+
+    /**
+     * Gets the desired indent of a token
+     * @param {Token} token The token
+     * @returns {string} The desired indent of the token
+     */
+    getDesiredIndent(token) {
+        if (!this._desiredIndentCache.has(token)) {
+
+            if (this._ignoredTokens.has(token)) {
+
+                /*
+                 * If the token is ignored, use the actual indent of the token as the desired indent.
+                 * This ensures that no errors are reported for this token.
+                 */
+                this._desiredIndentCache.set(
+                    token,
+                    this._tokenInfo.getTokenIndent(token)
+                );
+            } else if (this._lockedFirstTokens.has(token)) {
+                const firstToken = this._lockedFirstTokens.get(token);
+
+                this._desiredIndentCache.set(
+                    token,
+
+                    // (indentation for the first element's line)
+                    this.getDesiredIndent(this._tokenInfo.getFirstTokenOfLine(firstToken)) +
+
+                        // (space between the start of the first element's line and the first element)
+                        this._indentType.repeat(firstToken.loc.start.column - this._tokenInfo.getFirstTokenOfLine(firstToken).loc.start.column)
+                );
+            } else {
+                const offsetInfo = this._getOffsetDescriptor(token);
+                const offset = (
+                    offsetInfo.from &&
+                    offsetInfo.from.loc.start.line === token.loc.start.line &&
+                    !/^\s*?\n/u.test(token.value) &&
+                    !offsetInfo.force
+                ) ? 0 : offsetInfo.offset * this._indentSize;
+
+                this._desiredIndentCache.set(
+                    token,
+                    (offsetInfo.from ? this.getDesiredIndent(offsetInfo.from) : "") + this._indentType.repeat(offset)
+                );
+            }
+        }
+        return this._desiredIndentCache.get(token);
+    }
+
+    /**
+     * Ignores a token, preventing it from being reported.
+     * @param {Token} token The token
+     * @returns {void}
+     */
+    ignoreToken(token) {
+        if (this._tokenInfo.isFirstTokenOfLine(token)) {
+            this._ignoredTokens.add(token);
+        }
+    }
+
+    /**
+     * Gets the first token that the given token's indentation is dependent on
+     * @param {Token} token The token
+     * @returns {Token} The token that the given token depends on, or `null` if the given token is at the top level
+     */
+    getFirstDependency(token) {
+        return this._getOffsetDescriptor(token).from;
+    }
+}
+
+const ELEMENT_LIST_SCHEMA = {
+    oneOf: [
+        {
+            type: "integer",
+            minimum: 0
+        },
+        {
+            enum: ["first", "off"]
+        }
+    ]
+};
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: [],
+        type: "layout",
+
+        docs: {
+            description: "Enforce consistent indentation",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/indent"
+        },
+
+        fixable: "whitespace",
+
+        schema: [
+            {
+                oneOf: [
+                    {
+                        enum: ["tab"]
+                    },
+                    {
+                        type: "integer",
+                        minimum: 0
+                    }
+                ]
+            },
+            {
+                type: "object",
+                properties: {
+                    SwitchCase: {
+                        type: "integer",
+                        minimum: 0,
+                        default: 0
+                    },
+                    VariableDeclarator: {
+                        oneOf: [
+                            ELEMENT_LIST_SCHEMA,
+                            {
+                                type: "object",
+                                properties: {
+                                    var: ELEMENT_LIST_SCHEMA,
+                                    let: ELEMENT_LIST_SCHEMA,
+                                    const: ELEMENT_LIST_SCHEMA
+                                },
+                                additionalProperties: false
+                            }
+                        ]
+                    },
+                    outerIIFEBody: {
+                        oneOf: [
+                            {
+                                type: "integer",
+                                minimum: 0
+                            },
+                            {
+                                enum: ["off"]
+                            }
+                        ]
+                    },
+                    MemberExpression: {
+                        oneOf: [
+                            {
+                                type: "integer",
+                                minimum: 0
+                            },
+                            {
+                                enum: ["off"]
+                            }
+                        ]
+                    },
+                    FunctionDeclaration: {
+                        type: "object",
+                        properties: {
+                            parameters: ELEMENT_LIST_SCHEMA,
+                            body: {
+                                type: "integer",
+                                minimum: 0
+                            }
+                        },
+                        additionalProperties: false
+                    },
+                    FunctionExpression: {
+                        type: "object",
+                        properties: {
+                            parameters: ELEMENT_LIST_SCHEMA,
+                            body: {
+                                type: "integer",
+                                minimum: 0
+                            }
+                        },
+                        additionalProperties: false
+                    },
+                    StaticBlock: {
+                        type: "object",
+                        properties: {
+                            body: {
+                                type: "integer",
+                                minimum: 0
+                            }
+                        },
+                        additionalProperties: false
+                    },
+                    CallExpression: {
+                        type: "object",
+                        properties: {
+                            arguments: ELEMENT_LIST_SCHEMA
+                        },
+                        additionalProperties: false
+                    },
+                    ArrayExpression: ELEMENT_LIST_SCHEMA,
+                    ObjectExpression: ELEMENT_LIST_SCHEMA,
+                    ImportDeclaration: ELEMENT_LIST_SCHEMA,
+                    flatTernaryExpressions: {
+                        type: "boolean",
+                        default: false
+                    },
+                    offsetTernaryExpressions: {
+                        type: "boolean",
+                        default: false
+                    },
+                    ignoredNodes: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                            not: {
+                                pattern: ":exit$"
+                            }
+                        }
+                    },
+                    ignoreComments: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: {
+            wrongIndentation: "Expected indentation of {{expected}} but found {{actual}}."
+        }
+    },
+
+    create(context) {
+        const DEFAULT_VARIABLE_INDENT = 1;
+        const DEFAULT_PARAMETER_INDENT = 1;
+        const DEFAULT_FUNCTION_BODY_INDENT = 1;
+
+        let indentType = "space";
+        let indentSize = 4;
+        const options = {
+            SwitchCase: 0,
+            VariableDeclarator: {
+                var: DEFAULT_VARIABLE_INDENT,
+                let: DEFAULT_VARIABLE_INDENT,
+                const: DEFAULT_VARIABLE_INDENT
+            },
+            outerIIFEBody: 1,
+            FunctionDeclaration: {
+                parameters: DEFAULT_PARAMETER_INDENT,
+                body: DEFAULT_FUNCTION_BODY_INDENT
+            },
+            FunctionExpression: {
+                parameters: DEFAULT_PARAMETER_INDENT,
+                body: DEFAULT_FUNCTION_BODY_INDENT
+            },
+            StaticBlock: {
+                body: DEFAULT_FUNCTION_BODY_INDENT
+            },
+            CallExpression: {
+                arguments: DEFAULT_PARAMETER_INDENT
+            },
+            MemberExpression: 1,
+            ArrayExpression: 1,
+            ObjectExpression: 1,
+            ImportDeclaration: 1,
+            flatTernaryExpressions: false,
+            ignoredNodes: [],
+            ignoreComments: false
+        };
+
+        if (context.options.length) {
+            if (context.options[0] === "tab") {
+                indentSize = 1;
+                indentType = "tab";
+            } else {
+                indentSize = context.options[0];
+                indentType = "space";
+            }
+
+            if (context.options[1]) {
+                Object.assign(options, context.options[1]);
+
+                if (typeof options.VariableDeclarator === "number" || options.VariableDeclarator === "first") {
+                    options.VariableDeclarator = {
+                        var: options.VariableDeclarator,
+                        let: options.VariableDeclarator,
+                        const: options.VariableDeclarator
+                    };
+                }
+            }
+        }
+
+        const sourceCode = context.sourceCode;
+        const tokenInfo = new TokenInfo(sourceCode);
+        const offsets = new OffsetStorage(tokenInfo, indentSize, indentType === "space" ? " " : "\t", sourceCode.text.length);
+        const parameterParens = new WeakSet();
+
+        /**
+         * Creates an error message for a line, given the expected/actual indentation.
+         * @param {int} expectedAmount The expected amount of indentation characters for this line
+         * @param {int} actualSpaces The actual number of indentation spaces that were found on this line
+         * @param {int} actualTabs The actual number of indentation tabs that were found on this line
+         * @returns {string} An error message for this line
+         */
+        function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {
+            const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? "" : "s"}`; // e.g. "2 tabs"
+            const foundSpacesWord = `space${actualSpaces === 1 ? "" : "s"}`; // e.g. "space"
+            const foundTabsWord = `tab${actualTabs === 1 ? "" : "s"}`; // e.g. "tabs"
+            let foundStatement;
+
+            if (actualSpaces > 0) {
+
+                /*
+                 * Abbreviate the message if the expected indentation is also spaces.
+                 * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces'
+                 */
+                foundStatement = indentType === "space" ? actualSpaces : `${actualSpaces} ${foundSpacesWord}`;
+            } else if (actualTabs > 0) {
+                foundStatement = indentType === "tab" ? actualTabs : `${actualTabs} ${foundTabsWord}`;
+            } else {
+                foundStatement = "0";
+            }
+            return {
+                expected: expectedStatement,
+                actual: foundStatement
+            };
+        }
+
+        /**
+         * Reports a given indent violation
+         * @param {Token} token Token violating the indent rule
+         * @param {string} neededIndent Expected indentation string
+         * @returns {void}
+         */
+        function report(token, neededIndent) {
+            const actualIndent = Array.from(tokenInfo.getTokenIndent(token));
+            const numSpaces = actualIndent.filter(char => char === " ").length;
+            const numTabs = actualIndent.filter(char => char === "\t").length;
+
+            context.report({
+                node: token,
+                messageId: "wrongIndentation",
+                data: createErrorMessageData(neededIndent.length, numSpaces, numTabs),
+                loc: {
+                    start: { line: token.loc.start.line, column: 0 },
+                    end: { line: token.loc.start.line, column: token.loc.start.column }
+                },
+                fix(fixer) {
+                    const range = [token.range[0] - token.loc.start.column, token.range[0]];
+                    const newText = neededIndent;
+
+                    return fixer.replaceTextRange(range, newText);
+                }
+            });
+        }
+
+        /**
+         * Checks if a token's indentation is correct
+         * @param {Token} token Token to examine
+         * @param {string} desiredIndent Desired indentation of the string
+         * @returns {boolean} `true` if the token's indentation is correct
+         */
+        function validateTokenIndent(token, desiredIndent) {
+            const indentation = tokenInfo.getTokenIndent(token);
+
+            return indentation === desiredIndent ||
+
+                // To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed spaces and tabs.
+                indentation.includes(" ") && indentation.includes("\t");
+        }
+
+        /**
+         * Check to see if the node is a file level IIFE
+         * @param {ASTNode} node The function node to check.
+         * @returns {boolean} True if the node is the outer IIFE
+         */
+        function isOuterIIFE(node) {
+
+            /*
+             * Verify that the node is an IIFE
+             */
+            if (!node.parent || node.parent.type !== "CallExpression" || node.parent.callee !== node) {
+                return false;
+            }
+
+            /*
+             * Navigate legal ancestors to determine whether this IIFE is outer.
+             * A "legal ancestor" is an expression or statement that causes the function to get executed immediately.
+             * For example, `!(function(){})()` is an outer IIFE even though it is preceded by a ! operator.
+             */
+            let statement = node.parent && node.parent.parent;
+
+            while (
+                statement.type === "UnaryExpression" && ["!", "~", "+", "-"].includes(statement.operator) ||
+                statement.type === "AssignmentExpression" ||
+                statement.type === "LogicalExpression" ||
+                statement.type === "SequenceExpression" ||
+                statement.type === "VariableDeclarator"
+            ) {
+                statement = statement.parent;
+            }
+
+            return (statement.type === "ExpressionStatement" || statement.type === "VariableDeclaration") && statement.parent.type === "Program";
+        }
+
+        /**
+         * Counts the number of linebreaks that follow the last non-whitespace character in a string
+         * @param {string} string The string to check
+         * @returns {number} The number of JavaScript linebreaks that follow the last non-whitespace character,
+         * or the total number of linebreaks if the string is all whitespace.
+         */
+        function countTrailingLinebreaks(string) {
+            const trailingWhitespace = string.match(/\s*$/u)[0];
+            const linebreakMatches = trailingWhitespace.match(astUtils.createGlobalLinebreakMatcher());
+
+            return linebreakMatches === null ? 0 : linebreakMatches.length;
+        }
+
+        /**
+         * Check indentation for lists of elements (arrays, objects, function params)
+         * @param {ASTNode[]} elements List of elements that should be offset
+         * @param {Token} startToken The start token of the list that element should be aligned against, e.g. '['
+         * @param {Token} endToken The end token of the list, e.g. ']'
+         * @param {number|string} offset The amount that the elements should be offset
+         * @returns {void}
+         */
+        function addElementListIndent(elements, startToken, endToken, offset) {
+
+            /**
+             * Gets the first token of a given element, including surrounding parentheses.
+             * @param {ASTNode} element A node in the `elements` list
+             * @returns {Token} The first token of this element
+             */
+            function getFirstToken(element) {
+                let token = sourceCode.getTokenBefore(element);
+
+                while (astUtils.isOpeningParenToken(token) && token !== startToken) {
+                    token = sourceCode.getTokenBefore(token);
+                }
+                return sourceCode.getTokenAfter(token);
+            }
+
+            // Run through all the tokens in the list, and offset them by one indent level (mainly for comments, other things will end up overridden)
+            offsets.setDesiredOffsets(
+                [startToken.range[1], endToken.range[0]],
+                startToken,
+                typeof offset === "number" ? offset : 1
+            );
+            offsets.setDesiredOffset(endToken, startToken, 0);
+
+            // If the preference is "first" but there is no first element (e.g. sparse arrays w/ empty first slot), fall back to 1 level.
+            if (offset === "first" && elements.length && !elements[0]) {
+                return;
+            }
+            elements.forEach((element, index) => {
+                if (!element) {
+
+                    // Skip holes in arrays
+                    return;
+                }
+                if (offset === "off") {
+
+                    // Ignore the first token of every element if the "off" option is used
+                    offsets.ignoreToken(getFirstToken(element));
+                }
+
+                // Offset the following elements correctly relative to the first element
+                if (index === 0) {
+                    return;
+                }
+                if (offset === "first" && tokenInfo.isFirstTokenOfLine(getFirstToken(element))) {
+                    offsets.matchOffsetOf(getFirstToken(elements[0]), getFirstToken(element));
+                } else {
+                    const previousElement = elements[index - 1];
+                    const firstTokenOfPreviousElement = previousElement && getFirstToken(previousElement);
+                    const previousElementLastToken = previousElement && sourceCode.getLastToken(previousElement);
+
+                    if (
+                        previousElement &&
+                        previousElementLastToken.loc.end.line - countTrailingLinebreaks(previousElementLastToken.value) > startToken.loc.end.line
+                    ) {
+                        offsets.setDesiredOffsets(
+                            [previousElement.range[1], element.range[1]],
+                            firstTokenOfPreviousElement,
+                            0
+                        );
+                    }
+                }
+            });
+        }
+
+        /**
+         * Check and decide whether to check for indentation for blockless nodes
+         * Scenarios are for or while statements without braces around them
+         * @param {ASTNode} node node to examine
+         * @returns {void}
+         */
+        function addBlocklessNodeIndent(node) {
+            if (node.type !== "BlockStatement") {
+                const lastParentToken = sourceCode.getTokenBefore(node, astUtils.isNotOpeningParenToken);
+
+                let firstBodyToken = sourceCode.getFirstToken(node);
+                let lastBodyToken = sourceCode.getLastToken(node);
+
+                while (
+                    astUtils.isOpeningParenToken(sourceCode.getTokenBefore(firstBodyToken)) &&
+                    astUtils.isClosingParenToken(sourceCode.getTokenAfter(lastBodyToken))
+                ) {
+                    firstBodyToken = sourceCode.getTokenBefore(firstBodyToken);
+                    lastBodyToken = sourceCode.getTokenAfter(lastBodyToken);
+                }
+
+                offsets.setDesiredOffsets([firstBodyToken.range[0], lastBodyToken.range[1]], lastParentToken, 1);
+            }
+        }
+
+        /**
+         * Checks the indentation for nodes that are like function calls (`CallExpression` and `NewExpression`)
+         * @param {ASTNode} node A CallExpression or NewExpression node
+         * @returns {void}
+         */
+        function addFunctionCallIndent(node) {
+            let openingParen;
+
+            if (node.arguments.length) {
+                openingParen = sourceCode.getFirstTokenBetween(node.callee, node.arguments[0], astUtils.isOpeningParenToken);
+            } else {
+                openingParen = sourceCode.getLastToken(node, 1);
+            }
+            const closingParen = sourceCode.getLastToken(node);
+
+            parameterParens.add(openingParen);
+            parameterParens.add(closingParen);
+
+            /*
+             * If `?.` token exists, set desired offset for that.
+             * This logic is copied from `MemberExpression`'s.
+             */
+            if (node.optional) {
+                const dotToken = sourceCode.getTokenAfter(node.callee, astUtils.isQuestionDotToken);
+                const calleeParenCount = sourceCode.getTokensBetween(node.callee, dotToken, { filter: astUtils.isClosingParenToken }).length;
+                const firstTokenOfCallee = calleeParenCount
+                    ? sourceCode.getTokenBefore(node.callee, { skip: calleeParenCount - 1 })
+                    : sourceCode.getFirstToken(node.callee);
+                const lastTokenOfCallee = sourceCode.getTokenBefore(dotToken);
+                const offsetBase = lastTokenOfCallee.loc.end.line === openingParen.loc.start.line
+                    ? lastTokenOfCallee
+                    : firstTokenOfCallee;
+
+                offsets.setDesiredOffset(dotToken, offsetBase, 1);
+            }
+
+            const offsetAfterToken = node.callee.type === "TaggedTemplateExpression" ? sourceCode.getFirstToken(node.callee.quasi) : openingParen;
+            const offsetToken = sourceCode.getTokenBefore(offsetAfterToken);
+
+            offsets.setDesiredOffset(openingParen, offsetToken, 0);
+
+            addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments);
+        }
+
+        /**
+         * Checks the indentation of parenthesized values, given a list of tokens in a program
+         * @param {Token[]} tokens A list of tokens
+         * @returns {void}
+         */
+        function addParensIndent(tokens) {
+            const parenStack = [];
+            const parenPairs = [];
+
+            for (let i = 0; i < tokens.length; i++) {
+                const nextToken = tokens[i];
+
+                if (astUtils.isOpeningParenToken(nextToken)) {
+                    parenStack.push(nextToken);
+                } else if (astUtils.isClosingParenToken(nextToken)) {
+                    parenPairs.push({ left: parenStack.pop(), right: nextToken });
+                }
+            }
+
+            for (let i = parenPairs.length - 1; i >= 0; i--) {
+                const leftParen = parenPairs[i].left;
+                const rightParen = parenPairs[i].right;
+
+                // We only want to handle parens around expressions, so exclude parentheses that are in function parameters and function call arguments.
+                if (!parameterParens.has(leftParen) && !parameterParens.has(rightParen)) {
+                    const parenthesizedTokens = new Set(sourceCode.getTokensBetween(leftParen, rightParen));
+
+                    parenthesizedTokens.forEach(token => {
+                        if (!parenthesizedTokens.has(offsets.getFirstDependency(token))) {
+                            offsets.setDesiredOffset(token, leftParen, 1);
+                        }
+                    });
+                }
+
+                offsets.setDesiredOffset(rightParen, leftParen, 0);
+            }
+        }
+
+        /**
+         * Ignore all tokens within an unknown node whose offset do not depend
+         * on another token's offset within the unknown node
+         * @param {ASTNode} node Unknown Node
+         * @returns {void}
+         */
+        function ignoreNode(node) {
+            const unknownNodeTokens = new Set(sourceCode.getTokens(node, { includeComments: true }));
+
+            unknownNodeTokens.forEach(token => {
+                if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) {
+                    const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token);
+
+                    if (token === firstTokenOfLine) {
+                        offsets.ignoreToken(token);
+                    } else {
+                        offsets.setDesiredOffset(token, firstTokenOfLine, 0);
+                    }
+                }
+            });
+        }
+
+        /**
+         * Check whether the given token is on the first line of a statement.
+         * @param {Token} token The token to check.
+         * @param {ASTNode} leafNode The expression node that the token belongs directly.
+         * @returns {boolean} `true` if the token is on the first line of a statement.
+         */
+        function isOnFirstLineOfStatement(token, leafNode) {
+            let node = leafNode;
+
+            while (node.parent && !node.parent.type.endsWith("Statement") && !node.parent.type.endsWith("Declaration")) {
+                node = node.parent;
+            }
+            node = node.parent;
+
+            return !node || node.loc.start.line === token.loc.start.line;
+        }
+
+        /**
+         * Check whether there are any blank (whitespace-only) lines between
+         * two tokens on separate lines.
+         * @param {Token} firstToken The first token.
+         * @param {Token} secondToken The second token.
+         * @returns {boolean} `true` if the tokens are on separate lines and
+         *   there exists a blank line between them, `false` otherwise.
+         */
+        function hasBlankLinesBetween(firstToken, secondToken) {
+            const firstTokenLine = firstToken.loc.end.line;
+            const secondTokenLine = secondToken.loc.start.line;
+
+            if (firstTokenLine === secondTokenLine || firstTokenLine === secondTokenLine - 1) {
+                return false;
+            }
+
+            for (let line = firstTokenLine + 1; line < secondTokenLine; ++line) {
+                if (!tokenInfo.firstTokensByLineNumber.has(line)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        const ignoredNodeFirstTokens = new Set();
+
+        const baseOffsetListeners = {
+            "ArrayExpression, ArrayPattern"(node) {
+                const openingBracket = sourceCode.getFirstToken(node);
+                const closingBracket = sourceCode.getTokenAfter([...node.elements].reverse().find(_ => _) || openingBracket, astUtils.isClosingBracketToken);
+
+                addElementListIndent(node.elements, openingBracket, closingBracket, options.ArrayExpression);
+            },
+
+            "ObjectExpression, ObjectPattern"(node) {
+                const openingCurly = sourceCode.getFirstToken(node);
+                const closingCurly = sourceCode.getTokenAfter(
+                    node.properties.length ? node.properties[node.properties.length - 1] : openingCurly,
+                    astUtils.isClosingBraceToken
+                );
+
+                addElementListIndent(node.properties, openingCurly, closingCurly, options.ObjectExpression);
+            },
+
+            ArrowFunctionExpression(node) {
+                const maybeOpeningParen = sourceCode.getFirstToken(node, { skip: node.async ? 1 : 0 });
+
+                if (astUtils.isOpeningParenToken(maybeOpeningParen)) {
+                    const openingParen = maybeOpeningParen;
+                    const closingParen = sourceCode.getTokenBefore(node.body, astUtils.isClosingParenToken);
+
+                    parameterParens.add(openingParen);
+                    parameterParens.add(closingParen);
+                    addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);
+                }
+
+                addBlocklessNodeIndent(node.body);
+            },
+
+            AssignmentExpression(node) {
+                const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
+
+                offsets.setDesiredOffsets([operator.range[0], node.range[1]], sourceCode.getLastToken(node.left), 1);
+                offsets.ignoreToken(operator);
+                offsets.ignoreToken(sourceCode.getTokenAfter(operator));
+            },
+
+            "BinaryExpression, LogicalExpression"(node) {
+                const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
+
+                /*
+                 * For backwards compatibility, don't check BinaryExpression indents, e.g.
+                 * var foo = bar &&
+                 *                   baz;
+                 */
+
+                const tokenAfterOperator = sourceCode.getTokenAfter(operator);
+
+                offsets.ignoreToken(operator);
+                offsets.ignoreToken(tokenAfterOperator);
+                offsets.setDesiredOffset(tokenAfterOperator, operator, 0);
+            },
+
+            "BlockStatement, ClassBody"(node) {
+                let blockIndentLevel;
+
+                if (node.parent && isOuterIIFE(node.parent)) {
+                    blockIndentLevel = options.outerIIFEBody;
+                } else if (node.parent && (node.parent.type === "FunctionExpression" || node.parent.type === "ArrowFunctionExpression")) {
+                    blockIndentLevel = options.FunctionExpression.body;
+                } else if (node.parent && node.parent.type === "FunctionDeclaration") {
+                    blockIndentLevel = options.FunctionDeclaration.body;
+                } else {
+                    blockIndentLevel = 1;
+                }
+
+                /*
+                 * For blocks that aren't lone statements, ensure that the opening curly brace
+                 * is aligned with the parent.
+                 */
+                if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
+                    offsets.setDesiredOffset(sourceCode.getFirstToken(node), sourceCode.getFirstToken(node.parent), 0);
+                }
+
+                addElementListIndent(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), blockIndentLevel);
+            },
+
+            CallExpression: addFunctionCallIndent,
+
+            "ClassDeclaration[superClass], ClassExpression[superClass]"(node) {
+                const classToken = sourceCode.getFirstToken(node);
+                const extendsToken = sourceCode.getTokenBefore(node.superClass, astUtils.isNotOpeningParenToken);
+
+                offsets.setDesiredOffsets([extendsToken.range[0], node.body.range[0]], classToken, 1);
+            },
+
+            ConditionalExpression(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+
+                // `flatTernaryExpressions` option is for the following style:
+                // var a =
+                //     foo > 0 ? bar :
+                //     foo < 0 ? baz :
+                //     /*else*/ qiz ;
+                if (!options.flatTernaryExpressions ||
+                    !astUtils.isTokenOnSameLine(node.test, node.consequent) ||
+                    isOnFirstLineOfStatement(firstToken, node)
+                ) {
+                    const questionMarkToken = sourceCode.getFirstTokenBetween(node.test, node.consequent, token => token.type === "Punctuator" && token.value === "?");
+                    const colonToken = sourceCode.getFirstTokenBetween(node.consequent, node.alternate, token => token.type === "Punctuator" && token.value === ":");
+
+                    const firstConsequentToken = sourceCode.getTokenAfter(questionMarkToken);
+                    const lastConsequentToken = sourceCode.getTokenBefore(colonToken);
+                    const firstAlternateToken = sourceCode.getTokenAfter(colonToken);
+
+                    offsets.setDesiredOffset(questionMarkToken, firstToken, 1);
+                    offsets.setDesiredOffset(colonToken, firstToken, 1);
+
+                    offsets.setDesiredOffset(firstConsequentToken, firstToken, firstConsequentToken.type === "Punctuator" &&
+                        options.offsetTernaryExpressions ? 2 : 1);
+
+                    /*
+                     * The alternate and the consequent should usually have the same indentation.
+                     * If they share part of a line, align the alternate against the first token of the consequent.
+                     * This allows the alternate to be indented correctly in cases like this:
+                     * foo ? (
+                     *   bar
+                     * ) : ( // this '(' is aligned with the '(' above, so it's considered to be aligned with `foo`
+                     *   baz // as a result, `baz` is offset by 1 rather than 2
+                     * )
+                     */
+                    if (lastConsequentToken.loc.end.line === firstAlternateToken.loc.start.line) {
+                        offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0);
+                    } else {
+
+                        /**
+                         * If the alternate and consequent do not share part of a line, offset the alternate from the first
+                         * token of the conditional expression. For example:
+                         * foo ? bar
+                         *   : baz
+                         *
+                         * If `baz` were aligned with `bar` rather than being offset by 1 from `foo`, `baz` would end up
+                         * having no expected indentation.
+                         */
+                        offsets.setDesiredOffset(firstAlternateToken, firstToken, firstAlternateToken.type === "Punctuator" &&
+                            options.offsetTernaryExpressions ? 2 : 1);
+                    }
+                }
+            },
+
+            "DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement, WithStatement": node => addBlocklessNodeIndent(node.body),
+
+            ExportNamedDeclaration(node) {
+                if (node.declaration === null) {
+                    const closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken);
+
+                    // Indent the specifiers in `export {foo, bar, baz}`
+                    addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);
+
+                    if (node.source) {
+
+                        // Indent everything after and including the `from` token in `export {foo, bar, baz} from 'qux'`
+                        offsets.setDesiredOffsets([closingCurly.range[1], node.range[1]], sourceCode.getFirstToken(node), 1);
+                    }
+                }
+            },
+
+            ForStatement(node) {
+                const forOpeningParen = sourceCode.getFirstToken(node, 1);
+
+                if (node.init) {
+                    offsets.setDesiredOffsets(node.init.range, forOpeningParen, 1);
+                }
+                if (node.test) {
+                    offsets.setDesiredOffsets(node.test.range, forOpeningParen, 1);
+                }
+                if (node.update) {
+                    offsets.setDesiredOffsets(node.update.range, forOpeningParen, 1);
+                }
+                addBlocklessNodeIndent(node.body);
+            },
+
+            "FunctionDeclaration, FunctionExpression"(node) {
+                const closingParen = sourceCode.getTokenBefore(node.body);
+                const openingParen = sourceCode.getTokenBefore(node.params.length ? node.params[0] : closingParen);
+
+                parameterParens.add(openingParen);
+                parameterParens.add(closingParen);
+                addElementListIndent(node.params, openingParen, closingParen, options[node.type].parameters);
+            },
+
+            IfStatement(node) {
+                addBlocklessNodeIndent(node.consequent);
+                if (node.alternate) {
+                    addBlocklessNodeIndent(node.alternate);
+                }
+            },
+
+            /*
+             * For blockless nodes with semicolon-first style, don't indent the semicolon.
+             * e.g.
+             * if (foo)
+             *     bar()
+             * ; [1, 2, 3].map(foo)
+             *
+             * Traversal into the node sets indentation of the semicolon, so we need to override it on exit.
+             */
+            ":matches(DoWhileStatement, ForStatement, ForInStatement, ForOfStatement, IfStatement, WhileStatement, WithStatement):exit"(node) {
+                let nodesToCheck;
+
+                if (node.type === "IfStatement") {
+                    nodesToCheck = [node.consequent];
+                    if (node.alternate) {
+                        nodesToCheck.push(node.alternate);
+                    }
+                } else {
+                    nodesToCheck = [node.body];
+                }
+
+                for (const nodeToCheck of nodesToCheck) {
+                    const lastToken = sourceCode.getLastToken(nodeToCheck);
+
+                    if (astUtils.isSemicolonToken(lastToken)) {
+                        const tokenBeforeLast = sourceCode.getTokenBefore(lastToken);
+                        const tokenAfterLast = sourceCode.getTokenAfter(lastToken);
+
+                        // override indentation of `;` only if its line looks like a semicolon-first style line
+                        if (
+                            !astUtils.isTokenOnSameLine(tokenBeforeLast, lastToken) &&
+                            tokenAfterLast &&
+                            astUtils.isTokenOnSameLine(lastToken, tokenAfterLast)
+                        ) {
+                            offsets.setDesiredOffset(
+                                lastToken,
+                                sourceCode.getFirstToken(node),
+                                0
+                            );
+                        }
+                    }
+                }
+            },
+
+            ImportDeclaration(node) {
+                if (node.specifiers.some(specifier => specifier.type === "ImportSpecifier")) {
+                    const openingCurly = sourceCode.getFirstToken(node, astUtils.isOpeningBraceToken);
+                    const closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken);
+
+                    addElementListIndent(node.specifiers.filter(specifier => specifier.type === "ImportSpecifier"), openingCurly, closingCurly, options.ImportDeclaration);
+                }
+
+                const fromToken = sourceCode.getLastToken(node, token => token.type === "Identifier" && token.value === "from");
+                const sourceToken = sourceCode.getLastToken(node, token => token.type === "String");
+                const semiToken = sourceCode.getLastToken(node, token => token.type === "Punctuator" && token.value === ";");
+
+                if (fromToken) {
+                    const end = semiToken && semiToken.range[1] === sourceToken.range[1] ? node.range[1] : sourceToken.range[1];
+
+                    offsets.setDesiredOffsets([fromToken.range[0], end], sourceCode.getFirstToken(node), 1);
+                }
+            },
+
+            ImportExpression(node) {
+                const openingParen = sourceCode.getFirstToken(node, 1);
+                const closingParen = sourceCode.getLastToken(node);
+
+                parameterParens.add(openingParen);
+                parameterParens.add(closingParen);
+                offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0);
+
+                addElementListIndent([node.source], openingParen, closingParen, options.CallExpression.arguments);
+            },
+
+            "MemberExpression, JSXMemberExpression, MetaProperty"(node) {
+                const object = node.type === "MetaProperty" ? node.meta : node.object;
+                const firstNonObjectToken = sourceCode.getFirstTokenBetween(object, node.property, astUtils.isNotClosingParenToken);
+                const secondNonObjectToken = sourceCode.getTokenAfter(firstNonObjectToken);
+
+                const objectParenCount = sourceCode.getTokensBetween(object, node.property, { filter: astUtils.isClosingParenToken }).length;
+                const firstObjectToken = objectParenCount
+                    ? sourceCode.getTokenBefore(object, { skip: objectParenCount - 1 })
+                    : sourceCode.getFirstToken(object);
+                const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken);
+                const firstPropertyToken = node.computed ? firstNonObjectToken : secondNonObjectToken;
+
+                if (node.computed) {
+
+                    // For computed MemberExpressions, match the closing bracket with the opening bracket.
+                    offsets.setDesiredOffset(sourceCode.getLastToken(node), firstNonObjectToken, 0);
+                    offsets.setDesiredOffsets(node.property.range, firstNonObjectToken, 1);
+                }
+
+                /*
+                 * If the object ends on the same line that the property starts, match against the last token
+                 * of the object, to ensure that the MemberExpression is not indented.
+                 *
+                 * Otherwise, match against the first token of the object, e.g.
+                 * foo
+                 *   .bar
+                 *   .baz // <-- offset by 1 from `foo`
+                 */
+                const offsetBase = lastObjectToken.loc.end.line === firstPropertyToken.loc.start.line
+                    ? lastObjectToken
+                    : firstObjectToken;
+
+                if (typeof options.MemberExpression === "number") {
+
+                    // Match the dot (for non-computed properties) or the opening bracket (for computed properties) against the object.
+                    offsets.setDesiredOffset(firstNonObjectToken, offsetBase, options.MemberExpression);
+
+                    /*
+                     * For computed MemberExpressions, match the first token of the property against the opening bracket.
+                     * Otherwise, match the first token of the property against the object.
+                     */
+                    offsets.setDesiredOffset(secondNonObjectToken, node.computed ? firstNonObjectToken : offsetBase, options.MemberExpression);
+                } else {
+
+                    // If the MemberExpression option is off, ignore the dot and the first token of the property.
+                    offsets.ignoreToken(firstNonObjectToken);
+                    offsets.ignoreToken(secondNonObjectToken);
+
+                    // To ignore the property indentation, ensure that the property tokens depend on the ignored tokens.
+                    offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0);
+                    offsets.setDesiredOffset(secondNonObjectToken, firstNonObjectToken, 0);
+                }
+            },
+
+            NewExpression(node) {
+
+                // Only indent the arguments if the NewExpression has parens (e.g. `new Foo(bar)` or `new Foo()`, but not `new Foo`
+                if (node.arguments.length > 0 ||
+                        astUtils.isClosingParenToken(sourceCode.getLastToken(node)) &&
+                        astUtils.isOpeningParenToken(sourceCode.getLastToken(node, 1))) {
+                    addFunctionCallIndent(node);
+                }
+            },
+
+            Property(node) {
+                if (!node.shorthand && !node.method && node.kind === "init") {
+                    const colon = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isColonToken);
+
+                    offsets.ignoreToken(sourceCode.getTokenAfter(colon));
+                }
+            },
+
+            PropertyDefinition(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+                const maybeSemicolonToken = sourceCode.getLastToken(node);
+                let keyLastToken = null;
+
+                // Indent key.
+                if (node.computed) {
+                    const bracketTokenL = sourceCode.getTokenBefore(node.key, astUtils.isOpeningBracketToken);
+                    const bracketTokenR = keyLastToken = sourceCode.getTokenAfter(node.key, astUtils.isClosingBracketToken);
+                    const keyRange = [bracketTokenL.range[1], bracketTokenR.range[0]];
+
+                    if (bracketTokenL !== firstToken) {
+                        offsets.setDesiredOffset(bracketTokenL, firstToken, 0);
+                    }
+                    offsets.setDesiredOffsets(keyRange, bracketTokenL, 1);
+                    offsets.setDesiredOffset(bracketTokenR, bracketTokenL, 0);
+                } else {
+                    const idToken = keyLastToken = sourceCode.getFirstToken(node.key);
+
+                    if (idToken !== firstToken) {
+                        offsets.setDesiredOffset(idToken, firstToken, 1);
+                    }
+                }
+
+                // Indent initializer.
+                if (node.value) {
+                    const eqToken = sourceCode.getTokenBefore(node.value, astUtils.isEqToken);
+                    const valueToken = sourceCode.getTokenAfter(eqToken);
+
+                    offsets.setDesiredOffset(eqToken, keyLastToken, 1);
+                    offsets.setDesiredOffset(valueToken, eqToken, 1);
+                    if (astUtils.isSemicolonToken(maybeSemicolonToken)) {
+                        offsets.setDesiredOffset(maybeSemicolonToken, eqToken, 1);
+                    }
+                } else if (astUtils.isSemicolonToken(maybeSemicolonToken)) {
+                    offsets.setDesiredOffset(maybeSemicolonToken, keyLastToken, 1);
+                }
+            },
+
+            StaticBlock(node) {
+                const openingCurly = sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
+                const closingCurly = sourceCode.getLastToken(node);
+
+                addElementListIndent(node.body, openingCurly, closingCurly, options.StaticBlock.body);
+            },
+
+            SwitchStatement(node) {
+                const openingCurly = sourceCode.getTokenAfter(node.discriminant, astUtils.isOpeningBraceToken);
+                const closingCurly = sourceCode.getLastToken(node);
+
+                offsets.setDesiredOffsets([openingCurly.range[1], closingCurly.range[0]], openingCurly, options.SwitchCase);
+
+                if (node.cases.length) {
+                    sourceCode.getTokensBetween(
+                        node.cases[node.cases.length - 1],
+                        closingCurly,
+                        { includeComments: true, filter: astUtils.isCommentToken }
+                    ).forEach(token => offsets.ignoreToken(token));
+                }
+            },
+
+            SwitchCase(node) {
+                if (!(node.consequent.length === 1 && node.consequent[0].type === "BlockStatement")) {
+                    const caseKeyword = sourceCode.getFirstToken(node);
+                    const tokenAfterCurrentCase = sourceCode.getTokenAfter(node);
+
+                    offsets.setDesiredOffsets([caseKeyword.range[1], tokenAfterCurrentCase.range[0]], caseKeyword, 1);
+                }
+            },
+
+            TemplateLiteral(node) {
+                node.expressions.forEach((expression, index) => {
+                    const previousQuasi = node.quasis[index];
+                    const nextQuasi = node.quasis[index + 1];
+                    const tokenToAlignFrom = previousQuasi.loc.start.line === previousQuasi.loc.end.line
+                        ? sourceCode.getFirstToken(previousQuasi)
+                        : null;
+
+                    offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, 1);
+                    offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0);
+                });
+            },
+
+            VariableDeclaration(node) {
+                let variableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclarator, node.kind)
+                    ? options.VariableDeclarator[node.kind]
+                    : DEFAULT_VARIABLE_INDENT;
+
+                const firstToken = sourceCode.getFirstToken(node),
+                    lastToken = sourceCode.getLastToken(node);
+
+                if (options.VariableDeclarator[node.kind] === "first") {
+                    if (node.declarations.length > 1) {
+                        addElementListIndent(
+                            node.declarations,
+                            firstToken,
+                            lastToken,
+                            "first"
+                        );
+                        return;
+                    }
+
+                    variableIndent = DEFAULT_VARIABLE_INDENT;
+                }
+
+                if (node.declarations[node.declarations.length - 1].loc.start.line > node.loc.start.line) {
+
+                    /*
+                     * VariableDeclarator indentation is a bit different from other forms of indentation, in that the
+                     * indentation of an opening bracket sometimes won't match that of a closing bracket. For example,
+                     * the following indentations are correct:
+                     *
+                     * var foo = {
+                     *   ok: true
+                     * };
+                     *
+                     * var foo = {
+                     *     ok: true,
+                     *   },
+                     *   bar = 1;
+                     *
+                     * Account for when exiting the AST (after indentations have already been set for the nodes in
+                     * the declaration) by manually increasing the indentation level of the tokens in this declarator
+                     * on the same line as the start of the declaration, provided that there are declarators that
+                     * follow this one.
+                     */
+                    offsets.setDesiredOffsets(node.range, firstToken, variableIndent, true);
+                } else {
+                    offsets.setDesiredOffsets(node.range, firstToken, variableIndent);
+                }
+
+                if (astUtils.isSemicolonToken(lastToken)) {
+                    offsets.ignoreToken(lastToken);
+                }
+            },
+
+            VariableDeclarator(node) {
+                if (node.init) {
+                    const equalOperator = sourceCode.getTokenBefore(node.init, astUtils.isNotOpeningParenToken);
+                    const tokenAfterOperator = sourceCode.getTokenAfter(equalOperator);
+
+                    offsets.ignoreToken(equalOperator);
+                    offsets.ignoreToken(tokenAfterOperator);
+                    offsets.setDesiredOffsets([tokenAfterOperator.range[0], node.range[1]], equalOperator, 1);
+                    offsets.setDesiredOffset(equalOperator, sourceCode.getLastToken(node.id), 0);
+                }
+            },
+
+            "JSXAttribute[value]"(node) {
+                const equalsToken = sourceCode.getFirstTokenBetween(node.name, node.value, token => token.type === "Punctuator" && token.value === "=");
+
+                offsets.setDesiredOffsets([equalsToken.range[0], node.value.range[1]], sourceCode.getFirstToken(node.name), 1);
+            },
+
+            JSXElement(node) {
+                if (node.closingElement) {
+                    addElementListIndent(node.children, sourceCode.getFirstToken(node.openingElement), sourceCode.getFirstToken(node.closingElement), 1);
+                }
+            },
+
+            JSXOpeningElement(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+                let closingToken;
+
+                if (node.selfClosing) {
+                    closingToken = sourceCode.getLastToken(node, { skip: 1 });
+                    offsets.setDesiredOffset(sourceCode.getLastToken(node), closingToken, 0);
+                } else {
+                    closingToken = sourceCode.getLastToken(node);
+                }
+                offsets.setDesiredOffsets(node.name.range, sourceCode.getFirstToken(node));
+                addElementListIndent(node.attributes, firstToken, closingToken, 1);
+            },
+
+            JSXClosingElement(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+
+                offsets.setDesiredOffsets(node.name.range, firstToken, 1);
+            },
+
+            JSXFragment(node) {
+                const firstOpeningToken = sourceCode.getFirstToken(node.openingFragment);
+                const firstClosingToken = sourceCode.getFirstToken(node.closingFragment);
+
+                addElementListIndent(node.children, firstOpeningToken, firstClosingToken, 1);
+            },
+
+            JSXOpeningFragment(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+                const closingToken = sourceCode.getLastToken(node);
+
+                offsets.setDesiredOffsets(node.range, firstToken, 1);
+                offsets.matchOffsetOf(firstToken, closingToken);
+            },
+
+            JSXClosingFragment(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+                const slashToken = sourceCode.getLastToken(node, { skip: 1 });
+                const closingToken = sourceCode.getLastToken(node);
+                const tokenToMatch = astUtils.isTokenOnSameLine(slashToken, closingToken) ? slashToken : closingToken;
+
+                offsets.setDesiredOffsets(node.range, firstToken, 1);
+                offsets.matchOffsetOf(firstToken, tokenToMatch);
+            },
+
+            JSXExpressionContainer(node) {
+                const openingCurly = sourceCode.getFirstToken(node);
+                const closingCurly = sourceCode.getLastToken(node);
+
+                offsets.setDesiredOffsets(
+                    [openingCurly.range[1], closingCurly.range[0]],
+                    openingCurly,
+                    1
+                );
+            },
+
+            JSXSpreadAttribute(node) {
+                const openingCurly = sourceCode.getFirstToken(node);
+                const closingCurly = sourceCode.getLastToken(node);
+
+                offsets.setDesiredOffsets(
+                    [openingCurly.range[1], closingCurly.range[0]],
+                    openingCurly,
+                    1
+                );
+            },
+
+            "*"(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+
+                // Ensure that the children of every node are indented at least as much as the first token.
+                if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) {
+                    offsets.setDesiredOffsets(node.range, firstToken, 0);
+                }
+            }
+        };
+
+        const listenerCallQueue = [];
+
+        /*
+         * To ignore the indentation of a node:
+         * 1. Don't call the node's listener when entering it (if it has a listener)
+         * 2. Don't set any offsets against the first token of the node.
+         * 3. Call `ignoreNode` on the node sometime after exiting it and before validating offsets.
+         */
+        const offsetListeners = {};
+
+        for (const [selector, listener] of Object.entries(baseOffsetListeners)) {
+
+            /*
+             * Offset listener calls are deferred until traversal is finished, and are called as
+             * part of the final `Program:exit` listener. This is necessary because a node might
+             * be matched by multiple selectors.
+             *
+             * Example: Suppose there is an offset listener for `Identifier`, and the user has
+             * specified in configuration that `MemberExpression > Identifier` should be ignored.
+             * Due to selector specificity rules, the `Identifier` listener will get called first. However,
+             * if a given Identifier node is supposed to be ignored, then the `Identifier` offset listener
+             * should not have been called at all. Without doing extra selector matching, we don't know
+             * whether the Identifier matches the `MemberExpression > Identifier` selector until the
+             * `MemberExpression > Identifier` listener is called.
+             *
+             * To avoid this, the `Identifier` listener isn't called until traversal finishes and all
+             * ignored nodes are known.
+             */
+            offsetListeners[selector] = node => listenerCallQueue.push({ listener, node });
+        }
+
+        // For each ignored node selector, set up a listener to collect it into the `ignoredNodes` set.
+        const ignoredNodes = new Set();
+
+        /**
+         * Ignores a node
+         * @param {ASTNode} node The node to ignore
+         * @returns {void}
+         */
+        function addToIgnoredNodes(node) {
+            ignoredNodes.add(node);
+            ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));
+        }
+
+        const ignoredNodeListeners = options.ignoredNodes.reduce(
+            (listeners, ignoredSelector) => Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }),
+            {}
+        );
+
+        /*
+         * Join the listeners, and add a listener to verify that all tokens actually have the correct indentation
+         * at the end.
+         *
+         * Using Object.assign will cause some offset listeners to be overwritten if the same selector also appears
+         * in `ignoredNodeListeners`. This isn't a problem because all of the matching nodes will be ignored,
+         * so those listeners wouldn't be called anyway.
+         */
+        return Object.assign(
+            offsetListeners,
+            ignoredNodeListeners,
+            {
+                "*:exit"(node) {
+
+                    // If a node's type is nonstandard, we can't tell how its children should be offset, so ignore it.
+                    if (!KNOWN_NODES.has(node.type)) {
+                        addToIgnoredNodes(node);
+                    }
+                },
+                "Program:exit"() {
+
+                    // If ignoreComments option is enabled, ignore all comment tokens.
+                    if (options.ignoreComments) {
+                        sourceCode.getAllComments()
+                            .forEach(comment => offsets.ignoreToken(comment));
+                    }
+
+                    // Invoke the queued offset listeners for the nodes that aren't ignored.
+                    for (let i = 0; i < listenerCallQueue.length; i++) {
+                        const nodeInfo = listenerCallQueue[i];
+
+                        if (!ignoredNodes.has(nodeInfo.node)) {
+                            nodeInfo.listener(nodeInfo.node);
+                        }
+                    }
+
+                    // Update the offsets for ignored nodes to prevent their child tokens from being reported.
+                    ignoredNodes.forEach(ignoreNode);
+
+                    addParensIndent(sourceCode.ast.tokens);
+
+                    /*
+                     * Create a Map from (tokenOrComment) => (precedingToken).
+                     * This is necessary because sourceCode.getTokenBefore does not handle a comment as an argument correctly.
+                     */
+                    const precedingTokens = new WeakMap();
+
+                    for (let i = 0; i < sourceCode.ast.comments.length; i++) {
+                        const comment = sourceCode.ast.comments[i];
+
+                        const tokenOrCommentBefore = sourceCode.getTokenBefore(comment, { includeComments: true });
+                        const hasToken = precedingTokens.has(tokenOrCommentBefore) ? precedingTokens.get(tokenOrCommentBefore) : tokenOrCommentBefore;
+
+                        precedingTokens.set(comment, hasToken);
+                    }
+
+                    for (let i = 1; i < sourceCode.lines.length + 1; i++) {
+
+                        if (!tokenInfo.firstTokensByLineNumber.has(i)) {
+
+                            // Don't check indentation on blank lines
+                            continue;
+                        }
+
+                        const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(i);
+
+                        if (firstTokenOfLine.loc.start.line !== i) {
+
+                            // Don't check the indentation of multi-line tokens (e.g. template literals or block comments) twice.
+                            continue;
+                        }
+
+                        if (astUtils.isCommentToken(firstTokenOfLine)) {
+                            const tokenBefore = precedingTokens.get(firstTokenOfLine);
+                            const tokenAfter = tokenBefore ? sourceCode.getTokenAfter(tokenBefore) : sourceCode.ast.tokens[0];
+                            const mayAlignWithBefore = tokenBefore && !hasBlankLinesBetween(tokenBefore, firstTokenOfLine);
+                            const mayAlignWithAfter = tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter);
+
+                            /*
+                             * If a comment precedes a line that begins with a semicolon token, align to that token, i.e.
+                             *
+                             * let foo
+                             * // comment
+                             * ;(async () => {})()
+                             */
+                            if (tokenAfter && astUtils.isSemicolonToken(tokenAfter) && !astUtils.isTokenOnSameLine(firstTokenOfLine, tokenAfter)) {
+                                offsets.setDesiredOffset(firstTokenOfLine, tokenAfter, 0);
+                            }
+
+                            // If a comment matches the expected indentation of the token immediately before or after, don't report it.
+                            if (
+                                mayAlignWithBefore && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore)) ||
+                                mayAlignWithAfter && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenAfter))
+                            ) {
+                                continue;
+                            }
+                        }
+
+                        // If the token matches the expected indentation, don't report it.
+                        if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) {
+                            continue;
+                        }
+
+                        // Otherwise, report the token/comment.
+                        report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));
+                    }
+                }
+            }
+        );
+    }
+};