indent.js

/**
* Forked from: https://github.com/eslint/eslint/blob/v5.10.0/lib/rules/indent.js
* This modification adds the `VariableDeclaratorOffset` configuration variable
* that allows specifying how many spaces a multi-line variable declaration should
* be offset from the normal indentation level. For example:
*
* var something,
*     anotherSomething,
*     somethingElse;
*
* The multi-line variable declaration is indented 4 spaces from the normal indentation
* level, so VariableDeclaratorOffset should be set to '1' (i.e. indent of 3, offset adds
* 1, total indent 4).  es6 const declarations would need an offset of 3 (indent of 3,
* offset adds 3, total indent 6) to line up.
*
* Example configuration: "silvermine/indent":
* [
*    "error",
*    3,
*    {
*       "VariableDeclaratorOffset": { "var": 1, "let": 1, "const": 3 },
*       "SwitchCase": 1
*    }
* ]
*
*/

'use strict';

// ------------------------------------------------------------------------------
// Requirements
// ------------------------------------------------------------------------------

const lodash = require('lodash');

const astUtils = require('eslint/lib/util/ast-utils');

const createTree = require('functional-red-black-tree');

// ------------------------------------------------------------------------------
// Rule Definition
// ------------------------------------------------------------------------------

const KNOWN_NODES = new Set([
   'AssignmentExpression',
   'AssignmentPattern',
   'ArrayExpression',
   'ArrayPattern',
   'ArrowFunctionExpression',
   'AwaitExpression',
   'BlockStatement',
   'BinaryExpression',
   'BreakStatement',
   'CallExpression',
   'CatchClause',
   'ClassBody',
   'ClassDeclaration',
   'ClassExpression',
   'ConditionalExpression',
   'ContinueStatement',
   'DoWhileStatement',
   'DebuggerStatement',
   'EmptyStatement',
   'ExperimentalRestProperty',
   'ExperimentalSpreadProperty',
   'ExpressionStatement',
   'ForStatement',
   'ForInStatement',
   'ForOfStatement',
   'FunctionDeclaration',
   'FunctionExpression',
   'Identifier',
   'IfStatement',
   'Literal',
   'LabeledStatement',
   'LogicalExpression',
   'MemberExpression',
   'MetaProperty',
   'MethodDefinition',
   'NewExpression',
   'ObjectExpression',
   'ObjectPattern',
   'Program',
   'Property',
   'RestElement',
   'ReturnStatement',
   'SequenceExpression',
   'SpreadElement',
   'Super',
   'SwitchCase',
   'SwitchStatement',
   'TaggedTemplateExpression',
   'TemplateElement',
   'TemplateLiteral',
   'ThisExpression',
   'ThrowStatement',
   'TryStatement',
   'UnaryExpression',
   'UpdateExpression',
   'VariableDeclaration',
   'VariableDeclarator',
   'WhileStatement',
   'WithStatement',
   'YieldExpression',
   'JSXIdentifier',
   'JSXNamespacedName',
   'JSXMemberExpression',
   'JSXEmptyExpression',
   'JSXExpressionContainer',
   'JSXElement',
   'JSXClosingElement',
   'JSXOpeningElement',
   'JSXAttribute',
   'JSXSpreadAttribute',
   'JSXText',
   'ExportDefaultDeclaration',
   'ExportNamedDeclaration',
   'ExportAllDeclaration',
   'ExportSpecifier',
   'ImportDeclaration',
   'ImportSpecifier',
   'ImportDefaultSpecifier',
   'ImportNamespaceSpecifier',
]);

/*
 * General rule strategy:
 * 1. An OffsetStorage instance stores a map of desired offsets, where each token has a
 *    specified offset from another specified token or to the first column.
 * 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For
 *    example, when entering a BlockStatement, offset all of the tokens in the
 *    BlockStatement by 1 indent level from the opening curly brace of the BlockStatement.
 * 3. After traversing the AST, calculate the expected indentation levels of every token
 *    according to the OffsetStorage container.
 * 4. For each line, compare the expected indentation of the first token to the actual
 *    indentation in the file, and report the token if the two values are not equal.
 */


/**
 * A mutable balanced binary search tree that stores (key, value) pairs. The keys are
 * numeric, and must be unique. This is intended to be a generic wrapper around a balanced
 * binary search tree library, so that the underlying implementation can easily be swapped
 * out.
 */
class BinarySearchTree {

   /**
    * Creates an empty tree
    */
   constructor() {
      this._rbTree = createTree();
   }

   /**
    * Inserts an entry into the tree.
    * @param {number} key The entry's key
    * @param {*} value The entry's value
    * @returns {void}
    */
   insert(key, value) {
      const iterator = this._rbTree.find(key);

      if (iterator.valid) {
         this._rbTree = iterator.update(value);
      } else {
         this._rbTree = this._rbTree.insert(key, value);
      }
   }

   /**
    * Finds the entry with the largest key less than or equal to the provided key
    * @param {number} key The provided key
    * @returns {{key: number, value: *}|null} The found entry, or null if no such entry
    * exists.
    */
   findLe(key) {
      const iterator = this._rbTree.le(key);

      return iterator && { key: iterator.key, value: iterator.value };
   }

   /**
    * Deletes all of the keys in the interval [start, end)
    * @param {number} start The start of the range
    * @param {number} end The end of the range
    * @returns {void}
    */
   deleteRange(start, end) {

      // Exit without traversing the tree if the range has zero size.
      if (start === end) {
         return;
      }
      const iterator = this._rbTree.ge(start);

      while (iterator.valid && iterator.key < end) {
         this._rbTree = this._rbTree.remove(iterator.key);
         iterator.next();
      }
   }
}

/**
 * A helper class to get token-based info related to indentation
 */
class TokenInfo {

   /**
    * @param {SourceCode} sourceCode A SourceCode object
    */
   constructor(sourceCode) {
      this.sourceCode = sourceCode;
      this.firstTokensByLineNumber = sourceCode.tokensAndComments.reduce((map, token) => {
         if (!map.has(token.loc.start.line)) {
            map.set(token.loc.start.line, token);
         }
         if (!map.has(token.loc.end.line) && sourceCode.text.slice(token.range[1] - token.loc.end.column, token.range[1]).trim()) {
            map.set(token.loc.end.line, token);
         }

         return map;
      }, new Map());
   }

   /**
    * Gets the first token on a given token's line
    * @param {Token|ASTNode} token a node or token
    * @returns {Token} The first token on the given line
    */
   getFirstTokenOfLine(token) {
      return this.firstTokensByLineNumber.get(token.loc.start.line);
   }

   /**
    * Determines whether a token is the first token in its line
    * @param {Token} token The token
    * @returns {boolean} `true` if the token is the first on its line
    */
   isFirstTokenOfLine(token) {
      return this.getFirstTokenOfLine(token) === token;
   }

   /**
    * Get the actual indent of a token
    * @param {Token} token Token to examine. This should be the first token on its line.
    * @returns {string} The indentation characters that precede the token
    */
   getTokenIndent(token) {
      return this.sourceCode.text.slice(token.range[0] - token.loc.start.column, token.range[0]);
   }
}

/**
 * A class to store information on desired offsets of tokens from each other
 */
