docs: function processEvaluates() {
              const evaluates = microTemplateService
                  .getMicroTemplateTokens()
                  .filter(t => t.type === "MicroTemplateEvaluate")
                  .sort((a, b) => a.range[0] - b.range[0])
  
              /**
               * Find indentation-start punctuator token, within micro-template evaluate.
               * @param {Node} evaluate The micro-template evaluate to set
               * @returns {Token} The indentation-start punctuator token.
               */
              function findIndentationStartPunctuator(evaluate) {
                  const searchIndex = evaluate.code.search(/(\S)\s*$/u)
                  if (searchIndex < 0) {
                      return null
                  }
                  const charIndex =
                      evaluate.expressionStart.range[1] + searchIndex
                  const node = sourceCode.getNodeByRangeIndex(charIndex)
                  if (!node) {
                      // comment only
                      return null
                  }
                  const tokens = sourceCode
                      .getTokens(node)
                      .filter(
                          t =>
                              t.range[0] <= evaluate.range[1] &&
                              t.range[1] >= evaluate.range[0]
                      )
  
                  let targetToken = tokens.find(
                      t => t.range[0] <= charIndex && charIndex < t.range[1]
                  )
                  if (!targetToken) {
                      targetToken = tokens
                          .reverse()
                          .find(t => t.range[1] <= charIndex)
                  }
                  let token = targetToken
                  while (token) {
                      if (
                          token.range[0] > evaluate.range[1] ||
                          token.range[1] < evaluate.range[0]
                      ) {
                          return null
                      }
                      if (isIndentationStartPunctuator(token)) {
                          return token
                      }
                      if (isIndentationEndPunctuator(token)) {
                          // skip
                          const next = findPairOpenPunctuator(token)
                          token = sourceCode.getTokenBefore(next)
                          continue
                      }
  
                      token = sourceCode.getTokenBefore(token)
                  }
  
                  return null
              }
  
              /**
               * Find pair open punctuator token.
               * @param {Node} closeToken The close punctuator token
               * @returns {Token} The indentation-start punctuator token.
               */
              function findPairOpenPunctuator(closeToken) {
                  const closePunctuatorText = closeToken.value
  
                  const isPairOpenPunctuator =
                      closePunctuatorText === ")"
                          ? isLeftParen
                          : closePunctuatorText === "}"
                          ? isLeftBrace
                          : isLeftBracket
                  let token = sourceCode.getTokenBefore(closeToken)
                  while (token) {
                      if (isPairOpenPunctuator(token)) {
                          return token
                      }
                      if (isIndentationEndPunctuator(token)) {
                          // skip
                          const next = findPairOpenPunctuator(token)
                          token = sourceCode.getTokenBefore(next)
                          continue
                      }
  
                      token = sourceCode.getTokenBefore(token)
                  }
                  return null
              }
  
              /**
               * Find pair close punctuator token.
               * @param {Node} openToken The open punctuator token
               * @returns {Token} The indentation-end punctuator token.
               */
              function findPairClosePunctuator(openToken) {
                  const openPunctuatorText = openToken.value
  
                  const isPairClosePunctuator =
                      openPunctuatorText === "("
                          ? isRightParen
                          : openPunctuatorText === "{"
                          ? isRightBrace
                          : isRightBracket
                  let token = sourceCode.getTokenAfter(openToken)
                  while (token) {
                      if (isPairClosePunctuator(token)) {
                          return token
                      }
                      if (isIndentationStartPunctuator(token)) {
                          // skip
                          const next = findPairClosePunctuator(token)
                          token = sourceCode.getTokenAfter(next)
                          continue
                      }
  
                      token = sourceCode.getTokenAfter(token)
                  }
                  return null
              }
  
              /**
               * Set offset to the given range line blick.
               * @param {number} baseAndStartLine The start line no to set.
               * @param {number} endLine The end line no to set.
               * @returns {void}
               */
              function setOffsetToRangeLines(baseAndStartLine, endLine) {
                  const baseLine = baseAndStartLine
                  for (let lineNo = baseLine + 1; lineNo <= endLine; lineNo++) {
                      const offset = offsets.get(lineNo)
                      if (offset) {
                          if (offset.baseline <= baseLine) {
                              offset.baseline = baseLine
                              offset.offset = 1
                          }
                      } else {
                          setOffsetToLine(lineNo, 1, baseLine)
                      }
                  }
              }
  
              /**
               * Set offset to the given range line blick.
               * @param {number} baseAndStartLine The start line no to set.
               * @param {number} endLine The end line no to set.
               * @param {ASTNode} switchStatementNode The node of SwitchStatement.
               * @returns {void}
               */
              function setOffsetToRangeLinesForSwitch(
                  baseAndStartLine,
                  endLine,
                  switchStatementNode
              ) {
                  /**
                   * Find evaluate token of SwitchCase body from the given line.
                   * @param {number} line The line no to set.
                   * @returns {Token} The evaluate token of SwitchCase.
                   */
                  function findSwitchCaseBodyInfoAtLineStart(line) {
                      const index = sourceCode.getIndexFromLoc({
                          line,
                          column: 0,
                      })
  
                      let switchCaseNode = sourceCode.getNodeByRangeIndex(index)
                      if (
                          !switchCaseNode ||
                          switchCaseNode.type === "SwitchStatement"
                      ) {
                          switchCaseNode = switchStatementNode.cases.find(
                              (_token, i) => {
                                  const next = switchStatementNode.cases[i + 1]
                                  if (!next || index < next.range[0]) {
                                      return true
                                  }
                                  return false
                              }
                          )
                      }
                      if (
                          !switchCaseNode ||
                          switchCaseNode.type !== "SwitchCase"
                      ) {
                          // not SwitchCase
                          return null
                      }
  
                      if (switchCaseNode.test) {
                          if (index < switchCaseNode.test.range[1]) {
                              // not body
                              return null
                          }
                      } else {
                          // default:
                          const fToken = sourceCode.getFirstToken(switchCaseNode)
                          const colon = sourceCode.getTokenAfter(
                              fToken,
                              t => t.type === "Punctuator" && t.value === ":"
                          )
                          if (index < colon.range[1]) {
                              // not body
                              return null
                          }
                      }
                      if (
                          !equalsLocation(
                              switchCaseNode.parent,
                              switchStatementNode
                          )
                      ) {
                          // not target
                          return null
                      }
                      const casesIndex = switchStatementNode.cases.findIndex(c =>
                          equalsLocation(c, switchCaseNode)
                      )
                      const evaluate = evaluates.find(
                          e =>
                              e.range[0] <= switchCaseNode.range[0] &&
                              switchCaseNode.range[0] < e.range[1]
                      )
                      return {
                          evaluate,
                          casesIndex,
                          node: switchCaseNode,
                      }
                  }
  
                  const switchStatementLine = baseAndStartLine
                  // const switchStatementLineOffset = getBaseLineOffset(
                  //     switchStatementLine
                  // )
  
                  for (
                      let lineNo = baseAndStartLine + 1;
                      lineNo <= endLine;
                      lineNo++
                  ) {
                      const switchCaseInfo = findSwitchCaseBodyInfoAtLineStart(
                          lineNo
                      )
                      if (!switchCaseInfo) {
                          continue
                      }
                      const baseLine = switchCaseInfo.evaluate.loc.start.line
  
                      const offset = offsets.get(lineNo)
                      if (offset) {
                          if (offset.baseline <= baseLine) {
                              offset.baseline = switchStatementLine
                              offset.offset = 1
                          }
                      } else {
                          setOffsetToLine(lineNo, 1, switchStatementLine)
                      }
                  }
              }
  
              const closeEvaluateOffsets = new Map()
              for (const evaluate of evaluates) {
                  const leftToken = findIndentationStartPunctuator(evaluate)
                  if (!leftToken) {
                      continue
                  }
                  const rightToken = findPairClosePunctuator(leftToken)
                  if (!rightToken) {
                      continue
                  }
  
                  const closeEvaluate = evaluates.find(
                      e =>
                          e.range[0] <= rightToken.range[0] &&
                          rightToken.range[0] < e.range[1]
                  )
                  if (!closeEvaluate) {
                      continue
                  }
  
                  const closingStartIsBaseIndent =
                      isLineStart(closeEvaluate.loc.start) &&
                      closeEvaluate.loc.start.line === rightToken.loc.start.line
                  const endLine = closingStartIsBaseIndent
                      ? closeEvaluate.loc.start.line - 1
                      : closeEvaluate.loc.start.line
                  setOffsetToRangeLines(leftToken.loc.start.line, endLine)
  
                  const startAstNode = sourceCode.getNodeByRangeIndex(
                      leftToken.range[0]
                  )
                  const isSwitchStatement =
                      startAstNode && startAstNode.type === "SwitchStatement"
                  if (isSwitchStatement) {
                      setOffsetToRangeLinesForSwitch(
                          leftToken.loc.start.line,
                          endLine,
                          startAstNode
                      )
                  }
                  closeEvaluateOffsets.set(closeEvaluate, {
                      baseline: leftToken.loc.start.line,
                      startLine: endLine + 1,
                  })
              }
  
              // 最後にscript閉じ括弧位置の調整
              closeEvaluateOffsets.forEach((info, closeEvaluate) => {
                  const baseline = info.baseline
                  // 実際は開始位置しかインデントされない。
                  // 後続で正しいインデント位置を知るためにマークをつけている。
                  for (
                      let line = info.startLine;
                      line <= closeEvaluate.loc.end.line;
                      line++
                  ) {
                      setOffsetToLine(line, 0, baseline)
                  }
              })
          }