import { E as getCommentsBetween, I as isEqToken, K as isSingleLine, Q as warnDeprecatedOptions, S as STATEMENT_LIST_PARENTS, T as createGlobalLinebreakMatcher, W as isQuestionToken, Z as skipChainExpression, f as createRule, g as import_ast_utils, l as isESTreeSourceCode, m as AST_NODE_TYPES } from "../utils.js";
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",
	"ExpressionStatement",
	"ForStatement",
	"ForInStatement",
	"ForOfStatement",
	"FunctionDeclaration",
	"FunctionExpression",
	"Identifier",
	"IfStatement",
	"Literal",
	"LabeledStatement",
	"LogicalExpression",
	"MemberExpression",
	"MetaProperty",
	"MethodDefinition",
	"NewExpression",
	"ObjectExpression",
	"ObjectPattern",
	"PrivateIdentifier",
	"Program",
	"Property",
	"PropertyDefinition",
	AST_NODE_TYPES.AccessorProperty,
	"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",
	"ImportAttribute",
	AST_NODE_TYPES.TSAbstractKeyword,
	AST_NODE_TYPES.TSAnyKeyword,
	AST_NODE_TYPES.TSBooleanKeyword,
	AST_NODE_TYPES.TSNeverKeyword,
	AST_NODE_TYPES.TSNumberKeyword,
	AST_NODE_TYPES.TSStringKeyword,
	AST_NODE_TYPES.TSSymbolKeyword,
	AST_NODE_TYPES.TSUndefinedKeyword,
	AST_NODE_TYPES.TSUnknownKeyword,
	AST_NODE_TYPES.TSVoidKeyword,
	AST_NODE_TYPES.TSNullKeyword,
	AST_NODE_TYPES.TSAbstractPropertyDefinition,
	AST_NODE_TYPES.TSAbstractAccessorProperty,
	AST_NODE_TYPES.TSAbstractMethodDefinition,
	AST_NODE_TYPES.TSArrayType,
	AST_NODE_TYPES.TSAsExpression,
	AST_NODE_TYPES.TSCallSignatureDeclaration,
	AST_NODE_TYPES.TSConditionalType,
	AST_NODE_TYPES.TSConstructorType,
	AST_NODE_TYPES.TSConstructSignatureDeclaration,
	AST_NODE_TYPES.TSDeclareFunction,
	AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
	AST_NODE_TYPES.TSEnumDeclaration,
	AST_NODE_TYPES.TSEnumBody,
	AST_NODE_TYPES.TSEnumMember,
	AST_NODE_TYPES.TSExportAssignment,
	AST_NODE_TYPES.TSExternalModuleReference,
	AST_NODE_TYPES.TSFunctionType,
	AST_NODE_TYPES.TSImportType,
	AST_NODE_TYPES.TSIndexedAccessType,
	AST_NODE_TYPES.TSIndexSignature,
	AST_NODE_TYPES.TSInferType,
	AST_NODE_TYPES.TSInterfaceBody,
	AST_NODE_TYPES.TSInterfaceDeclaration,
	AST_NODE_TYPES.TSInterfaceHeritage,
	AST_NODE_TYPES.TSImportEqualsDeclaration,
	AST_NODE_TYPES.TSLiteralType,
	AST_NODE_TYPES.TSMappedType,
	AST_NODE_TYPES.TSMethodSignature,
	AST_NODE_TYPES.TSModuleBlock,
	AST_NODE_TYPES.TSModuleDeclaration,
	AST_NODE_TYPES.TSNonNullExpression,
	AST_NODE_TYPES.TSParameterProperty,
	AST_NODE_TYPES.TSPropertySignature,
	AST_NODE_TYPES.TSQualifiedName,
	AST_NODE_TYPES.TSRestType,
	AST_NODE_TYPES.TSThisType,
	AST_NODE_TYPES.TSTupleType,
	AST_NODE_TYPES.TSTypeAliasDeclaration,
	AST_NODE_TYPES.TSTypeAnnotation,
	AST_NODE_TYPES.TSTypeLiteral,
	AST_NODE_TYPES.TSTypeOperator,
	AST_NODE_TYPES.TSTypeParameter,
	AST_NODE_TYPES.TSTypeParameterDeclaration,
	AST_NODE_TYPES.TSTypeParameterInstantiation,
	AST_NODE_TYPES.TSTypeReference,
	AST_NODE_TYPES.Decorator
]);
var IndexMap = class {
	_values;
	constructor(maxKey) {
		this._values = new Array(maxKey + 1);
	}
	insert(key, value) {
		this._values[key] = value;
	}
	findLastNotAfter(key) {
		const values = this._values;
		for (let index = key; index >= 0; index--) {
			const value = values[index];
			if (value) return value;
		}
	}
	deleteRange(start, end) {
		this._values.fill(void 0, start, end);
	}
};
var TokenInfo = class {
	sourceCode;
	firstTokensByLineNumber;
	constructor(sourceCode) {
		this.sourceCode = sourceCode;
		this.firstTokensByLineNumber = /* @__PURE__ */ 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);
		}
	}
	getFirstTokenOfLine(token) {
		return this.firstTokensByLineNumber.get(token.loc.start.line);
	}
	isFirstTokenOfLine(token) {
		return this.getFirstTokenOfLine(token) === token;
	}
	getTokenIndent(token) {
		return this.sourceCode.text.slice(token.range[0] - token.loc.start.column, token.range[0]);
	}
};
var OffsetStorage = class {
	_tokenInfo;
	_indentSize;
	_indentType;
	_indexMap;
	_lockedFirstTokens = /* @__PURE__ */ new WeakMap();
	_desiredIndentCache = /* @__PURE__ */ new WeakMap();
	_ignoredTokens = /* @__PURE__ */ new WeakSet();
	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
		});
	}
	_getOffsetDescriptor(token) {
		return this._indexMap.findLastNotAfter(token.range[0]);
	}
	matchOffsetOf(baseToken, offsetToken) {
		this._lockedFirstTokens.set(offsetToken, baseToken);
	}
	setDesiredOffset(token, fromToken, offset) {
		if (token) this.setDesiredOffsets(token.range, fromToken, offset);
	}
	setDesiredOffsets(range, fromToken, offset, force = false) {
		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);
		this._indexMap.deleteRange(range[0] + 1, range[1]);
		this._indexMap.insert(range[0], descriptorToInsert);
		if (fromTokenIsInRange) {
			this._indexMap.insert(fromToken.range[0], fromTokenDescriptor);
			this._indexMap.insert(fromToken.range[1], descriptorToInsert);
		}
		this._indexMap.insert(range[1], descriptorAfterRange);
	}
	getDesiredIndent(token) {
		if (!this._desiredIndentCache.has(token)) if (this._ignoredTokens.has(token)) this._desiredIndentCache.set(token, this._tokenInfo.getTokenIndent(token));
		else if (this._lockedFirstTokens.has(token)) {
			const firstToken = this._lockedFirstTokens.get(token);
			const firstTokenOfLine = this._tokenInfo.getFirstTokenOfLine(firstToken);
			this._desiredIndentCache.set(token, this.getDesiredIndent(firstTokenOfLine) + this._indentType.repeat(firstToken.loc.start.column - firstTokenOfLine.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);
	}
	ignoreToken(token) {
		if (this._tokenInfo.isFirstTokenOfLine(token)) this._ignoredTokens.add(token);
	}
	getFirstDependency(token) {
		return this._getOffsetDescriptor(token).from;
	}
};
const ELEMENT_LIST_SCHEMA = { oneOf: [{
	type: "integer",
	minimum: 0
}, {
	type: "string",
	enum: ["first", "off"]
}] };
var indent_default = createRule({
	name: "indent",
	meta: {
		type: "layout",
		docs: { description: "Enforce consistent indentation" },
		fixable: "whitespace",
		schema: [{ oneOf: [{
			type: "string",
			enum: ["tab"]
		}, {
			type: "integer",
			minimum: 0
		}] }, {
			type: "object",
			properties: {
				SwitchCase: {
					type: "integer",
					minimum: 0
				},
				VariableDeclarator: { oneOf: [ELEMENT_LIST_SCHEMA, {
					type: "object",
					properties: {
						var: ELEMENT_LIST_SCHEMA,
						let: ELEMENT_LIST_SCHEMA,
						const: ELEMENT_LIST_SCHEMA,
						using: ELEMENT_LIST_SCHEMA
					},
					additionalProperties: false
				}] },
				assignmentOperator: { oneOf: [{
					type: "integer",
					minimum: 0
				}, {
					type: "string",
					enum: ["off"]
				}] },
				outerIIFEBody: { oneOf: [{
					type: "integer",
					minimum: 0
				}, {
					type: "string",
					enum: ["off"]
				}] },
				MemberExpression: { oneOf: [{
					type: "integer",
					minimum: 0
				}, {
					type: "string",
					enum: ["off"]
				}] },
				FunctionDeclaration: {
					type: "object",
					properties: {
						parameters: ELEMENT_LIST_SCHEMA,
						body: {
							type: "integer",
							minimum: 0
						},
						returnType: {
							type: "integer",
							minimum: 0
						}
					},
					additionalProperties: false
				},
				FunctionExpression: {
					type: "object",
					properties: {
						parameters: ELEMENT_LIST_SCHEMA,
						body: {
							type: "integer",
							minimum: 0
						},
						returnType: {
							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" },
				offsetTernaryExpressions: { oneOf: [{ type: "boolean" }, {
					type: "object",
					properties: {
						CallExpression: { type: "boolean" },
						AwaitExpression: { type: "boolean" },
						NewExpression: { type: "boolean" }
					},
					additionalProperties: false
				}] },
				offsetTernaryExpressionsOffsetCallExpressions: { type: "boolean" },
				ignoredNodes: {
					type: "array",
					items: {
						type: "string",
						not: {
							type: "string",
							pattern: ":exit$"
						}
					}
				},
				ignoreComments: { type: "boolean" },
				tabLength: { type: "number" }
			},
			additionalProperties: false
		}],
		defaultOptions: [4, {
			SwitchCase: 1,
			flatTernaryExpressions: false,
			ignoredNodes: []
		}],
		messages: { wrongIndentation: "Expected indentation of {{expected}} but found {{actual}}." }
	},
	create(context, optionsWithDefaults) {
		if (!isESTreeSourceCode(context.sourceCode)) return {};
		const DEFAULT_VARIABLE_INDENT = 1;
		const DEFAULT_PARAMETER_INDENT = 1;
		const DEFAULT_FUNCTION_BODY_INDENT = 1;
		const DEFAULT_FUNCTION_RETURN_TYPE_INDENT = 1;
		warnDeprecatedOptions(context.options[1], "offsetTernaryExpressionsOffsetCallExpressions", "offsetTernaryExpressions.CallExpression", "indent");
		let indentType = "space";
		let indentSize = 4;
		const options = {
			SwitchCase: 0,
			VariableDeclarator: {
				var: DEFAULT_VARIABLE_INDENT,
				let: DEFAULT_VARIABLE_INDENT,
				const: DEFAULT_VARIABLE_INDENT,
				using: DEFAULT_VARIABLE_INDENT
			},
			outerIIFEBody: 1,
			assignmentOperator: 1,
			FunctionDeclaration: {
				parameters: DEFAULT_PARAMETER_INDENT,
				body: DEFAULT_FUNCTION_BODY_INDENT,
				returnType: DEFAULT_FUNCTION_RETURN_TYPE_INDENT
			},
			FunctionExpression: {
				parameters: DEFAULT_PARAMETER_INDENT,
				body: DEFAULT_FUNCTION_BODY_INDENT,
				returnType: DEFAULT_FUNCTION_RETURN_TYPE_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,
			offsetTernaryExpressions: false,
			offsetTernaryExpressionsOffsetCallExpressions: true,
			tabLength: 4
		};
		if (optionsWithDefaults.length) {
			if (optionsWithDefaults[0] === "tab") {
				indentSize = 1;
				indentType = "tab";
			} else {
				indentSize = optionsWithDefaults[0] ?? indentSize;
				indentType = "space";
			}
			const userOptions = optionsWithDefaults[1];
			if (userOptions) {
				Object.assign(options, userOptions);
				if (typeof userOptions.VariableDeclarator === "number" || userOptions.VariableDeclarator === "first") options.VariableDeclarator = {
					var: userOptions.VariableDeclarator,
					let: userOptions.VariableDeclarator,
					const: userOptions.VariableDeclarator,
					using: userOptions.VariableDeclarator
				};
			}
		}
		const sourceCode = context.sourceCode;
		const tokenInfo = new TokenInfo(sourceCode);
		const offsets = new OffsetStorage(tokenInfo, indentSize, indentType === "space" ? " " : "	", sourceCode.text.length);
		const parameterParens = /* @__PURE__ */ new WeakSet();
		function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {
			const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? "" : "s"}`;
			const foundSpacesWord = `space${actualSpaces === 1 ? "" : "s"}`;
			const foundTabsWord = `tab${actualTabs === 1 ? "" : "s"}`;
			let foundStatement;
			if (actualSpaces > 0) foundStatement = indentType === "space" ? actualSpaces : `${actualSpaces} ${foundSpacesWord}`;
			else if (actualTabs > 0) foundStatement = indentType === "tab" ? actualTabs : `${actualTabs} ${foundTabsWord}`;
			else foundStatement = "0";
			return {
				expected: expectedStatement,
				actual: foundStatement
			};
		}
		function report(token, neededIndent) {
			const actualIndent = Array.from(tokenInfo.getTokenIndent(token));
			const numSpaces = actualIndent.filter((char) => char === " ").length;
			const numTabs = actualIndent.filter((char) => char === "	").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);
				}
			});
		}
		function validateTokenIndent(token, desiredIndent) {
			return tokenInfo.getTokenIndent(token) === desiredIndent;
		}
		function isOuterIIFE(node) {
			if (!node.parent || node.parent.type !== "CallExpression" || node.parent.callee !== node) return false;
			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";
		}
		function countTrailingLinebreaks(string) {
			const linebreakMatches = string.match(/\s*$/u)[0].match(createGlobalLinebreakMatcher());
			return linebreakMatches === null ? 0 : linebreakMatches.length;
		}
		function addElementListIndent(elements, startToken, endToken, offset) {
			function getFirstToken(element) {
				let token = sourceCode.getTokenBefore(element);
				while ((0, import_ast_utils.isOpeningParenToken)(token) && token !== startToken) token = sourceCode.getTokenBefore(token);
				return sourceCode.getTokenAfter(token);
			}
			offsets.setDesiredOffsets([startToken.range[1], endToken.range[0]], startToken, typeof offset === "number" ? offset : 1);
			offsets.setDesiredOffset(endToken, startToken, 0);
			if (offset === "first" && elements.length && !elements[0]) return;
			elements.forEach((element, index) => {
				if (!element) return;
				if (offset === "off") offsets.ignoreToken(getFirstToken(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);
				}
			});
		}
		function addBlocklessNodeIndent(node) {
			if (node.type !== "BlockStatement") {
				const lastParentToken = sourceCode.getTokenBefore(node, import_ast_utils.isNotOpeningParenToken);
				let firstBodyToken = sourceCode.getFirstToken(node);
				let lastBodyToken = sourceCode.getLastToken(node);
				while ((0, import_ast_utils.isOpeningParenToken)(sourceCode.getTokenBefore(firstBodyToken)) && (0, import_ast_utils.isClosingParenToken)(sourceCode.getTokenAfter(lastBodyToken))) {
					firstBodyToken = sourceCode.getTokenBefore(firstBodyToken);
					lastBodyToken = sourceCode.getTokenAfter(lastBodyToken);
				}
				offsets.setDesiredOffsets([firstBodyToken.range[0], lastBodyToken.range[1]], lastParentToken, 1);
			}
		}
		function addFunctionCallIndent(node) {
			let openingParen;
			if (node.arguments.length) openingParen = sourceCode.getTokenAfter(node.typeArguments ?? node.callee, import_ast_utils.isOpeningParenToken);
			else openingParen = sourceCode.getLastToken(node, 1);
			const closingParen = sourceCode.getLastToken(node);
			parameterParens.add(openingParen);
			parameterParens.add(closingParen);
			if ("optional" in node && node.optional) {
				const dotToken = sourceCode.getTokenAfter(node.callee, import_ast_utils.isOptionalChainPunctuator);
				const calleeParenCount = sourceCode.getTokensBetween(node.callee, dotToken, { filter: import_ast_utils.isClosingParenToken }).length;
				const firstTokenOfCallee = calleeParenCount ? sourceCode.getTokenBefore(node.callee, { skip: calleeParenCount - 1 }) : sourceCode.getFirstToken(node.callee);
				const lastTokenOfCallee = sourceCode.getTokenBefore(dotToken);
				const offsetBase = (0, import_ast_utils.isTokenOnSameLine)(lastTokenOfCallee, openingParen) ? lastTokenOfCallee : firstTokenOfCallee;
				offsets.setDesiredOffset(dotToken, offsetBase, 1);
			}
			const offsetAfterToken = node.callee.type === "TaggedTemplateExpression" ? sourceCode.getFirstToken(node.callee.quasi) : node.typeArguments ?? openingParen;
			const offsetToken = sourceCode.getTokenBefore(offsetAfterToken);
			offsets.setDesiredOffset(openingParen, offsetToken, 0);
			addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments);
		}
		function addParensIndent(tokens) {
			const parenStack = [];
			const parenPairs = [];
			for (let i = 0; i < tokens.length; i++) {
				const nextToken = tokens[i];
				if ((0, import_ast_utils.isOpeningParenToken)(nextToken)) parenStack.push(nextToken);
				else if ((0, import_ast_utils.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;
				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);
			}
		}
		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);
				}
			});
		}
		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;
		}
		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 = /* @__PURE__ */ new Set();
		function checkAssignmentOperator(operator) {
			const left = sourceCode.getTokenBefore(operator);
			const right = sourceCode.getTokenAfter(operator);
			if (typeof options.assignmentOperator === "number") {
				offsets.setDesiredOffset(operator, left, options.assignmentOperator);
				offsets.setDesiredOffset(right, operator, options.assignmentOperator);
			} else {
				offsets.ignoreToken(operator);
				offsets.ignoreToken(right);
			}
		}
		function checkArrayLikeNode(node) {
			const elementList = node.type === AST_NODE_TYPES.TSTupleType ? node.elementTypes : node.elements;
			const openingBracket = sourceCode.getFirstToken(node);
			addElementListIndent(elementList, openingBracket, sourceCode.getTokenAfter([...elementList].reverse().find((_) => _) || openingBracket, import_ast_utils.isClosingBracketToken), options.ArrayExpression);
		}
		function checkObjectLikeNode(node, properties) {
			const openingCurly = sourceCode.getFirstToken(node, import_ast_utils.isOpeningBraceToken);
			addElementListIndent(properties, openingCurly, sourceCode.getTokenAfter(properties.length ? properties[properties.length - 1] : openingCurly, import_ast_utils.isClosingBraceToken), options.ObjectExpression);
		}
		function checkConditionalNode(node, test, consequent, alternate) {
			const firstToken = sourceCode.getFirstToken(node);
			if (options.flatTernaryExpressions && (0, import_ast_utils.isTokenOnSameLine)(test, consequent) && !isOnFirstLineOfStatement(firstToken, node)) return;
			const ternaryOptions = options.offsetTernaryExpressions === true ? {
				CallExpression: options.offsetTernaryExpressionsOffsetCallExpressions ?? true,
				AwaitExpression: options.offsetTernaryExpressionsOffsetCallExpressions ?? true,
				NewExpression: true
			} : options.offsetTernaryExpressions;
			function checkBranch(branch, branchFirstToken) {
				let offset = 1;
				if (ternaryOptions) {
					const branchType = skipChainExpression(branch).type;
					if (branchFirstToken.type === "Punctuator" || ternaryOptions[branchType]) offset = 2;
				}
				offsets.setDesiredOffset(branchFirstToken, firstToken, offset);
			}
			const questionMarkToken = sourceCode.getFirstTokenBetween(test, consequent, isQuestionToken);
			const colonToken = sourceCode.getFirstTokenBetween(consequent, alternate, import_ast_utils.isColonToken);
			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);
			checkBranch(consequent, firstConsequentToken);
			if ((0, import_ast_utils.isTokenOnSameLine)(lastConsequentToken, firstAlternateToken)) offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0);
			else checkBranch(alternate, firstAlternateToken);
		}
		function checkOperatorToken(left, right, operator) {
			const operatorToken = sourceCode.getFirstTokenBetween(left, right, (token) => token.value === operator);
			const tokenAfterOperator = sourceCode.getTokenAfter(operatorToken);
			offsets.ignoreToken(operatorToken);
			offsets.ignoreToken(tokenAfterOperator);
			offsets.setDesiredOffset(tokenAfterOperator, operatorToken, 0);
		}
		function checkMemberExpression(node, object, property, computed = false) {
			const firstNonObjectToken = sourceCode.getFirstTokenBetween(object, property, import_ast_utils.isNotClosingParenToken);
			const secondNonObjectToken = sourceCode.getTokenAfter(firstNonObjectToken);
			const objectParenCount = sourceCode.getTokensBetween(object, property, { filter: import_ast_utils.isClosingParenToken }).length;
			const firstObjectToken = objectParenCount ? sourceCode.getTokenBefore(object, { skip: objectParenCount - 1 }) : sourceCode.getFirstToken(object);
			const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken);
			const firstPropertyToken = computed ? firstNonObjectToken : secondNonObjectToken;
			if (computed) {
				offsets.setDesiredOffset(sourceCode.getLastToken(node), firstNonObjectToken, 0);
				offsets.setDesiredOffsets(property.range, firstNonObjectToken, 1);
			}
			const offsetBase = (0, import_ast_utils.isTokenOnSameLine)(lastObjectToken, firstPropertyToken) ? lastObjectToken : firstObjectToken;
			if (typeof options.MemberExpression === "number") {
				offsets.setDesiredOffset(firstNonObjectToken, offsetBase, options.MemberExpression);
				offsets.setDesiredOffset(secondNonObjectToken, computed ? firstNonObjectToken : offsetBase, options.MemberExpression);
			} else {
				offsets.ignoreToken(firstNonObjectToken);
				offsets.ignoreToken(secondNonObjectToken);
				offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0);
				offsets.setDesiredOffset(secondNonObjectToken, firstNonObjectToken, 0);
			}
		}
		function checkBlockLikeNode(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;
			if (!STATEMENT_LIST_PARENTS.has(node.parent.type)) offsets.setDesiredOffset(sourceCode.getFirstToken(node), sourceCode.getFirstToken(node.parent), 0);
			addElementListIndent(node.type === AST_NODE_TYPES.TSEnumBody ? node.members : node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), blockIndentLevel);
		}
		function checkHeritages(node, heritages) {
			const classToken = sourceCode.getFirstToken(node);
			const extendsToken = sourceCode.getTokenBefore(heritages[0], import_ast_utils.isNotOpeningParenToken);
			offsets.setDesiredOffsets([extendsToken.range[0], node.body.range[0]], classToken, 1);
		}
		function checkClassProperty(node) {
			const firstToken = sourceCode.getFirstToken(node);
			const lastToken = sourceCode.getLastToken(node);
			let keyLastToken;
			if (node.computed) {
				const bracketTokenL = sourceCode.getTokenBefore(node.key, import_ast_utils.isOpeningBracketToken);
				const bracketTokenR = keyLastToken = sourceCode.getTokenAfter(node.key, import_ast_utils.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 (!node.decorators?.length && idToken !== firstToken) offsets.setDesiredOffset(idToken, firstToken, 1);
			}
			if (node.value) {
				const operator = sourceCode.getTokenBefore(node.value, isEqToken);
				checkAssignmentOperator(operator);
				if ((0, import_ast_utils.isSemicolonToken)(lastToken)) offsets.setDesiredOffset(lastToken, operator, 1);
			} else if ((0, import_ast_utils.isSemicolonToken)(lastToken)) offsets.setDesiredOffset(lastToken, keyLastToken, 1);
		}
		const baseOffsetListeners = {
			"ArrayExpression": checkArrayLikeNode,
			"ArrayPattern": checkArrayLikeNode,
			ObjectExpression(node) {
				checkObjectLikeNode(node, node.properties);
			},
			ObjectPattern(node) {
				checkObjectLikeNode(node, node.properties);
			},
			ArrowFunctionExpression(node) {
				const maybeOpeningParen = sourceCode.getFirstToken(node, { skip: node.async ? 1 : 0 });
				if ((0, import_ast_utils.isOpeningParenToken)(maybeOpeningParen)) {
					const openingParen = maybeOpeningParen;
					const closingParen = sourceCode.getTokenBefore(node.returnType ?? node.body, { filter: import_ast_utils.isClosingParenToken });
					parameterParens.add(openingParen);
					parameterParens.add(closingParen);
					addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);
				}
				addBlocklessNodeIndent(node.body);
			},
			AssignmentExpression(node) {
				checkAssignmentOperator(sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator));
			},
			AssignmentPattern(node) {
				checkAssignmentOperator(sourceCode.getFirstTokenBetween(node.left, node.right, isEqToken));
			},
			BinaryExpression(node) {
				checkOperatorToken(node.left, node.right, node.operator);
			},
			LogicalExpression(node) {
				checkOperatorToken(node.left, node.right, node.operator);
			},
			"BlockStatement": checkBlockLikeNode,
			"ClassBody": checkBlockLikeNode,
			"CallExpression": addFunctionCallIndent,
			ClassDeclaration(node) {
				if (!node.superClass) return;
				checkHeritages(node, [node.superClass]);
			},
			ClassExpression(node) {
				if (!node.superClass) return;
				checkHeritages(node, [node.superClass]);
			},
			ConditionalExpression(node) {
				checkConditionalNode(node, node.test, node.consequent, node.alternate);
			},
			"DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement, WithStatement": function(node) {
				addBlocklessNodeIndent(node.body);
			},
			ExportNamedDeclaration(node) {
				if (node.declaration === null) {
					const closingCurly = node.source ? sourceCode.getTokenBefore(node.source, import_ast_utils.isClosingBraceToken) : sourceCode.getLastToken(node, import_ast_utils.isClosingBraceToken);
					addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);
					if (node.source) {
						const fromToken = sourceCode.getTokenAfter(closingCurly, (token) => token.type === "Identifier" && token.value === "from");
						const lastToken = sourceCode.getLastToken(node, import_ast_utils.isNotSemicolonToken);
						offsets.setDesiredOffsets([fromToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
						const lastClosingCurly = sourceCode.getLastToken(node, import_ast_utils.isClosingBraceToken);
						if (lastClosingCurly && node.source.range[1] < lastClosingCurly.range[0]) {
							const openingCurly = sourceCode.getTokenAfter(node.source, import_ast_utils.isOpeningBraceToken);
							const closingCurly = lastClosingCurly;
							addElementListIndent(node.attributes, openingCurly, closingCurly, 1);
						}
					}
				}
			},
			ExportAllDeclaration(node) {
				const fromToken = sourceCode.getTokenAfter(node.exported || sourceCode.getFirstToken(node), (token) => token.type === "Identifier" && token.value === "from");
				const lastToken = sourceCode.getLastToken(node, import_ast_utils.isNotSemicolonToken);
				offsets.setDesiredOffsets([fromToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
				const lastClosingCurly = sourceCode.getLastToken(node, import_ast_utils.isClosingBraceToken);
				if (lastClosingCurly && node.source.range[1] < lastClosingCurly.range[0]) {
					const openingCurly = sourceCode.getTokenAfter(node.source, import_ast_utils.isOpeningBraceToken);
					const closingCurly = lastClosingCurly;
					addElementListIndent(node.attributes, openingCurly, closingCurly, 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": function(node) {
				const paramsClosingParen = sourceCode.getTokenBefore(node.returnType ?? node.body, { filter: import_ast_utils.isClosingParenToken });
				const paramsOpeningParen = sourceCode.getTokenBefore(node.params.length ? node.params[0].decorators?.[0] ?? node.params[0] : paramsClosingParen, { filter: import_ast_utils.isOpeningParenToken });
				parameterParens.add(paramsOpeningParen);
				parameterParens.add(paramsClosingParen);
				addElementListIndent(node.params, paramsOpeningParen, paramsClosingParen, options[node.type].parameters);
				if (node.returnType) offsets.setDesiredOffsets(node.returnType.range, paramsClosingParen, options[node.type].returnType);
			},
			IfStatement(node) {
				addBlocklessNodeIndent(node.consequent);
				if (node.alternate) addBlocklessNodeIndent(node.alternate);
			},
			":matches(DoWhileStatement, ForStatement, ForInStatement, ForOfStatement, IfStatement, WhileStatement, WithStatement):exit": function(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 ((0, import_ast_utils.isSemicolonToken)(lastToken)) {
						const tokenBeforeLast = sourceCode.getTokenBefore(lastToken);
						const tokenAfterLast = sourceCode.getTokenAfter(lastToken);
						if (!(0, import_ast_utils.isTokenOnSameLine)(tokenBeforeLast, lastToken) && tokenAfterLast && (0, import_ast_utils.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, import_ast_utils.isOpeningBraceToken);
					const closingCurly = sourceCode.getTokenBefore(node.source, import_ast_utils.isClosingBraceToken);
					addElementListIndent(node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier"), openingCurly, closingCurly, options.ImportDeclaration);
				}
				const fromToken = node.specifiers.length ? sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1], (token) => token.type === "Identifier" && token.value === "from") : sourceCode.getFirstToken(node, (token) => token.type === "Identifier" && token.value === "from");
				const lastToken = sourceCode.getLastToken(node, import_ast_utils.isNotSemicolonToken);
				if (fromToken) offsets.setDesiredOffsets([fromToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
				const lastClosingCurly = sourceCode.getLastToken(node, import_ast_utils.isClosingBraceToken);
				if (lastClosingCurly && node.source.range[1] < lastClosingCurly.range[0]) {
					const openingCurly = sourceCode.getTokenAfter(node.source, import_ast_utils.isOpeningBraceToken);
					const closingCurly = lastClosingCurly;
					if (!fromToken) {
						const withToken = sourceCode.getTokenBefore(openingCurly, (token) => token.value === "with");
						offsets.setDesiredOffsets([withToken.range[0], lastToken.range[1]], sourceCode.getFirstToken(node), 1);
					}
					addElementListIndent(node.attributes, openingCurly, closingCurly, 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(node) {
				checkMemberExpression(node, node.object, node.property, node.computed);
			},
			MetaProperty(node) {
				checkMemberExpression(node, node.meta, node.property);
			},
			NewExpression(node) {
				if (node.arguments.length > 0 || (0, import_ast_utils.isClosingParenToken)(sourceCode.getLastToken(node)) && (0, import_ast_utils.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, import_ast_utils.isColonToken);
					offsets.ignoreToken(sourceCode.getTokenAfter(colon));
				}
			},
			"PropertyDefinition": checkClassProperty,
			"AccessorProperty": checkClassProperty,
			"TSAbstractPropertyDefinition": checkClassProperty,
			"TSAbstractAccessorProperty": checkClassProperty,
			StaticBlock(node) {
				const openingCurly = sourceCode.getFirstToken(node, { skip: 1 });
				const closingCurly = sourceCode.getLastToken(node);
				addElementListIndent(node.body, openingCurly, closingCurly, options.StaticBlock.body);
			},
			SwitchStatement(node) {
				const openingCurly = sourceCode.getTokenAfter(node.discriminant, import_ast_utils.isOpeningBraceToken);
				const closingCurly = sourceCode.getLastToken(node);
				offsets.setDesiredOffsets([openingCurly.range[1], closingCurly.range[0]], openingCurly, options.SwitchCase);
				if (node.cases.length) getCommentsBetween(sourceCode, node.cases[node.cases.length - 1], closingCurly).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 = isSingleLine(previousQuasi) ? sourceCode.getFirstToken(previousQuasi) : null;
					const startsOnSameLine = (0, import_ast_utils.isTokenOnSameLine)(previousQuasi, expression);
					const endsOnSameLine = (0, import_ast_utils.isTokenOnSameLine)(expression, nextQuasi);
					if (tokenToAlignFrom || endsOnSameLine && !startsOnSameLine) {
						offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, 1);
						offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0);
						return;
					}
					const tokenBeforeText = sourceCode.text.slice(previousQuasi.range[1] - previousQuasi.loc.end.column, previousQuasi.range[1] - 2).split("");
					let numIndentation = tokenBeforeText.findIndex((char) => char !== " " && char !== "	");
					if (numIndentation === -1) numIndentation = tokenBeforeText.length;
					const numSpaces = tokenBeforeText.slice(0, numIndentation).filter((char) => char === " ").length;
					const indentOffset = numIndentation - numSpaces + Math.ceil(numSpaces / (indentType === "tab" ? options.tabLength : indentSize));
					const innerIndentation = endsOnSameLine ? indentOffset : indentOffset + 1;
					offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, innerIndentation);
					offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, indentOffset);
				});
			},
			VariableDeclaration(node) {
				if (node.declarations.length === 0) return;
				const kind = node.kind === "await using" ? "using" : node.kind;
				let variableIndent = Object.hasOwn(options.VariableDeclarator, kind) ? options.VariableDeclarator[kind] : DEFAULT_VARIABLE_INDENT;
				const alignFirstVariable = variableIndent === "first";
				const firstToken = sourceCode.getFirstToken(node);
				const lastToken = sourceCode.getLastToken(node);
				if (node.declarations.at(-1).loc.start.line > node.loc.start.line) {
					if (alignFirstVariable) {
						addElementListIndent(node.declarations, firstToken, lastToken, variableIndent);
						const firstTokenOfFirstElement = sourceCode.getFirstToken(node.declarations[0]);
						variableIndent = (tokenInfo.getTokenIndent(firstTokenOfFirstElement).length - tokenInfo.getTokenIndent(firstToken).length) / indentSize;
					}
					offsets.setDesiredOffsets(node.range, firstToken, variableIndent, true);
				} else {
					if (alignFirstVariable) variableIndent = DEFAULT_VARIABLE_INDENT;
					offsets.setDesiredOffsets(node.range, firstToken, variableIndent);
				}
				if ((0, import_ast_utils.isSemicolonToken)(lastToken)) offsets.ignoreToken(lastToken);
			},
			VariableDeclarator(node) {
				if (node.init) checkAssignmentOperator(sourceCode.getTokenBefore(node.init, import_ast_utils.isNotOpeningParenToken));
				const lastToken = sourceCode.getLastToken(node);
				if ((0, import_ast_utils.isSemicolonToken)(lastToken)) offsets.ignoreToken(lastToken);
			},
			JSXText(node) {
				if (!node.parent) return;
				if (node.parent.type !== "JSXElement" && node.parent.type !== "JSXFragment") return;
				const nodeIndentRegExp = new RegExp(`\n(${offsets._indentType}*)[\t ]*\\S`, "g");
				const nodeIndentsPerLine = Array.from(String(node.value).matchAll(nodeIndentRegExp), (match) => match[1] ? match[1].length : 0);
				if (nodeIndentsPerLine.length === 0) return;
				const parentIndentText = sourceCode.lines[node.parent.loc.start.line - 1].slice(0, node.parent.loc.start.column);
				const parentIndent = new RegExp(`^[${offsets._indentType}]+`).exec(parentIndentText);
				const targetIndent = (parentIndent ? parentIndent[0].length : 0) + indentSize;
				nodeIndentsPerLine.forEach((nodeIndent) => {
					if (nodeIndent === targetIndent) return;
					context.report({
						node,
						messageId: "wrongIndentation",
						data: createErrorMessageData(targetIndent, nodeIndent, nodeIndent),
						fix(fixer) {
							const indentStr = new Array(targetIndent + 1).join(offsets._indentType);
							const fixedText = node.raw.replace(/\n[\t ]*(\S)/g, (match, p1) => `\n${indentStr}${p1}`);
							return fixer.replaceText(node, fixedText);
						}
					});
				});
			},
			JSXAttribute(node) {
				if (!node.value) return;
				checkAssignmentOperator(sourceCode.getFirstTokenBetween(node.name, node.value, isEqToken));
			},
			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, firstToken, 0);
				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 closingToken = sourceCode.getLastToken(node);
				offsets.setDesiredOffsets(node.range, firstToken, 1);
				const slashToken = sourceCode.getLastToken(node, (token) => token.value === "/");
				if (slashToken) {
					const tokenToMatch = (0, import_ast_utils.isTokenOnSameLine)(slashToken, closingToken) ? slashToken : closingToken;
					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);
			},
			JSXMemberExpression(node) {
				checkMemberExpression(node, node.object, node.property);
			},
			TSTypeAliasDeclaration(node) {
				checkAssignmentOperator(sourceCode.getTokenBefore(node.typeAnnotation, import_ast_utils.isNotOpeningParenToken));
				const lastToken = sourceCode.getLastToken(node);
				if ((0, import_ast_utils.isSemicolonToken)(lastToken)) offsets.ignoreToken(lastToken);
			},
			"TSTupleType": checkArrayLikeNode,
			"TSEnumBody": checkBlockLikeNode,
			TSEnumMember(node) {
				if (!node.initializer) return;
				checkAssignmentOperator(sourceCode.getTokenBefore(node.initializer, isEqToken));
			},
			TSTypeLiteral(node) {
				checkObjectLikeNode(node, node.members);
			},
			TSMappedType(node) {
				const startToken = sourceCode.getFirstToken(node, import_ast_utils.isOpeningBraceToken);
				const endToken = sourceCode.getLastToken(node, import_ast_utils.isClosingBraceToken);
				offsets.setDesiredOffsets([startToken.range[1], endToken.range[0]], startToken, 1);
				offsets.setDesiredOffset(endToken, startToken, 0);
			},
			TSAsExpression(node) {
				checkOperatorToken(node.expression, node.typeAnnotation, "as");
			},
			TSConditionalType(node) {
				checkConditionalNode(node, node.extendsType, node.trueType, node.falseType);
			},
			TSImportEqualsDeclaration(node) {
				if (node.moduleReference) checkAssignmentOperator(sourceCode.getTokenBefore(node.moduleReference, isEqToken));
				const lastToken = sourceCode.getLastToken(node);
				if ((0, import_ast_utils.isSemicolonToken)(lastToken)) offsets.ignoreToken(lastToken);
			},
			TSIndexedAccessType(node) {
				checkMemberExpression(node, node.objectType, node.indexType, true);
			},
			"TSInterfaceBody": checkBlockLikeNode,
			TSInterfaceDeclaration(node) {
				if (node.extends.length === 0) return;
				checkHeritages(node, node.extends);
			},
			TSQualifiedName(node) {
				checkMemberExpression(node, node.left, node.right);
			},
			TSTypeParameter(node) {
				if (!node.default) return;
				checkAssignmentOperator(sourceCode.getTokenBefore(node.default, isEqToken));
			},
			TSTypeParameterDeclaration(node) {
				if (!node.params.length) return;
				const firstToken = sourceCode.getFirstToken(node);
				const closingToken = sourceCode.getLastToken(node);
				addElementListIndent(node.params, firstToken, closingToken, 1);
			},
			TSTypeParameterInstantiation(node) {
				if (!node.params.length) return;
				const firstToken = sourceCode.getFirstToken(node);
				const closingToken = sourceCode.getLastToken(node);
				addElementListIndent(node.params, firstToken, closingToken, 1);
			},
			"TSModuleBlock": checkBlockLikeNode,
			"*": function(node) {
				const firstToken = sourceCode.getFirstToken(node);
				if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) offsets.setDesiredOffsets(node.range, firstToken, 0);
			}
		};
		const listenerCallQueue = [];
		const offsetListeners = {};
		for (const [selector, listener] of Object.entries(baseOffsetListeners)) offsetListeners[selector] = (node) => listenerCallQueue.push({
			listener,
			node
		});
		const ignoredNodes = /* @__PURE__ */ new Set();
		function addToIgnoredNodes(node) {
			ignoredNodes.add(node);
			ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));
		}
		const ignoredNodeListeners = options.ignoredNodes.reduce((listeners, ignoredSelector) => Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }), {});
		return {
			...offsetListeners,
			...ignoredNodeListeners,
			"*:exit": function(node) {
				if (!KNOWN_NODES.has(node.type)) addToIgnoredNodes(node);
			},
			"Program:exit": function() {
				if (options.ignoreComments) sourceCode.getAllComments().forEach((comment) => offsets.ignoreToken(comment));
				for (let i = 0; i < listenerCallQueue.length; i++) {
					const nodeInfo = listenerCallQueue[i];
					if (!ignoredNodes.has(nodeInfo.node)) nodeInfo.listener?.(nodeInfo.node);
				}
				ignoredNodes.forEach(ignoreNode);
				addParensIndent(sourceCode.ast.tokens);
				const precedingTokens = /* @__PURE__ */ 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)) continue;
					const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(i);
					if (firstTokenOfLine.loc.start.line !== i) continue;
					if ((0, import_ast_utils.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 (tokenAfter && (0, import_ast_utils.isSemicolonToken)(tokenAfter) && !(0, import_ast_utils.isTokenOnSameLine)(firstTokenOfLine, tokenAfter)) offsets.setDesiredOffset(firstTokenOfLine, tokenAfter, 0);
						if (mayAlignWithBefore && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore)) || mayAlignWithAfter && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenAfter))) continue;
					}
					if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) continue;
					report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));
				}
			}
		};
	}
});
export { indent_default as t };