@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/indent.js

@@ -1,2334 +0,0 @@
-/**
- * @fileoverview This rule sets a specific indentation style and width for your code
- *
- * @author Teddy Katz
- * @author Vitaly Puzrin
- * @author Gyandeep Singh
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const KNOWN_NODES = new Set([
-	"AssignmentExpression",
-	"AssignmentPattern",
-	"ArrayExpression",
-	"ArrayPattern",
-	"ArrowFunctionExpression",
-	"AwaitExpression",
-	"BlockStatement",
-	"BinaryExpression",
-	"BreakStatement",
-	"CallExpression",
-	"CatchClause",
-	"ChainExpression",
-	"ClassBody",
-	"ClassDeclaration",
-	"ClassExpression",
-	"ConditionalExpression",
-	"ContinueStatement",
-	"DoWhileStatement",
-	"DebuggerStatement",
-	"EmptyStatement",
-	"ExperimentalRestProperty",
-	"ExperimentalSpreadProperty",
-	"ExpressionStatement",
-	"ForStatement",
-	"ForInStatement",
-	"ForOfStatement",
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"Identifier",
-	"IfStatement",
-	"Literal",
-	"LabeledStatement",
-	"LogicalExpression",
-	"MemberExpression",
-	"MetaProperty",
-	"MethodDefinition",
-	"NewExpression",
-	"ObjectExpression",
-	"ObjectPattern",
-	"PrivateIdentifier",
-	"Program",
-	"Property",
-	"PropertyDefinition",
-	"RestElement",
-	"ReturnStatement",
-	"SequenceExpression",
-	"SpreadElement",
-	"StaticBlock",
-	"Super",
-	"SwitchCase",
-	"SwitchStatement",
-	"TaggedTemplateExpression",
-	"TemplateElement",
-	"TemplateLiteral",
-	"ThisExpression",
-	"ThrowStatement",
-	"TryStatement",
-	"UnaryExpression",
-	"UpdateExpression",
-	"VariableDeclaration",
-	"VariableDeclarator",
-	"WhileStatement",
-	"WithStatement",
-	"YieldExpression",
-	"JSXFragment",
-	"JSXOpeningFragment",
-	"JSXClosingFragment",
-	"JSXIdentifier",
-	"JSXNamespacedName",
-	"JSXMemberExpression",
-	"JSXEmptyExpression",
-	"JSXExpressionContainer",
-	"JSXElement",
-	"JSXClosingElement",
-	"JSXOpeningElement",
-	"JSXAttribute",
-	"JSXSpreadAttribute",
-	"JSXText",
-	"ExportDefaultDeclaration",
-	"ExportNamedDeclaration",
-	"ExportAllDeclaration",
-	"ExportSpecifier",
-	"ImportDeclaration",
-	"ImportSpecifier",
-	"ImportDefaultSpecifier",
-	"ImportNamespaceSpecifier",
-	"ImportExpression",
-]);
-
-/*
- * General rule strategy:
- * 1. An OffsetStorage instance stores a map of desired offsets, where each token has a specified offset from another
- *    specified token or to the first column.
- * 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For example, when entering a
- *    BlockStatement, offset all of the tokens in the BlockStatement by 1 indent level from the opening curly
- *    brace of the BlockStatement.
- * 3. After traversing the AST, calculate the expected indentation levels of every token according to the
- *    OffsetStorage container.
- * 4. For each line, compare the expected indentation of the first token to the actual indentation in the file,
- *    and report the token if the two values are not equal.
- */
-
-/**
- * A mutable map that stores (key, value) pairs. The keys are numeric indices, and must be unique.
- * This is intended to be a generic wrapper around a map with non-negative integer keys, so that the underlying implementation
- * can easily be swapped out.
- */
-class IndexMap {
-	/**
-	 * Creates an empty map
-	 * @param {number} maxKey The maximum key
-	 */
-	constructor(maxKey) {
-		// Initializing the array with the maximum expected size avoids dynamic reallocations that could degrade performance.
-		this._values = Array(maxKey + 1);
-	}
-
-	/**
-	 * Inserts an entry into the map.
-	 * @param {number} key The entry's key
-	 * @param {any} value The entry's value
-	 * @returns {void}
-	 */
-	insert(key, value) {
-		this._values[key] = value;
-	}
-
-	/**
-	 * Finds the value of the entry with the largest key less than or equal to the provided key
-	 * @param {number} key The provided key
-	 * @returns {*|undefined} The value of the found entry, or undefined if no such entry exists.
-	 */
-	findLastNotAfter(key) {
-		const values = this._values;
-
-		for (let index = key; index >= 0; index--) {
-			const value = values[index];
-
-			if (value) {
-				return value;
-			}
-		}
-		return void 0;
-	}
-
-	/**
-	 * Deletes all of the keys in the interval [start, end)
-	 * @param {number} start The start of the range
-	 * @param {number} end The end of the range
-	 * @returns {void}
-	 */
-	deleteRange(start, end) {
-		this._values.fill(void 0, start, end);
-	}
-}
-
-/**
- * A helper class to get token-based info related to indentation
- */
-class TokenInfo {
-	/**
-	 * @param {SourceCode} sourceCode A SourceCode object
-	 */
-	constructor(sourceCode) {
-		this.sourceCode = sourceCode;
-		this.firstTokensByLineNumber = new Map();
-		const tokens = sourceCode.tokensAndComments;
-
-		for (let i = 0; i < tokens.length; i++) {
-			const token = tokens[i];
-
-			if (!this.firstTokensByLineNumber.has(token.loc.start.line)) {
-				this.firstTokensByLineNumber.set(token.loc.start.line, token);
-			}
-			if (
-				!this.firstTokensByLineNumber.has(token.loc.end.line) &&
-				sourceCode.text
-					.slice(
-						token.range[1] - token.loc.end.column,
-						token.range[1],
-					)
-					.trim()
-			) {
-				this.firstTokensByLineNumber.set(token.loc.end.line, token);
-			}
-		}
-	}
-
-	/**
-	 * Gets the first token on a given token's line
-	 * @param {Token|ASTNode} token a node or token
-	 * @returns {Token} The first token on the given line
-	 */
-	getFirstTokenOfLine(token) {
-		return this.firstTokensByLineNumber.get(token.loc.start.line);
-	}
-
-	/**
-	 * Determines whether a token is the first token in its line
-	 * @param {Token} token The token
-	 * @returns {boolean} `true` if the token is the first on its line
-	 */
-	isFirstTokenOfLine(token) {
-		return this.getFirstTokenOfLine(token) === token;
-	}
-
-	/**
-	 * Get the actual indent of a token
-	 * @param {Token} token Token to examine. This should be the first token on its line.
-	 * @returns {string} The indentation characters that precede the token
-	 */
-	getTokenIndent(token) {
-		return this.sourceCode.text.slice(
-			token.range[0] - token.loc.start.column,
-			token.range[0],
-		);
-	}
-}
-
-/**
- * A class to store information on desired offsets of tokens from each other
- */
-class OffsetStorage {
-	/**
-	 * @param {TokenInfo} tokenInfo a TokenInfo instance
-	 * @param {number} indentSize The desired size of each indentation level
-	 * @param {string} indentType The indentation character
-	 * @param {number} maxIndex The maximum end index of any token
-	 */
-	constructor(tokenInfo, indentSize, indentType, maxIndex) {
-		this._tokenInfo = tokenInfo;
-		this._indentSize = indentSize;
-		this._indentType = indentType;
-
-		this._indexMap = new IndexMap(maxIndex);
-		this._indexMap.insert(0, { offset: 0, from: null, force: false });
-
-		this._lockedFirstTokens = new WeakMap();
-		this._desiredIndentCache = new WeakMap();
-		this._ignoredTokens = new WeakSet();
-	}
-
-	_getOffsetDescriptor(token) {
-		return this._indexMap.findLastNotAfter(token.range[0]);
-	}
-
-	/**
-	 * Sets the offset column of token B to match the offset column of token A.
-	 * - **WARNING**: This matches a *column*, even if baseToken is not the first token on its line. In
-	 * most cases, `setDesiredOffset` should be used instead.
-	 * @param {Token} baseToken The first token
-	 * @param {Token} offsetToken The second token, whose offset should be matched to the first token
-	 * @returns {void}
-	 */
-	matchOffsetOf(baseToken, offsetToken) {
-		/*
-		 * lockedFirstTokens is a map from a token whose indentation is controlled by the "first" option to
-		 * the token that it depends on. For example, with the `ArrayExpression: first` option, the first
-		 * token of each element in the array after the first will be mapped to the first token of the first
-		 * element. The desired indentation of each of these tokens is computed based on the desired indentation
-		 * of the "first" element, rather than through the normal offset mechanism.
-		 */
-		this._lockedFirstTokens.set(offsetToken, baseToken);
-	}
-
-	/**
-	 * Sets the desired offset of a token.
-	 *
-	 * This uses a line-based offset collapsing behavior to handle tokens on the same line.
-	 * For example, consider the following two cases:
-	 *
-	 * (
-	 *     [
-	 *         bar
-	 *     ]
-	 * )
-	 *
-	 * ([
-	 *     bar
-	 * ])
-	 *
-	 * Based on the first case, it's clear that the `bar` token needs to have an offset of 1 indent level (4 spaces) from
-	 * the `[` token, and the `[` token has to have an offset of 1 indent level from the `(` token. Since the `(` token is
-	 * the first on its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 indent levels (8 spaces)
-	 * from the start of its line.
-	 *
-	 * However, in the second case `bar` should only be indented by 4 spaces. This is because the offset of 1 indent level
-	 * between the `(` and the `[` tokens gets "collapsed" because the two tokens are on the same line. As a result, the
-	 * `(` token is mapped to the `[` token with an offset of 0, and the rule correctly decides that `bar` should be indented
-	 * by 1 indent level from the start of the line.
-	 *
-	 * This is useful because rule listeners can usually just call `setDesiredOffset` for all the tokens in the node,
-	 * without needing to check which lines those tokens are on.
-	 *
-	 * Note that since collapsing only occurs when two tokens are on the same line, there are a few cases where non-intuitive
-	 * behavior can occur. For example, consider the following cases:
-	 *
-	 * foo(
-	 * ).
-	 *     bar(
-	 *         baz
-	 *     )
-	 *
-	 * foo(
-	 * ).bar(
-	 *     baz
-	 * )
-	 *
-	 * Based on the first example, it would seem that `bar` should be offset by 1 indent level from `foo`, and `baz`
-	 * should be offset by 1 indent level from `bar`. However, this is not correct, because it would result in `baz`
-	 * being indented by 2 indent levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, no
-	 * collapsing would occur).
-	 *
-	 * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset `bar` by 1 level from the `)`, and
-	 * offset the `)` by 0 levels from `foo`. This ensures that the offset between `bar` and the `)` are correctly collapsed
-	 * in the second case.
-	 * @param {Token} token The token
-	 * @param {Token} fromToken The token that `token` should be offset from
-	 * @param {number} offset The desired indent level
-	 * @returns {void}
-	 */
-	setDesiredOffset(token, fromToken, offset) {
-		return this.setDesiredOffsets(token.range, fromToken, offset);
-	}
-
-	/**
-	 * Sets the desired offset of all tokens in a range
-	 * It's common for node listeners in this file to need to apply the same offset to a large, contiguous range of tokens.
-	 * Moreover, the offset of any given token is usually updated multiple times (roughly once for each node that contains
-	 * it). This means that the offset of each token is updated O(AST depth) times.
-	 * It would not be performant to store and update the offsets for each token independently, because the rule would end
-	 * up having a time complexity of O(number of tokens * AST depth), which is quite slow for large files.
-	 *
-	 * Instead, the offset tree is represented as a collection of contiguous offset ranges in a file. For example, the following
-	 * list could represent the state of the offset tree at a given point:
-	 *
-	 * - Tokens starting in the interval [0, 15) are aligned with the beginning of the file
-	 * - Tokens starting in the interval [15, 30) are offset by 1 indent level from the `bar` token
-	 * - Tokens starting in the interval [30, 43) are offset by 1 indent level from the `foo` token
-	 * - Tokens starting in the interval [43, 820) are offset by 2 indent levels from the `bar` token
-	 * - Tokens starting in the interval [820, ∞) are offset by 1 indent level from the `baz` token
-	 *
-	 * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line above would be inserted by using:
-	 * `setDesiredOffsets([30, 43], fooToken, 1);`
-	 * @param {[number, number]} range A [start, end] pair. All tokens with range[0] <= token.start < range[1] will have the offset applied.
-	 * @param {Token} fromToken The token that this is offset from
-	 * @param {number} offset The desired indent level
-	 * @param {boolean} force `true` if this offset should not use the normal collapsing behavior. This should almost always be false.
-	 * @returns {void}
-	 */
-	setDesiredOffsets(range, fromToken, offset, force) {
-		/*
-		 * Offset ranges are stored as a collection of nodes, where each node maps a numeric key to an offset
-		 * descriptor. The tree for the example above would have the following nodes:
-		 *
-		 * * key: 0, value: { offset: 0, from: null }
-		 * * key: 15, value: { offset: 1, from: barToken }
-		 * * key: 30, value: { offset: 1, from: fooToken }
-		 * * key: 43, value: { offset: 2, from: barToken }
-		 * * key: 820, value: { offset: 1, from: bazToken }
-		 *
-		 * To find the offset descriptor for any given token, one needs to find the node with the largest key
-		 * which is <= token.start. To make this operation fast, the nodes are stored in a map indexed by key.
-		 */
-
-		const descriptorToInsert = { offset, from: fromToken, force };
-
-		const descriptorAfterRange = this._indexMap.findLastNotAfter(range[1]);
-
-		const fromTokenIsInRange =
-			fromToken &&
-			fromToken.range[0] >= range[0] &&
-			fromToken.range[1] <= range[1];
-		const fromTokenDescriptor =
-			fromTokenIsInRange && this._getOffsetDescriptor(fromToken);
-
-		// First, remove any existing nodes in the range from the map.
-		this._indexMap.deleteRange(range[0] + 1, range[1]);
-
-		// Insert a new node into the map for this range
-		this._indexMap.insert(range[0], descriptorToInsert);
-
-		/*
-		 * To avoid circular offset dependencies, keep the `fromToken` token mapped to whatever it was mapped to previously,
-		 * even if it's in the current range.
-		 */
-		if (fromTokenIsInRange) {
-			this._indexMap.insert(fromToken.range[0], fromTokenDescriptor);
-			this._indexMap.insert(fromToken.range[1], descriptorToInsert);
-		}
-
-		/*
-		 * To avoid modifying the offset of tokens after the range, insert another node to keep the offset of the following
-		 * tokens the same as it was before.
-		 */
-		this._indexMap.insert(range[1], descriptorAfterRange);
-	}
-
-	/**
-	 * Gets the desired indent of a token
-	 * @param {Token} token The token
-	 * @returns {string} The desired indent of the token
-	 */
-	getDesiredIndent(token) {
-		if (!this._desiredIndentCache.has(token)) {
-			if (this._ignoredTokens.has(token)) {
-				/*
-				 * If the token is ignored, use the actual indent of the token as the desired indent.
-				 * This ensures that no errors are reported for this token.
-				 */
-				this._desiredIndentCache.set(
-					token,
-					this._tokenInfo.getTokenIndent(token),
-				);
-			} else if (this._lockedFirstTokens.has(token)) {
-				const firstToken = this._lockedFirstTokens.get(token);
-
-				this._desiredIndentCache.set(
-					token,
-
-					// (indentation for the first element's line)
-					this.getDesiredIndent(
-						this._tokenInfo.getFirstTokenOfLine(firstToken),
-					) +
-						// (space between the start of the first element's line and the first element)
-						this._indentType.repeat(
-							firstToken.loc.start.column -
-								this._tokenInfo.getFirstTokenOfLine(firstToken)
-									.loc.start.column,
-						),
-				);
-			} else {
-				const offsetInfo = this._getOffsetDescriptor(token);
-				const offset =
-					offsetInfo.from &&
-					offsetInfo.from.loc.start.line === token.loc.start.line &&
-					!/^\s*?\n/u.test(token.value) &&
-					!offsetInfo.force
-						? 0
-						: offsetInfo.offset * this._indentSize;
-
-				this._desiredIndentCache.set(
-					token,
-					(offsetInfo.from
-						? this.getDesiredIndent(offsetInfo.from)
-						: "") + this._indentType.repeat(offset),
-				);
-			}
-		}
-		return this._desiredIndentCache.get(token);
-	}
-
-	/**
-	 * Ignores a token, preventing it from being reported.
-	 * @param {Token} token The token
-	 * @returns {void}
-	 */
-	ignoreToken(token) {
-		if (this._tokenInfo.isFirstTokenOfLine(token)) {
-			this._ignoredTokens.add(token);
-		}
-	}
-
-	/**
-	 * Gets the first token that the given token's indentation is dependent on
-	 * @param {Token} token The token
-	 * @returns {Token} The token that the given token depends on, or `null` if the given token is at the top level
-	 */
-	getFirstDependency(token) {
-		return this._getOffsetDescriptor(token).from;
-	}
-}
-
-const ELEMENT_LIST_SCHEMA = {
-	oneOf: [
-		{
-			type: "integer",
-			minimum: 0,
-		},
-		{
-			enum: ["first", "off"],
-		},
-	],
-};
-
-/** @type {import('../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: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"ESLint Stylistic now maintains deprecated stylistic core rules.",
-					url: "https://eslint.style/guide/migration",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "indent",
-						url: "https://eslint.style/rules/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 {number} expectedAmount The expected amount of indentation characters for this line
-		 * @param {number} actualSpaces The actual number of indentation spaces that were found on this line
-		 * @param {number} 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),
-					);
-				}
-			},
-		});
-	},
-};