docs: function validateIndent() {
              /**
               * Check whether the line start is in template tag.
               * @param {number} line The line.
               * @returns {boolean} `true` if the line start is in template tag.
               */
              function inTemplateTag(line) {
                  if (line <= 1) {
                      return false
                  }
                  const lineStartIndex = sourceCode.getIndexFromLoc({
                      line,
                      column: 0,
                  })
                  return microTemplateService.inTemplateTag(lineStartIndex - 1)
              }
  
              /**
               * Check whether the line start is in ignore range.
               * @param {number} line The line.
               * @returns {boolean} `true` if the line start is in ignore range.
               */
              function inIgnore(line) {
                  const index = sourceCode.getIndexFromLoc({
                      line,
                      column: 0,
                  })
                  return ignoreRanges.find(
                      range => range[0] <= index && index < range[1]
                  )
              }
  
              /**
               * Define the function which fixes the problem.
               * @param {number} line The number of line.
               * @param {number} actualIndent The number of actual indentation.
               * @param {number} expectedIndent The number of expected indentation.
               * @returns {function} The defined function.
               */
              function defineFix(line, actualIndent, expectedIndent) {
                  return fixer => {
                      const start = sourceCode.getIndexFromLoc({
                          line,
                          column: 0,
                      })
                      const indent = options.indentChar.repeat(expectedIndent)
                      return fixer.replaceTextRange(
                          [start, start + actualIndent],
                          indent
                      )
                  }
              }
  
              offsets.forEach((value, line) => {
                  if (inTemplateTag(line)) {
                      return
                  }
                  if (inIgnore(line)) {
                      return
                  }
                  if (!getLineText(line).trim()) {
                      // empty line
                      return
                  }
                  const actualText = value.actualText
                  const actualIndent = actualText.length
                  const expectedIndent = getExpectedIndent(line)
  
                  for (let i = 0; i < actualText.length; ++i) {
                      if (actualText[i] !== options.indentChar) {
                          context.report({
                              loc: {
                                  start: { line, column: i },
                                  end: { line, column: i + 1 },
                              },
                              messageId: "unexpectedIndentationCharacter",
                              data: {
                                  expected: JSON.stringify(options.indentChar),
                                  actual: JSON.stringify(actualText[i]),
                              },
                              fix: defineFix(line, actualIndent, expectedIndent),
                          })
                          return
                      }
                  }
  
                  if (actualIndent !== expectedIndent) {
                      context.report({
                          loc: {
                              start: { line, column: 0 },
                              end: { line, column: actualIndent },
                          },
                          messageId: "unexpectedIndentation",
                          data: {
                              expectedIndent,
                              actualIndent,
                              unit,
                              expectedIndentPlural:
                                  expectedIndent === 1 ? "" : "s",
                              actualIndentPlural: actualIndent === 1 ? "" : "s",
                          },
                          fix: defineFix(line, actualIndent, expectedIndent),
                      })
                  }
              })
          }