diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index cdd408e3..6bb0a761 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -55,10 +55,8 @@ jobs:
       run: npm install -f
     - name: Install ESLint v${{ matrix.eslint }}
       run: node scripts/ci-install-eslint ${{ matrix.eslint }}
-    - name: Build
-      run: npm run -s build
     - name: Test
-      run: npm run -s test:mocha
+      run: npm run -s test
   test-for-old-eslint:
     name: Test
     strategy:
@@ -82,29 +80,4 @@ jobs:
     - name: Install ESLint v${{ matrix.eslint }}
       run: node scripts/ci-install-eslint ${{ matrix.eslint }}
     - name: Test
-      run: npm run -s test:debug
-
-  test-cov:
-    name: Test and Send Coverage
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-    - name: Checkout submodules
-      run: git submodule update --init
-    - name: Install Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: 'lts/*'
-    - name: Install Packages
-      run: npm install
-    - name: Install ESLint v9
-      run: node scripts/ci-install-eslint 9
-    - name: Build
-      run: npm run -s build
-    - name: Test
-      run: npm run -s test:cover
-    - name: Send Coverage
-      run: npm run -s codecov
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      run: npm run -s test
diff --git a/.gitignore b/.gitignore
index 8bf60fc5..387f51ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,3 @@
-/.nyc_output
 /.temp
 /coverage
 node_modules