class OffsetStorage {

   /**
    * @param {TokenInfo} tokenInfo a TokenInfo instance
    * @param {number} indentSize The desired size of each indentation level
    * @param {string} indentType The indentation character
    */
   constructor(tokenInfo, indentSize, indentType) {
      this._tokenInfo = tokenInfo;
      this._indentSize = indentSize;
      this._indentType = indentType;

      this._tree = new BinarySearchTree();
      this._tree.insert(0, { offset: 0, from: null, force: false });

      this._lockedFirstTokens = new WeakMap();
      this._desiredIndentCache = new WeakMap();
      this._ignoredTokens = new WeakSet();
   }

   _getOffsetDescriptor(token) {
      return this._tree.findLe(token.range[0]).value;
   }

   /**
    * Sets the offset column of token B to match the offset column of token A.
    * **WARNING**: This matches a *column*, even if baseToken is not the first token on
    * its line. In most cases, `setDesiredOffset` should be used instead.
    * @param {Token} baseToken The first token
    * @param {Token} offsetToken The second token, whose offset should be matched to the
    *                            first token
    * @returns {void}
    */
   matchOffsetOf(baseToken, offsetToken) {

      /*
       * lockedFirstTokens is a map from a token whose indentation is controlled by the
       * "first" option to the token that it depends on. For example, with the
       * `ArrayExpression: first` option, the first token of each element in the array
       * after the first will be mapped to the first token of the first element. The
       * desired indentation of each of these tokens is computed based on the desired
       * indentation of the "first" element, rather than through the normal offset
       * mechanism.
       */
      this._lockedFirstTokens.set(offsetToken, baseToken);
   }

   /**
    * Sets the desired offset of a token.
    *
    * This uses a line-based offset collapsing behavior to handle tokens on the same
    * line.
    * For example, consider the following two cases:
    *
    * (
    *     [
    *         bar
    *     ]
    * )
    *
    * ([
    *     bar
    * ])
    *
    * Based on the first case, it's clear that the `bar` token needs to have an offset of
    * 1 indent level (4 spaces) from the `[` token, and the `[` token has to have an
    * offset of 1 indent level from the `(` token. Since the `(` token is the first on
    * its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2
    * indent levels (8 spaces) from the start of its line.
    *
    * However, in the second case `bar` should only be indented by 4 spaces. This is
    * because the offset of 1 indent level between the `(` and the `[` tokens gets
    * "collapsed" because the two tokens are on the same line. As a result, the `(` token
    * is mapped to the `[` token with an offset of 0, and the rule correctly decides that
    * `bar` should be indented by 1 indent level from the start of the line.
    *
    * This is useful because rule listeners can usually just call `setDesiredOffset` for
    * all the tokens in the node, without needing to check which lines those tokens are
    * on.
    *
    * Note that since collapsing only occurs when two tokens are on the same line, there
    * are a few cases where non-intuitive behavior can occur. For example, consider the
    * following cases:
    *
    * foo(
    * ).
    *     bar(
    *         baz
    *     )
    *
    * foo(
    * ).bar(
    *     baz
    * )
    *
    * Based on the first example, it would seem that `bar` should be offset by 1 indent
    * level from `foo`, and `baz` should be offset by 1 indent level from `bar`. However,
    * this is not correct, because it would result in `baz` being indented by 2 indent
    * levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines,
    * no collapsing would occur).
    *
    * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset
    * `bar` by 1 level from the `)`, and offset the `)` by 0 levels from `foo`. This
    * ensures that the offset between `bar` and the `)` are correctly collapsed in the
    * second case.
    *
    * @param {Token} token The token
    * @param {Token} fromToken The token that `token` should be offset from
    * @param {number} offset The desired indent level
    * @param {number} extraIndent The extra static indent amount to add to desired offset
    * @returns {void}
    */
   setDesiredOffset(token, fromToken, offset, extraIndent) {
      return this.setDesiredOffsets(token.range, fromToken, offset, extraIndent);
   }

   /**
    * Sets the desired offset of all tokens in a range
    * It's common for node listeners in this file to need to apply the same offset to a
    * large, contiguous range of tokens.  Moreover, the offset of any given token is
    * usually updated multiple times (roughly once for each node that contains it). This
    * means that the offset of each token is updated O(AST depth) times.
    * It would not be performant to store and update the offsets for each token
    * independently, because the rule would end up having a time complexity of O(number
    * of tokens * AST depth), which is quite slow for large files.
    *
    * Instead, the offset tree is represented as a collection of contiguous offset ranges
    * in a file. For example, the following list could represent the state of the offset
    * tree at a given point:
    *
    * * Tokens starting in the interval [0, 15) are aligned with the beginning of the
    *   file
    * * Tokens starting in the interval [15, 30) are offset by 1 indent level from the
    *   `bar` token
    * * Tokens starting in the interval [30, 43) are offset by 1 indent level from the
    *   `foo` token
    * * Tokens starting in the interval [43, 820) are offset by 2 indent levels from the
    *   `bar` token
    * * Tokens starting in the interval [820, ∞) are offset by 1 indent
    * level from the `baz` token
    *
    * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line
    * above would be inserted by using: `setDesiredOffsets([30, 43], fooToken, 1);`
    *
    * @param {[number, number]} range A [start, end] pair. All tokens with range[0] <=
    *                                 token.start < range[1] will have the offset
    *                                 applied.
    * @param {Token} fromToken The token that this is offset from
    * @param {number} offset The desired indent level
    * @param {boolean} force `true` if this offset should not use the normal collapsing
    *                        behavior. This should almost always be false.
    * @param {number} extraIndent The extra static indent amount to add to desired offset
    * @returns {void}
    */
   setDesiredOffsets(range, fromToken, offset, force, extraIndent) {

      /*
       * Offset ranges are stored as a collection of nodes, where each node maps a
       * numeric key to an offset descriptor. The tree for the example above would have
       * the following nodes:
       *
       * * key: 0, value: { offset: 0, from: null }
       * * key: 15, value: { offset: 1, from: barToken }
       * * key: 30, value: { offset: 1, from: fooToken }
       * * key: 43, value: { offset: 2, from: barToken }
       * * key: 820, value: { offset: 1, from: bazToken }
       *
       * To find the offset descriptor for any given token, one needs to find the node
       * with the largest key which is <= token.start. To make this operation fast, the
       * nodes are stored in a balanced binary search tree indexed by key.
       */
      const descriptorToInsert = { offset, from: fromToken, force, extraIndent };

      const descriptorAfterRange = this._tree.findLe(range[1]).value;

      const fromTokenIsInRange = fromToken && fromToken.range[0] >= range[0] && fromToken.range[1] <= range[1];

      const fromTokenDescriptor = fromTokenIsInRange && this._getOffsetDescriptor(fromToken);

      // First, remove any existing nodes in the range from the tree.
      this._tree.deleteRange(range[0] + 1, range[1]);

      // Insert a new node into the tree for this range
      this._tree.insert(range[0], descriptorToInsert);

      /*
       * To avoid circular offset dependencies, keep the `fromToken` token mapped to
       * whatever it was mapped to previously, even if it's in the current range.
       */
      if (fromTokenIsInRange) {
         this._tree.insert(fromToken.range[0], fromTokenDescriptor);
         this._tree.insert(fromToken.range[1], descriptorToInsert);
      }

      /*
       * To avoid modifying the offset of tokens after the range, insert another node to
       * keep the offset of the following tokens the same as it was before.
       */
      this._tree.insert(range[1], descriptorAfterRange);
   }

