eslint 9.22.0 → 9.24.0

package/lib/rules/indent.js

@@ -20,93 +20,93 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 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"
+	"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",
 ]);
 
 /*
@@ -122,1700 +122,2213 @@ const KNOWN_NODES = new Set([
  *    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);
-    }
+	/**
+	 * 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]);
-    }
+	/**
+	 * @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;
-    }
+	/**
+	 * @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"]
-        }
-    ]
+	oneOf: [
+		{
+			type: "integer",
+			minimum: 0,
+		},
+		{
+			enum: ["first", "off"],
+		},
+	],
 };
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        deprecated: {
-            message: "Formatting rules are being moved out of ESLint core.",
-            url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-            deprecatedSince: "8.53.0",
-            availableUntil: "10.0.0",
-            replacedBy: [
-                {
-                    message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
-                    url: "https://eslint.style/guide/migration",
-                    plugin: {
-                        name: "@stylistic/eslint-plugin-js",
-                        url: "https://eslint.style/packages/js"
-                    },
-                    rule: {
-                        name: "indent",
-                        url: "https://eslint.style/rules/js/indent"
-                    }
-                }
-            ]
-        },
-        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.at(-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;
-
-                // 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.at(-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.hasOwn(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.at(-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));
-                    }
-                }
-            }
-        );
-    }
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "10.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin-js",
+						url: "https://eslint.style/packages/js",
+					},
+					rule: {
+						name: "indent",
+						url: "https://eslint.style/rules/js/indent",
+					},
+				},
+			],
+		},
+		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.at(-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;
+
+				// 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.at(-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.hasOwn(
+					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.at(-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),
+					);
+				}
+			},
+		});
+	},
 };