diff --git a/.nycrc b/.nycrc
deleted file mode 100644
index a31275f2..00000000
--- a/.nycrc
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-    "include": [
-        "src/**/*.ts"
-    ],
-    "exclude": [
-        "src/external/**/*.ts"
-    ],
-    "extension": [
-        ".ts"
-    ],
-    "require": [
-        "ts-node/register"
-    ],
-    "reporter": [
-        "lcov",
-        "text-summary"
-    ],
-    "sourceMap": true
-}
diff --git a/README.md b/README.md
index b4d1a580..57e0668f 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,6 @@
 [![npm version](https://img.shields.io/npm/v/vue-eslint-parser.svg)](https://www.npmjs.com/package/vue-eslint-parser)
 [![Downloads/month](https://img.shields.io/npm/dm/vue-eslint-parser.svg)](http://www.npmtrends.com/vue-eslint-parser)
 [![Build Status](https://github.com/vuejs/vue-eslint-parser/workflows/CI/badge.svg)](https://github.com/vuejs/vue-eslint-parser/actions)
-[![Coverage Status](https://codecov.io/gh/vuejs/vue-eslint-parser/branch/master/graph/badge.svg)](https://codecov.io/gh/vuejs/vue-eslint-parser)
 
 The ESLint custom parser for `.vue` files.
 
@@ -260,6 +259,7 @@ See [implementing-custom-template-tokenizers.md](./docs/implementing-custom-temp
     - `defineDocumentVisitor(documentVisitor, options)` ... returns ESLint visitor to traverses the document.
 - [ast.md](./docs/ast.md) is `<template>` AST specification.
 - [mustache-interpolation-spacing.js](https://github.com/vuejs/eslint-plugin-vue/blob/b434ff99d37f35570fa351681e43ba2cf5746db3/lib/rules/mustache-interpolation-spacing.js) is an example.
+- Check your version of ESLint as the location of `defineTemplateBodyVisitor` was moved from `context` to `context.sourceCode` after major version `9.x`
 
 ### `defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor, options)`
 
@@ -274,7 +274,7 @@ See [implementing-custom-template-tokenizers.md](./docs/implementing-custom-temp
 import { AST } from "vue-eslint-parser"
 
 export function create(context) {
-    return context.parserServices.defineTemplateBodyVisitor(
+    return context.sourceCode.parserServices.defineTemplateBodyVisitor(
         // Event handlers for <template>.
         {
             VElement(node: AST.VElement): void {
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 5e81622f..a46acd53 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -22,7 +22,6 @@ const compat = new FlatCompat({
 export default [
     {
         ignores: [
-            ".nyc_output",
             ".temp",
             "coverage",
             "**/node_modules",
@@ -64,7 +63,7 @@ export default [
                 },
 
                 loggerFn: false,
-                project: "tsconfig.json",
+                project: ["tsconfig.json", "tsconfig.test.json"],
             },
         },
 
diff --git a/package.json b/package.json
index 500d3790..b325e750 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-eslint-parser",
-  "version": "10.1.1",
+  "version": "10.2.0",
   "description": "The ESLint custom parser for `.vue` files.",
   "main": "index.js",
   "files": [
@@ -18,7 +18,6 @@
     "eslint-visitor-keys": "^4.2.0",
     "espree": "^10.3.0",
     "esquery": "^1.6.0",
-    "lodash": "^4.17.21",
     "semver": "^7.6.3"
   },
   "devDependencies": {
@@ -31,14 +30,13 @@
     "@eslint/js": "^9.19.0",
     "@types/debug": "^4.1.7",
     "@types/estree": "^1.0.0",
-    "@types/lodash": "^4.14.186",
-    "@types/mocha": "^9.0.0",
     "@types/node": "^18.8.4",
     "@types/semver": "^7.3.12",
     "@typescript-eslint/eslint-plugin": "^8.22.0",
     "@typescript-eslint/parser": "^8.22.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
     "chokidar": "^3.5.2",
-    "codecov": "^3.8.3",
     "cross-spawn": "^7.0.3",
     "dts-bundle": "^0.7.3",
     "eslint": "^9.19.0",
@@ -50,10 +48,7 @@
     "eslint-plugin-unicorn": "^57.0.0",
     "fs-extra": "^10.0.0",
     "jsonc-eslint-parser": "^2.0.3",
-    "mocha": "^9.1.3",
     "npm-run-all": "^4.1.5",
-    "nyc": "^15.1.0",
-    "opener": "^1.5.2",
     "prettier": "^3.4.2",
     "rimraf": "^3.0.2",
     "rollup": "^2.60.0",
@@ -62,21 +57,19 @@
     "rollup-plugin-sourcemaps": "^0.6.3",
     "ts-node": "^10.9.2",
     "typescript": "~5.7.3",
+    "vite": "^6.3.5",
+    "vitest": "^3.2.4",
     "wait-on": "^6.0.0",
     "warun": "^1.0.0"
   },
   "scripts": {
     "prebuild": "npm run -s clean",
     "build": "tsc --module es2015 && rollup -c -o index.js && dts-bundle --name vue-eslint-parser --main .temp/index.d.ts --out ../index.d.ts",
-    "clean": "rimraf .nyc_output .temp coverage index.*",
-    "codecov": "codecov",
-    "coverage": "opener ./coverage/lcov-report/index.html",
+    "clean": "rimraf .temp index.*",
+    "coverage": "vitest --coverage --ui",
     "lint": "eslint src test package.json",
-    "pretest": "run-s build lint",
-    "test": "npm run -s test:mocha",
-    "test:mocha": "mocha --require ts-node/register \"test/*.js\" --reporter dot --timeout 60000",
-    "test:cover": "nyc mocha \"test/*.js\" --reporter dot --timeout 60000",
-    "test:debug": "mocha --require ts-node/register/transpile-only \"test/*.js\" --reporter dot --timeout 60000",
+    "test": "vitest",
+    "test:cover": "vitest --coverage",
     "update-fixtures": "ts-node --transpile-only scripts/update-fixtures-ast.js && ts-node --transpile-only scripts/update-fixtures-document-fragment.js",
     "preversion": "npm test",
     "version": "npm run -s build",
@@ -85,9 +78,7 @@
     "watch": "run-p watch:*",
     "watch:tsc": "tsc --module es2015 --watch",
     "watch:rollup": "wait-on .temp/index.js && rollup -c -o index.js --watch",
-    "watch:test": "wait-on index.js && warun index.js \"test/*.js\" \"test/fixtures/ast/*/*.json\" \"test/fixtures/*\" --debounce 1000 --no-initial -- nyc mocha \"test/*.js\" --reporter dot --timeout 10000",
-    "watch:update-ast": "wait-on index.js && warun index.js \"test/fixtures/ast/*/*.vue\" -- node scripts/update-fixtures-ast.js",
-    "watch:coverage-report": "wait-on coverage/lcov-report/index.html && opener coverage/lcov-report/index.html"
+    "watch:update-ast": "wait-on index.js && warun index.js \"test/fixtures/ast/*/*.vue\" -- ts-node scripts/update-fixtures-ast.js"
   },
   "repository": {
     "type": "git",
diff --git a/rollup.config.js b/rollup.config.js
index fef6483f..ce75d20c 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -9,7 +9,7 @@ import replace from "rollup-plugin-replace"
 
 const pkg = require("./package.json")
 const deps = new Set(
-    ["assert", "events", "path"].concat(Object.keys(pkg.dependencies))
+    ["assert", "events", "path"].concat(Object.keys(pkg.dependencies)),
 )
 
 export default {
@@ -31,5 +31,5 @@ export default {
             "process.env.PACKAGE_VERSION": `"${pkg.version}"`,
         }),
     ],
-    external: id => deps.has(id) || id.startsWith("lodash"),
+    external: (id) => deps.has(id),
 }
diff --git a/scripts/ci-install-eslint.js b/scripts/ci-install-eslint.js
index c3626692..fe2f96c3 100644
--- a/scripts/ci-install-eslint.js
+++ b/scripts/ci-install-eslint.js
@@ -30,6 +30,8 @@ function sh(command) {
 
     // Install ESLint of the requested version
     await sh(`npm install eslint@${requestedVersionSpec} -f`)
+    if (Number(requestedVersion) < 9)
+        await sh(`npm install @types/eslint -D -f`)
 
     // Install ESLint submodule of the requested version
     // const installedVersion = require("eslint/package.json").version
diff --git a/src/ast/nodes.ts b/src/ast/nodes.ts
index 5ebf7039..c24e3727 100644
--- a/src/ast/nodes.ts
+++ b/src/ast/nodes.ts
@@ -7,8 +7,8 @@ import type { ScopeManager } from "eslint-scope"
 import type { ParseError } from "./errors"
 import type { HasLocation } from "./locations"
 import type { Token } from "./tokens"
-// eslint-disable-next-line node/no-extraneous-import -- ignore
 import type { TSESTree } from "@typescript-eslint/utils"
+import type { ParserServices } from "../parser-services"
 
 //------------------------------------------------------------------------------
 // Common
@@ -71,7 +71,7 @@ export type ESLintNode =
  */
 export interface ESLintExtendedProgram {
     ast: ESLintProgram
-    services?: {}
+    services?: ParserServices
     visitorKeys?: { [type: string]: string[] }
     scopeManager?: ScopeManager
 }
diff --git a/src/common/error-utils.ts b/src/common/error-utils.ts
index 378aacba..42f3f14e 100644
--- a/src/common/error-utils.ts
+++ b/src/common/error-utils.ts
@@ -1,5 +1,5 @@
 import type { ParseError, VDocumentFragment } from "../ast/index"
-import sortedIndexBy from "lodash/sortedIndexBy"
+import { sortedIndexBy } from "../utils/utils"
 /**
  * Insert the given error.
  * @param document The document that the node is belonging to.
diff --git a/src/common/lines-and-columns.ts b/src/common/lines-and-columns.ts
index c62d781a..b1b51085 100644
--- a/src/common/lines-and-columns.ts
+++ b/src/common/lines-and-columns.ts
@@ -1,4 +1,4 @@
-import sortedLastIndex from "lodash/sortedLastIndex"
+import { sortedLastIndex } from "../utils/utils"
 import type { Location } from "../ast/index"
 import type { LocationCalculator } from "./location-calculator"
 /**
diff --git a/src/common/location-calculator.ts b/src/common/location-calculator.ts
index 8c8cf344..75126d07 100644
--- a/src/common/location-calculator.ts
+++ b/src/common/location-calculator.ts
@@ -3,7 +3,7 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
-import sortedLastIndex from "lodash/sortedLastIndex"
+import { sortedLastIndex } from "../utils/utils"
 import type { Location } from "../ast/index"
 import { LinesAndColumns } from "./lines-and-columns"
 
diff --git a/src/common/token-utils.ts b/src/common/token-utils.ts
index 3013061d..21414a85 100644
--- a/src/common/token-utils.ts
+++ b/src/common/token-utils.ts
@@ -1,5 +1,4 @@
-import sortedIndexBy from "lodash/sortedIndexBy"
-import sortedLastIndexBy from "lodash/sortedLastIndexBy"
+import { sortedIndexBy, sortedLastIndexBy } from "../utils/utils"
 import type { LocationRange, Token, VDocumentFragment } from "../ast/index"
 import type { LinesAndColumns } from "./lines-and-columns"
 
diff --git a/src/external/node-event-generator.ts b/src/external/node-event-generator.ts
index b8eb78dc..a601f125 100644
--- a/src/external/node-event-generator.ts
+++ b/src/external/node-event-generator.ts
@@ -4,9 +4,8 @@
 import type EventEmitter from "events"
 import type { ESQueryOptions, Selector } from "esquery"
 import esquery from "esquery"
-import union from "lodash/union"
-import intersection from "lodash/intersection"
-import memoize from "lodash/memoize"
+import { memoize } from "../utils/memoize"
+import { union, intersection } from "../utils/utils"
 import type { Node } from "../ast/index"
 
 interface NodeSelector {
diff --git a/src/external/token-store/utils.ts b/src/external/token-store/utils.ts
index 64cc8690..574c9348 100644
--- a/src/external/token-store/utils.ts
+++ b/src/external/token-store/utils.ts
@@ -2,7 +2,7 @@
  * @fileoverview Define utilify functions for token store.
  * @author Toru Nagashima
  */
-import sortedIndexBy from "lodash/sortedIndexBy"
+import { sortedIndexBy } from "../../utils/utils"
 import type { HasLocation } from "../../ast/index"
 
 /**
diff --git a/src/html/intermediate-tokenizer.ts b/src/html/intermediate-tokenizer.ts
index 62d4ca90..fbe5f546 100644
--- a/src/html/intermediate-tokenizer.ts
+++ b/src/html/intermediate-tokenizer.ts
@@ -4,7 +4,6 @@
  * See LICENSE file in root directory for full license.
  */
 import assert from "assert"
-import last from "lodash/last"
 import type {
     ErrorCode,
     HasLocation,
@@ -175,7 +174,7 @@ export class IntermediateTokenizer {
             // VExpressionEnd was not found.
             // Concatenate the deferred tokens to the committed token.
             const start = this.expressionStartToken
-            const end = last(this.expressionTokens) || start
+            const end = this.expressionTokens.at(-1) || start
             const value = this.expressionTokens.reduce(concat, start.value)
             this.expressionStartToken = null
             this.expressionTokens = []
@@ -240,7 +239,7 @@ export class IntermediateTokenizer {
         if (this.expressionStartToken != null) {
             // Defer this token until a VExpressionEnd token or a non-text token appear.
             const lastToken =
-                last(this.expressionTokens) || this.expressionStartToken
+                this.expressionTokens.at(-1) || this.expressionStartToken
             if (lastToken.range[1] === token.range[0]) {
                 this.expressionTokens.push(token)
                 return null
@@ -552,7 +551,7 @@ export class IntermediateTokenizer {
         }
 
         const start = this.expressionStartToken
-        const end = last(this.expressionTokens) || start
+        const end = this.expressionTokens.at(-1) || start
 
         // If it's '{{}}', it's handled as a text.
         if (token.range[0] === start.range[1]) {
diff --git a/src/html/parser.ts b/src/html/parser.ts
index ed155e9a..908056c6 100644
--- a/src/html/parser.ts
+++ b/src/html/parser.ts
@@ -4,8 +4,6 @@
  * See LICENSE file in root directory for full license.
  */
 import assert from "assert"
-import last from "lodash/last"
-import findLastIndex from "lodash/findLastIndex"
 import type {
     ErrorCode,
     HasLocation,
@@ -52,8 +50,7 @@ import {
     getScriptParser,
     getParserLangFromSFC,
 } from "../common/parser-options"
-import sortedIndexBy from "lodash/sortedIndexBy"
-import sortedLastIndexBy from "lodash/sortedLastIndexBy"
+import { sortedIndexBy, sortedLastIndexBy } from "../utils/utils"
 import type {
     CustomTemplateTokenizer,
     CustomTemplateTokenizerConstructor,
@@ -160,7 +157,7 @@ function adjustAttributeName(name: string, namespace: Namespace): string {
  */
 function propagateEndLocation(node: VDocumentFragment | VElement): void {
     const lastChild =
-        (node.type === "VElement" ? node.endTag : null) || last(node.children)
+        (node.type === "VElement" ? node.endTag : null) || node.children.at(-1)
     if (lastChild != null) {
         node.range[1] = lastChild.range[1]
         node.loc.end = lastChild.loc.end
@@ -236,7 +233,7 @@ export class Parser {
      * Get the current node.
      */
     private get currentNode(): VDocumentFragment | VElement {
-        return last(this.elementStack) || this.document
+        return this.elementStack.at(-1) || this.document
     }
 
     /**
@@ -701,8 +698,7 @@ export class Parser {
     protected EndTag(token: EndTag): void {
         debug("[html] EndTag %j", token)
 
-        const i = findLastIndex(
-            this.elementStack,
+        const i = this.elementStack.findLastIndex(
             (el) => el.name.toLowerCase() === token.name,
         )
         if (i === -1) {
diff --git a/src/html/tokenizer.ts b/src/html/tokenizer.ts
index 6285cdfa..d18081db 100644
--- a/src/html/tokenizer.ts
+++ b/src/html/tokenizer.ts
@@ -1892,9 +1892,9 @@ export class Tokenizer {
             const type = isWhitespace(cp)
                 ? "HTMLWhitespace"
                 : state === "RCDATA"
-                  ? "HTMLRawText"
+                  ? "HTMLRCDataText"
                   : state === "RAWTEXT"
-                    ? "HTMLRCDataText"
+                    ? "HTMLRawText"
                     : "HTMLText"
             if (this.currentToken != null && this.currentToken.type !== type) {
                 this.endToken()
@@ -1942,9 +1942,12 @@ export class Tokenizer {
             this.startToken("VExpressionEnd")
             this.appendTokenValue(RIGHT_CURLY_BRACKET, null)
             this.appendTokenValue(RIGHT_CURLY_BRACKET, null)
-            return this.vExpressionScriptState
-                ? this.vExpressionScriptState.state
-                : this.returnState
+            if (this.vExpressionScriptState) {
+                const state = this.vExpressionScriptState.state
+                this.vExpressionScriptState = null
+                return state
+            }
+            return this.returnState
         }
 
         this.appendTokenValue(RIGHT_CURLY_BRACKET, null)
diff --git a/src/index.ts b/src/index.ts
index 13cb5300..45d43d64 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -84,7 +84,7 @@ export function parseForESLint(
  * @param options The parser options.
  * @returns The parsing result.
  */
-export function parse(code: string, options: any): AST.ESLintProgram {
+export function parse(code: string, options?: any): AST.ESLintProgram {
     return parseForESLint(code, options).ast
 }
 
diff --git a/src/parser-services.ts b/src/parser-services.ts
index 3b830c41..b84faa43 100644
--- a/src/parser-services.ts
+++ b/src/parser-services.ts
@@ -83,7 +83,7 @@ export interface ParserServices {
                 | ((lang: string | null, customBlock: VElement) => boolean)
             create: CustomBlockVisitorFactory
         },
-        scriptVisitor: { [key: string]: (...args: any) => void },
+        scriptVisitor?: { [key: string]: (...args: any) => void },
     ): { [key: string]: (...args: any) => void }
 
     /**
@@ -262,7 +262,7 @@ export function define(
                     | ((lang: string | null, customBlock: VElement) => boolean)
                 create: CustomBlockVisitorFactory
             },
-            scriptVisitor: { [key: string]: (...args: any) => void },
+            scriptVisitor?: { [key: string]: (...args: any) => void },
         ): { [key: string]: (...args: any) => void } {
             if (scriptVisitor == null) {
                 scriptVisitor = {} //eslint-disable-line no-param-reassign
diff --git a/src/script-setup/index.ts b/src/script-setup/index.ts
index 671a2bc5..81bb75bb 100644
--- a/src/script-setup/index.ts
+++ b/src/script-setup/index.ts
@@ -308,6 +308,10 @@ export function parseScriptSetupElements(
         }
         result.ast.tokens.sort((a, b) => a.range[0] - b.range[0])
     }
+
+    if (result.ast.comments != null) {
+        result.ast.comments.sort((a, b) => a.range[0] - b.range[0])
+    }
     result.ast.body.sort((a, b) => a.range[0] - b.range[0])
 
     const programStartOffset = result.ast.body.reduce(
diff --git a/src/script/index.ts b/src/script/index.ts
index 18f67d13..279095bf 100644
--- a/src/script/index.ts
+++ b/src/script/index.ts
@@ -3,9 +3,7 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
-import first from "lodash/first"
-import last from "lodash/last"
-import sortedIndexBy from "lodash/sortedIndexBy"
+import { sortedIndexBy } from "../utils/utils"
 import type {
     ESLintArrayExpression,
     ESLintArrayPattern,
@@ -521,7 +519,7 @@ function parseFilter(
                     }
                 }
 
-                const token = last(ast.tokens)!
+                const token = ast.tokens!.at(-1)!
                 return throwUnexpectedTokenError(token.value, token)
             }
 
@@ -536,7 +534,7 @@ function parseFilter(
 
         // Update range.
         const firstToken = tokens[0]
-        const lastToken = last(tokens)!
+        const lastToken = tokens.at(-1)!
         expression.range = [firstToken.range[0], lastToken.range[1]]
         expression.loc = { start: firstToken.loc.start, end: lastToken.loc.end }
 
@@ -778,7 +776,7 @@ export function parseExpression(
     }
 
     // Update range.
-    const lastToken = last(ret.tokens)!
+    const lastToken = ret.tokens.at(-1)!
     ret.expression.range[1] = lastToken.range[1]
     ret.expression.loc.end = lastToken.loc.end
 
@@ -933,7 +931,7 @@ function parseVForExpressionForEcmaVersion5(
             if (open != null) {
                 open.value = "("
             }
-            const close = last(parsedAliases.tokens)
+            const close = parsedAliases.tokens.at(-1)
             if (close != null) {
                 close.value = ")"
             }
@@ -977,7 +975,7 @@ function parseVForExpressionForEcmaVersion5(
         comments.push(...parsedIterator.comments)
         const { right, references } = parsedIterator
         const firstToken = tokens[0]
-        const lastToken = last(tokens) || firstToken
+        const lastToken = tokens.at(-1) || firstToken
         const expression: VForExpression = {
             type: "VForExpression",
             range: [firstToken.range[0], lastToken.range[1]],
@@ -1136,8 +1134,8 @@ function parseVOnExpressionBody(
         ).argument as ESLintFunctionExpression
         const block = functionDecl.body
         const body = block.body
-        const firstStatement = first(body)
-        const lastStatement = last(body)
+        const firstStatement = body[0]
+        const lastStatement = body.at(-1)
         const expression: VOnExpression = {
             type: "VOnExpression",
             range: [
@@ -1231,8 +1229,8 @@ export function parseSlotScopeExpression(
         )
         const references = scope.references
         const variables = scope.variables
-        const firstParam = first(params)!
-        const lastParam = last(params)!
+        const firstParam = params[0]
+        const lastParam = params.at(-1)!
         const expression: VSlotScopeExpression = {
             type: "VSlotScopeExpression",
             range: [firstParam.range[0], lastParam.range[1]],
@@ -1330,8 +1328,8 @@ export function parseGenericExpression(
         )
         const references = scope.references
         const variables = scope.variables
-        const firstParam = first(params)!
-        const lastParam = last(params)!
+        const firstParam = params[0]
+        const lastParam = params.at(-1)!
         const expression: VGenericExpression = {
             type: "VGenericExpression",
             range: [firstParam.range[0], lastParam.range[1]],
diff --git a/src/utils/memoize.ts b/src/utils/memoize.ts
new file mode 100644
index 00000000..1dda47a9
--- /dev/null
+++ b/src/utils/memoize.ts
@@ -0,0 +1,157 @@
+/**
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
+ *
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
+ *
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @template F - The type of the function to be memoized.
+ * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
+ * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns The memoized function with an additional `cache` property that exposes the internal cache.
+ *
+ * @example
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
+ * const memoizedAdd = memoize(add);
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
+ * console.log(memoizedAdd.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
+ *   }
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
+ *   }
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
+ *   }
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
+ *   }
+ *
+ *   clear(): void {
+ *     this.cache.clear();
+ *   }
+ *
+ *   get size(): number {
+ *     return this.cache.size;
+ *   }
+ * }
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
+ * console.log(memoizedAddWithCustomCache.cache.size); // 1
+ *
+ * MIT © Viva Republica, Inc. | https://es-toolkit.dev/
+ *
+ * The implementation is copied from es-toolkit package:
+ * https://github.com/toss/es-toolkit/blob/16709839f131269b84cdd96e9645df52648ccedf/src/function/memoize.ts
+ */
+export function memoize<F extends (...args: any) => any>(
+    fn: F,
+    options: {
+        cache?: MemoizeCache<any, ReturnType<F>>
+        getCacheKey?: (args: Parameters<F>[0]) => unknown
+    } = {},
+): F & { cache: MemoizeCache<any, ReturnType<F>> } {
+    const { cache = new Map<unknown, ReturnType<F>>(), getCacheKey } = options
+
+    const memoizedFn = function (
+        this: unknown,
+        arg: Parameters<F>[0],
+    ): ReturnType<F> {
+        const key = getCacheKey ? getCacheKey(arg) : arg
+
+        if (cache.has(key)) {
+            return cache.get(key)!
+        }
+
+        const result = fn.call(this, arg)
+
+        cache.set(key, result)
+
+        return result
+    }
+
+    memoizedFn.cache = cache
+
+    return memoizedFn as F & { cache: MemoizeCache<any, ReturnType<F>> }
+}
+
+/**
+ * Represents a cache for memoization, allowing storage and retrieval of computed values.
+ *
+ * @template K - The type of keys used to store values in the cache.
+ * @template V - The type of values stored in the cache.
+ */
+interface MemoizeCache<K, V> {
+    /**
+     * Stores a value in the cache with the specified key.
+     *
+     * @param key - The key to associate with the value.
+     * @param value - The value to store in the cache.
+     */
+    set(key: K, value: V): void
+
+    /**
+     * Retrieves a value from the cache by its key.
+     *
+     * @param key - The key of the value to retrieve.
+     * @returns The value associated with the key, or undefined if the key does not exist.
+     */
+    get(key: K): V | undefined
+
+    /**
+     * Checks if a value exists in the cache for the specified key.
+     *
+     * @param key - The key to check for existence in the cache.
+     * @returns True if the cache contains the key, false otherwise.
+     */
+    has(key: K): boolean
+
+    /**
+     * Deletes a value from the cache by its key.
+     *
+     * @param key - The key of the value to delete.
+     * @returns True if the value was successfully deleted, false otherwise.
+     */
+    delete(key: K): boolean | void
+
+    /**
+     * Clears all values from the cache.
+     */
+    clear(): void
+
+    /**
+     * The number of entries in the cache.
+     */
+    size: number
+}
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
index 1ecc2415..87ade949 100644
--- a/src/utils/utils.ts
+++ b/src/utils/utils.ts
@@ -4,3 +4,277 @@
 export function camelize(str: string) {
     return str.replace(/-(\w)/gu, (_, c) => (c ? c.toUpperCase() : ""))
 }
+
+/**
+ * A binary search implementation that finds the index at which `predicate`
+ * stops returning `true` and starts returning `false` (consistently) when run
+ * on the items of the array. It **assumes** that mapping the array via the
+ * predicate results in the shape `[...true[], ...false[]]`. *For any other case
+ * the result is unpredictable*.
+ *
+ * This is the base implementation of the `sortedIndex` functions which define
+ * the predicate for the user, for common use-cases.
+ *
+ * It is similar to `findIndex`, but runs at O(logN), whereas the latter is
+ * general purpose function which runs on any array and predicate, but runs at
+ * O(N) time.
+ *
+ * MIT License | Copyright (c) 2018 remeda | https://remedajs.com/
+ *
+ * The implementation is copied from remeda package:
+ * https://github.com/remeda/remeda/blob/df5fe74841c07bc356bbaa2c89bc7ba0cafafd0a/packages/remeda/src/internal/binarySearchCutoffIndex.ts#L15
+ */
+function binarySearchCutoffIndex<T>(
+    array: readonly T[],
+    predicate: (value: T, index: number, data: readonly T[]) => boolean,
+): number {
+    let lowIndex = 0
+    let highIndex = array.length
+
+    while (lowIndex < highIndex) {
+        const pivotIndex = (lowIndex + highIndex) >>> 1
+        const pivot = array[pivotIndex]
+
+        if (predicate(pivot, pivotIndex, array)) {
+            lowIndex = pivotIndex + 1
+        } else {
+            highIndex = pivotIndex
+        }
+    }
+
+    return highIndex
+}
+
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *last*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param item - The item to insert.
+ * @returns Insertion index (In the range 0..data.length).
+ * @signature
+ *    R.sortedLastIndex(item)(data)
+ * @example
+ *    R.pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5
+ *
+ * MIT License | Copyright (c) 2018 remeda | https://remedajs.com/
+ *
+ * The implementation is copied from remeda package:
+ * https://github.com/remeda/remeda/blob/df5fe74841c07bc356bbaa2c89bc7ba0cafafd0a/packages/remeda/src/sortedLastIndex.ts#L51
+ */
+export function sortedLastIndex<T>(array: readonly T[], item: T): number {
+    return binarySearchCutoffIndex(array, (pivot) => pivot <= item)
+}
+
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that
+ * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
+ * ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * See also:
+ * * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * * `sortedIndex` - like this function, but doesn't take a callbackfn.
+ * * `sortedLastIndexBy` - like this function, but finds the last suitable index.
+ * * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
+ * * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array. The function is called exactly once on
+ * each items that is compared against in the array, and once at the beginning
+ * on `item`. When called on `item` the `index` argument is `undefined`.
+ * @returns Insertion index (In the range 0..data.length).
+ * @signature
+ *    R.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    R.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ *
+ * MIT License | Copyright (c) 2018 remeda | https://remedajs.com/
+ *
+ * The implementation is copied from remeda package:
+ * https://github.com/remeda/remeda/blob/df5fe74841c07bc356bbaa2c89bc7ba0cafafd0a/packages/remeda/src/sortedIndexBy.ts#L37
+ */
+export function sortedIndexBy<T>(
+    array: readonly T[],
+    item: T,
+    valueFunction: (
+        item: T,
+        index: number | undefined,
+        data: readonly T[],
+    ) => number,
+): number {
+    const value = valueFunction(item, undefined, array)
+
+    return binarySearchCutoffIndex(
+        array,
+        (pivot, index) => valueFunction(pivot, index, array) < value,
+    )
+}
+
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that
+ * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
+ * ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *last*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * See also:
+ * * `findIndex` - scans a possibly unsorted array in-order (linear search).
+ * * `sortedLastIndex` - a simplified version of this function, without a callbackfn.
+ * * `sortedIndexBy` - like this function, but returns the first suitable index.
+ * * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.
+ * * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array. The function is called exactly once on
+ * each items that is compared against in the array, and once at the beginning
+ * on `item`. When called on `item` the `index` argument is `undefined`.
+ * @returns Insertion index (In the range 0..data.length).
+ * @signature
+ *    R.sortedLastIndexBy(data, item, valueFunction)
+ * @example
+ *    R.sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ *
+ * MIT License | Copyright (c) 2018 remeda | https://remedajs.com/
+ *
+ * The implementation is copied from remeda package:
+ * https://github.com/remeda/remeda/blob/df5fe74841c07bc356bbaa2c89bc7ba0cafafd0a/packages/remeda/src/sortedLastIndexBy.ts#L37
+ */
+export function sortedLastIndexBy<T>(
+    array: readonly T[],
+    item: T,
+    valueFunction: (
+        item: T,
+        index: number | undefined,
+        data: readonly T[],
+    ) => number,
+): number {
+    const value = valueFunction(item, undefined, array)
+
+    return binarySearchCutoffIndex(
+        array,
+        (pivot, index) => valueFunction(pivot, index, array) <= value,
+    )
+}
+
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * This function takes an array and returns a new array containing only the unique values
+ * from the original array, preserving the order of first occurrence.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
+ *
+ * @example
+ * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
+ *
+ * MIT © Viva Republica, Inc. | https://es-toolkit.dev/
+ *
+ * The implementation is copied from es-toolkit package:
+ * https://github.com/toss/es-toolkit/blob/16709839f131269b84cdd96e9645df52648ccedf/src/array/uniq.ts#L16
+ */
+export function uniq<T>(arr: readonly T[]): T[] {
+    return Array.from(new Set(arr))
+}
+
+/**
+ * Returns the intersection of multiple arrays.
+ *
+ * This function takes multiple arrays and returns a new array containing the elements that are
+ * present in all provided arrays. It effectively filters out any elements that are not found
+ * in every array.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {...(ArrayLike<T> | null | undefined)} arrays - The arrays to compare.
+ * @returns {T[]} A new array containing the elements that are present in all arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ *
+ * MIT © Viva Republica, Inc. | https://es-toolkit.dev/
+ *
+ * The implementation is copied from es-toolkit package:
+ * https://github.com/toss/es-toolkit/blob/16709839f131269b84cdd96e9645df52648ccedf/src/compat/array/intersection.ts#L22
+ * https://github.com/toss/es-toolkit/blob/16709839f131269b84cdd96e9645df52648ccedf/src/array/intersection.ts#L19
+ */
+export function intersection<T>(...arrays: (T[] | null | undefined)[]): T[] {
+    if (arrays.length === 0) {
+        return []
+    }
+
+    let result: T[] = uniq(arrays[0]!)
+
+    for (let i = 1; i < arrays.length; i++) {
+        const array = arrays[i]
+        const secondSet = new Set(array)
+
+        result = result.filter((item) => secondSet.has(item))
+    }
+
+    return result
+}
+
+/**
+ * This function takes multiple arrays and returns a new array containing only the unique values
+ * from all input arrays, preserving the order of their first occurrence.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param {Array<ArrayLike<T> | null | undefined>} arrays - The arrays to inspect.
+ * @returns {T[]} Returns the new array of combined unique values.
+ *
+ * @example
+ * // Returns [2, 1]
+ * union([2], [1, 2]);
+ *
+ * @example
+ * // Returns [2, 1, 3]
+ * union([2], [1, 2], [2, 3]);
+ *
+ * @example
+ * // Returns [1, 3, 2, [5], [4]] (does not deeply flatten nested arrays)
+ * union([1, 3, 2], [1, [5]], [2, [4]]);
+ *
+ * @example
+ * // Returns [0, 2, 1] (ignores non-array values like 3 and { '0': 1 })
+ * union([0], 3, { '0': 1 }, null, [2, 1]);
+ * @example
+ * // Returns [0, 'a', 2, 1] (treats array-like object { 0: 'a', length: 1 } as a valid array)
+ * union([0], { 0: 'a', length: 1 }, [2, 1]);
+ *
+ * MIT © Viva Republica, Inc. | https://es-toolkit.dev/
+ *
+ * The implementation is copied from es-toolkit package:
+ * https://github.com/toss/es-toolkit/blob/16709839f131269b84cdd96e9645df52648ccedf/src/compat/array/union.ts#L61
+ * https://github.com/toss/es-toolkit/blob/16709839f131269b84cdd96e9645df52648ccedf/src/compat/array/flattenDepth.ts#L21
+ */
+export function union<T>(...arrays: T[][]): T[] {
+    const flattened = arrays.flat()
+
+    return uniq(flattened)
+}
diff --git a/test/ast.js b/test/ast.test.ts
similarity index 74%
rename from test/ast.js
rename to test/ast.test.ts
index c033c807..b402aa91 100644
--- a/test/ast.js
+++ b/test/ast.test.ts
@@ -3,28 +3,29 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const fs = require("fs")
-const path = require("path")
-const lodash = require("lodash")
-const parser = require("../src")
-const eslint = require("eslint")
-const semver = require("semver")
-const { scopeToJSON, analyze, replacer, getAllTokens } = require("./test-utils")
+import type { Rule } from "eslint"
+import type { Node } from "../src/ast"
+import type { ParserOptions } from "../src/common/parser-options"
+import fs from "node:fs"
+import path from "node:path"
+import { describe, it, assert } from "vitest"
+import { Linter } from "eslint"
+import semver from "semver"
+import * as parser from "../src"
+import { scopeToJSON, analyze, replacer, getAllTokens } from "./test-utils"
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
-const Linter = eslint.Linter
+// eslint-disable-next-line no-undef
 const ROOT = path.join(__dirname, "fixtures/ast")
 const TARGETS = fs.readdirSync(ROOT)
-const PARSER_OPTIONS = {
+const PARSER_OPTIONS: ParserOptions = {
     comment: true,
     ecmaVersion: "latest",
     sourceType: "module",
@@ -34,22 +35,28 @@ const PARSER_OPTIONS = {
     eslintScopeManager: true,
 }
 
+type TreeNode = {
+    type?: string
+    text?: string
+    children: TreeNode[]
+}
+
 /**
  * Create simple tree.
- * @param {string} source The source code.
- * @param {object} parserOptions The parser options.
- * @returns {object} Simple tree.
+ * @param source The source code.
+ * @param parserOptions The parser options.
+ * @returns Simple tree.
  */
-function getTree(source, parserOptions) {
+function getTree(source: string, parserOptions: any) {
     const linter = new Linter({ configType: "flat" })
-    const stack = []
-    const root = { children: [] }
-    let current = root
+    const stack: TreeNode[] = []
+    const root: TreeNode = { children: [] }
+    let current: TreeNode = root
 
-    const maketree = {
+    const maketree: Rule.RuleModule = {
         create: (ruleContext) =>
             ruleContext.sourceCode.parserServices.defineTemplateBodyVisitor({
-                "*"(node) {
+                "*"(node: Node) {
                     stack.push(current)
                     current.children.push(
                         (current = {
@@ -60,32 +67,27 @@ function getTree(source, parserOptions) {
                     )
                 },
                 "*:exit"() {
-                    current = stack.pop()
+                    current = stack.pop()!
                 },
             }),
     }
-    const result = linter.verify(
-        source,
-        {
-            files: ["**"],
-            plugins: {
-                test: {
-                    rules: {
-                        maketree,
-                    },
+    const result = linter.verify(source, {
+        files: ["**"],
+        plugins: {
+            test: {
+                rules: {
+                    maketree,
                 },
             },
-            languageOptions: {
-                parser: parser,
-                ecmaVersion: parserOptions.ecmaVersion ?? "latest",
-                sourceType: parserOptions.sourceType ?? "module",
-                parserOptions: parserOptions,
-            },
-            rules: { "test/maketree": "error" },
         },
-        undefined,
-        true,
-    )
+        languageOptions: {
+            parser,
+            ecmaVersion: parserOptions.ecmaVersion ?? "latest",
+            sourceType: parserOptions.sourceType ?? "module",
+            parserOptions,
+        },
+        rules: { "test/maketree": "error" },
+    })
     assert.deepStrictEqual(result, [])
 
     return root.children
@@ -93,30 +95,29 @@ function getTree(source, parserOptions) {
 
 /**
  * Convert a given node to string.
- * @param {Node} node The node to make string expression.
- * @param {string} source The source code.
- * @returns {string} The string expression of the node.
+ * @param node The node to make string expression.
+ * @param source The source code.
+ * @returns The string expression of the node.
  */
-function nodeToString(node, source) {
+function nodeToString(node: Node, source: string): string {
     return node ? `${node.type}[${source.slice(...node.range)}]` : "undefined"
 }
 
 /**
  * Validate the parent property of every node.
- * @param {string} source The source code.
- * @param {object} parserOptions The parser options.
- * @returns {void}
+ * @param source The source code.
+ * @param parserOptions The parser options.
  */
-function validateParent(source, parserOptions) {
+function validateParent(source: string, parserOptions: any) {
     const linter = new Linter({ configType: "flat" })
-    const stack = []
+    const stack: Node[] = []
 
-    const validateparent = {
+    const validateparent: Rule.RuleModule = {
         create: (ruleContext) =>
             ruleContext.sourceCode.parserServices.defineTemplateBodyVisitor({
-                "*"(node) {
+                "*"(node: Node) {
                     if (stack.length >= 1) {
-                        const parent = lodash.last(stack)
+                        const parent = stack.at(-1)!
                         assert(
                             node.parent === parent,
                             `The parent of ${nodeToString(
@@ -125,7 +126,7 @@ function validateParent(source, parserOptions) {
                             )} should be ${nodeToString(
                                 parent,
                                 source,
-                            )}, but got ${nodeToString(node.parent, source)}`,
+                            )}, but got ${nodeToString(node.parent!, source)}`,
                         )
                     }
                     stack.push(node)
@@ -135,28 +136,23 @@ function validateParent(source, parserOptions) {
                 },
             }),
     }
-    const result = linter.verify(
-        source,
-        {
-            files: ["**"],
-            plugins: {
-                test: {
-                    rules: {
-                        validateparent,
-                    },
+    const result = linter.verify(source, {
+        files: ["**"],
+        plugins: {
+            test: {
+                rules: {
+                    validateparent,
                 },
             },
-            languageOptions: {
-                parser,
-                ecmaVersion: parserOptions.ecmaVersion ?? "latest",
-                sourceType: parserOptions.sourceType ?? "module",
-                parserOptions: parserOptions,
-            },
-            rules: { "test/validateparent": "error" },
         },
-        undefined,
-        true,
-    )
+        languageOptions: {
+            parser,
+            ecmaVersion: parserOptions.ecmaVersion ?? "latest",
+            sourceType: parserOptions.sourceType ?? "module",
+            parserOptions,
+        },
+        rules: { "test/validateparent": "error" },
+    })
     assert.deepStrictEqual(result, [])
 }
 
@@ -174,8 +170,13 @@ describe("Template AST", () => {
         const requirementsPath = path.join(ROOT, `${name}/requirements.json`)
         const servicesPath = path.join(ROOT, `${name}/services.json`)
         const source = fs.readFileSync(sourcePath, "utf8")
-        const parserOptions = optionsPath ? require(optionsPath) : {}
-        const requirements = fs.existsSync(requirementsPath)
+
+        const parserOptions: ParserOptions = optionsPath
+            ? require(optionsPath) // eslint-disable-line @typescript-eslint/no-require-imports
+            : {}
+        const requirements: Record<string, string> = fs.existsSync(
+            requirementsPath,
+        )
             ? JSON.parse(fs.readFileSync(requirementsPath, "utf8"))
             : {}
         const services = fs.existsSync(servicesPath)
@@ -186,12 +187,13 @@ describe("Template AST", () => {
                 Object.entries(parserOptions.templateTokenizer).map(
                     ([key, value]) => [
                         key,
-                        path.resolve(__dirname, "../", value),
+                        // eslint-disable-next-line no-undef
+                        path.resolve(__dirname, "../", value as string),
                     ],
                 ),
             )
         }
-        const options = {
+        const options: ParserOptions = {
             filePath: sourcePath,
             ...PARSER_OPTIONS,
             ...parserOptions,
@@ -202,7 +204,7 @@ describe("Template AST", () => {
                 const version =
                     pkgName === "node"
                         ? process.version
-                        : require(`${pkgName}/package.json`).version
+                        : require(`${pkgName}/package.json`).version // eslint-disable-line @typescript-eslint/no-require-imports
                 return !semver.satisfies(version, pkgVersion)
             })
         ) {
@@ -253,7 +255,8 @@ describe("Template AST", () => {
             })
 
             it("should have correct location.", () => {
-                const lines = source.match(/[^\r\n]*(?:\r?\n|$)/gu) ?? []
+                const lines: string[] =
+                    source.match(/[^\r\n]*(?:\r?\n|$)/gu) ?? []
                 lines.push(String.fromCodePoint(0))
                 for (const token of getAllTokens(actual.ast)) {
                     const line0 = token.loc.start.line - 1
@@ -319,7 +322,7 @@ describe("Template AST", () => {
             if (services) {
                 it("should have correct services.", () => {
                     assert.deepStrictEqual(
-                        Object.keys(actual.services).sort(),
+                        Object.keys(actual.services!).sort(),
                         services,
                     )
                 })
diff --git a/test/crlf.js b/test/crlf.test.ts
similarity index 73%
rename from test/crlf.js
rename to test/crlf.test.ts
index d35ce260..c2ecb46d 100644
--- a/test/crlf.js
+++ b/test/crlf.test.ts
@@ -1,9 +1,10 @@
-const assert = require("assert")
-const parser = require("../src")
+import type { VElement, VText } from "../src/ast"
+import { describe, it, assert } from "vitest"
+import { parseForESLint } from "../src"
 
 describe("About CRLF tests", () => {
     it("should not contain CR in `<script>` contents.", () => {
-        const parsed = parser.parseForESLint(
+        const parsed = parseForESLint(
             `<script>\r
                 export default {\r
                     computed: {\r
@@ -23,15 +24,15 @@ describe("About CRLF tests", () => {
                 sourceType: "module",
             },
         )
-        const script = parsed.services
-            .getDocumentFragment()
+        const script = parsed
+            .services!.getDocumentFragment()!
             .children.find(
                 (child) => child.type === "VElement" && child.name === "script",
-            )
-        assert.ok(!script.children[0].value.includes("\r"))
+            ) as VElement
+        assert.ok(!(script.children[0] as VText).value.includes("\r"))
     })
-    it("should contain CRLF in script comment.", async () => {
-        const parsed = parser.parseForESLint(
+    it("should contain CRLF in script comment.", () => {
+        const parsed = parseForESLint(
             `<script>\r
                 export default {\r
                     computed: {\r
@@ -51,6 +52,6 @@ describe("About CRLF tests", () => {
                 sourceType: "module",
             },
         )
-        assert.ok(parsed.ast.comments[0].value.includes("\r\n"))
+        assert.ok(parsed.ast.comments![0].value.includes("\r\n"))
     })
 })
diff --git a/test/define-custom-blocks-visitor.js b/test/define-custom-blocks-visitor.test.ts
similarity index 88%
rename from test/define-custom-blocks-visitor.js
rename to test/define-custom-blocks-visitor.test.ts
index 79bd5332..f57ddf15 100644
--- a/test/define-custom-blocks-visitor.js
+++ b/test/define-custom-blocks-visitor.test.ts
@@ -1,26 +1,27 @@
 /**
  * @author Yosuke Ota <https://github.com/ota-meshi>
  */
-"use strict"
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const path = require("path")
-const eslint = require("eslint")
-const jsonParser = require("jsonc-eslint-parser")
-const espree = require("espree")
+import type { ESLint, Rule } from "eslint"
+import type { Location, VElement } from "../src/ast"
+import type { CustomBlockContext } from "../src/sfc/custom-block"
+import { assert, describe, it } from "vitest"
+import { Linter } from "eslint"
+import { builtinRules } from "eslint/use-at-your-own-risk"
+import jsonParser from "jsonc-eslint-parser"
+import * as espree from "espree"
+import * as parser from "../src"
+import type { Program } from "estree"
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
-const Linter = eslint.Linter
 
-const parser = require("../src/index.ts")
-
-const noNumberLiteralRule = {
+const noNumberLiteralRule: Rule.RuleModule = {
     create(context) {
         let count = 0
         return {
@@ -35,7 +36,7 @@ const noNumberLiteralRule = {
         }
     },
 }
-const noNoForbiddenKeyRule = {
+const noNoForbiddenKeyRule: Rule.RuleModule = {
     create(context) {
         return {
             'JSONProperty > JSONLiteral[value="forbidden"]'(node) {
@@ -49,11 +50,11 @@ const noNoForbiddenKeyRule = {
         }
     },
 }
-const noParsingErrorRule = {
+const noParsingErrorRule: Rule.RuleModule = {
     create(context) {
         const parseError = context.getSourceCode().parserServices.parseError
         if (parseError) {
-            let loc = undefined
+            let loc: Location | undefined = undefined
             if ("column" in parseError && "lineNumber" in parseError) {
                 loc = {
                     line: parseError.lineNumber,
@@ -73,11 +74,11 @@ const noParsingErrorRule = {
         return {}
     },
 }
-const noParsingErrorRule2 = {
-    create(context) {
+const noParsingErrorRule2: Rule.RuleModule = {
+    create(context: any) {
         const parseError = context.parserServices.parseError
         if (parseError) {
-            let loc = undefined
+            let loc: Location | undefined = undefined
             if ("column" in parseError && "lineNumber" in parseError) {
                 loc = {
                     line: parseError.lineNumber,
@@ -97,7 +98,7 @@ const noParsingErrorRule2 = {
         return {}
     },
 }
-const noProgramExitRule = {
+const noProgramExitRule: Rule.RuleModule = {
     create(context) {
         return {
             "Program:exit"(node) {
@@ -109,7 +110,7 @@ const noProgramExitRule = {
         }
     },
 }
-const siblingSelectorRule = {
+const siblingSelectorRule: Rule.RuleModule = {
     create(context) {
         return {
             "* ~ *"(node) {
@@ -122,19 +123,15 @@ const siblingSelectorRule = {
     },
 }
 
-function getConfig(target = "json") {
-    const spaceUnaryOps =
-        require("eslint/use-at-your-own-risk").builtinRules.get(
-            "space-unary-ops",
-        )
-    const noParamReassign =
-        require("eslint/use-at-your-own-risk").builtinRules.get(
-            "no-param-reassign",
-        )
-    const noUnusedVars =
-        require("eslint/use-at-your-own-risk").builtinRules.get(
-            "no-unused-vars",
-        )
+function getConfig(
+    target:
+        | string
+        | string[]
+        | ((lang: string | null, customBlock: VElement) => boolean) = "json",
+): Linter.Config {
+    const spaceUnaryOps = builtinRules.get("space-unary-ops")!
+    const noParamReassign = builtinRules.get("no-param-reassign")!
+    const noUnusedVars = builtinRules.get("no-unused-vars")!
 
     return {
         files: ["**"],
@@ -142,7 +139,7 @@ function getConfig(target = "json") {
             test: {
                 rules: {
                     "test-no-number-literal": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
@@ -153,7 +150,7 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-no-forbidden-key": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
@@ -164,7 +161,7 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-no-parsing-error": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
@@ -175,7 +172,7 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-no-parsing-error2": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
@@ -186,7 +183,7 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-no-program-exit": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
@@ -198,7 +195,7 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-no-yml-parsing-error": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 {
@@ -214,7 +211,7 @@ function getConfig(target = "json") {
                     },
 
                     "test-for-sibling-selector": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
@@ -225,15 +222,15 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-for-parse-custom-block-element": {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
                                 {
                                     target: "json",
-                                    create(ctx) {
+                                    create(ctx: CustomBlockContext) {
                                         return {
-                                            Program(node) {
+                                            Program(node: Program) {
                                                 const error =
                                                     ctx.sourceCode.parserServices.parseCustomBlockElement(
                                                         jsonParser,
@@ -255,13 +252,15 @@ function getConfig(target = "json") {
                             ),
                     },
                     "test-mark-vars": {
-                        create(context) {
+                        create(context: any) {
                             return context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 espree,
                                 {
                                     target: "js",
-                                    create(customBlockContext) {
+                                    create(
+                                        customBlockContext: CustomBlockContext,
+                                    ) {
                                         return {
                                             Literal() {
                                                 customBlockContext.markVariableAsUsed(
@@ -280,13 +279,15 @@ function getConfig(target = "json") {
 
                     "test-space-unary-ops": {
                         ...spaceUnaryOps,
-                        create(context) {
+                        create(context: any) {
                             return context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 espree,
                                 {
                                     target: "js",
-                                    create(customBlockContext) {
+                                    create(
+                                        customBlockContext: Rule.RuleContext,
+                                    ) {
                                         return spaceUnaryOps.create(
                                             customBlockContext,
                                         )
@@ -297,13 +298,15 @@ function getConfig(target = "json") {
                     },
                     "test-no-param-reassign": {
                         ...noParamReassign,
-                        create(context) {
+                        create(context: any) {
                             return context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 espree,
                                 {
                                     target: "js",
-                                    create(customBlockContext) {
+                                    create(
+                                        customBlockContext: Rule.RuleContext,
+                                    ) {
                                         return noParamReassign.create(
                                             customBlockContext,
                                         )
@@ -314,13 +317,15 @@ function getConfig(target = "json") {
                     },
                     "test-no-unused-vars": {
                         ...noUnusedVars,
-                        create(context) {
+                        create(context: any) {
                             return context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 espree,
                                 {
                                     target: "js",
-                                    create(customBlockContext) {
+                                    create(
+                                        customBlockContext: Rule.RuleContext,
+                                    ) {
                                         return noUnusedVars.create(
                                             customBlockContext,
                                         )
@@ -341,7 +346,7 @@ function getConfig(target = "json") {
             "test/test-no-parsing-error": "error",
             "test/test-no-parsing-error2": "error",
         },
-    }
+    } satisfies Linter.Config
 }
 
 function createLinter() {
@@ -455,7 +460,8 @@ describe("parserServices.defineCustomBlocksVisitor tests", () => {
         const linter = createLinter()
         const config = getConfig(
             (lang, block) =>
-                (lang === "json" && lang === "json5") ||
+                lang === "json" ||
+                lang === "json5" ||
                 (!lang && block.name === "i18n"),
         )
 
@@ -637,19 +643,21 @@ describe("parserServices.defineCustomBlocksVisitor tests", () => {
             const linter = createLinter()
             const baseConfig = getConfig()
 
-            const plugin = {
+            const plugin: ESLint.Plugin = {
                 rules: {
                     test: {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
                                 {
                                     target: "json",
-                                    create(customBlockContext) {
+                                    create(
+                                        customBlockContext: CustomBlockContext,
+                                    ) {
                                         return {
                                             "JSONLiteral[value='target']"(
-                                                node,
+                                                node: any,
                                             ) {
                                                 customBlockContext.report({
                                                     node,
@@ -696,19 +704,21 @@ describe("parserServices.defineCustomBlocksVisitor tests", () => {
             const linter = createLinter()
             const baseConfig = getConfig()
 
-            const plugin = {
+            const plugin: ESLint.Plugin = {
                 rules: {
                     test: {
-                        create: (context) =>
+                        create: (context: any) =>
                             context.sourceCode.parserServices.defineCustomBlocksVisitor(
                                 context,
                                 jsonParser,
                                 {
                                     target: "json",
-                                    create(customBlockContext) {
+                                    create(
+                                        customBlockContext: CustomBlockContext,
+                                    ) {
                                         return {
                                             "JSONLiteral[value='target']"(
-                                                node,
+                                                node: any,
                                             ) {
                                                 customBlockContext.report({
                                                     node,
diff --git a/test/define-document-visitor.js b/test/define-document-visitor.test.ts
similarity index 82%
rename from test/define-document-visitor.js
rename to test/define-document-visitor.test.ts
index 049c51a2..c55a3d9a 100644
--- a/test/define-document-visitor.js
+++ b/test/define-document-visitor.test.ts
@@ -1,22 +1,16 @@
 /**
  * @author Yosuke Ota <https://github.com/ota-meshi>
  */
-"use strict"
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const path = require("path")
-const eslint = require("eslint")
-const parser = require("../src/index.ts")
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const Linter = eslint.Linter
+import type { ESLint } from "eslint"
+import { Linter } from "eslint"
+import { assert, describe, it } from "vitest"
+import * as parser from "../src/index"
+import type { CallExpression, Identifier } from "estree"
 
 //------------------------------------------------------------------------------
 // Tests
@@ -44,12 +38,12 @@ describe("parserServices.defineDocumentVisitor tests", () => {
 
         const linter = new Linter({ configType: "flat" })
 
-        const rules = {
+        const rules: ESLint.Plugin["rules"] = {
             "test-no-forbidden": {
-                create(context) {
+                create(context: any) {
                     return context.sourceCode.parserServices.defineDocumentVisitor(
                         {
-                            'Identifier[name="forbidden"]'(node) {
+                            'Identifier[name="forbidden"]'(node: Identifier) {
                                 context.report({
                                     node,
                                     message: 'no "forbidden"',
@@ -60,10 +54,10 @@ describe("parserServices.defineDocumentVisitor tests", () => {
                 },
             },
             "test-no-call": {
-                create(context) {
+                create(context: any) {
                     return context.sourceCode.parserServices.defineDocumentVisitor(
                         {
-                            CallExpression(node) {
+                            CallExpression(node: CallExpression) {
                                 context.report({
                                     node,
                                     message: "no call",
diff --git a/test/document-fragment.js b/test/document-fragment.test.ts
similarity index 76%
rename from test/document-fragment.js
rename to test/document-fragment.test.ts
index 9204ce7d..d3f8a740 100644
--- a/test/document-fragment.js
+++ b/test/document-fragment.test.ts
@@ -1,18 +1,19 @@
-"use strict"
-
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const fs = require("fs")
-const path = require("path")
-const parser = require("../src")
+import type { VDocumentFragment } from "../src/ast"
+import fs from "node:fs"
+import path from "node:path"
+import { describe, it, assert } from "vitest"
+import * as parser from "../src"
+import { replacer } from "./test-utils"
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
+// eslint-disable-next-line no-undef
 const ROOT = path.join(__dirname, "fixtures/document-fragment")
 const TARGETS = fs.readdirSync(ROOT)
 const PARSER_OPTIONS = {
@@ -24,27 +25,6 @@ const PARSER_OPTIONS = {
     sourceType: "module",
 }
 
-/**
- * Remove `parent` proeprties from the given AST.
- * @param {string} key The key.
- * @param {any} value The value of the key.
- * @returns {any} The value of the key to output.
- */
-function replacer(key, value) {
-    if (key === "parent") {
-        return undefined
-    }
-    if (key === "errors" && Array.isArray(value)) {
-        return value.map((e) => ({
-            message: e.message,
-            index: e.index,
-            lineNumber: e.lineNumber,
-            column: e.column,
-        }))
-    }
-    return value
-}
-
 //------------------------------------------------------------------------------
 // Main
 //------------------------------------------------------------------------------
@@ -60,6 +40,7 @@ describe("services.getDocumentFragment", () => {
             path.join(ROOT, `${name}/parser-options.js`),
         ].find((fp) => fs.existsSync(fp))
         const source = fs.readFileSync(sourcePath, "utf8")
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const parserOptions = optionsPath ? require(optionsPath) : {}
         const options = {
             filePath: sourcePath,
@@ -67,7 +48,7 @@ describe("services.getDocumentFragment", () => {
             ...parserOptions,
         }
         const result = parser.parseForESLint(source, options)
-        const actual = result.services.getDocumentFragment()
+        const actual = result.services!.getDocumentFragment()
 
         describe(`'test/fixtures/document-fragment/${name}/${sourceFileName}'`, () => {
             it("should be parsed to valid document fragment.", () => {
@@ -86,7 +67,7 @@ describe("services.getDocumentFragment", () => {
             it("should have correct range.", () => {
                 const resultPath = path.join(ROOT, `${name}/token-ranges.json`)
                 const expectedText = fs.readFileSync(resultPath, "utf8")
-                const tokens = getAllTokens(actual).map((t) =>
+                const tokens = getAllTokens(actual!).map((t) =>
                     source.slice(t.range[0], t.range[1]),
                 )
                 const actualText = JSON.stringify(tokens, null, 4)
@@ -97,7 +78,7 @@ describe("services.getDocumentFragment", () => {
     }
 })
 
-function getAllTokens(fgAst) {
+function getAllTokens(fgAst: VDocumentFragment) {
     const tokenArrays = [fgAst.tokens, fgAst.comments]
 
     return Array.prototype.concat.apply([], tokenArrays)
diff --git a/test/fixtures/ast/mustache-errors-in-textarea/ast.json b/test/fixtures/ast/mustache-errors-in-textarea/ast.json
new file mode 100644
index 00000000..9dd73fed
--- /dev/null
+++ b/test/fixtures/ast/mustache-errors-in-textarea/ast.json
@@ -0,0 +1,495 @@
+{
+    "type": "Program",
+    "start": 0,
+    "end": 0,
+    "loc": {
+        "start": {
+            "line": 1,
+            "column": 0
+        },
+        "end": {
+            "line": 1,
+            "column": 0
+        }
+    },
+    "range": [
+        0,
+        0
+    ],
+    "body": [],
+    "sourceType": "module",
+    "comments": [],
+    "tokens": [],
+    "templateBody": {
+        "type": "VElement",
+        "range": [
+            0,
+            59
+        ],
+        "loc": {
+            "start": {
+                "line": 1,
+                "column": 0
+            },
+            "end": {
+                "line": 3,
+                "column": 11
+            }
+        },
+        "name": "template",
+        "rawName": "template",
+        "namespace": "http://www.w3.org/1999/xhtml",
+        "startTag": {
+            "type": "VStartTag",
+            "range": [
+                0,
+                10
+            ],
+            "loc": {
+                "start": {
+                    "line": 1,
+                    "column": 0
+                },
+                "end": {
+                    "line": 1,
+                    "column": 10
+                }
+            },
+            "selfClosing": false,
+            "attributes": []
+        },
+        "children": [
+            {
+                "type": "VText",
+                "range": [
+                    10,
+                    15
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 10
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 4
+                    }
+                },
+                "value": "\n    "
+            },
+            {
+                "type": "VElement",
+                "range": [
+                    15,
+                    47
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 4
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 36
+                    }
+                },
+                "name": "textarea",
+                "rawName": "textarea",
+                "namespace": "http://www.w3.org/1999/xhtml",
+                "startTag": {
+                    "type": "VStartTag",
+                    "range": [
+                        15,
+                        25
+                    ],
+                    "loc": {
+                        "start": {
+                            "line": 2,
+                            "column": 4
+                        },
+                        "end": {
+                            "line": 2,
+                            "column": 14
+                        }
+                    },
+                    "selfClosing": false,
+                    "attributes": []
+                },
+                "children": [
+                    {
+                        "type": "VExpressionContainer",
+                        "range": [
+                            25,
+                            36
+                        ],
+                        "loc": {
+                            "start": {
+                                "line": 2,
+                                "column": 14
+                            },
+                            "end": {
+                                "line": 2,
+                                "column": 25
+                            }
+                        },
+                        "expression": null,
+                        "references": []
+                    }
+                ],
+                "endTag": {
+                    "type": "VEndTag",
+                    "range": [
+                        36,
+                        47
+                    ],
+                    "loc": {
+                        "start": {
+                            "line": 2,
+                            "column": 25
+                        },
+                        "end": {
+                            "line": 2,
+                            "column": 36
+                        }
+                    }
+                },
+                "variables": []
+            },
+            {
+                "type": "VText",
+                "range": [
+                    47,
+                    48
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 36
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 0
+                    }
+                },
+                "value": "\n"
+            }
+        ],
+        "endTag": {
+            "type": "VEndTag",
+            "range": [
+                48,
+                59
+            ],
+            "loc": {
+                "start": {
+                    "line": 3,
+                    "column": 0
+                },
+                "end": {
+                    "line": 3,
+                    "column": 11
+                }
+            }
+        },
+        "variables": [],
+        "tokens": [
+            {
+                "type": "HTMLTagOpen",
+                "range": [
+                    0,
+                    9
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 0
+                    },
+                    "end": {
+                        "line": 1,
+                        "column": 9
+                    }
+                },
+                "value": "template"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    9,
+                    10
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 9
+                    },
+                    "end": {
+                        "line": 1,
+                        "column": 10
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    10,
+                    15
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 10
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 4
+                    }
+                },
+                "value": "\n    "
+            },
+            {
+                "type": "HTMLTagOpen",
+                "range": [
+                    15,
+                    24
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 4
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 13
+                    }
+                },
+                "value": "textarea"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    24,
+                    25
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 13
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 14
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "VExpressionStart",
+                "range": [
+                    25,
+                    27
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 14
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 16
+                    }
+                },
+                "value": "{{"
+            },
+            {
+                "type": "HTMLRCDataText",
+                "range": [
+                    27,
+                    30
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 16
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 19
+                    }
+                },
+                "value": "foo"
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    30,
+                    31
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 19
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 20
+                    }
+                },
+                "value": " "
+            },
+            {
+                "type": "HTMLRCDataText",
+                "range": [
+                    31,
+                    34
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 20
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 23
+                    }
+                },
+                "value": "bar"
+            },
+            {
+                "type": "VExpressionEnd",
+                "range": [
+                    34,
+                    36
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 23
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 25
+                    }
+                },
+                "value": "}}"
+            },
+            {
+                "type": "HTMLEndTagOpen",
+                "range": [
+                    36,
+                    46
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 25
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 35
+                    }
+                },
+                "value": "textarea"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    46,
+                    47
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 35
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 36
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    47,
+                    48
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 36
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 0
+                    }
+                },
+                "value": "\n"
+            },
+            {
+                "type": "HTMLEndTagOpen",
+                "range": [
+                    48,
+                    58
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 0
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 10
+                    }
+                },
+                "value": "template"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    58,
+                    59
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 10
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 11
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    59,
+                    60
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 11
+                    },
+                    "end": {
+                        "line": 4,
+                        "column": 0
+                    }
+                },
+                "value": "\n"
+            }
+        ],
+        "comments": [],
+        "errors": [
+            {
+                "message": "Unexpected token bar",
+                "index": 31,
+                "lineNumber": 2,
+                "column": 20
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/test/fixtures/ast/mustache-errors-in-textarea/source.vue b/test/fixtures/ast/mustache-errors-in-textarea/source.vue
new file mode 100644
index 00000000..da4a40ab
--- /dev/null
+++ b/test/fixtures/ast/mustache-errors-in-textarea/source.vue
@@ -0,0 +1,3 @@
+<template>
+    <textarea>{{foo bar}}</textarea>
+</template>
diff --git a/test/fixtures/ast/mustache-errors-in-textarea/token-ranges.json b/test/fixtures/ast/mustache-errors-in-textarea/token-ranges.json
new file mode 100644
index 00000000..8f3b13ea
--- /dev/null
+++ b/test/fixtures/ast/mustache-errors-in-textarea/token-ranges.json
@@ -0,0 +1,18 @@
+[
+    "<template",
+    ">",
+    "\n    ",
+    "<textarea",
+    ">",
+    "{{",
+    "foo",
+    " ",
+    "bar",
+    "}}",
+    "</textarea",
+    ">",
+    "\n",
+    "</template",
+    ">",
+    "\n"
+]
\ No newline at end of file
diff --git a/test/fixtures/ast/mustache-errors-in-textarea/tree.json b/test/fixtures/ast/mustache-errors-in-textarea/tree.json
new file mode 100644
index 00000000..f5b30cc1
--- /dev/null
+++ b/test/fixtures/ast/mustache-errors-in-textarea/tree.json
@@ -0,0 +1,49 @@
+[
+    {
+        "type": "VElement",
+        "text": "<template>\n    <textarea>{{foo bar}}</textarea>\n</template>",
+        "children": [
+            {
+                "type": "VStartTag",
+                "text": "<template>",
+                "children": []
+            },
+            {
+                "type": "VText",
+                "text": "\n    ",
+                "children": []
+            },
+            {
+                "type": "VElement",
+                "text": "<textarea>{{foo bar}}</textarea>",
+                "children": [
+                    {
+                        "type": "VStartTag",
+                        "text": "<textarea>",
+                        "children": []
+                    },
+                    {
+                        "type": "VExpressionContainer",
+                        "text": "{{foo bar}}",
+                        "children": []
+                    },
+                    {
+                        "type": "VEndTag",
+                        "text": "</textarea>",
+                        "children": []
+                    }
+                ]
+            },
+            {
+                "type": "VText",
+                "text": "\n",
+                "children": []
+            },
+            {
+                "type": "VEndTag",
+                "text": "</template>",
+                "children": []
+            }
+        ]
+    }
+]
\ No newline at end of file
diff --git a/test/fixtures/ast/mustache-without-open-in-textarea/ast.json b/test/fixtures/ast/mustache-without-open-in-textarea/ast.json
new file mode 100644
index 00000000..cc24dc1c
--- /dev/null
+++ b/test/fixtures/ast/mustache-without-open-in-textarea/ast.json
@@ -0,0 +1,618 @@
+{
+    "type": "Program",
+    "start": 0,
+    "end": 0,
+    "loc": {
+        "start": {
+            "line": 1,
+            "column": 0
+        },
+        "end": {
+            "line": 1,
+            "column": 0
+        }
+    },
+    "range": [
+        0,
+        0
+    ],
+    "body": [],
+    "sourceType": "module",
+    "comments": [],
+    "tokens": [],
+    "templateBody": {
+        "type": "VElement",
+        "range": [
+            0,
+            67
+        ],
+        "loc": {
+            "start": {
+                "line": 1,
+                "column": 0
+            },
+            "end": {
+                "line": 4,
+                "column": 11
+            }
+        },
+        "name": "template",
+        "rawName": "template",
+        "namespace": "http://www.w3.org/1999/xhtml",
+        "startTag": {
+            "type": "VStartTag",
+            "range": [
+                0,
+                10
+            ],
+            "loc": {
+                "start": {
+                    "line": 1,
+                    "column": 0
+                },
+                "end": {
+                    "line": 1,
+                    "column": 10
+                }
+            },
+            "selfClosing": false,
+            "attributes": []
+        },
+        "children": [
+            {
+                "type": "VText",
+                "range": [
+                    10,
+                    13
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 10
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 2
+                    }
+                },
+                "value": "\n  "
+            },
+            {
+                "type": "VExpressionContainer",
+                "range": [
+                    13,
+                    22
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 2
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 11
+                    }
+                },
+                "expression": {
+                    "type": "Literal",
+                    "start": 16,
+                    "end": 19,
+                    "loc": {
+                        "start": {
+                            "line": 2,
+                            "column": 5
+                        },
+                        "end": {
+                            "line": 2,
+                            "column": 8
+                        }
+                    },
+                    "range": [
+                        16,
+                        19
+                    ],
+                    "value": 123,
+                    "raw": "123"
+                },
+                "references": []
+            },
+            {
+                "type": "VText",
+                "range": [
+                    22,
+                    25
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 11
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 2
+                    }
+                },
+                "value": "\n  "
+            },
+            {
+                "type": "VElement",
+                "range": [
+                    25,
+                    55
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 2
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 32
+                    }
+                },
+                "name": "textarea",
+                "rawName": "textarea",
+                "namespace": "http://www.w3.org/1999/xhtml",
+                "startTag": {
+                    "type": "VStartTag",
+                    "range": [
+                        25,
+                        35
+                    ],
+                    "loc": {
+                        "start": {
+                            "line": 3,
+                            "column": 2
+                        },
+                        "end": {
+                            "line": 3,
+                            "column": 12
+                        }
+                    },
+                    "selfClosing": false,
+                    "attributes": []
+                },
+                "children": [
+                    {
+                        "type": "VText",
+                        "range": [
+                            35,
+                            44
+                        ],
+                        "loc": {
+                            "start": {
+                                "line": 3,
+                                "column": 12
+                            },
+                            "end": {
+                                "line": 3,
+                                "column": 21
+                            }
+                        },
+                        "value": " }} <div "
+                    }
+                ],
+                "endTag": {
+                    "type": "VEndTag",
+                    "range": [
+                        44,
+                        55
+                    ],
+                    "loc": {
+                        "start": {
+                            "line": 3,
+                            "column": 21
+                        },
+                        "end": {
+                            "line": 3,
+                            "column": 32
+                        }
+                    }
+                },
+                "variables": []
+            },
+            {
+                "type": "VText",
+                "range": [
+                    55,
+                    56
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 32
+                    },
+                    "end": {
+                        "line": 4,
+                        "column": 0
+                    }
+                },
+                "value": "\n"
+            }
+        ],
+        "endTag": {
+            "type": "VEndTag",
+            "range": [
+                56,
+                67
+            ],
+            "loc": {
+                "start": {
+                    "line": 4,
+                    "column": 0
+                },
+                "end": {
+                    "line": 4,
+                    "column": 11
+                }
+            }
+        },
+        "variables": [],
+        "tokens": [
+            {
+                "type": "HTMLTagOpen",
+                "range": [
+                    0,
+                    9
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 0
+                    },
+                    "end": {
+                        "line": 1,
+                        "column": 9
+                    }
+                },
+                "value": "template"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    9,
+                    10
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 9
+                    },
+                    "end": {
+                        "line": 1,
+                        "column": 10
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    10,
+                    13
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 10
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 2
+                    }
+                },
+                "value": "\n  "
+            },
+            {
+                "type": "VExpressionStart",
+                "range": [
+                    13,
+                    15
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 2
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 4
+                    }
+                },
+                "value": "{{"
+            },
+            {
+                "type": "Numeric",
+                "value": "123",
+                "start": 16,
+                "end": 19,
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 5
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 8
+                    }
+                },
+                "range": [
+                    16,
+                    19
+                ]
+            },
+            {
+                "type": "VExpressionEnd",
+                "range": [
+                    20,
+                    22
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 9
+                    },
+                    "end": {
+                        "line": 2,
+                        "column": 11
+                    }
+                },
+                "value": "}}"
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    22,
+                    25
+                ],
+                "loc": {
+                    "start": {
+                        "line": 2,
+                        "column": 11
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 2
+                    }
+                },
+                "value": "\n  "
+            },
+            {
+                "type": "HTMLTagOpen",
+                "range": [
+                    25,
+                    34
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 2
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 11
+                    }
+                },
+                "value": "textarea"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    34,
+                    35
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 11
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 12
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    35,
+                    36
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 12
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 13
+                    }
+                },
+                "value": " "
+            },
+            {
+                "type": "VExpressionEnd",
+                "range": [
+                    36,
+                    38
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 13
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 15
+                    }
+                },
+                "value": "}}"
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    38,
+                    39
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 15
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 16
+                    }
+                },
+                "value": " "
+            },
+            {
+                "type": "HTMLRCDataText",
+                "range": [
+                    39,
+                    43
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 16
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 20
+                    }
+                },
+                "value": "<div"
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    43,
+                    44
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 20
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 21
+                    }
+                },
+                "value": " "
+            },
+            {
+                "type": "HTMLEndTagOpen",
+                "range": [
+                    44,
+                    54
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 21
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 31
+                    }
+                },
+                "value": "textarea"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    54,
+                    55
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 31
+                    },
+                    "end": {
+                        "line": 3,
+                        "column": 32
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    55,
+                    56
+                ],
+                "loc": {
+                    "start": {
+                        "line": 3,
+                        "column": 32
+                    },
+                    "end": {
+                        "line": 4,
+                        "column": 0
+                    }
+                },
+                "value": "\n"
+            },
+            {
+                "type": "HTMLEndTagOpen",
+                "range": [
+                    56,
+                    66
+                ],
+                "loc": {
+                    "start": {
+                        "line": 4,
+                        "column": 0
+                    },
+                    "end": {
+                        "line": 4,
+                        "column": 10
+                    }
+                },
+                "value": "template"
+            },
+            {
+                "type": "HTMLTagClose",
+                "range": [
+                    66,
+                    67
+                ],
+                "loc": {
+                    "start": {
+                        "line": 4,
+                        "column": 10
+                    },
+                    "end": {
+                        "line": 4,
+                        "column": 11
+                    }
+                },
+                "value": ""
+            },
+            {
+                "type": "HTMLWhitespace",
+                "range": [
+                    67,
+                    68
+                ],
+                "loc": {
+                    "start": {
+                        "line": 4,
+                        "column": 11
+                    },
+                    "end": {
+                        "line": 5,
+                        "column": 0
+                    }
+                },
+                "value": "\n"
+            }
+        ],
+        "comments": [],
+        "errors": []
+    }
+}
\ No newline at end of file
diff --git a/test/fixtures/ast/mustache-without-open-in-textarea/source.vue b/test/fixtures/ast/mustache-without-open-in-textarea/source.vue
new file mode 100644
index 00000000..5f979d1d
--- /dev/null
+++ b/test/fixtures/ast/mustache-without-open-in-textarea/source.vue
@@ -0,0 +1,4 @@
+<template>
+  {{ 123 }}
+  <textarea> }} <div </textarea>
+</template>
diff --git a/test/fixtures/ast/mustache-without-open-in-textarea/token-ranges.json b/test/fixtures/ast/mustache-without-open-in-textarea/token-ranges.json
new file mode 100644
index 00000000..8d08b5f6
--- /dev/null
+++ b/test/fixtures/ast/mustache-without-open-in-textarea/token-ranges.json
@@ -0,0 +1,22 @@
+[
+    "<template",
+    ">",
+    "\n  ",
+    "{{",
+    "123",
+    "}}",
+    "\n  ",
+    "<textarea",
+    ">",
+    " ",
+    "}}",
+    " ",
+    "<div",
+    " ",
+    "</textarea",
+    ">",
+    "\n",
+    "</template",
+    ">",
+    "\n"
+]
\ No newline at end of file
diff --git a/test/fixtures/ast/mustache-without-open-in-textarea/tree.json b/test/fixtures/ast/mustache-without-open-in-textarea/tree.json
new file mode 100644
index 00000000..7312fcac
--- /dev/null
+++ b/test/fixtures/ast/mustache-without-open-in-textarea/tree.json
@@ -0,0 +1,65 @@
+[
+    {
+        "type": "VElement",
+        "text": "<template>\n  {{ 123 }}\n  <textarea> }} <div </textarea>\n</template>",
+        "children": [
+            {
+                "type": "VStartTag",
+                "text": "<template>",
+                "children": []
+            },
+            {
+                "type": "VText",
+                "text": "\n  ",
+                "children": []
+            },
+            {
+                "type": "VExpressionContainer",
+                "text": "{{ 123 }}",
+                "children": [
+                    {
+                        "type": "Literal",
+                        "text": "123",
+                        "children": []
+                    }
+                ]
+            },
+            {
+                "type": "VText",
+                "text": "\n  ",
+                "children": []
+            },
+            {
+                "type": "VElement",
+                "text": "<textarea> }} <div </textarea>",
+                "children": [
+                    {
+                        "type": "VStartTag",
+                        "text": "<textarea>",
+                        "children": []
+                    },
+                    {
+                        "type": "VText",
+                        "text": " }} <div ",
+                        "children": []
+                    },
+                    {
+                        "type": "VEndTag",
+                        "text": "</textarea>",
+                        "children": []
+                    }
+                ]
+            },
+            {
+                "type": "VText",
+                "text": "\n",
+                "children": []
+            },
+            {
+                "type": "VEndTag",
+                "text": "</template>",
+                "children": []
+            }
+        ]
+    }
+]
\ No newline at end of file
diff --git a/test/index.js b/test/index.test.ts
similarity index 88%
rename from test/index.js
rename to test/index.test.ts
index e4d898b3..852ec521 100644
--- a/test/index.js
+++ b/test/index.test.ts
@@ -3,26 +3,29 @@
  * @copyright 2016 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const path = require("path")
-const fs = require("fs-extra")
-const parse = require("../src").parse
-const parseForESLint = require("../src").parseForESLint
-const eslint = require("eslint")
+import type { Rule } from "eslint"
+import path from "node:path"
+import { describe, it, assert, beforeEach, afterEach } from "vitest"
+import tsParser from "@typescript-eslint/parser"
+import fs from "fs-extra"
+import eslint from "eslint"
+import { parse, parseForESLint } from "../src"
+import * as parser from "../src"
+import type { Node, VAttribute, VElement, VText } from "../src/ast"
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
+// eslint-disable-next-line no-undef
 const ORIGINAL_FIXTURE_DIR = path.join(__dirname, "fixtures")
+// eslint-disable-next-line no-undef
 const FIXTURE_DIR = path.join(__dirname, "temp")
-const parser = require("../src/index.ts")
 
 const BABEL_PARSER_OPTIONS = {
     parser: "@babel/eslint-parser",
@@ -46,6 +49,7 @@ const BABEL_PARSER_OPTIONS = {
 describe("Basic tests", async () => {
     const ESLint = await eslint.loadESLint({ useFlatConfig: true })
     const Linter = class extends eslint.Linter {
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
         constructor() {
             super({ configType: "flat" })
         }
@@ -356,7 +360,7 @@ describe("Basic tests", async () => {
                         parser,
                         globals: {},
                         parserOptions: {
-                            parser: require("@typescript-eslint/parser"),
+                            parser: tsParser,
                         },
                     },
                     rules: { semi: ["error", "never"] },
@@ -379,7 +383,7 @@ describe("Basic tests", async () => {
                         globals: {},
                         parserOptions: {
                             parser: {
-                                ts: require("@typescript-eslint/parser"),
+                                ts: tsParser,
                             },
                         },
                     },
@@ -601,8 +605,8 @@ describe("Basic tests", async () => {
     describe("About unexpected-null-character errors", () => {
         it("should keep NULL in DATA state.", () => {
             const ast = parse("<template>\u0000</template>")
-            const text = ast.templateBody.children[0]
-            const errors = ast.templateBody.errors
+            const text = ast.templateBody!.children[0] as VText
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(text.value, "\u0000")
             assert.strictEqual(errors.length, 1)
@@ -613,8 +617,9 @@ describe("Basic tests", async () => {
             const ast = parse(
                 "<template><textarea>\u0000</textarea></template>",
             )
-            const text = ast.templateBody.children[0].children[0]
-            const errors = ast.templateBody.errors
+            const text = (ast.templateBody!.children[0] as VElement)
+                .children[0] as VText
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(text.value, "\uFFFD")
             assert.strictEqual(errors.length, 1)
@@ -623,8 +628,9 @@ describe("Basic tests", async () => {
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in RAWTEXT state.", () => {
             const ast = parse("<template><style>\u0000</style></template>")
-            const text = ast.templateBody.children[0].children[0]
-            const errors = ast.templateBody.errors
+            const text = (ast.templateBody!.children[0] as VElement)
+                .children[0] as VText
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(text.value, "\uFFFD")
             assert.strictEqual(errors.length, 1)
@@ -633,8 +639,8 @@ describe("Basic tests", async () => {
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in TAG_NAME state.", () => {
             const ast = parse("<template><test\u0000></template>")
-            const element = ast.templateBody.children[0]
-            const errors = ast.templateBody.errors
+            const element = ast.templateBody!.children[0] as VElement
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(element.name, "test\uFFFD")
             assert.strictEqual(errors.length, 1)
@@ -643,9 +649,9 @@ describe("Basic tests", async () => {
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in ATTRIBUTE_NAME state.", () => {
             const ast = parse("<template><div a\u0000></div></template>")
-            const attribute =
-                ast.templateBody.children[0].startTag.attributes[0]
-            const errors = ast.templateBody.errors
+            const attribute = (ast.templateBody!.children[0] as VElement)
+                .startTag.attributes[0]
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(attribute.key.name, "a\uFFFD")
             assert.strictEqual(errors.length, 1)
@@ -654,41 +660,41 @@ describe("Basic tests", async () => {
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in ATTRIBUTE_VALUE_DOUBLE_QUOTED state.", () => {
             const ast = parse('<template><div a="\u0000"></div></template>')
-            const attribute =
-                ast.templateBody.children[0].startTag.attributes[0]
-            const errors = ast.templateBody.errors
+            const attribute = (ast.templateBody!.children[0] as VElement)
+                .startTag.attributes[0] as VAttribute
+            const errors = ast.templateBody!.errors
 
-            assert.strictEqual(attribute.value.value, "\uFFFD")
+            assert.strictEqual(attribute.value!.value, "\uFFFD")
             assert.strictEqual(errors.length, 1)
             assert.strictEqual(errors[0].code, "unexpected-null-character")
         })
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in ATTRIBUTE_VALUE_SINGLE_QUOTED state.", () => {
             const ast = parse("<template><div a='\u0000'></div></template>")
-            const attribute =
-                ast.templateBody.children[0].startTag.attributes[0]
-            const errors = ast.templateBody.errors
+            const attribute = (ast.templateBody!.children[0] as VElement)
+                .startTag.attributes[0] as VAttribute
+            const errors = ast.templateBody!.errors
 
-            assert.strictEqual(attribute.value.value, "\uFFFD")
+            assert.strictEqual(attribute.value!.value, "\uFFFD")
             assert.strictEqual(errors.length, 1)
             assert.strictEqual(errors[0].code, "unexpected-null-character")
         })
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in ATTRIBUTE_VALUE_UNQUOTED state.", () => {
             const ast = parse("<template><div a=\u0000></div></template>")
-            const attribute =
-                ast.templateBody.children[0].startTag.attributes[0]
-            const errors = ast.templateBody.errors
+            const attribute = (ast.templateBody!.children[0] as VElement)
+                .startTag.attributes[0] as VAttribute
+            const errors = ast.templateBody!.errors
 
-            assert.strictEqual(attribute.value.value, "\uFFFD")
+            assert.strictEqual(attribute.value!.value, "\uFFFD")
             assert.strictEqual(errors.length, 1)
             assert.strictEqual(errors[0].code, "unexpected-null-character")
         })
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in COMMENT state.", () => {
             const ast = parse("<template><!-- \u0000 --></template>")
-            const comment = ast.templateBody.comments[0]
-            const errors = ast.templateBody.errors
+            const comment = ast.templateBody!.comments[0]
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(comment.value, " \uFFFD ")
             assert.strictEqual(errors.length, 1)
@@ -697,8 +703,8 @@ describe("Basic tests", async () => {
 
         it("should replace NULL by U+FFFD REPLACEMENT CHARACTER in BOGUS_COMMENT state.", () => {
             const ast = parse("<template><? \u0000 ?></template>")
-            const comment = ast.templateBody.comments[0]
-            const errors = ast.templateBody.errors
+            const comment = ast.templateBody!.comments[0]
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(comment.value, "? \uFFFD ?")
             assert.strictEqual(errors.length, 1)
@@ -710,8 +716,9 @@ describe("Basic tests", async () => {
 
         it("should not error in CDATA section state.", () => {
             const ast = parse("<template><svg><![CDATA[\u0000]]></template>")
-            const cdata = ast.templateBody.children[0].children[0]
-            const errors = ast.templateBody.errors
+            const cdata = (ast.templateBody!.children[0] as VElement)
+                .children[0] as VText
+            const errors = ast.templateBody!.errors
 
             assert.strictEqual(cdata.value, "\u0000")
             assert.strictEqual(errors.length, 0)
@@ -736,7 +743,7 @@ describe("Basic tests", async () => {
 
     describe("https://github.com/vuejs/vue-eslint-parser/issues/21", () => {
         it("should make the correct location of decorators", () => {
-            const code = fs.readFileSync(
+            const code: string = fs.readFileSync(
                 path.join(FIXTURE_DIR, "issue21.vue"),
                 "utf8",
             )
@@ -753,7 +760,8 @@ describe("Basic tests", async () => {
 
             assert.strictEqual(ast.body[2].range[0], indexOfDecorator)
             assert.strictEqual(
-                ast.body[2].decorators[0].range[0],
+                // TSESLintClassDeclaration
+                (ast.body[2] as any).decorators[0].range[0],
                 indexOfDecorator,
             )
         })
@@ -762,7 +770,7 @@ describe("Basic tests", async () => {
     describe("parserServices.defineTemplateBodyVisitor", () => {
         it("should work even if AST object was reused.", () => {
             const code = "<template><div/></template>"
-            const config = {
+            const config: eslint.Linter.Config = {
                 languageOptions: {
                     parser,
                 },
@@ -770,7 +778,7 @@ describe("Basic tests", async () => {
                     create(context) {
                         return context.sourceCode.parserServices.defineTemplateBodyVisitor(
                             {
-                                "VElement[name='div']"(node) {
+                                "VElement[name='div']"(node: VElement) {
                                     context.report({ node, message: "OK" })
                                 },
                             },
@@ -793,7 +801,7 @@ describe("Basic tests", async () => {
 
         it("should work even if used sibling selector.", () => {
             const code = "<template><div/><div/></template>"
-            const config = {
+            const config: eslint.Linter.Config = {
                 languageOptions: {
                     parser,
                 },
@@ -801,7 +809,7 @@ describe("Basic tests", async () => {
                     create(context) {
                         return context.sourceCode.parserServices.defineTemplateBodyVisitor(
                             {
-                                "* ~ *"(node) {
+                                "* ~ *"(node: Node) {
                                     context.report({
                                         node,
                                         message: "OK",
@@ -846,7 +854,7 @@ describe("Basic tests", async () => {
         })
         it("should notify parsing error #2", () => {
             const code = "<script>var a = `</script><script setup>`</script>"
-            const config = {
+            const config: eslint.Linter.Config = {
                 languageOptions: {
                     parser,
                     parserOptions: {
@@ -882,7 +890,7 @@ describe("Basic tests", async () => {
         it("should notify 1 no-undef error", () => {
             const code =
                 "<script>var a = 1, b = 2;</script><script setup>c = a + b</script>"
-            const config = {
+            const config: eslint.Linter.Config = {
                 languageOptions: {
                     parser,
                 },
@@ -896,10 +904,48 @@ describe("Basic tests", async () => {
             assert.strictEqual(messages.length, 1)
             assert.strictEqual(messages[0].message, "'c' is not defined.")
         })
+
+        it("should sort comments by their original source position", () => {
+            const code = `<script lang="ts" setup>
+const test = () => {
+  // first
+  return false
+}
+</script>
+
+<script lang="ts">
+/**
+ * second
+ */
+export default {}
+</script>
+
+<template>
+  <div @click="test" />
+</template>`
+
+            const result = parseForESLint(code, { sourceType: "module" })
+            const comments = result.ast.comments!
+
+            // Should have 2 comments
+            assert.strictEqual(comments.length, 2)
+
+            // Comments should be sorted by their original position in source code
+            assert.strictEqual(comments[0].type, "Line")
+            assert.strictEqual(comments[0].value, " first")
+            assert.strictEqual(comments[0].loc.start.line, 3)
+
+            assert.strictEqual(comments[1].type, "Block")
+            assert.strictEqual(comments[1].value, "*\n * second\n ")
+            assert.strictEqual(comments[1].loc.start.line, 9)
+
+            // Verify comments are sorted by range
+            assert.ok(comments[0].range[0] < comments[1].range[0])
+        })
     })
 })
 
-function buildPlugins(rule) {
+function buildPlugins(rule: Rule.RuleModule) {
     return {
         test: {
             rules: {
diff --git a/test/integrations.js b/test/integrations.test.ts
similarity index 67%
rename from test/integrations.js
rename to test/integrations.test.ts
index 88e9c501..651e6616 100644
--- a/test/integrations.js
+++ b/test/integrations.test.ts
@@ -2,16 +2,18 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const path = require("path")
-const fs = require("fs-extra")
-const cp = require("child_process")
-const eslintCompat = require("./lib/eslint-compat")
+import { assert, beforeAll, describe, it } from "vitest"
+import path from "node:path"
+import fs from "node:fs"
+import cp from "child_process"
+import eslintCompat from "./lib/eslint-compat"
+import ESLintRaw from "eslint"
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
+// eslint-disable-next-line no-undef
 const FIXTURE_DIR = path.join(__dirname, "fixtures/integrations")
 
 //------------------------------------------------------------------------------
@@ -19,15 +21,19 @@ const FIXTURE_DIR = path.join(__dirname, "fixtures/integrations")
 //------------------------------------------------------------------------------
 
 describe("Integration tests", () => {
+    beforeAll(async () => {
+        await import("ts-node/register")
+    })
     for (const target of fs.readdirSync(FIXTURE_DIR)) {
         it(target, async () => {
-            let ESLint = eslintCompat(require("eslint")).ESLint
+            let ESLint = eslintCompat(ESLintRaw).ESLint
             if (fs.existsSync(path.join(FIXTURE_DIR, target, "package.json"))) {
                 const originalCwd = process.cwd()
                 try {
                     process.chdir(path.join(FIXTURE_DIR, target))
                     cp.execSync("npm i", { stdio: "inherit" })
                     ESLint = eslintCompat(
+                        // eslint-disable-next-line @typescript-eslint/no-require-imports
                         require(
                             path.join(
                                 FIXTURE_DIR,
@@ -46,7 +52,7 @@ describe("Integration tests", () => {
             })
             const report = await cli.lintFiles(["**/*.vue"])
 
-            const outputPath = path.join(FIXTURE_DIR, target, `output.json`)
+            const outputPath = path.join(FIXTURE_DIR, target, "output.json")
             const expected = JSON.parse(fs.readFileSync(outputPath, "utf8"))
             try {
                 assert.deepStrictEqual(
@@ -59,7 +65,7 @@ describe("Integration tests", () => {
                 const actualPath = path.join(
                     FIXTURE_DIR,
                     target,
-                    `_actual.json`,
+                    "_actual.json",
                 )
                 fs.writeFileSync(
                     actualPath,
@@ -69,25 +75,24 @@ describe("Integration tests", () => {
                 throw e
             }
 
-            function normalizeReport(report, option = {}) {
-                return report
+            function normalizeReport(
+                result: ESLintRaw.ESLint.LintResult[],
+                option: { withoutMessage?: boolean } = {},
+            ) {
+                return result
                     .filter((res) => res.messages.length)
-                    .map((res) => {
-                        return {
-                            filePath: res.filePath
-                                .replace(cwd, "")
-                                .replace(/\\/gu, "/"),
-                            messages: res.messages.map((msg) => {
-                                return {
-                                    ruleId: msg.ruleId,
-                                    line: msg.line,
-                                    ...(option.withoutMessage
-                                        ? {}
-                                        : { message: msg.message }),
-                                }
-                            }),
-                        }
-                    })
+                    .map((res) => ({
+                        filePath: res.filePath
+                            .replace(cwd, "")
+                            .replace(/\\/gu, "/"),
+                        messages: res.messages.map((msg) => ({
+                            ruleId: msg.ruleId,
+                            line: msg.line,
+                            ...(option.withoutMessage
+                                ? {}
+                                : { message: msg.message }),
+                        })),
+                    }))
                     .sort((a, b) =>
                         a.filePath < b.filePath
                             ? -1
diff --git a/test/lib/eslint-compat.js b/test/lib/eslint-compat.ts
similarity index 60%
rename from test/lib/eslint-compat.js
rename to test/lib/eslint-compat.ts
index 9077ec55..ae96362f 100644
--- a/test/lib/eslint-compat.js
+++ b/test/lib/eslint-compat.ts
@@ -1,11 +1,10 @@
-"use strict"
+import type { ESLint, Linter, RuleTester } from "eslint"
 
-/**
- * @typedef {import('eslint')} eslint
- */
-
-/** @param {eslint} eslint */
-module.exports = function compat(eslint) {
+export default function compat(eslint: any): {
+    ESLint: typeof ESLint
+    RuleTester: typeof RuleTester
+    Linter: typeof Linter
+} {
     return {
         ESLint: eslint.ESLint || getESLintClassForV6(eslint),
         RuleTester: eslint.RuleTester,
@@ -13,15 +12,17 @@ module.exports = function compat(eslint) {
     }
 }
 
-/** @returns {typeof eslint.ESLint} */
-function getESLintClassForV6(eslint) {
+function getESLintClassForV6(eslint: any): typeof ESLint {
     class ESLintForV6 {
+        public engine
+
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
         static get version() {
             return eslint.CLIEngine.version
         }
 
-        /** @param {eslint.ESLint.Options} options */
-        constructor(options) {
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+        constructor(options: any) {
             const {
                 overrideConfig: {
                     plugins,
@@ -33,14 +34,13 @@ function getESLintClassForV6(eslint) {
                     plugins: [],
                     globals: {},
                     rules: {},
-                },
+                } as any,
                 overrideConfigFile,
                 fix,
                 reportUnusedDisableDirectives,
                 plugins: pluginsMap,
                 ...otherOptions
             } = options || {}
-            /** @type {eslint.CLIEngine.Options} */
             const newOptions = {
                 fix: Boolean(fix),
                 reportUnusedDisableDirectives: reportUnusedDisableDirectives
@@ -64,7 +64,7 @@ function getESLintClassForV6(eslint) {
                               }
                               return o
                           },
-                          /** @type {NonNullable<eslint.CLIEngine.Options["rules"]>} */ {},
+                          {} as Record<string, any>,
                       )
                     : undefined,
                 ...overrideConfig,
@@ -76,41 +76,37 @@ function getESLintClassForV6(eslint) {
             }
         }
 
-        /**
-         * @param {Parameters<eslint.ESLint['lintText']>} params
-         * @returns {ReturnType<eslint.ESLint['lintText']>}
-         */
-        async lintText(...params) {
-            const result = this.engine.executeOnText(
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+        async lintText(
+            ...params: Parameters<ESLint["lintText"]>
+        ): ReturnType<ESLint["lintText"]> {
+            const result = await this.engine.executeOnText(
                 params[0],
-                params[1].filePath,
+                params[1]!.filePath,
             )
             return result.results
         }
 
-        /**
-         * @param {Parameters<eslint.ESLint['lintFiles']>} params
-         * @returns {ReturnType<eslint.ESLint['lintFiles']>}
-         */
-        async lintFiles(...params) {
-            const result = this.engine.executeOnFiles(
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+        async lintFiles(
+            ...params: Parameters<ESLint["lintFiles"]>
+        ): ReturnType<ESLint["lintFiles"]> {
+            const result = await this.engine.executeOnFiles(
                 Array.isArray(params[0]) ? params[0] : [params[0]],
             )
             return result.results
         }
 
-        /**
-         * @param {Parameters<eslint.ESLint['outputFixes']>} params
-         * @returns {ReturnType<eslint.ESLint['outputFixes']>}
-         */
-        static async outputFixes(...params) {
-            return eslint.CLIEngine.outputFixes({
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+        static async outputFixes(
+            ...params: Parameters<typeof ESLint.outputFixes>
+        ): ReturnType<typeof ESLint.outputFixes> {
+            // eslint-disable-next-line no-return-await
+            return await eslint.CLIEngine.outputFixes({
                 results: params[0],
             })
         }
     }
 
-    /** @type {typeof eslint.ESLint} */
-    const eslintClass = /** @type {any} */ ESLintForV6
-    return eslintClass
+    return ESLintForV6 as any
 }
diff --git a/test/parser-options-project.js b/test/parser-options-project.test.ts
similarity index 93%
rename from test/parser-options-project.js
rename to test/parser-options-project.test.ts
index 1fc3b12a..257f4ded 100644
--- a/test/parser-options-project.js
+++ b/test/parser-options-project.test.ts
@@ -1,8 +1,7 @@
-"use strict"
-
-const assert = require("assert")
-const { parseForESLint } = require("../src")
-const espree = require("espree")
+import { describe, it, assert } from "vitest"
+import { parseForESLint } from "../src"
+import * as espree from "espree"
+import type { Linter } from "eslint"
 
 describe("use `project: undefined` when parsing template script-let", () => {
     it("should be the project option is defined only once in Simple SFC.", () => {
@@ -39,7 +38,7 @@ describe("use `project: undefined` when parsing template script-let", () => {
                             ast: espree.parse(code, options),
                         }
                     },
-                },
+                } satisfies Linter.Parser,
             },
         )
         assert.strictEqual(projectCount, 1)
@@ -83,7 +82,7 @@ describe("use `project: undefined` when parsing template script-let", () => {
                             ast: espree.parse(code, options),
                         }
                     },
-                },
+                } satisfies Linter.Parser,
             },
         )
         assert.strictEqual(projectCount, 1)
@@ -126,7 +125,7 @@ describe("use `project: undefined` when parsing template script-let", () => {
                             ast: espree.parse(code, options),
                         }
                     },
-                },
+                } satisfies Linter.Parser,
             },
         )
         assert.strictEqual(projectCount, 1)
diff --git a/test/parser-options.js b/test/parser-options.test.ts
similarity index 86%
rename from test/parser-options.js
rename to test/parser-options.test.ts
index 3c7e4e1b..37aa60a9 100644
--- a/test/parser-options.js
+++ b/test/parser-options.test.ts
@@ -2,18 +2,17 @@
  * @author Toru Nagashima <https://github.com/mysticatea>
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
-const assert = require("assert")
-const { parseForESLint } = require("../src")
-const eslint = require("eslint")
-const Linter = eslint.Linter
+import { describe, it, assert } from "vitest"
+import { parseForESLint } from "../src"
+import type { ESLint } from "eslint"
+import { Linter } from "eslint"
 
 describe("parserOptions", () => {
     describe("parser", () => {
         const linter = new Linter({ configType: "flat" })
-        const parser = { parseForESLint }
-        const plugin = {
+        const parser: Linter.Parser = { parseForESLint }
+        const plugin: ESLint.Plugin = {
             rules: {
                 "template-test": {
                     create(context) {
@@ -33,7 +32,7 @@ describe("parserOptions", () => {
         it("false then skip parsing '<script>'.", () => {
             const code = `<template>Hello</template>
 <script>This is syntax error</script>`
-            const config = {
+            const config: Linter.Config = {
                 files: ["*.vue"],
                 plugins: {
                     vue: plugin,
@@ -57,7 +56,7 @@ describe("parserOptions", () => {
         it("Fail in <script setup> with sourceType: script.", () => {
             const code = `<template>Hello</template>
 <script setup>import Foo from './foo'</script>`
-            const config = {
+            const config: Linter.Config = {
                 files: ["*.vue"],
                 plugins: {
                     vue: plugin,
diff --git a/test/test-utils.js b/test/test-utils.ts
similarity index 68%
rename from test/test-utils.js
rename to test/test-utils.ts
index 8ea0b760..f5305181 100644
--- a/test/test-utils.js
+++ b/test/test-utils.ts
@@ -1,14 +1,22 @@
-const escope = require("eslint-scope")
-
-module.exports = { replacer, getAllTokens, scopeToJSON, analyze }
+import type { Identifier, Node } from "estree"
+import type {
+    Scope,
+    ScopeManager,
+    Variable,
+    VariableDefinition,
+} from "eslint-scope"
+import type { ESLintProgram, Token } from "../src/ast"
+import type { ParserOptions } from "../src/common/parser-options"
+import * as escope from "eslint-scope"
+import { getFallbackKeys } from "../src/ast"
 
 /**
  * Remove `parent` properties from the given AST.
- * @param {string} key The key.
- * @param {any} value The value of the key.
- * @returns {any} The value of the key to output.
+ * @param key The key.
+ * @param value The value of the key.
+ * @returns The value of the key to output.
  */
-function replacer(key, value) {
+export function replacer(key: string, value: any): any {
     if (key === "parent") {
         return undefined
     }
@@ -25,10 +33,10 @@ function replacer(key, value) {
 
 /**
  * Get all tokens of the given AST.
- * @param {ASTNode} ast The root node of AST.
- * @returns {Token[]} Tokens.
+ * @param ast The root node of AST.
+ * @returns Tokens.
  */
-function getAllTokens(ast) {
+export function getAllTokens(ast: ESLintProgram): Token[] {
     const tokenArrays = [ast.tokens, ast.comments]
     if (ast.templateBody != null) {
         tokenArrays.push(ast.templateBody.tokens, ast.templateBody.comments)
@@ -36,10 +44,10 @@ function getAllTokens(ast) {
     return Array.prototype.concat.apply([], tokenArrays)
 }
 
-function scopeToJSON(scopeManager) {
+export function scopeToJSON(scopeManager: ScopeManager) {
     return JSON.stringify(normalizeScope(scopeManager.globalScope), replacer, 4)
 
-    function normalizeScope(scope) {
+    function normalizeScope(scope: Scope): any {
         return {
             type: scope.type,
             variables: scope.variables.map(normalizeVar),
@@ -49,7 +57,7 @@ function scopeToJSON(scopeManager) {
         }
     }
 
-    function normalizeVar(v) {
+    function normalizeVar(v: Variable) {
         return {
             name: v.name,
             identifiers: v.identifiers.map(normalizeId),
@@ -58,7 +66,7 @@ function scopeToJSON(scopeManager) {
         }
     }
 
-    function normalizeReference(reference) {
+    function normalizeReference(reference: any) {
         return {
             identifier: normalizeId(reference.identifier),
             from: reference.from.type,
@@ -75,7 +83,7 @@ function scopeToJSON(scopeManager) {
         }
     }
 
-    function normalizeDef(def) {
+    function normalizeDef(def: VariableDefinition) {
         return {
             type: def.type,
             node: normalizeDefNode(def.node),
@@ -83,7 +91,7 @@ function scopeToJSON(scopeManager) {
         }
     }
 
-    function normalizeId(identifier) {
+    function normalizeId(identifier: Identifier | null) {
         return (
             identifier && {
                 type: identifier.type,
@@ -93,7 +101,7 @@ function scopeToJSON(scopeManager) {
         )
     }
 
-    function normalizeDefNode(node) {
+    function normalizeDefNode(node: Node) {
         return {
             type: node.type,
             loc: node.loc,
@@ -104,7 +112,10 @@ function scopeToJSON(scopeManager) {
 /**
  * Analyze scope
  */
-function analyze(ast, parserOptions) {
+export function analyze(
+    ast: ESLintProgram,
+    parserOptions: ParserOptions,
+): ScopeManager {
     const ecmaVersion = parserOptions.ecmaVersion ?? 2022
     const ecmaFeatures = parserOptions.ecmaFeatures ?? {}
     const sourceType = parserOptions.sourceType ?? "script"
@@ -118,23 +129,4 @@ function analyze(ast, parserOptions) {
     })
 
     return result
-
-    function getFallbackKeys(node) {
-        return Object.keys(node).filter(fallbackKeysFilter, node)
-    }
-
-    function fallbackKeysFilter(key) {
-        const value = null
-        return (
-            key !== "comments" &&
-            key !== "leadingComments" &&
-            key !== "loc" &&
-            key !== "parent" &&
-            key !== "range" &&
-            key !== "tokens" &&
-            key !== "trailingComments" &&
-            typeof value === "object" &&
-            (typeof value.type === "string" || Array.isArray(value))
-        )
-    }
 }
diff --git a/test/tokens.js b/test/tokens.test.ts
similarity index 70%
rename from test/tokens.js
rename to test/tokens.test.ts
index de370298..b7133625 100644
--- a/test/tokens.js
+++ b/test/tokens.test.ts
@@ -3,14 +3,20 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const parse = require("../src").parseForESLint
+import type {
+    ESLintProgram,
+    Token,
+    VElement,
+    VExpressionContainer,
+} from "../src/ast"
+import type TokenStore from "../src/external/token-store"
+import { assert, beforeAll, describe, it } from "vitest"
+import { parseForESLint as parse } from "../src"
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -26,10 +32,10 @@ const PARSER_OPTIONS = {
 
 /**
  * Get the value of the given node.
- * @param {ASTNode} token The node to get value.
- * @returns {string} The value of the node.
+ * @param token The node to get value.
+ * @returns The value of the node.
  */
-function toValue(token) {
+function toValue(token: Token): string {
     if (token.type === "HTMLAssociation") {
         return "="
     }
@@ -48,18 +54,18 @@ describe("services.getTemplateBodyTokenStore", () => {
     <!--comment1-->
     <div a="b" v-show="c &lt; 3 &amp;&amp; ok == &quot;ok&quot;"><!--comment2-->{{ message /*comment3*/ }}<!--comment4--></div>
 </template>`
-    let ast = null
-    let tokens = null
+    let ast: ESLintProgram | null = null
+    let tokens: TokenStore | null = null
 
-    before(() => {
+    beforeAll(() => {
         const result = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS })
         ast = result.ast
-        tokens = result.services.getTemplateBodyTokenStore()
+        tokens = result.services!.getTemplateBodyTokenStore()
     })
 
     describe("ast.templateBody", () => {
         it("should return all tokens (except comments) in the template.", () => {
-            const actual = tokens.getTokens(ast.templateBody).map(toValue)
+            const actual = tokens!.getTokens(ast!.templateBody!).map(toValue)
 
             assert.deepStrictEqual(actual, [
                 "template",
@@ -94,8 +100,8 @@ describe("services.getTemplateBodyTokenStore", () => {
         })
 
         it("should return all tokens (include comments) in the template if you give {includeComments: true} option.", () => {
-            const actual = tokens
-                .getTokens(ast.templateBody, { includeComments: true })
+            const actual = tokens!
+                .getTokens(ast!.templateBody!, { includeComments: true })
                 .map(toValue)
 
             assert.deepStrictEqual(actual, [
@@ -137,8 +143,8 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[0] (VText)", () => {
         it("should return a text token.", () => {
-            const node = ast.templateBody.children[0]
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = ast!.templateBody!.children[0]
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, ["\n    "])
         })
@@ -146,8 +152,8 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2] (VElement)", () => {
         it("should return all tokens in the element.", () => {
-            const node = ast.templateBody.children[2]
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = ast!.templateBody!.children[2]
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, [
                 "div",
@@ -177,8 +183,8 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag (VStartTag)", () => {
         it("should return all tokens in the tag.", () => {
-            const node = ast.templateBody.children[2].startTag
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).startTag
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, [
                 "div",
@@ -203,8 +209,9 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag.attributes[0] (VAttribute)", () => {
         it("should return all tokens in the attribute.", () => {
-            const node = ast.templateBody.children[2].startTag.attributes[0]
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).startTag
+                .attributes[0]
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, ["a", "=", "b"])
         })
@@ -212,8 +219,9 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag.attributes[0].key (VIdentifier)", () => {
         it("should return the identifier token.", () => {
-            const node = ast.templateBody.children[2].startTag.attributes[0].key
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).startTag
+                .attributes[0].key
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, ["a"])
         })
@@ -221,9 +229,9 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag.attributes[0].value (VAttributeValue)", () => {
         it("should return the value token.", () => {
-            const node =
-                ast.templateBody.children[2].startTag.attributes[0].value
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).startTag
+                .attributes[0].value!
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, ["b"])
         })
@@ -231,8 +239,9 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag.attributes[1].key (VDirectiveKey)", () => {
         it("should return the identifier token.", () => {
-            const node = ast.templateBody.children[2].startTag.attributes[1].key
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).startTag
+                .attributes[1].key
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, ["v-show"])
         })
@@ -240,9 +249,9 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag.attributes[1].value (VExpressionContainer)", () => {
         it("should return all tokens in the value.", () => {
-            const node =
-                ast.templateBody.children[2].startTag.attributes[1].value
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).startTag
+                .attributes[1].value!
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, [
                 '"',
@@ -260,10 +269,11 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].startTag.attributes[1].value.expression (BinaryExpression)", () => {
         it("should return all tokens in the expression.", () => {
-            const node =
-                ast.templateBody.children[2].startTag.attributes[1].value
-                    .expression
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (
+                (ast!.templateBody!.children[2] as VElement).startTag
+                    .attributes[1].value as VExpressionContainer
+            ).expression!
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, [
                 "c",
@@ -279,8 +289,8 @@ describe("services.getTemplateBodyTokenStore", () => {
 
     describe("ast.templateBody.children[2].endTag (VEndTag)", () => {
         it("should return all tokens in the tag.", () => {
-            const node = ast.templateBody.children[2].endTag
-            const actual = tokens.getTokens(node).map(toValue)
+            const node = (ast!.templateBody!.children[2] as VElement).endTag!
+            const actual = tokens!.getTokens(node).map(toValue)
 
             assert.deepStrictEqual(actual, ["div", ">"])
         })
@@ -289,15 +299,13 @@ describe("services.getTemplateBodyTokenStore", () => {
     describe("TokenStore#get{Range,Loc}()", () => {
         it("should return loc and range.", () => {
             const {
-                templateBody: {
-                    children: [node],
-                    tokens: [token],
-                },
-            } = ast
-            assert.equal(typeof tokens.getRange(node)[0], "number")
-            assert.equal(typeof tokens.getRange(token)[1], "number")
-            assert.equal(typeof tokens.getLoc(node).start.line, "number")
-            assert.equal(typeof tokens.getLoc(node).end.column, "number")
+                children: [node],
+                tokens: [token],
+            } = ast!.templateBody!
+            assert.equal(typeof tokens!.getRange(node)[0], "number")
+            assert.equal(typeof tokens!.getRange(token)[1], "number")
+            assert.equal(typeof tokens!.getLoc(node).start.line, "number")
+            assert.equal(typeof tokens!.getLoc(node).end.column, "number")
         })
     })
 })
diff --git a/test/variables-references.js b/test/variables-references.test.ts
similarity index 53%
rename from test/variables-references.js
rename to test/variables-references.test.ts
index 4e6a590b..e0a9e765 100644
--- a/test/variables-references.js
+++ b/test/variables-references.test.ts
@@ -3,14 +3,26 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert")
-const parse = require("../src").parseForESLint
+import type {
+    ESLintBinaryExpression,
+    ESLintCallExpression,
+    ESLintExpressionStatement,
+    ESLintProgram,
+    Reference,
+    Variable,
+    VDirective,
+    VElement,
+    VExpressionContainer,
+    VForExpression,
+    VOnExpression,
+} from "../src/ast"
+import { describe, it, assert, beforeAll } from "vitest"
+import { parseForESLint as parse } from "../src"
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -31,65 +43,82 @@ const PARSER_OPTIONS = {
 describe("[references] expression containers", () => {
     describe("in directives", () => {
         const code = '<template><div v-foo="a + b"></div></template>'
-        let ast = null
+        // @ts-expect-error init in beforeAll
+        let ast: ESLintProgram = null
 
-        before(() => {
+        beforeAll(() => {
             ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
         })
 
         it("should have references", () => {
-            const directive =
-                ast.templateBody.children[0].startTag.attributes[0]
+            const element = ast.templateBody!.children[0] as VElement
+            const directive = element.startTag.attributes[0] as VDirective
 
             assert(directive.key.type === "VDirectiveKey")
-            assert(directive.value.references != null)
+            assert(directive.value!.references != null)
             assert(
-                directive.value.references[0].id ===
-                    directive.value.expression.left,
+                directive.value!.references[0].id ===
+                    (directive.value!.expression as ESLintBinaryExpression)
+                        .left,
             )
             assert(
-                directive.value.references[1].id ===
-                    directive.value.expression.right,
+                directive.value!.references[1].id ===
+                    (directive.value!.expression as ESLintBinaryExpression)
+                        .right,
             )
         })
     })
 
     describe("in text", () => {
         const code = "<template>{{a + b}}</template>"
-        let ast = null
+        // @ts-expect-error init in beforeAll
+        let ast: ESLintProgram = null
 
-        before(() => {
+        beforeAll(() => {
             ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
         })
 
         it("should have references", () => {
-            const container = ast.templateBody.children[0]
+            const container = ast.templateBody!
+                .children[0] as VExpressionContainer
 
             assert(container.type === "VExpressionContainer")
             assert(container.references != null)
-            assert(container.references[0].id === container.expression.left)
-            assert(container.references[1].id === container.expression.right)
+            assert(
+                container.references[0].id ===
+                    (container.expression as ESLintBinaryExpression).left,
+            )
+            assert(
+                container.references[1].id ===
+                    (container.expression as ESLintBinaryExpression).right,
+            )
         })
     })
 
     describe("in v-on directive", () => {
         const code = '<template><div @foo="foo($event)"></div></template>'
-        let ast = null
+        // @ts-expect-error init in beforeAll
+        let ast: ESLintProgram = null
 
-        before(() => {
+        beforeAll(() => {
             ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
         })
 
         it("should not include $event references.", () => {
-            const directive =
-                ast.templateBody.children[0].startTag.attributes[0]
+            const element = ast.templateBody!.children[0] as VElement
+            const directive = element.startTag.attributes[0] as VDirective
 
             assert(directive.key.type === "VDirectiveKey")
             assert(directive.key.name.name === "on")
-            assert(directive.value.references.length === 1)
+            assert(directive.value!.references.length === 1)
             assert(
-                directive.value.references[0].id ===
-                    directive.value.expression.body[0].expression.callee,
+                directive.value!.references[0].id ===
+                    (
+                        (
+                            (directive.value!.expression as VOnExpression)
+                                .body[0] as ESLintExpressionStatement
+                        ).expression as ESLintCallExpression
+                    ).callee,
             )
         })
     })
@@ -98,68 +127,61 @@ describe("[references] expression containers", () => {
 describe("[variables] elements", () => {
     describe("which have v-for directive", () => {
         const code = '<template><div v-for="a in b"></div></template>'
-        let ast = null
+        // @ts-expect-error init in beforeAll
+        let ast: ESLintProgram = null
 
-        before(() => {
+        beforeAll(() => {
             ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
         })
 
         it("should have references", () => {
-            const element = ast.templateBody.children[0]
-            const directive = element.startTag.attributes[0]
+            const element = ast.templateBody!.children[0] as VElement
+            const directive = element.startTag.attributes[0] as VDirective
+            const vForExpression = directive.value!.expression as VForExpression
 
             assert(element.type === "VElement")
             assert(element.variables.length === 1)
-            assert(
-                element.variables[0].id === directive.value.expression.left[0],
-            )
-            assert(directive.value.references.length === 1)
-            assert(
-                directive.value.references[0].id ===
-                    directive.value.expression.right,
-            )
+            assert(element.variables[0].id === vForExpression.left[0])
+            assert(directive.value!.references.length === 1)
+            assert(directive.value!.references[0].id === vForExpression.right)
         })
     })
 
     describe("which have v-for directive (with index)", () => {
         const code = '<template><div v-for="(a, i) in b"></div></template>'
-        let ast = null
+        // @ts-expect-error init in beforeAll
+        let ast: ESLintProgram = null
 
-        before(() => {
+        beforeAll(() => {
             ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
         })
 
         it("should have references", () => {
-            const element = ast.templateBody.children[0]
-            const directive = element.startTag.attributes[0]
+            const element = ast.templateBody!.children[0] as VElement
+            const directive = element.startTag.attributes[0] as VDirective
+            const vForExpression = directive.value!.expression as VForExpression
 
             assert(element.type === "VElement")
             assert(element.variables.length === 2)
-            assert(
-                element.variables[0].id === directive.value.expression.left[0],
-            )
-            assert(
-                element.variables[1].id === directive.value.expression.left[1],
-            )
-            assert(directive.value.references.length === 1)
-            assert(
-                directive.value.references[0].id ===
-                    directive.value.expression.right,
-            )
+            assert(element.variables[0].id === vForExpression.left[0])
+            assert(element.variables[1].id === vForExpression.left[1])
+            assert(directive.value!.references.length === 1)
+            assert(directive.value!.references[0].id === vForExpression.right)
         })
     })
 
     describe("which have scope attribute", () => {
         const code = '<template><template scope="a"></template></template>'
-        let ast = null
+        // @ts-expect-error init in beforeAll
+        let ast: ESLintProgram = null
 
-        before(() => {
+        beforeAll(() => {
             ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
         })
 
         it("should have variables", () => {
-            const element = ast.templateBody.children[0]
-            const attribute = element.startTag.attributes[0]
+            const element = ast.templateBody!.children[0] as VElement
+            const attribute = element.startTag.attributes[0] as VDirective
 
             assert(element.type === "VElement")
             assert(element.variables.length === 1)
@@ -167,10 +189,10 @@ describe("[variables] elements", () => {
             assert(element.variables[0].id.range[0] === 27)
             assert(element.variables[0].id.range[1] === 28)
             assert(element.variables[0].kind === "scope")
-            assert(attribute.value.type === "VExpressionContainer")
-            assert(attribute.value.expression.type === "VSlotScopeExpression")
-            assert(attribute.value.expression.params[0].type === "Identifier")
-            assert(attribute.value.expression.params[0].name === "a")
+            assert(attribute.value!.type === "VExpressionContainer")
+            assert(attribute.value!.expression!.type === "VSlotScopeExpression")
+            assert(attribute.value!.expression.params[0].type === "Identifier")
+            assert(attribute.value!.expression.params[0].name === "a")
         })
     })
 })
@@ -178,25 +200,38 @@ describe("[variables] elements", () => {
 describe("Variables of v-for and references", () => {
     const code =
         '<template><div v-for="x of xs" :key="x">{{x + y}}<div>{{x}}</div></div>{{x}}</template>'
-    let variables = null
-    let vForReferences = null
-    let vBindKeyReferences = null
-    let mustacheReferences1 = null
-    let mustacheReferences2 = null
-    let mustacheReferences3 = null
-
-    before(() => {
+    // @ts-expect-error init in beforeAll
+    let variables: Variable[] = null
+    // @ts-expect-error init in beforeAll
+    let vForReferences: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let vBindKeyReferences: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let mustacheReferences1: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let mustacheReferences2: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let mustacheReferences3: Reference[] = null
+
+    beforeAll(() => {
         const ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
-        variables = ast.templateBody.children[0].variables
-        vForReferences =
-            ast.templateBody.children[0].startTag.attributes[0].value.references
-        vBindKeyReferences =
-            ast.templateBody.children[0].startTag.attributes[1].value.references
-        mustacheReferences1 =
-            ast.templateBody.children[0].children[0].references
-        mustacheReferences2 =
-            ast.templateBody.children[0].children[1].children[0].references
-        mustacheReferences3 = ast.templateBody.children[1].references
+        const firstChild = ast.templateBody!.children[0] as VElement
+        const secondChild = ast.templateBody!
+            .children[1] as VExpressionContainer
+        variables = firstChild.variables
+        vForReferences = (
+            firstChild.startTag.attributes[0].value as VExpressionContainer
+        ).references
+        vBindKeyReferences = (
+            firstChild.startTag.attributes[1].value as VExpressionContainer
+        ).references
+        mustacheReferences1 = (firstChild.children[0] as VExpressionContainer)
+            .references
+        mustacheReferences2 = (
+            (firstChild.children[1] as VElement)
+                .children[0] as VExpressionContainer
+        ).references
+        mustacheReferences3 = secondChild.references
     })
 
     it("should have relationship each other", () => {
@@ -221,14 +256,14 @@ describe("Variables of v-for and references", () => {
     it("`Variable#references` should be non-enumerable", () => {
         for (const variable of variables) {
             assert(
-                Object.getOwnPropertyDescriptor(variable, "references")
+                Object.getOwnPropertyDescriptor(variable, "references")!
                     .enumerable === false,
             )
         }
     })
 
     it("`Reference#variable` should be non-enumerable", () => {
-        for (const reference of [].concat(
+        for (const reference of ([] as Reference[]).concat(
             vForReferences,
             vBindKeyReferences,
             mustacheReferences1,
@@ -236,7 +271,7 @@ describe("Variables of v-for and references", () => {
             mustacheReferences3,
         )) {
             assert(
-                Object.getOwnPropertyDescriptor(reference, "variable")
+                Object.getOwnPropertyDescriptor(reference, "variable")!
                     .enumerable === false,
             )
         }
@@ -246,22 +281,33 @@ describe("Variables of v-for and references", () => {
 describe("Variables of template-scope and references", () => {
     const code =
         '<template><template scope="x" :key="x">{{x + y}}<div>{{x}}</div></template>{{x}}</template>'
-    let variables = null
-    let vBindKeyReferences = null
-    let mustacheReferences1 = null
-    let mustacheReferences2 = null
-    let mustacheReferences3 = null
-
-    before(() => {
+    // @ts-expect-error init in beforeAll
+    let variables: Variable[] = null
+    // @ts-expect-error init in beforeAll
+    let vBindKeyReferences: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let mustacheReferences1: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let mustacheReferences2: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let mustacheReferences3: Reference[] = null
+
+    beforeAll(() => {
         const ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
-        variables = ast.templateBody.children[0].variables
-        vBindKeyReferences =
-            ast.templateBody.children[0].startTag.attributes[1].value.references
-        mustacheReferences1 =
-            ast.templateBody.children[0].children[0].references
-        mustacheReferences2 =
-            ast.templateBody.children[0].children[1].children[0].references
-        mustacheReferences3 = ast.templateBody.children[1].references
+        const element = ast.templateBody!.children[0] as VElement
+        const secondElement = ast.templateBody!
+            .children[1] as VExpressionContainer
+
+        variables = element.variables
+        vBindKeyReferences = (element.startTag.attributes[1] as VDirective)
+            .value!.references
+        mustacheReferences1 = (element.children[0] as VExpressionContainer)
+            .references
+        mustacheReferences2 = (
+            (element.children[1] as VElement)
+                .children[0] as VExpressionContainer
+        ).references
+        mustacheReferences3 = secondElement.references
     })
 
     it("should have relationship each other", () => {
@@ -284,21 +330,21 @@ describe("Variables of template-scope and references", () => {
     it("`Variable#references` should be non-enumerable", () => {
         for (const variable of variables) {
             assert(
-                Object.getOwnPropertyDescriptor(variable, "references")
+                Object.getOwnPropertyDescriptor(variable, "references")!
                     .enumerable === false,
             )
         }
     })
 
     it("`Reference#variable` should be non-enumerable", () => {
-        for (const reference of [].concat(
+        for (const reference of ([] as Reference[]).concat(
             vBindKeyReferences,
             mustacheReferences1,
             mustacheReferences2,
             mustacheReferences3,
         )) {
             assert(
-                Object.getOwnPropertyDescriptor(reference, "variable")
+                Object.getOwnPropertyDescriptor(reference, "variable")!
                     .enumerable === false,
             )
         }
@@ -307,18 +353,24 @@ describe("Variables of template-scope and references", () => {
 
 describe("Variables of v-for and references of dynamic arguments", () => {
     const code = '<template><div v-for="x of xs" :[x]="1" /></template>'
-    let variables = null
-    let vForReferences = null
-    let vBindKeyReferences = null
-
-    before(() => {
+    // @ts-expect-error init in beforeAll
+    let variables: Variable[] = null
+    // @ts-expect-error init in beforeAll
+    let vForReferences: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let vBindKeyReferences: Reference[] = null
+
+    beforeAll(() => {
         const ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
-        variables = ast.templateBody.children[0].variables
-        vForReferences =
-            ast.templateBody.children[0].startTag.attributes[0].value.references
-        vBindKeyReferences =
-            ast.templateBody.children[0].startTag.attributes[1].key.argument
-                .references
+        const element = ast.templateBody!.children[0] as VElement
+
+        variables = element.variables
+        vForReferences = (element.startTag.attributes[0] as VDirective).value!
+            .references
+        vBindKeyReferences = (
+            (element.startTag.attributes[1] as VDirective).key
+                .argument as VExpressionContainer
+        ).references
     })
 
     it("should have relationship each other", () => {
@@ -334,17 +386,22 @@ describe("Variables of v-for and references of dynamic arguments", () => {
 
 describe("Variables of v-for and references of v-bind same-name shorthand", () => {
     const code = '<template><div v-for="x of xs" :x /></template>'
-    let variables = null
-    let vForReferences = null
-    let vBindReferences = null
-
-    before(() => {
+    // @ts-expect-error init in beforeAll
+    let variables: Variable[] = null
+    // @ts-expect-error init in beforeAll
+    let vForReferences: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let vBindReferences: Reference[] = null
+
+    beforeAll(() => {
         const ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
-        variables = ast.templateBody.children[0].variables
-        vForReferences =
-            ast.templateBody.children[0].startTag.attributes[0].value.references
-        vBindReferences =
-            ast.templateBody.children[0].startTag.attributes[1].value.references
+        const element = ast.templateBody!.children[0] as VElement
+
+        variables = element.variables
+        vForReferences = (element.startTag.attributes[0] as VDirective).value!
+            .references
+        vBindReferences = (element.startTag.attributes[1] as VDirective).value!
+            .references
     })
 
     it("should have relationship each other", () => {
@@ -360,17 +417,22 @@ describe("Variables of v-for and references of v-bind same-name shorthand", () =
 
 describe("Variables of v-for and references of v-bind same-name shorthand with kebab-case", () => {
     const code = '<template><div v-for="dataXx of xs" :data-xx /></template>'
-    let variables = null
-    let vForReferences = null
-    let vBindReferences = null
-
-    before(() => {
+    // @ts-expect-error init in beforeAll
+    let variables: Variable[] = null
+    // @ts-expect-error init in beforeAll
+    let vForReferences: Reference[] = null
+    // @ts-expect-error init in beforeAll
+    let vBindReferences: Reference[] = null
+
+    beforeAll(() => {
         const ast = parse(code, { filePath: "test.vue", ...PARSER_OPTIONS }).ast
-        variables = ast.templateBody.children[0].variables
-        vForReferences =
-            ast.templateBody.children[0].startTag.attributes[0].value.references
-        vBindReferences =
-            ast.templateBody.children[0].startTag.attributes[1].value.references
+        const element = ast.templateBody!.children[0] as VElement
+
+        variables = element.variables
+        vForReferences = (element.startTag.attributes[0] as VDirective).value!
+            .references
+        vBindReferences = (element.startTag.attributes[1] as VDirective).value!
+            .references
     })
 
     it("should have relationship each other", () => {
diff --git a/tsconfig.json b/tsconfig.json
index e4cbfcc2..677d8fec 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -12,7 +12,7 @@
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "inlineSources": true,
-    "lib": ["es2015"],
+    "lib": ["es2023"],
     "module": "commonjs",
     "moduleResolution": "node",
     "newLine": "LF",
@@ -37,5 +37,6 @@
 
     "skipLibCheck": true
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts"],
+  "references": [{ "path": "./tsconfig.test.json" }]
 }
diff --git a/tsconfig.test.json b/tsconfig.test.json
new file mode 100644
index 00000000..a5e080f7
--- /dev/null
+++ b/tsconfig.test.json
@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "paths": {
+      "*": ["typings/*"]
+    },
+    "module": "esnext",
+    "moduleResolution": "Bundler"
+  },
+  "include": ["test/**/*.ts", "vitest.config.ts"]
+}
diff --git a/typings/eslint-scope/index.d.ts b/typings/eslint-scope/index.d.ts
index 6d14afcf..1469f501 100644
--- a/typings/eslint-scope/index.d.ts
+++ b/typings/eslint-scope/index.d.ts
@@ -14,7 +14,7 @@ export interface AnalysisOptions {
     impliedStrict?: boolean
     fallback?: string | Function
     sourceType?: "script" | "module"
-    ecmaVersion?: number
+    ecmaVersion?: number | "latest"
     childVisitorKeys?: VisitorKeys
 }
 
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 00000000..9df42d5d
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+    test: {
+        reporters: "dot",
+        include: ["test/**/*.test.ts"],
+        testTimeout: 60000,
+        coverage: {
+            include: ["src/**/*.ts"],
+            exclude: ["src/external/**/*.ts"],
+            reporter: ["html", "lcov", "text-summary"],
+        },
+    },
+})