   /**
    * Gets the desired indent of a token
    * @param {Token} token The token
    * @returns {string} The desired indent of the token
    */
   getDesiredIndent(token) {
      if (!this._desiredIndentCache.has(token)) {

         if (this._ignoredTokens.has(token)) {

            /*
             * If the token is ignored, use the actual indent of the token as the
             * desired indent.
             * This ensures that no errors are reported for this token.
             */
            this._desiredIndentCache.set(token, this._tokenInfo.getTokenIndent(token));
         } else if (this._lockedFirstTokens.has(token)) {
            const firstToken = this._lockedFirstTokens.get(token);

            this._desiredIndentCache.set(
               token,

               // (indentation for the first element's line)
               this.getDesiredIndent(this._tokenInfo.getFirstTokenOfLine(firstToken)) +

               // (space between the start of the first element's line and the first
               // element)
               this._indentType.repeat(firstToken.loc.start.column - this._tokenInfo.getFirstTokenOfLine(firstToken).loc.start.column)
            );
         } else {
            const offsetInfo = this._getOffsetDescriptor(token);

            const extraIndent = offsetInfo.extraIndent ? offsetInfo.extraIndent : 0;

            const offset = (
                    offsetInfo.from &&
                    offsetInfo.from.loc.start.line === token.loc.start.line &&
                    !/^\s*?\n/.test(token.value) &&
                    !offsetInfo.force
                ) ? 0 : offsetInfo.offset * this._indentSize + extraIndent;

            this._desiredIndentCache.set(
               token,
               (offsetInfo.from ? this.getDesiredIndent(offsetInfo.from) : '') + this._indentType.repeat(offset)
            );
         }
      }

      return this._desiredIndentCache.get(token);
   }

   /**
    * Ignores a token, preventing it from being reported.
    * @param {Token} token The token
    * @returns {void}
    */
   ignoreToken(token) {
      if (this._tokenInfo.isFirstTokenOfLine(token)) {
         this._ignoredTokens.add(token);
      }
   }

   /**
    * Gets the first token that the given token's indentation is dependent on
    * @param {Token} token The token
    * @returns {Token} The token that the given token depends on, or `null` if the given
    * token is at the top level
    */
   getFirstDependency(token) {
      return this._getOffsetDescriptor(token).from;
   }
}

const ELEMENT_LIST_SCHEMA = {
   oneOf: [
   {
      type: 'integer',
      minimum: 0,
   },
   {
      'enum': [ 'first', 'off' ],
   },
   ],
};

