@alexlit/lint-kit 183.0.0 → 183.2.0

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

@@ -1,1369 +0,0 @@
-/**
- * @fileoverview This option sets a specific tab width for your code
- *
- * This rule has been ported and modified from nodeca.
- * @author Vitaly Puzrin
- * @author Gyandeep Singh
- * @deprecated in ESLint v4.0.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-// this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway.
-/* c8 ignore next */
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "layout",
-
-		docs: {
-			description: "Enforce consistent indentation",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/indent-legacy",
-		},
-
-		deprecated: {
-			message: "Formatting rules are being moved out of ESLint core.",
-			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-			deprecatedSince: "4.0.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",
-					},
-				},
-			],
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: ["tab"],
-					},
-					{
-						type: "integer",
-						minimum: 0,
-					},
-				],
-			},
-			{
-				type: "object",
-				properties: {
-					SwitchCase: {
-						type: "integer",
-						minimum: 0,
-					},
-					VariableDeclarator: {
-						oneOf: [
-							{
-								type: "integer",
-								minimum: 0,
-							},
-							{
-								type: "object",
-								properties: {
-									var: {
-										type: "integer",
-										minimum: 0,
-									},
-									let: {
-										type: "integer",
-										minimum: 0,
-									},
-									const: {
-										type: "integer",
-										minimum: 0,
-									},
-								},
-							},
-						],
-					},
-					outerIIFEBody: {
-						type: "integer",
-						minimum: 0,
-					},
-					MemberExpression: {
-						type: "integer",
-						minimum: 0,
-					},
-					FunctionDeclaration: {
-						type: "object",
-						properties: {
-							parameters: {
-								oneOf: [
-									{
-										type: "integer",
-										minimum: 0,
-									},
-									{
-										enum: ["first"],
-									},
-								],
-							},
-							body: {
-								type: "integer",
-								minimum: 0,
-							},
-						},
-					},
-					FunctionExpression: {
-						type: "object",
-						properties: {
-							parameters: {
-								oneOf: [
-									{
-										type: "integer",
-										minimum: 0,
-									},
-									{
-										enum: ["first"],
-									},
-								],
-							},
-							body: {
-								type: "integer",
-								minimum: 0,
-							},
-						},
-					},
-					CallExpression: {
-						type: "object",
-						properties: {
-							parameters: {
-								oneOf: [
-									{
-										type: "integer",
-										minimum: 0,
-									},
-									{
-										enum: ["first"],
-									},
-								],
-							},
-						},
-					},
-					ArrayExpression: {
-						oneOf: [
-							{
-								type: "integer",
-								minimum: 0,
-							},
-							{
-								enum: ["first"],
-							},
-						],
-					},
-					ObjectExpression: {
-						oneOf: [
-							{
-								type: "integer",
-								minimum: 0,
-							},
-							{
-								enum: ["first"],
-							},
-						],
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			expected:
-				"Expected indentation of {{expected}} but found {{actual}}.",
-		},
-	},
-
-	create(context) {
-		const DEFAULT_VARIABLE_INDENT = 1;
-		const DEFAULT_PARAMETER_INDENT = null; // For backwards compatibility, don't check parameter indentation unless specified in the config
-		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: null,
-			FunctionDeclaration: {
-				parameters: DEFAULT_PARAMETER_INDENT,
-				body: DEFAULT_FUNCTION_BODY_INDENT,
-			},
-			FunctionExpression: {
-				parameters: DEFAULT_PARAMETER_INDENT,
-				body: DEFAULT_FUNCTION_BODY_INDENT,
-			},
-			CallExpression: {
-				arguments: DEFAULT_PARAMETER_INDENT,
-			},
-			ArrayExpression: 1,
-			ObjectExpression: 1,
-		};
-
-		const sourceCode = context.sourceCode;
-
-		if (context.options.length) {
-			if (context.options[0] === "tab") {
-				indentSize = 1;
-				indentType = "tab";
-			} /* c8 ignore start */ else if (
-				typeof context.options[0] === "number"
-			) {
-				indentSize = context.options[0];
-				indentType = "space";
-			} /* c8 ignore stop */
-
-			if (context.options[1]) {
-				const opts = context.options[1];
-
-				options.SwitchCase = opts.SwitchCase || 0;
-				const variableDeclaratorRules = opts.VariableDeclarator;
-
-				if (typeof variableDeclaratorRules === "number") {
-					options.VariableDeclarator = {
-						var: variableDeclaratorRules,
-						let: variableDeclaratorRules,
-						const: variableDeclaratorRules,
-					};
-				} else if (typeof variableDeclaratorRules === "object") {
-					Object.assign(
-						options.VariableDeclarator,
-						variableDeclaratorRules,
-					);
-				}
-
-				if (typeof opts.outerIIFEBody === "number") {
-					options.outerIIFEBody = opts.outerIIFEBody;
-				}
-
-				if (typeof opts.MemberExpression === "number") {
-					options.MemberExpression = opts.MemberExpression;
-				}
-
-				if (typeof opts.FunctionDeclaration === "object") {
-					Object.assign(
-						options.FunctionDeclaration,
-						opts.FunctionDeclaration,
-					);
-				}
-
-				if (typeof opts.FunctionExpression === "object") {
-					Object.assign(
-						options.FunctionExpression,
-						opts.FunctionExpression,
-					);
-				}
-
-				if (typeof opts.CallExpression === "object") {
-					Object.assign(options.CallExpression, opts.CallExpression);
-				}
-
-				if (
-					typeof opts.ArrayExpression === "number" ||
-					typeof opts.ArrayExpression === "string"
-				) {
-					options.ArrayExpression = opts.ArrayExpression;
-				}
-
-				if (
-					typeof opts.ObjectExpression === "number" ||
-					typeof opts.ObjectExpression === "string"
-				) {
-					options.ObjectExpression = opts.ObjectExpression;
-				}
-			}
-		}
-
-		const caseIndentStore = {};
-
-		/**
-		 * 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 && actualTabs > 0) {
-				foundStatement = `${actualSpaces} ${foundSpacesWord} and ${actualTabs} ${foundTabsWord}`; // e.g. "1 space and 2 tabs"
-			} else 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 {ASTNode} node Node violating the indent rule
-		 * @param {number} needed Expected indentation character count
-		 * @param {number} gottenSpaces Indentation space count in the actual node/code
-		 * @param {number} gottenTabs Indentation tab count in the actual node/code
-		 * @param {Object} [loc] Error line and column location
-		 * @param {boolean} isLastNodeCheck Is the error for last node check
-		 * @returns {void}
-		 */
-		function report(
-			node,
-			needed,
-			gottenSpaces,
-			gottenTabs,
-			loc,
-			isLastNodeCheck,
-		) {
-			if (gottenSpaces && gottenTabs) {
-				// To avoid conflicts with `no-mixed-spaces-and-tabs`, don't report lines that have both spaces and tabs.
-				return;
-			}
-
-			const desiredIndent = (indentType === "space" ? " " : "\t").repeat(
-				needed,
-			);
-
-			const textRange = isLastNodeCheck
-				? [
-						node.range[1] - node.loc.end.column,
-						node.range[1] -
-							node.loc.end.column +
-							gottenSpaces +
-							gottenTabs,
-					]
-				: [
-						node.range[0] - node.loc.start.column,
-						node.range[0] -
-							node.loc.start.column +
-							gottenSpaces +
-							gottenTabs,
-					];
-
-			context.report({
-				node,
-				loc,
-				messageId: "expected",
-				data: createErrorMessageData(needed, gottenSpaces, gottenTabs),
-				fix: fixer => fixer.replaceTextRange(textRange, desiredIndent),
-			});
-		}
-
-		/**
-		 * Get the actual indent of node
-		 * @param {ASTNode|Token} node Node to examine
-		 * @param {boolean} [byLastLine=false] get indent of node's last line
-		 * @returns {Object} The node's indent. Contains keys `space` and `tab`, representing the indent of each character. Also
-		 * contains keys `goodChar` and `badChar`, where `goodChar` is the amount of the user's desired indentation character, and
-		 * `badChar` is the amount of the other indentation character.
-		 */
-		function getNodeIndent(node, byLastLine) {
-			const token = byLastLine
-				? sourceCode.getLastToken(node)
-				: sourceCode.getFirstToken(node);
-			const srcCharsBeforeNode = sourceCode
-				.getText(token, token.loc.start.column)
-				.split("");
-			const indentChars = srcCharsBeforeNode.slice(
-				0,
-				srcCharsBeforeNode.findIndex(
-					char => char !== " " && char !== "\t",
-				),
-			);
-			const spaces = indentChars.filter(char => char === " ").length;
-			const tabs = indentChars.filter(char => char === "\t").length;
-
-			return {
-				space: spaces,
-				tab: tabs,
-				goodChar: indentType === "space" ? spaces : tabs,
-				badChar: indentType === "space" ? tabs : spaces,
-			};
-		}
-
-		/**
-		 * Checks node is the first in its own start line. By default it looks by start line.
-		 * @param {ASTNode} node The node to check
-		 * @param {boolean} [byEndLocation=false] Lookup based on start position or end
-		 * @returns {boolean} true if its the first in the its start line
-		 */
-		function isNodeFirstInLine(node, byEndLocation) {
-			const firstToken =
-					byEndLocation === true
-						? sourceCode.getLastToken(node, 1)
-						: sourceCode.getTokenBefore(node),
-				startLine =
-					byEndLocation === true
-						? node.loc.end.line
-						: node.loc.start.line,
-				endLine = firstToken ? firstToken.loc.end.line : -1;
-
-			return startLine !== endLine;
-		}
-
-		/**
-		 * Check indent for node
-		 * @param {ASTNode} node Node to check
-		 * @param {number} neededIndent needed indent
-		 * @returns {void}
-		 */
-		function checkNodeIndent(node, neededIndent) {
-			const actualIndent = getNodeIndent(node, false);
-
-			if (
-				node.type !== "ArrayExpression" &&
-				node.type !== "ObjectExpression" &&
-				(actualIndent.goodChar !== neededIndent ||
-					actualIndent.badChar !== 0) &&
-				isNodeFirstInLine(node)
-			) {
-				report(
-					node,
-					neededIndent,
-					actualIndent.space,
-					actualIndent.tab,
-				);
-			}
-
-			if (node.type === "IfStatement" && node.alternate) {
-				const elseToken = sourceCode.getTokenBefore(node.alternate);
-
-				checkNodeIndent(elseToken, neededIndent);
-
-				if (!isNodeFirstInLine(node.alternate)) {
-					checkNodeIndent(node.alternate, neededIndent);
-				}
-			}
-
-			if (node.type === "TryStatement" && node.handler) {
-				const catchToken = sourceCode.getFirstToken(node.handler);
-
-				checkNodeIndent(catchToken, neededIndent);
-			}
-
-			if (node.type === "TryStatement" && node.finalizer) {
-				const finallyToken = sourceCode.getTokenBefore(node.finalizer);
-
-				checkNodeIndent(finallyToken, neededIndent);
-			}
-
-			if (node.type === "DoWhileStatement") {
-				const whileToken = sourceCode.getTokenAfter(node.body);
-
-				checkNodeIndent(whileToken, neededIndent);
-			}
-		}
-
-		/**
-		 * Check indent for nodes list
-		 * @param {ASTNode[]} nodes list of node objects
-		 * @param {number} indent needed indent
-		 * @returns {void}
-		 */
-		function checkNodesIndent(nodes, indent) {
-			nodes.forEach(node => checkNodeIndent(node, indent));
-		}
-
-		/**
-		 * Check last node line indent this detects, that block closed correctly
-		 * @param {ASTNode} node Node to examine
-		 * @param {number} lastLineIndent needed indent
-		 * @returns {void}
-		 */
-		function checkLastNodeLineIndent(node, lastLineIndent) {
-			const lastToken = sourceCode.getLastToken(node);
-			const endIndent = getNodeIndent(lastToken, true);
-
-			if (
-				(endIndent.goodChar !== lastLineIndent ||
-					endIndent.badChar !== 0) &&
-				isNodeFirstInLine(node, true)
-			) {
-				report(
-					node,
-					lastLineIndent,
-					endIndent.space,
-					endIndent.tab,
-					{
-						line: lastToken.loc.start.line,
-						column: lastToken.loc.start.column,
-					},
-					true,
-				);
-			}
-		}
-
-		/**
-		 * Check last node line indent this detects, that block closed correctly
-		 * This function for more complicated return statement case, where closing parenthesis may be followed by ';'
-		 * @param {ASTNode} node Node to examine
-		 * @param {number} firstLineIndent first line needed indent
-		 * @returns {void}
-		 */
-		function checkLastReturnStatementLineIndent(node, firstLineIndent) {
-			/*
-			 * in case if return statement ends with ');' we have traverse back to ')'
-			 * otherwise we'll measure indent for ';' and replace ')'
-			 */
-			const lastToken = sourceCode.getLastToken(
-				node,
-				astUtils.isClosingParenToken,
-			);
-			const textBeforeClosingParenthesis = sourceCode
-				.getText(lastToken, lastToken.loc.start.column)
-				.slice(0, -1);
-
-			if (textBeforeClosingParenthesis.trim()) {
-				// There are tokens before the closing paren, don't report this case
-				return;
-			}
-
-			const endIndent = getNodeIndent(lastToken, true);
-
-			if (endIndent.goodChar !== firstLineIndent) {
-				report(
-					node,
-					firstLineIndent,
-					endIndent.space,
-					endIndent.tab,
-					{
-						line: lastToken.loc.start.line,
-						column: lastToken.loc.start.column,
-					},
-					true,
-				);
-			}
-		}
-
-		/**
-		 * Check first node line indent is correct
-		 * @param {ASTNode} node Node to examine
-		 * @param {number} firstLineIndent needed indent
-		 * @returns {void}
-		 */
-		function checkFirstNodeLineIndent(node, firstLineIndent) {
-			const startIndent = getNodeIndent(node, false);
-
-			if (
-				(startIndent.goodChar !== firstLineIndent ||
-					startIndent.badChar !== 0) &&
-				isNodeFirstInLine(node)
-			) {
-				report(
-					node,
-					firstLineIndent,
-					startIndent.space,
-					startIndent.tab,
-					{
-						line: node.loc.start.line,
-						column: node.loc.start.column,
-					},
-				);
-			}
-		}
-
-		/**
-		 * Returns a parent node of given node based on a specified type
-		 * if not present then return null
-		 * @param {ASTNode} node node to examine
-		 * @param {string} type type that is being looked for
-		 * @param {string} stopAtList end points for the evaluating code
-		 * @returns {ASTNode|void} if found then node otherwise null
-		 */
-		function getParentNodeByType(node, type, stopAtList) {
-			let parent = node.parent;
-			const stopAtSet = new Set(stopAtList || ["Program"]);
-
-			while (
-				parent.type !== type &&
-				!stopAtSet.has(parent.type) &&
-				parent.type !== "Program"
-			) {
-				parent = parent.parent;
-			}
-
-			return parent.type === type ? parent : null;
-		}
-
-		/**
-		 * Returns the VariableDeclarator based on the current node
-		 * if not present then return null
-		 * @param {ASTNode} node node to examine
-		 * @returns {ASTNode|void} if found then node otherwise null
-		 */
-		function getVariableDeclaratorNode(node) {
-			return getParentNodeByType(node, "VariableDeclarator");
-		}
-
-		/**
-		 * Check to see if the node is part of the multi-line variable declaration.
-		 * Also if its on the same line as the varNode
-		 * @param {ASTNode} node node to check
-		 * @param {ASTNode} varNode variable declaration node to check against
-		 * @returns {boolean} True if all the above condition satisfy
-		 */
-		function isNodeInVarOnTop(node, varNode) {
-			return (
-				varNode &&
-				varNode.parent.loc.start.line === node.loc.start.line &&
-				varNode.parent.declarations.length > 1
-			);
-		}
-
-		/**
-		 * Check to see if the argument before the callee node is multi-line and
-		 * there should only be 1 argument before the callee node
-		 * @param {ASTNode} node node to check
-		 * @returns {boolean} True if arguments are multi-line
-		 */
-		function isArgBeforeCalleeNodeMultiline(node) {
-			const parent = node.parent;
-
-			if (parent.arguments.length >= 2 && parent.arguments[1] === node) {
-				return (
-					parent.arguments[0].loc.end.line >
-					parent.arguments[0].loc.start.line
-				);
-			}
-
-			return false;
-		}
-
-		/**
-		 * 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) {
-			const parent = node.parent;
-			let stmt = parent.parent;
-
-			/*
-			 * Verify that the node is an IIEF
-			 */
-			if (parent.type !== "CallExpression" || parent.callee !== node) {
-				return false;
-			}
-
-			/*
-			 * Navigate legal ancestors to determine whether this IIEF is outer
-			 */
-			while (
-				(stmt.type === "UnaryExpression" &&
-					(stmt.operator === "!" ||
-						stmt.operator === "~" ||
-						stmt.operator === "+" ||
-						stmt.operator === "-")) ||
-				stmt.type === "AssignmentExpression" ||
-				stmt.type === "LogicalExpression" ||
-				stmt.type === "SequenceExpression" ||
-				stmt.type === "VariableDeclarator"
-			) {
-				stmt = stmt.parent;
-			}
-
-			return (
-				(stmt.type === "ExpressionStatement" ||
-					stmt.type === "VariableDeclaration") &&
-				stmt.parent &&
-				stmt.parent.type === "Program"
-			);
-		}
-
-		/**
-		 * Check indent for function block content
-		 * @param {ASTNode} node A BlockStatement node that is inside of a function.
-		 * @returns {void}
-		 */
-		function checkIndentInFunctionBlock(node) {
-			/*
-			 * Search first caller in chain.
-			 * Ex.:
-			 *
-			 * Models <- Identifier
-			 *   .User
-			 *   .find()
-			 *   .exec(function() {
-			 *   // function body
-			 * });
-			 *
-			 * Looks for 'Models'
-			 */
-			const calleeNode = node.parent; // FunctionExpression
-			let indent;
-
-			if (
-				calleeNode.parent &&
-				(calleeNode.parent.type === "Property" ||
-					calleeNode.parent.type === "ArrayExpression")
-			) {
-				// If function is part of array or object, comma can be put at left
-				indent = getNodeIndent(calleeNode, false).goodChar;
-			} else {
-				// If function is standalone, simple calculate indent
-				indent = getNodeIndent(calleeNode).goodChar;
-			}
-
-			if (calleeNode.parent.type === "CallExpression") {
-				const calleeParent = calleeNode.parent;
-
-				if (
-					calleeNode.type !== "FunctionExpression" &&
-					calleeNode.type !== "ArrowFunctionExpression"
-				) {
-					if (
-						calleeParent &&
-						calleeParent.loc.start.line < node.loc.start.line
-					) {
-						indent = getNodeIndent(calleeParent).goodChar;
-					}
-				} else {
-					if (
-						isArgBeforeCalleeNodeMultiline(calleeNode) &&
-						calleeParent.callee.loc.start.line ===
-							calleeParent.callee.loc.end.line &&
-						!isNodeFirstInLine(calleeNode)
-					) {
-						indent = getNodeIndent(calleeParent).goodChar;
-					}
-				}
-			}
-
-			/*
-			 * function body indent should be indent + indent size, unless this
-			 * is a FunctionDeclaration, FunctionExpression, or outer IIFE and the corresponding options are enabled.
-			 */
-			let functionOffset = indentSize;
-
-			if (options.outerIIFEBody !== null && isOuterIIFE(calleeNode)) {
-				functionOffset = options.outerIIFEBody * indentSize;
-			} else if (calleeNode.type === "FunctionExpression") {
-				functionOffset = options.FunctionExpression.body * indentSize;
-			} else if (calleeNode.type === "FunctionDeclaration") {
-				functionOffset = options.FunctionDeclaration.body * indentSize;
-			}
-			indent += functionOffset;
-
-			// check if the node is inside a variable
-			const parentVarNode = getVariableDeclaratorNode(node);
-
-			if (parentVarNode && isNodeInVarOnTop(node, parentVarNode)) {
-				indent +=
-					indentSize *
-					options.VariableDeclarator[parentVarNode.parent.kind];
-			}
-
-			if (node.body.length > 0) {
-				checkNodesIndent(node.body, indent);
-			}
-
-			checkLastNodeLineIndent(node, indent - functionOffset);
-		}
-
-		/**
-		 * Checks if the given node starts and ends on the same line
-		 * @param {ASTNode} node The node to check
-		 * @returns {boolean} Whether or not the block starts and ends on the same line.
-		 */
-		function isSingleLineNode(node) {
-			const lastToken = sourceCode.getLastToken(node),
-				startLine = node.loc.start.line,
-				endLine = lastToken.loc.end.line;
-
-			return startLine === endLine;
-		}
-
-		/**
-		 * Check indent for array block content or object block content
-		 * @param {ASTNode} node node to examine
-		 * @returns {void}
-		 */
-		function checkIndentInArrayOrObjectBlock(node) {
-			// Skip inline
-			if (isSingleLineNode(node)) {
-				return;
-			}
-
-			let elements =
-				node.type === "ArrayExpression"
-					? node.elements
-					: node.properties;
-
-			// filter out empty elements example would be [ , 2] so remove first element as espree considers it as null
-			elements = elements.filter(elem => elem !== null);
-
-			let nodeIndent;
-			let elementsIndent;
-			const parentVarNode = getVariableDeclaratorNode(node);
-
-			// TODO - come up with a better strategy in future
-			if (isNodeFirstInLine(node)) {
-				const parent = node.parent;
-
-				nodeIndent = getNodeIndent(parent).goodChar;
-				if (
-					!parentVarNode ||
-					parentVarNode.loc.start.line !== node.loc.start.line
-				) {
-					if (
-						parent.type !== "VariableDeclarator" ||
-						parentVarNode === parentVarNode.parent.declarations[0]
-					) {
-						if (
-							parent.type === "VariableDeclarator" &&
-							parentVarNode.loc.start.line ===
-								parent.loc.start.line
-						) {
-							nodeIndent +=
-								indentSize *
-								options.VariableDeclarator[
-									parentVarNode.parent.kind
-								];
-						} else if (
-							parent.type === "ObjectExpression" ||
-							parent.type === "ArrayExpression"
-						) {
-							const parentElements =
-								node.parent.type === "ObjectExpression"
-									? node.parent.properties
-									: node.parent.elements;
-
-							if (
-								parentElements[0] &&
-								parentElements[0].loc.start.line ===
-									parent.loc.start.line &&
-								parentElements[0].loc.end.line !==
-									parent.loc.start.line
-							) {
-								/*
-								 * If the first element of the array spans multiple lines, don't increase the expected indentation of the rest.
-								 * e.g. [{
-								 *        foo: 1
-								 *      },
-								 *      {
-								 *        bar: 1
-								 *      }]
-								 * the second object is not indented.
-								 */
-							} else if (
-								typeof options[parent.type] === "number"
-							) {
-								nodeIndent += options[parent.type] * indentSize;
-							} else {
-								nodeIndent = parentElements[0].loc.start.column;
-							}
-						} else if (
-							parent.type === "CallExpression" ||
-							parent.type === "NewExpression"
-						) {
-							if (
-								typeof options.CallExpression.arguments ===
-								"number"
-							) {
-								nodeIndent +=
-									options.CallExpression.arguments *
-									indentSize;
-							} else if (
-								options.CallExpression.arguments === "first"
-							) {
-								if (parent.arguments.includes(node)) {
-									nodeIndent =
-										parent.arguments[0].loc.start.column;
-								}
-							} else {
-								nodeIndent += indentSize;
-							}
-						} else if (
-							parent.type === "LogicalExpression" ||
-							parent.type === "ArrowFunctionExpression"
-						) {
-							nodeIndent += indentSize;
-						}
-					}
-				}
-
-				checkFirstNodeLineIndent(node, nodeIndent);
-			} else {
-				nodeIndent = getNodeIndent(node).goodChar;
-			}
-
-			if (options[node.type] === "first") {
-				elementsIndent = elements.length
-					? elements[0].loc.start.column
-					: 0; // If there are no elements, elementsIndent doesn't matter.
-			} else {
-				elementsIndent = nodeIndent + indentSize * options[node.type];
-			}
-
-			/*
-			 * Check if the node is a multiple variable declaration; if so, then
-			 * make sure indentation takes that into account.
-			 */
-			if (isNodeInVarOnTop(node, parentVarNode)) {
-				elementsIndent +=
-					indentSize *
-					options.VariableDeclarator[parentVarNode.parent.kind];
-			}
-
-			checkNodesIndent(elements, elementsIndent);
-
-			if (elements.length > 0) {
-				// Skip last block line check if last item in same line
-				if (elements.at(-1).loc.end.line === node.loc.end.line) {
-					return;
-				}
-			}
-
-			checkLastNodeLineIndent(
-				node,
-				nodeIndent +
-					(isNodeInVarOnTop(node, parentVarNode)
-						? options.VariableDeclarator[
-								parentVarNode.parent.kind
-							] * indentSize
-						: 0),
-			);
-		}
-
-		/**
-		 * Check if the node or node body is a BlockStatement or not
-		 * @param {ASTNode} node node to test
-		 * @returns {boolean} True if it or its body is a block statement
-		 */
-		function isNodeBodyBlock(node) {
-			return (
-				node.type === "BlockStatement" ||
-				node.type === "ClassBody" ||
-				(node.body && node.body.type === "BlockStatement") ||
-				(node.consequent && node.consequent.type === "BlockStatement")
-			);
-		}
-
-		/**
-		 * Check indentation for blocks
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function blockIndentationCheck(node) {
-			// Skip inline blocks
-			if (isSingleLineNode(node)) {
-				return;
-			}
-
-			if (
-				node.parent &&
-				(node.parent.type === "FunctionExpression" ||
-					node.parent.type === "FunctionDeclaration" ||
-					node.parent.type === "ArrowFunctionExpression")
-			) {
-				checkIndentInFunctionBlock(node);
-				return;
-			}
-
-			let indent;
-			let nodesToCheck;
-
-			/*
-			 * For this statements we should check indent from statement beginning,
-			 * not from the beginning of the block.
-			 */
-			const statementsWithProperties = [
-				"IfStatement",
-				"WhileStatement",
-				"ForStatement",
-				"ForInStatement",
-				"ForOfStatement",
-				"DoWhileStatement",
-				"ClassDeclaration",
-				"TryStatement",
-			];
-
-			if (
-				node.parent &&
-				statementsWithProperties.includes(node.parent.type) &&
-				isNodeBodyBlock(node)
-			) {
-				indent = getNodeIndent(node.parent).goodChar;
-			} else if (node.parent && node.parent.type === "CatchClause") {
-				indent = getNodeIndent(node.parent.parent).goodChar;
-			} else {
-				indent = getNodeIndent(node).goodChar;
-			}
-
-			if (
-				node.type === "IfStatement" &&
-				node.consequent.type !== "BlockStatement"
-			) {
-				nodesToCheck = [node.consequent];
-			} else if (Array.isArray(node.body)) {
-				nodesToCheck = node.body;
-			} else {
-				nodesToCheck = [node.body];
-			}
-
-			if (nodesToCheck.length > 0) {
-				checkNodesIndent(nodesToCheck, indent + indentSize);
-			}
-
-			if (node.type === "BlockStatement") {
-				checkLastNodeLineIndent(node, indent);
-			}
-		}
-
-		/**
-		 * Filter out the elements which are on the same line of each other or the node.
-		 * basically have only 1 elements from each line except the variable declaration line.
-		 * @param {ASTNode} node Variable declaration node
-		 * @returns {ASTNode[]} Filtered elements
-		 */
-		function filterOutSameLineVars(node) {
-			return node.declarations.reduce((finalCollection, elem) => {
-				const lastElem = finalCollection.at(-1);
-
-				if (
-					(elem.loc.start.line !== node.loc.start.line &&
-						!lastElem) ||
-					(lastElem &&
-						lastElem.loc.start.line !== elem.loc.start.line)
-				) {
-					finalCollection.push(elem);
-				}
-
-				return finalCollection;
-			}, []);
-		}
-
-		/**
-		 * Check indentation for variable declarations
-		 * @param {ASTNode} node node to examine
-		 * @returns {void}
-		 */
-		function checkIndentInVariableDeclarations(node) {
-			const elements = filterOutSameLineVars(node);
-			const nodeIndent = getNodeIndent(node).goodChar;
-			const lastElement = elements.at(-1);
-
-			const elementsIndent =
-				nodeIndent + indentSize * options.VariableDeclarator[node.kind];
-
-			checkNodesIndent(elements, elementsIndent);
-
-			// Only check the last line if there is any token after the last item
-			if (
-				sourceCode.getLastToken(node).loc.end.line <=
-				lastElement.loc.end.line
-			) {
-				return;
-			}
-
-			const tokenBeforeLastElement =
-				sourceCode.getTokenBefore(lastElement);
-
-			if (tokenBeforeLastElement.value === ",") {
-				// Special case for comma-first syntax where the semicolon is indented
-				checkLastNodeLineIndent(
-					node,
-					getNodeIndent(tokenBeforeLastElement).goodChar,
-				);
-			} else {
-				checkLastNodeLineIndent(node, elementsIndent - indentSize);
-			}
-		}
-
-		/**
-		 * 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 blockLessNodes(node) {
-			if (node.body.type !== "BlockStatement") {
-				blockIndentationCheck(node);
-			}
-		}
-
-		/**
-		 * Returns the expected indentation for the case statement
-		 * @param {ASTNode} node node to examine
-		 * @param {number} [providedSwitchIndent] indent for switch statement
-		 * @returns {number} indent size
-		 */
-		function expectedCaseIndent(node, providedSwitchIndent) {
-			const switchNode =
-				node.type === "SwitchStatement" ? node : node.parent;
-			const switchIndent =
-				typeof providedSwitchIndent === "undefined"
-					? getNodeIndent(switchNode).goodChar
-					: providedSwitchIndent;
-			let caseIndent;
-
-			if (caseIndentStore[switchNode.loc.start.line]) {
-				return caseIndentStore[switchNode.loc.start.line];
-			}
-
-			if (switchNode.cases.length > 0 && options.SwitchCase === 0) {
-				caseIndent = switchIndent;
-			} else {
-				caseIndent = switchIndent + indentSize * options.SwitchCase;
-			}
-
-			caseIndentStore[switchNode.loc.start.line] = caseIndent;
-			return caseIndent;
-		}
-
-		/**
-		 * Checks whether a return statement is wrapped in ()
-		 * @param {ASTNode} node node to examine
-		 * @returns {boolean} the result
-		 */
-		function isWrappedInParenthesis(node) {
-			const regex = /^return\s*\(\s*\)/u;
-
-			const statementWithoutArgument = sourceCode
-				.getText(node)
-				.replace(sourceCode.getText(node.argument), "");
-
-			return regex.test(statementWithoutArgument);
-		}
-
-		return {
-			Program(node) {
-				if (node.body.length > 0) {
-					// Root nodes should have no indent
-					checkNodesIndent(node.body, getNodeIndent(node).goodChar);
-				}
-			},
-
-			ClassBody: blockIndentationCheck,
-
-			BlockStatement: blockIndentationCheck,
-
-			WhileStatement: blockLessNodes,
-
-			ForStatement: blockLessNodes,
-
-			ForInStatement: blockLessNodes,
-
-			ForOfStatement: blockLessNodes,
-
-			DoWhileStatement: blockLessNodes,
-
-			IfStatement(node) {
-				if (
-					node.consequent.type !== "BlockStatement" &&
-					node.consequent.loc.start.line > node.loc.start.line
-				) {
-					blockIndentationCheck(node);
-				}
-			},
-
-			VariableDeclaration(node) {
-				if (
-					node.declarations.at(-1).loc.start.line >
-					node.declarations[0].loc.start.line
-				) {
-					checkIndentInVariableDeclarations(node);
-				}
-			},
-
-			ObjectExpression(node) {
-				checkIndentInArrayOrObjectBlock(node);
-			},
-
-			ArrayExpression(node) {
-				checkIndentInArrayOrObjectBlock(node);
-			},
-
-			MemberExpression(node) {
-				if (typeof options.MemberExpression === "undefined") {
-					return;
-				}
-
-				if (isSingleLineNode(node)) {
-					return;
-				}
-
-				/*
-				 * The typical layout of variable declarations and assignments
-				 * alter the expectation of correct indentation. Skip them.
-				 * TODO: Add appropriate configuration options for variable
-				 * declarations and assignments.
-				 */
-				if (
-					getParentNodeByType(node, "VariableDeclarator", [
-						"FunctionExpression",
-						"ArrowFunctionExpression",
-					])
-				) {
-					return;
-				}
-
-				if (
-					getParentNodeByType(node, "AssignmentExpression", [
-						"FunctionExpression",
-					])
-				) {
-					return;
-				}
-
-				const propertyIndent =
-					getNodeIndent(node).goodChar +
-					indentSize * options.MemberExpression;
-
-				const checkNodes = [node.property];
-
-				const dot = sourceCode.getTokenBefore(node.property);
-
-				if (dot.type === "Punctuator" && dot.value === ".") {
-					checkNodes.push(dot);
-				}
-
-				checkNodesIndent(checkNodes, propertyIndent);
-			},
-
-			SwitchStatement(node) {
-				// Switch is not a 'BlockStatement'
-				const switchIndent = getNodeIndent(node).goodChar;
-				const caseIndent = expectedCaseIndent(node, switchIndent);
-
-				checkNodesIndent(node.cases, caseIndent);
-
-				checkLastNodeLineIndent(node, switchIndent);
-			},
-
-			SwitchCase(node) {
-				// Skip inline cases
-				if (isSingleLineNode(node)) {
-					return;
-				}
-				const caseIndent = expectedCaseIndent(node);
-
-				checkNodesIndent(node.consequent, caseIndent + indentSize);
-			},
-
-			FunctionDeclaration(node) {
-				if (isSingleLineNode(node)) {
-					return;
-				}
-				if (
-					options.FunctionDeclaration.parameters === "first" &&
-					node.params.length
-				) {
-					checkNodesIndent(
-						node.params.slice(1),
-						node.params[0].loc.start.column,
-					);
-				} else if (options.FunctionDeclaration.parameters !== null) {
-					checkNodesIndent(
-						node.params,
-						getNodeIndent(node).goodChar +
-							indentSize * options.FunctionDeclaration.parameters,
-					);
-				}
-			},
-
-			FunctionExpression(node) {
-				if (isSingleLineNode(node)) {
-					return;
-				}
-				if (
-					options.FunctionExpression.parameters === "first" &&
-					node.params.length
-				) {
-					checkNodesIndent(
-						node.params.slice(1),
-						node.params[0].loc.start.column,
-					);
-				} else if (options.FunctionExpression.parameters !== null) {
-					checkNodesIndent(
-						node.params,
-						getNodeIndent(node).goodChar +
-							indentSize * options.FunctionExpression.parameters,
-					);
-				}
-			},
-
-			ReturnStatement(node) {
-				if (isSingleLineNode(node)) {
-					return;
-				}
-
-				const firstLineIndent = getNodeIndent(node).goodChar;
-
-				// in case if return statement is wrapped in parenthesis
-				if (isWrappedInParenthesis(node)) {
-					checkLastReturnStatementLineIndent(node, firstLineIndent);
-				} else {
-					checkNodeIndent(node, firstLineIndent);
-				}
-			},
-
-			CallExpression(node) {
-				if (isSingleLineNode(node)) {
-					return;
-				}
-				if (
-					options.CallExpression.arguments === "first" &&
-					node.arguments.length
-				) {
-					checkNodesIndent(
-						node.arguments.slice(1),
-						node.arguments[0].loc.start.column,
-					);
-				} else if (options.CallExpression.arguments !== null) {
-					checkNodesIndent(
-						node.arguments,
-						getNodeIndent(node).goodChar +
-							indentSize * options.CallExpression.arguments,
-					);
-				}
-			},
-		};
-	},
-};