@alexlit/lint-kit 126.6.0 → 126.7.0

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

@@ -0,0 +1,1126 @@
+/**
+ * @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('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "layout",
+
+        docs: {
+            description: "Enforce consistent indentation",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/indent-legacy"
+        },
+
+        deprecated: true,
+
+        replacedBy: ["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";
+            } else /* c8 ignore start */ 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 {int} expectedAmount The expected amount of indentation characters for this line
+         * @param {int} actualSpaces The actual number of indentation spaces that were found on this line
+         * @param {int} actualTabs The actual number of indentation tabs that were found on this line
+         * @returns {string} An error message for this line
+         */
+        function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {
+            const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? "" : "s"}`; // e.g. "2 tabs"
+            const foundSpacesWord = `space${actualSpaces === 1 ? "" : "s"}`; // e.g. "space"
+            const foundTabsWord = `tab${actualTabs === 1 ? "" : "s"}`; // e.g. "tabs"
+            let foundStatement;
+
+            if (actualSpaces > 0 && 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 {int} needed Expected indentation character count
+         * @param {int} gottenSpaces Indentation space count in the actual node/code
+         * @param {int} 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 {int} 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 {int} 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 {int} 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 {int} 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 {int} 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 {int} [providedSwitchIndent] indent for switch statement
+         * @returns {int} 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);
+                }
+            }
+
+        };
+
+    }
+};