module.exports = {
   meta: {
      type: 'layout',

      docs: {
         description: 'enforce consistent indentation',
         category: 'Stylistic Issues',
         recommended: false,
         url: 'https://eslint.org/docs/rules/indent',
      },

      fixable: 'whitespace',

      schema: [
         {
            oneOf: [
               {
                  'enum': [ 'tab' ],
               },
               {
                  type: 'integer',
                  minimum: 0,
               },
            ],
         },
         {
            type: 'object',
            properties: {
               SwitchCase: {
                  type: 'integer',
                  minimum: 0,
               },
               VariableDeclarator: {
                  oneOf: [
                     {
                        type: 'number',
                        minimum: 0,
                     },
                     {
                        type: 'object',
                        properties: {
                           'var': {
                              type: 'number',
                              minimum: 0,
                           },
                           'let': {
                              type: 'number',
                              minimum: 0,
                           },
                           'const': {
                              type: 'number',
                              minimum: 0,
                           },
                        },
                        additionalProperties: false,
                     },
                  ],
               },
               VariableDeclaratorOffset: {
                  oneOf: [
                     {
                        type: 'integer',
                        minimum: 0,
                     },
                     {
                        type: 'object',
                        properties: {
                           'var': {
                              type: 'integer',
                              minimum: 0,
                           },
                           'let': {
                              type: 'integer',
                              minimum: 0,
                           },
                           'const': {
                              type: 'integer',
                              minimum: 0,
                           },
                        },
                        additionalProperties: false,
                     },
                  ],
               },
               outerIIFEBody: {
                  type: 'integer',
                  minimum: 0,
               },
               MemberExpression: {
                  oneOf: [
                     {
                        type: 'integer',
                        minimum: 0,
                     },
                     {
                        'enum': [ 'off' ],
                     },
                  ],
               },
               FunctionDeclaration: {
                  type: 'object',
                  properties: {
                     parameters: ELEMENT_LIST_SCHEMA,
                     body: {
                        type: 'integer',
                        minimum: 0,
                     },
                  },
                  additionalProperties: false,
               },
               FunctionExpression: {
                  type: 'object',
                  properties: {
                     parameters: ELEMENT_LIST_SCHEMA,
                     body: {
                        type: 'integer',
                        minimum: 0,
                     },
                  },
                  additionalProperties: false,
               },
               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',
               },
               ignoredNodes: {
                  type: 'array',
                  items: {
                     type: 'string',
                     not: {
                        pattern: ':exit$',
                     },
                  },
               },
               ignoreComments: {
                  type: 'boolean',
               },
            },
            additionalProperties: false,
         },
      ],
   },

   create(context) {
      const DEFAULT_VARIABLE_INDENT = 1,
            DEFAULT_VARIABLE_STATIC_OFFSET = 0,
            DEFAULT_PARAMETER_INDENT = 1,
            DEFAULT_FUNCTION_BODY_INDENT = 1;

      let indentType = 'space',
          indentSize = 4;

      const options = {
         SwitchCase: 0,
         VariableDeclarator: {
            'var': DEFAULT_VARIABLE_INDENT,
            let: DEFAULT_VARIABLE_INDENT,
            'const': DEFAULT_VARIABLE_INDENT,
         },
         VariableDeclaratorOffset: {
            'var': DEFAULT_VARIABLE_STATIC_OFFSET,
            let: DEFAULT_VARIABLE_STATIC_OFFSET,
            'const': DEFAULT_VARIABLE_STATIC_OFFSET,
         },
         outerIIFEBody: 1,
         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,
         },
         MemberExpression: 1,
         ArrayExpression: 1,
         ObjectExpression: 1,
         ImportDeclaration: 1,
         flatTernaryExpressions: false,
         ignoredNodes: [],
         ignoreComments: false,
      };

      if (context.options.length) {
         if (context.options[0] === 'tab') {
            indentSize = 1;
            indentType = 'tab';
         } else {
            indentSize = context.options[0];
            indentType = 'space';
         }

         if (context.options[1]) {
            lodash.merge(options, context.options[1]);

            if (typeof options.VariableDeclarator === 'number') {
               options.VariableDeclarator = {
                  'var': options.VariableDeclarator,
                  let: options.VariableDeclarator,
                  'const': options.VariableDeclarator,
               };
            }

            if (typeof options.VariableDeclaratorOffset === 'number') {
               options.VariableDeclaratorOffset = {
                  'var': options.VariableDeclaratorOffset,
                  let: options.VariableDeclaratorOffset,
                  'const': options.VariableDeclaratorOffset,
               };
            }
         }
      }

      const sourceCode = context.getSourceCode();

      const tokenInfo = new TokenInfo(sourceCode);

      const offsets = new OffsetStorage(tokenInfo, indentSize, indentType === 'space' ? ' ' : '\t');

      const parameterParens = new WeakSet();

      /**
       * Creates an error message for a line, given the expected/actual indentation.
       * @param {int} expectedAmount The expected amount of indentation characters for
       *                             this line
       * @param {int} actualSpaces The actual number of indentation spaces that were
       *                           found on this line
       * @param {int} actualTabs The actual number of indentation tabs that were found
       *                         on this line
       * @returns {string} An error message for this line
       */
      function createErrorMessage(expectedAmount, actualSpaces, actualTabs) {
         const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? '' : 's'}`; // e.g. "2 tabs"

         const foundSpacesWord = `space${actualSpaces === 1 ? '' : 's'}`; // e.g. "space"

         const foundTabsWord = `tab${actualTabs === 1 ? '' : 's'}`; // e.g. "tabs"

         let foundStatement;

         if (actualSpaces > 0) {

            /*
             * Abbreviate the message if the expected indentation is also spaces.
             * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but
             * found 2 spaces'
             */
            foundStatement = indentType === 'space' ? actualSpaces : `${actualSpaces} ${foundSpacesWord}`;
         } else if (actualTabs > 0) {
            foundStatement = indentType === 'tab' ? actualTabs : `${actualTabs} ${foundTabsWord}`;
         } else {
            foundStatement = '0';
         }

         return `Expected indentation of ${expectedStatement} but found ${foundStatement}.`;
      }

      /**
       * Reports a given indent violation
       * @param {Token} token Token violating the indent rule
       * @param {string} neededIndent Expected indentation string
       * @returns {void}
       */
      function report(token, neededIndent) {
         const actualIndent = Array.from(tokenInfo.getTokenIndent(token));

         const numSpaces = actualIndent.filter((char) => char === ' ').length;

         const numTabs = actualIndent.filter((char) => char === '\t').length;

         context.report({
            node: token,
            message: createErrorMessage(neededIndent.length, numSpaces, numTabs),
            loc: {
               start: { line: token.loc.start.line, column: 0 },
               end: { line: token.loc.start.line, column: token.loc.start.column },
            },
            fix(fixer) {
               const range = [ token.range[0] - token.loc.start.column, token.range[0] ];

               const newText = neededIndent;

               return fixer.replaceTextRange(range, newText);
            },
         });
      }

      /**
       * Checks if a token's indentation is correct
       * @param {Token} token Token to examine
       * @param {string} desiredIndent Desired indentation of the string
       * @returns {boolean} `true` if the token's indentation is correct
       */
      function validateTokenIndent(token, desiredIndent) {
         const indentation = tokenInfo.getTokenIndent(token);

         return indentation === desiredIndent ||
                // To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed
                // spaces and tabs.
                indentation.includes(' ') && indentation.includes('\t');
      }

      /**
       * Check to see if the node is a file level IIFE
       * @param {ASTNode} node The function node to check.
       * @returns {boolean} True if the node is the outer IIFE
       */
      function isOuterIIFE(node) {

         /*
          * Verify that the node is an IIFE
          */
         if (!node.parent || node.parent.type !== 'CallExpression' || node.parent.callee !== node) {
            return false;
         }

         /*
          * Navigate legal ancestors to determine whether this IIFE is outer.
          * A "legal ancestor" is an expression or statement that causes the function
          * to get executed immediately.
          * For example, `!(function(){})()` is an outer IIFE even though it is
          * preceded by a ! operator.
          */
         let statement = node.parent && node.parent.parent;

         function checkStatement(stmt) {
            return stmt.type === 'UnaryExpression' && [ '!', '~', '+', '-' ].indexOf(stmt.operator) > -1 ||
                   stmt.type === 'AssignmentExpression' ||
                   stmt.type === 'LogicalExpression' ||
                   stmt.type === 'SequenceExpression' ||
                   stmt.type === 'VariableDeclarator';
         }

         while (checkStatement(statement)) {
            statement = statement.parent;
         }

         return (statement.type === 'ExpressionStatement' || statement.type === 'VariableDeclaration') &&
                statement.parent.type === 'Program';
      }

      /**
       * Counts the number of linebreaks that follow the last non-whitespace character
       * in a string
       * @param {string} string The string to check
       * @returns {number} The number of JavaScript linebreaks that follow the last
       * non-whitespace character,
       * or the total number of linebreaks if the string is all whitespace.
       */
      function countTrailingLinebreaks(string) {
         const trailingWhitespace = string.match(/\s*$/)[0];

         const linebreakMatches = trailingWhitespace.match(astUtils.createGlobalLinebreakMatcher());

         return linebreakMatches === null ? 0 : linebreakMatches.length;
      }

      /**
       * Check indentation for lists of elements (arrays, objects, function params)
       * @param {ASTNode[]} elements List of elements that should be offset
       * @param {Token} startToken The start token of the list that element should be
       *                           aligned against, e.g. '['
       * @param {Token} endToken The end token of the list, e.g. ']'
       * @param {number|string} offset The amount that the elements should be offset
       * @returns {void}
       */
      function addElementListIndent(elements, startToken, endToken, offset) {

         /**
          * Gets the first token of a given element, including surrounding parentheses.
          * @param {ASTNode} element A node in the `elements` list
          * @returns {Token} The first token of this element
          */
         function getFirstToken(element) {
            let token = sourceCode.getTokenBefore(element);

            while (astUtils.isOpeningParenToken(token) && token !== startToken) {
               token = sourceCode.getTokenBefore(token);
            }

            return sourceCode.getTokenAfter(token);
         }

         // Run through all the tokens in the list, and offset them by one indent level
         // (mainly for comments, other things will end up overridden)
         offsets.setDesiredOffsets(
            [ startToken.range[1], endToken.range[0] ],
            startToken,
            typeof offset === 'number' ? offset : 1
         );
         offsets.setDesiredOffset(endToken, startToken, 0);

         // If the preference is "first" but there is no first element (e.g. sparse arrays
         // w/ empty first slot), fall back to 1 level.
         if (offset === 'first' && elements.length && !elements[0]) {
            return;
         }
         elements.forEach((element, index) => {
            if (!element) {

               // Skip holes in arrays
               return;
            }
            if (offset === 'off') {

               // Ignore the first token of every element if the "off" option is used
               offsets.ignoreToken(getFirstToken(element));
            }

            // Offset the following elements correctly relative to the first element
            if (index === 0) {
               return;
            }
            if (offset === 'first' && tokenInfo.isFirstTokenOfLine(getFirstToken(element))) {
               offsets.matchOffsetOf(getFirstToken(elements[0]), getFirstToken(element));
            } else {
               const previousElement = elements[index - 1],
                     firstTokenOfPreviousElement = previousElement && getFirstToken(previousElement),
                     previousElementLastToken = previousElement && sourceCode.getLastToken(previousElement),
                     prevElEndLine = previousElementLastToken.loc.end.line - countTrailingLinebreaks(previousElementLastToken.value);

               if (previousElement && prevElEndLine > startToken.loc.end.line) {
                  offsets.setDesiredOffsets([ previousElement.range[1], element.range[1] ], firstTokenOfPreviousElement, 0);
               }
            }
         });
      }

      /**
       * Check and decide whether to check for indentation for blockless nodes
       * Scenarios are for or while statements without braces around them
       * @param {ASTNode} node node to examine
       * @returns {void}
       */
      function addBlocklessNodeIndent(node) {
         if (node.type !== 'BlockStatement') {
            const lastParentToken = sourceCode.getTokenBefore(node, astUtils.isNotOpeningParenToken);

            let firstBodyToken = sourceCode.getFirstToken(node),
                lastBodyToken = sourceCode.getLastToken(node);

            // eslint-disable-next-line max-len
            while (astUtils.isOpeningParenToken(sourceCode.getTokenBefore(firstBodyToken)) && astUtils.isClosingParenToken(sourceCode.getTokenAfter(lastBodyToken))) {
               firstBodyToken = sourceCode.getTokenBefore(firstBodyToken);
               lastBodyToken = sourceCode.getTokenAfter(lastBodyToken);
            }

            offsets.setDesiredOffsets([ firstBodyToken.range[0], lastBodyToken.range[1] ], lastParentToken, 1);

            /*
             * For blockless nodes with semicolon-first style, don't indent the semicolon.
             * e.g.
             * if (foo) bar()
             * ; [1, 2, 3].map(foo)
             */
            const lastToken = sourceCode.getLastToken(node);

            if (node.type !== 'EmptyStatement' && astUtils.isSemicolonToken(lastToken)) {
               offsets.setDesiredOffset(lastToken, lastParentToken, 0);
            }
         }
      }

      /**
       * Checks the indentation for nodes that are like function calls (`CallExpression`
       * and `NewExpression`)
       * @param {ASTNode} node A CallExpression or NewExpression node
       * @returns {void}
       */
      function addFunctionCallIndent(node) {
         let openingParen;

         if (node.arguments.length) {
            openingParen = sourceCode.getFirstTokenBetween(node.callee, node.arguments[0], astUtils.isOpeningParenToken);
         } else {
            openingParen = sourceCode.getLastToken(node, 1);
         }
         const closingParen = sourceCode.getLastToken(node);

         parameterParens.add(openingParen);
         parameterParens.add(closingParen);
         offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0);

         addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments);
      }

      /**
       * Checks the indentation of parenthesized values, given a list of tokens in a
       * program
       * @param {Token[]} tokens A list of tokens
       * @returns {void}
       */
      function addParensIndent(tokens) {
         const parenStack = [];

         const parenPairs = [];

         tokens.forEach((nextToken) => {

            // Accumulate a list of parenthesis pairs
            if (astUtils.isOpeningParenToken(nextToken)) {
               parenStack.push(nextToken);
            } else if (astUtils.isClosingParenToken(nextToken)) {
               parenPairs.unshift({ left: parenStack.pop(), right: nextToken });
            }
         });

         parenPairs.forEach((pair) => {
            const leftParen = pair.left;

            const rightParen = pair.right;

            // We only want to handle parens around expressions, so exclude parentheses
            // that are in function parameters and function call arguments.
            if (!parameterParens.has(leftParen) && !parameterParens.has(rightParen)) {
               const parenthesizedTokens = new Set(sourceCode.getTokensBetween(leftParen, rightParen));

               parenthesizedTokens.forEach((token) => {
                  if (!parenthesizedTokens.has(offsets.getFirstDependency(token))) {
                     offsets.setDesiredOffset(token, leftParen, 1);
                  }
               });
            }

            offsets.setDesiredOffset(rightParen, leftParen, 0);
         });
      }

      /**
       * Ignore all tokens within an unknown node whose offset do not depend
       * on another token's offset within the unknown node
       * @param {ASTNode} node Unknown Node
       * @returns {void}
       */
      function ignoreNode(node) {
         const unknownNodeTokens = new Set(sourceCode.getTokens(node, { includeComments: true }));

         unknownNodeTokens.forEach((token) => {
            if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) {
               const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token);

               if (token === firstTokenOfLine) {
                  offsets.ignoreToken(token);
               } else {
                  offsets.setDesiredOffset(token, firstTokenOfLine, 0);
               }
            }
         });
      }

      /**
       * Check whether the given token is on the first line of a statement.
       * @param {Token} token The token to check.
       * @param {ASTNode} leafNode The expression node that the token belongs directly.
       * @returns {boolean} `true` if the token is on the first line of a statement.
       */
      function isOnFirstLineOfStatement(token, leafNode) {
         let node = leafNode;

         while (node.parent && !node.parent.type.endsWith('Statement') && !node.parent.type.endsWith('Declaration')) {
            node = node.parent;
         }
         node = node.parent;

         return !node || node.loc.start.line === token.loc.start.line;
      }

      /**
       * Check whether there are any blank (whitespace-only) lines between
       * two tokens on separate lines.
       * @param {Token} firstToken The first token.
       * @param {Token} secondToken The second token.
       * @returns {boolean} `true` if the tokens are on separate lines and
       *   there exists a blank line between them, `false` otherwise.
       */
      function hasBlankLinesBetween(firstToken, secondToken) {
         const firstTokenLine = firstToken.loc.end.line;

         const secondTokenLine = secondToken.loc.start.line;

         if (firstTokenLine === secondTokenLine || firstTokenLine === secondTokenLine - 1) {
            return false;
         }

         for (let line = firstTokenLine + 1; line < secondTokenLine; ++line) {
            if (!tokenInfo.firstTokensByLineNumber.has(line)) {
               return true;
            }
         }

         return false;
      }

      const ignoredNodeFirstTokens = new Set();

      const baseOffsetListeners = {
         'ArrayExpression, ArrayPattern'(node) {
            const openingBracket = sourceCode.getFirstToken(node),
                  prevToken = lodash.findLast(node.elements) || openingBracket,
                  closingBracket = sourceCode.getTokenAfter(prevToken, astUtils.isClosingBracketToken);

            addElementListIndent(node.elements, openingBracket, closingBracket, options.ArrayExpression);
         },

         'ObjectExpression, ObjectPattern'(node) {
            const openingCurly = sourceCode.getFirstToken(node);

            const closingCurly = sourceCode.getTokenAfter(
               node.properties.length ? node.properties[node.properties.length - 1] : openingCurly,
               astUtils.isClosingBraceToken
            );

            addElementListIndent(node.properties, openingCurly, closingCurly, options.ObjectExpression);
         },

         ArrowFunctionExpression(node) {
            const firstToken = sourceCode.getFirstToken(node);

            if (astUtils.isOpeningParenToken(firstToken)) {
               const openingParen = firstToken;

               const closingParen = sourceCode.getTokenBefore(node.body, astUtils.isClosingParenToken);

               parameterParens.add(openingParen);
               parameterParens.add(closingParen);
               addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);
            }
            addBlocklessNodeIndent(node.body);
         },

         AssignmentExpression(node) {
            const operator = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator);

            offsets.setDesiredOffsets([ operator.range[0], node.range[1] ], sourceCode.getLastToken(node.left), 1);
            offsets.ignoreToken(operator);
            offsets.ignoreToken(sourceCode.getTokenAfter(operator));
         },

         'BinaryExpression, LogicalExpression'(node) {
            const operator = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator);

            /*
             * For backwards compatibility, don't check BinaryExpression indents, e.g.
             * var foo = bar &&
             *                   baz;
             */
            const tokenAfterOperator = sourceCode.getTokenAfter(operator);

            offsets.ignoreToken(operator);
            offsets.ignoreToken(tokenAfterOperator);
            offsets.setDesiredOffset(tokenAfterOperator, operator, 0);
         },

         'BlockStatement, ClassBody'(node) {

            let blockIndentLevel;

            if (node.parent && isOuterIIFE(node.parent)) {
               blockIndentLevel = options.outerIIFEBody;
            } else if (node.parent && (node.parent.type === 'FunctionExpression' || node.parent.type === 'ArrowFunctionExpression')) {
               blockIndentLevel = options.FunctionExpression.body;
            } else if (node.parent && node.parent.type === 'FunctionDeclaration') {
               blockIndentLevel = options.FunctionDeclaration.body;
            } else {
               blockIndentLevel = 1;
            }

            /*
             * For blocks that aren't lone statements, ensure that the opening curly brace
             * is aligned with the parent.
             */
            if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
               offsets.setDesiredOffset(sourceCode.getFirstToken(node), sourceCode.getFirstToken(node.parent), 0);
            }
            addElementListIndent(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), blockIndentLevel);
         },

         CallExpression: addFunctionCallIndent,


         'ClassDeclaration[superClass], ClassExpression[superClass]'(node) {
            const classToken = sourceCode.getFirstToken(node);

            const extendsToken = sourceCode.getTokenBefore(node.superClass, astUtils.isNotOpeningParenToken);

            offsets.setDesiredOffsets([ extendsToken.range[0], node.body.range[0] ], classToken, 1);
         },

         ConditionalExpression(node) {
            const firstToken = sourceCode.getFirstToken(node),
                  isOnSameLine = !astUtils.isTokenOnSameLine(node.test, node.consequent),
                  isOnFirstLine = isOnFirstLineOfStatement(firstToken, node);

            // `flatTernaryExpressions` option is for the following style:
            // var a =
            //     foo > 0 ? bar :
            //     foo < 0 ? baz :
            //     /*else*/ qiz ;
            if (!options.flatTernaryExpressions || isOnSameLine || isOnFirstLine) {
               const questionMarkToken = sourceCode.getFirstTokenBetween(
                  node.test,
                  node.consequent,
                  (token) => token.type === 'Punctuator' && token.value === '?'
               );

               const colonToken = sourceCode.getFirstTokenBetween(
                  node.consequent,
                  node.alternate,
                  (token) => token.type === 'Punctuator' && token.value === ':'
               );

               const firstConsequentToken = sourceCode.getTokenAfter(questionMarkToken);

               const lastConsequentToken = sourceCode.getTokenBefore(colonToken);

               const firstAlternateToken = sourceCode.getTokenAfter(colonToken);

               offsets.setDesiredOffset(questionMarkToken, firstToken, 1);
               offsets.setDesiredOffset(colonToken, firstToken, 1);

               offsets.setDesiredOffset(firstConsequentToken, firstToken, 1);

               /*
                * The alternate and the consequent should usually have the same
                * indentation.
                * If they share part of a line, align the alternate against the first
                * token of the consequent.
                * This allows the alternate to be indented correctly in cases like this:
                * foo ? (
                *   bar
                * ) : ( // this '(' is aligned with the '(' above, so it's considered to
                *       // be aligned with `foo`
                *   baz // as a result, `baz` is offset by 1 rather than 2
                * )
                */
               if (lastConsequentToken.loc.end.line === firstAlternateToken.loc.start.line) {
                  offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0);
               } else {

                  /**
                   * If the alternate and consequent do not share part of a line, offset
                   * the alternate from the first token of the conditional expression.
                   * For example:
                   * foo ? bar
                   *   : baz
                   *
                   * If `baz` were aligned with `bar` rather than being offset by 1 from
                   * `foo`, `baz` would end up having no expected indentation.
                   */
                  offsets.setDesiredOffset(firstAlternateToken, firstToken, 1);
               }
            }
         },

         'DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement': (node) => addBlocklessNodeIndent(node.body),

         ExportNamedDeclaration(node) {
            if (node.declaration === null) {
               const closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken);

               // Indent the specifiers in `export {foo, bar, baz}`
               addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);

               if (node.source) {

                  // Indent everything after and including the `from` token in `export
                  // {foo, bar, baz} from 'qux'`
                  offsets.setDesiredOffsets([ closingCurly.range[1], node.range[1] ], sourceCode.getFirstToken(node), 1);
               }
            }
         },

         ForStatement(node) {
            const forOpeningParen = sourceCode.getFirstToken(node, 1);

            if (node.init) {
               offsets.setDesiredOffsets(node.init.range, forOpeningParen, 1);
            }
            if (node.test) {
               offsets.setDesiredOffsets(node.test.range, forOpeningParen, 1);
            }
            if (node.update) {
               offsets.setDesiredOffsets(node.update.range, forOpeningParen, 1);
            }
            addBlocklessNodeIndent(node.body);
         },

         'FunctionDeclaration, FunctionExpression'(node) {
            const closingParen = sourceCode.getTokenBefore(node.body);

            const openingParen = sourceCode.getTokenBefore(node.params.length ? node.params[0] : closingParen);

            parameterParens.add(openingParen);
            parameterParens.add(closingParen);
            addElementListIndent(node.params, openingParen, closingParen, options[node.type].parameters);
         },

         IfStatement(node) {
            addBlocklessNodeIndent(node.consequent);
            if (node.alternate && node.alternate.type !== 'IfStatement') {
               addBlocklessNodeIndent(node.alternate);
            }
         },

         ImportDeclaration(node) {
            if (node.specifiers.some((specifier) => specifier.type === 'ImportSpecifier')) {
               const openingCurly = sourceCode.getFirstToken(node, astUtils.isOpeningBraceToken),
                     closingCurly = sourceCode.getLastToken(node, astUtils.isClosingBraceToken),
                     nodeSpecifierFilter = (specifier) => specifier.type === 'ImportSpecifier';

               addElementListIndent(node.specifiers.filter(nodeSpecifierFilter), openingCurly, closingCurly, options.ImportDeclaration);
            }

            const fromToken = sourceCode.getLastToken(node, (token) => token.type === 'Identifier' && token.value === 'from');

            const sourceToken = sourceCode.getLastToken(node, (token) => token.type === 'String');

            const semiToken = sourceCode.getLastToken(node, (token) => token.type === 'Punctuator' && token.value === ';');

            if (fromToken) {
               const end = semiToken && semiToken.range[1] === sourceToken.range[1] ? node.range[1] : sourceToken.range[1];

               offsets.setDesiredOffsets([ fromToken.range[0], end ], sourceCode.getFirstToken(node), 1);
            }
         },

         'MemberExpression, JSXMemberExpression, MetaProperty'(node) {
            const object = node.type === 'MetaProperty' ? node.meta : node.object;

            const firstNonObjectToken = sourceCode.getFirstTokenBetween(object, node.property, astUtils.isNotClosingParenToken);

            const secondNonObjectToken = sourceCode.getTokenAfter(firstNonObjectToken);

            const objectParenCount = sourceCode.getTokensBetween(object, node.property, { filter: astUtils.isClosingParenToken }).length;

            const firstObjectToken = objectParenCount
                    ? sourceCode.getTokenBefore(object, { skip: objectParenCount - 1 })
                    : sourceCode.getFirstToken(object);

            const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken);

            const firstPropertyToken = node.computed ? firstNonObjectToken : secondNonObjectToken;

            if (node.computed) {
               // For computed MemberExpressions, match the closing bracket with the
               // opening bracket.
               offsets.setDesiredOffset(sourceCode.getLastToken(node), firstNonObjectToken, 0);
               offsets.setDesiredOffsets(node.property.range, firstNonObjectToken, 1);
            }

            /*
             * If the object ends on the same line that the property starts, match against
             * the last token of the object, to ensure that the MemberExpression is not
             * indented.
             *
             * Otherwise, match against the first token of the object, e.g.
             * foo
             *   .bar
             *   .baz // <-- offset by 1 from `foo`
             */
            const offsetBase = lastObjectToken.loc.end.line === firstPropertyToken.loc.start.line
                    ? lastObjectToken
                    : firstObjectToken;

            if (typeof options.MemberExpression === 'number') {

               // Match the dot (for non-computed properties) or the opening bracket (for
               // computed properties) against the object.
               offsets.setDesiredOffset(firstNonObjectToken, offsetBase, options.MemberExpression);

               /*
                * For computed MemberExpressions, match the first token of the property
                * against the opening bracket. Otherwise, match the first token of the
                * property against the object.
                */
               offsets.setDesiredOffset(secondNonObjectToken, node.computed ? firstNonObjectToken : offsetBase, options.MemberExpression);
            } else {

               // If the MemberExpression option is off, ignore the dot and the first
               // token of the property.
               offsets.ignoreToken(firstNonObjectToken);
               offsets.ignoreToken(secondNonObjectToken);

               // To ignore the property indentation, ensure that the property tokens
               // depend on the ignored tokens.
               offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0);
               offsets.setDesiredOffset(secondNonObjectToken, firstNonObjectToken, 0);
            }
         },

         NewExpression(node) {
            const isClosingParen = astUtils.isClosingParenToken(sourceCode.getLastToken(node)),
                  isOpeningParen = astUtils.isOpeningParenToken(sourceCode.getLastToken(node, 1));

            // Only indent the arguments if the NewExpression has parens (e.g. `new
            // Foo(bar)` or `new Foo()`, but not `new Foo`
            if (node.arguments.length > 0 || isClosingParen && isOpeningParen) {
               addFunctionCallIndent(node);
            }
         },

         Property(node) {
            if (!node.shorthand && !node.method && node.kind === 'init') {
               const colon = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isColonToken);

               offsets.ignoreToken(sourceCode.getTokenAfter(colon));
            }
         },

         SwitchStatement(node) {
            const openingCurly = sourceCode.getTokenAfter(node.discriminant, astUtils.isOpeningBraceToken);

            const closingCurly = sourceCode.getLastToken(node);

            offsets.setDesiredOffsets([ openingCurly.range[1], closingCurly.range[0] ], openingCurly, options.SwitchCase);

            if (node.cases.length) {
               const tokensBetween = sourceCode.getTokensBetween(
                  node.cases[node.cases.length - 1],
                  closingCurly,
                  { includeComments: true, filter: astUtils.isCommentToken }
               );

               tokensBetween.forEach((token) => offsets.ignoreToken(token));
            }
         },

         SwitchCase(node) {
            if (!(node.consequent.length === 1 && node.consequent[0].type === 'BlockStatement')) {
               const caseKeyword = sourceCode.getFirstToken(node);

               const tokenAfterCurrentCase = sourceCode.getTokenAfter(node);

               offsets.setDesiredOffsets([ caseKeyword.range[1], tokenAfterCurrentCase.range[0] ], caseKeyword, 1);
            }
         },

         TemplateLiteral(node) {
            node.expressions.forEach((expression, index) => {
               const previousQuasi = node.quasis[index];

               const nextQuasi = node.quasis[index + 1];

               const tokenToAlignFrom = previousQuasi.loc.start.line === previousQuasi.loc.end.line
                        ? sourceCode.getFirstToken(previousQuasi)
                        : null;

               offsets.setDesiredOffsets([ previousQuasi.range[1], nextQuasi.range[0] ], tokenToAlignFrom, 1);
               offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0);
            });
         },

         VariableDeclaration(node) {
            const variableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclarator, node.kind)
                    ? options.VariableDeclarator[node.kind]
                    : DEFAULT_VARIABLE_INDENT;

            const extraVariableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclaratorOffset, node.kind)
                    ? options.VariableDeclaratorOffset[node.kind]
                    : 0;

            if (node.declarations[node.declarations.length - 1].loc.start.line > node.loc.start.line) {

               /*
                * VariableDeclarator indentation is a bit different from other forms of
                * indentation, in that the indentation of an opening bracket sometimes
                * won't match that of a closing bracket. For example, the following
                * indentations are correct:
                *
                * var foo = {
                *   ok: true
                * };
                *
                * var foo = {
                *     ok: true,
                *   },
                *   bar = 1;
                *
                * Account for when exiting the AST (after indentations have already been
                * set for the nodes in the declaration) by manually increasing the
                * indentation level of the tokens in this declarator on the same line as
                * the start of the declaration, provided that there are declarators that
                * follow this one.
                */
               const firstToken = sourceCode.getFirstToken(node);

               offsets.setDesiredOffsets(node.range, firstToken, variableIndent, true, extraVariableIndent);
            } else if (node.loc.start.line === node.loc.end.line) {

               /* Only add the extra space if this declaration doesn't span multiple
                * lines. Otherwise, we can't do:
                * const myArr [
                *    {
                *       a: 1,
                *       b: 2,
                *    },
                * ];
                */
               offsets.setDesiredOffsets(node.range, sourceCode.getFirstToken(node), variableIndent, extraVariableIndent);
            } else {
               offsets.setDesiredOffsets(node.range, sourceCode.getFirstToken(node), variableIndent);
            }
            const lastToken = sourceCode.getLastToken(node);

            if (astUtils.isSemicolonToken(lastToken)) {
               offsets.ignoreToken(lastToken);
            }
         },

         VariableDeclarator(node) {
            if (node.init) {
               const equalOperator = sourceCode.getTokenBefore(node.init, astUtils.isNotOpeningParenToken);

               const tokenAfterOperator = sourceCode.getTokenAfter(equalOperator);

               offsets.ignoreToken(equalOperator);
               offsets.ignoreToken(tokenAfterOperator);
               offsets.setDesiredOffsets([ tokenAfterOperator.range[0], node.range[1] ], equalOperator, 1);
               offsets.setDesiredOffset(equalOperator, sourceCode.getLastToken(node.id), 0);
            }
         },

         'JSXAttribute[value]'(node) {
            const equalsToken = sourceCode.getFirstTokenBetween(
               node.name,
               node.value,
               (token) => token.type === 'Punctuator' && token.value === '='
            );

            offsets.setDesiredOffsets([ equalsToken.range[0], node.value.range[1] ], sourceCode.getFirstToken(node.name), 1);
         },

         JSXElement(node) {
            if (node.closingElement) {
               addElementListIndent(
                  node.children,
                  sourceCode.getFirstToken(node.openingElement),
                  sourceCode.getFirstToken(node.closingElement),
                  1
               );
            }
         },

         JSXOpeningElement(node) {
            const firstToken = sourceCode.getFirstToken(node);

            let closingToken;

            if (node.selfClosing) {
               closingToken = sourceCode.getLastToken(node, { skip: 1 });
               offsets.setDesiredOffset(sourceCode.getLastToken(node), closingToken, 0);
            } else {
               closingToken = sourceCode.getLastToken(node);
            }
            offsets.setDesiredOffsets(node.name.range, sourceCode.getFirstToken(node));
            addElementListIndent(node.attributes, firstToken, closingToken, 1);
         },

         JSXClosingElement(node) {
            const firstToken = sourceCode.getFirstToken(node);

            offsets.setDesiredOffsets(node.name.range, firstToken, 1);
         },

         JSXExpressionContainer(node) {
            const openingCurly = sourceCode.getFirstToken(node);

            const closingCurly = sourceCode.getLastToken(node);

            offsets.setDesiredOffsets([ openingCurly.range[1], closingCurly.range[0] ], openingCurly, 1);
         },

         '*'(node) {
            const firstToken = sourceCode.getFirstToken(node);

            // Ensure that the children of every node are indented at least as much as the
            // first token.
            if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) {
               offsets.setDesiredOffsets(node.range, firstToken, 0);
            }
         },
      };

      const listenerCallQueue = [];

      /*
       * To ignore the indentation of a node:
       * 1. Don't call the node's listener when entering it (if it has a listener)
       * 2. Don't set any offsets against the first token of the node.
       * 3. Call `ignoreNode` on the node sometime after exiting it and before
       *    validating offsets.
       */
      const offsetListeners = lodash.mapValues(
         baseOffsetListeners,

         /*
          * Offset listener calls are deferred until traversal is finished, and are
          * called as part of the final `Program:exit` listener. This is necessary
          * because a node might be matched by multiple selectors.
          *
          * Example: Suppose there is an offset listener for `Identifier`, and the user
          * has specified in configuration that `MemberExpression > Identifier` should
          * be ignored.  Due to selector specificity rules, the `Identifier` listener
          * will get called first. However, if a given Identifier node is supposed to
          * be ignored, then the `Identifier` offset listener should not have been
          * called at all. Without doing extra selector matching, we don't know whether
          * the Identifier matches the `MemberExpression > Identifier` selector until
          * the `MemberExpression > Identifier` listener is called.
          *
          * To avoid this, the `Identifier` listener isn't called until traversal
          * finishes and all ignored nodes are known.
          */
         (listener) => (node) => listenerCallQueue.push({ listener, node })
      );

      // For each ignored node selector, set up a listener to collect it into the
      // `ignoredNodes` set.
      const ignoredNodes = new Set();

      /**
       * Ignores a node
       * @param {ASTNode} node The node to ignore
       * @returns {void}
       */
      function addToIgnoredNodes(node) {
         ignoredNodes.add(node);
         ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));
      }

      const ignoredNodeListeners = options.ignoredNodes.reduce(
         (listeners, ignoredSelector) => Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }),
         {}
      );

      /*
       * Join the listeners, and add a listener to verify that all tokens actually have
       * the correct indentation at the end.
       *
       * Using Object.assign will cause some offset listeners to be overwritten if the
       * same selector also appears in `ignoredNodeListeners`. This isn't a problem
       * because all of the matching nodes will be ignored, so those listeners wouldn't
       * be called anyway.
       */
      return Object.assign(
         offsetListeners,
         ignoredNodeListeners,
         {
            '*:exit'(node) {

                // If a node's type is nonstandard, we can't tell how its children should
                // be offset, so ignore it.
               if (!KNOWN_NODES.has(node.type)) {
                  addToIgnoredNodes(node);
               }
            },
            'Program:exit'() {

                // If ignoreComments option is enabled, ignore all comment tokens.
               if (options.ignoreComments) {
                  sourceCode.getAllComments()
                     .forEach((comment) => offsets.ignoreToken(comment));
               }

                // Invoke the queued offset listeners for the nodes that aren't ignored.
               listenerCallQueue
                  .filter((nodeInfo) => !ignoredNodes.has(nodeInfo.node))
                  .forEach((nodeInfo) => nodeInfo.listener(nodeInfo.node));

                // Update the offsets for ignored nodes to prevent their child tokens from
                // being reported.
               ignoredNodes.forEach(ignoreNode);

               addParensIndent(sourceCode.ast.tokens);

               /*
                * Create a Map from (tokenOrComment) => (precedingToken).
                * This is necessary because sourceCode.getTokenBefore does not
                * handle a comment as an argument correctly.
                */
               const precedingTokens = sourceCode.ast.comments.reduce((commentMap, comment) => {
                  const tokenOrCommentBefore = sourceCode.getTokenBefore(comment, { includeComments: true }),
                        tokenBefore = commentMap.has(tokenOrCommentBefore) ? commentMap.get(tokenOrCommentBefore) : tokenOrCommentBefore;

                  return commentMap.set(comment, tokenBefore);
               }, new WeakMap());

               sourceCode.lines.forEach((line, lineIndex) => {
                  const lineNumber = lineIndex + 1;

                  if (!tokenInfo.firstTokensByLineNumber.has(lineNumber)) {

                     // Don't check indentation on blank lines
                     return;
                  }

                  const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(lineNumber);

                  if (firstTokenOfLine.loc.start.line !== lineNumber) {

                     // Don't check the indentation of multi-line tokens (e.g. template
                     // literals or block comments) twice.
                     return;
                  }

                  // If the token matches the expected expected indentation, don't report
                  // it.
                  if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) {
                     return;
                  }

                  if (astUtils.isCommentToken(firstTokenOfLine)) {
                     const tokenBefore = precedingTokens.get(firstTokenOfLine),
                           tokenAfter = tokenBefore ? sourceCode.getTokenAfter(tokenBefore) : sourceCode.ast.tokens[0],
                           mayAlignWithBefore = tokenBefore && !hasBlankLinesBetween(tokenBefore, firstTokenOfLine),
                           mayAlignWithAfter = tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter),
                           validateTokenBefore = validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore)),
                           validateTokenAfter = validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenAfter));

                     // If a comment matches the expected indentation of the token
                     // immediately before or after, don't report it.
                     if (mayAlignWithBefore && validateTokenBefore || mayAlignWithAfter && validateTokenAfter) {
                        return;
                     }
                  }

                  // Otherwise, report the token/comment.
                  report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));
               });
            },
         }
      );
   },
};