diff --git a/lib/configs/all.ts b/lib/configs/all.ts
index 030ee798..0afe7a19 100644
--- a/lib/configs/all.ts
+++ b/lib/configs/all.ts
@@ -1,6 +1,6 @@
-import { collectRules } from "../utils/rules"
+import { collectRules } from "../utils/rules";
 
 export = {
-    extends: require.resolve("./base"),
-    rules: collectRules(),
-}
+  extends: require.resolve("./base"),
+  rules: collectRules(),
+};
diff --git a/lib/configs/base.ts b/lib/configs/base.ts
index e3c1cef2..e19f6b8f 100644
--- a/lib/configs/base.ts
+++ b/lib/configs/base.ts
@@ -1,4 +1,4 @@
 export = {
-    parser: require.resolve("vue-eslint-parser"),
-    plugins: ["vue-scoped-css"],
-}
+  parser: require.resolve("vue-eslint-parser"),
+  plugins: ["vue-scoped-css"],
+};
diff --git a/lib/configs/recommended.ts b/lib/configs/recommended.ts
index 26094168..cd698fdb 100644
--- a/lib/configs/recommended.ts
+++ b/lib/configs/recommended.ts
@@ -1,6 +1,6 @@
-import { collectRules } from "../utils/rules"
+import { collectRules } from "../utils/rules";
 
 export = {
-    extends: require.resolve("./base"),
-    rules: collectRules("recommended"),
-}
+  extends: require.resolve("./base"),
+  rules: collectRules("recommended"),
+};
diff --git a/lib/configs/vue3-recommended.ts b/lib/configs/vue3-recommended.ts
index ae9d7e17..a96414de 100644
--- a/lib/configs/vue3-recommended.ts
+++ b/lib/configs/vue3-recommended.ts
@@ -1,6 +1,6 @@
-import { collectRules } from "../utils/rules"
+import { collectRules } from "../utils/rules";
 
 export = {
-    extends: require.resolve("./base"),
-    rules: collectRules("vue3-recommended"),
-}
+  extends: require.resolve("./base"),
+  rules: collectRules("vue3-recommended"),
+};
diff --git a/lib/index.ts b/lib/index.ts
index 8a2be93f..5542716d 100644
--- a/lib/index.ts
+++ b/lib/index.ts
@@ -1,19 +1,19 @@
-import { rules as ruleList } from "./utils/rules"
-import type { Rule } from "./types"
+import { rules as ruleList } from "./utils/rules";
+import type { Rule } from "./types";
 
 const configs = {
-    base: require("./configs/base"),
-    recommended: require("./configs/recommended"),
-    "vue3-recommended": require("./configs/vue3-recommended"),
-    all: require("./configs/all"),
-}
+  base: require("./configs/base"),
+  recommended: require("./configs/recommended"),
+  "vue3-recommended": require("./configs/vue3-recommended"),
+  all: require("./configs/all"),
+};
 
 const rules = ruleList.reduce((obj, r) => {
-    obj[r.meta.docs?.ruleName || ""] = r
-    return obj
-}, {} as { [key: string]: Rule })
+  obj[r.meta.docs?.ruleName || ""] = r;
+  return obj;
+}, {} as { [key: string]: Rule });
 
 export = {
-    configs,
-    rules,
-}
+  configs,
+  rules,
+};
diff --git a/lib/options.ts b/lib/options.ts
index 70aec52e..5988d938 100644
--- a/lib/options.ts
+++ b/lib/options.ts
@@ -1,26 +1,26 @@
-import { toRegExp } from "./utils/regexp"
+import { toRegExp } from "./utils/regexp";
 
 export interface QueryOptions {
-    ignoreBEMModifier?: boolean
-    captureClassesFromDoc?: string[]
+  ignoreBEMModifier?: boolean;
+  captureClassesFromDoc?: string[];
 }
 
 export interface ParsedQueryOptions {
-    ignoreBEMModifier: boolean
-    captureClassesFromDoc: RegExp[]
+  ignoreBEMModifier: boolean;
+  captureClassesFromDoc: RegExp[];
 }
 
 /**
  * Parse options
  */
 export function parseQueryOptions(
-    options: QueryOptions | undefined,
+  options: QueryOptions | undefined
 ): ParsedQueryOptions {
-    const { ignoreBEMModifier, captureClassesFromDoc } = options || {}
+  const { ignoreBEMModifier, captureClassesFromDoc } = options || {};
 
-    return {
-        ignoreBEMModifier: ignoreBEMModifier ?? false,
-        captureClassesFromDoc:
-            captureClassesFromDoc?.map((s) => toRegExp(s, "g")) ?? [],
-    }
+  return {
+    ignoreBEMModifier: ignoreBEMModifier ?? false,
+    captureClassesFromDoc:
+      captureClassesFromDoc?.map((s) => toRegExp(s, "g")) ?? [],
+  };
 }
diff --git a/lib/rules/enforce-style-type.ts b/lib/rules/enforce-style-type.ts
index 1df809f2..aa268d4c 100644
--- a/lib/rules/enforce-style-type.ts
+++ b/lib/rules/enforce-style-type.ts
@@ -1,256 +1,232 @@
-import lodash from "lodash"
-import type { RuleContext, AST, TokenStore, Rule, RuleFixer } from "../types"
+import lodash from "lodash";
+import type { RuleContext, AST, TokenStore, Rule, RuleFixer } from "../types";
 import {
-    getStyleContexts,
-    isValidStyleContext,
-    getCommentDirectivesReporter,
-} from "../styles/context"
+  getStyleContexts,
+  isValidStyleContext,
+  getCommentDirectivesReporter,
+} from "../styles/context";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
-const styleTypesAttrs = ["scoped", "module"] as const
-type StyleTypes = "plain" | typeof styleTypesAttrs[number]
-type AllowsOption = StyleTypes[]
+const styleTypesAttrs = ["scoped", "module"] as const;
+type StyleTypes = "plain" | typeof styleTypesAttrs[number];
+type AllowsOption = StyleTypes[];
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "enforce the `<style>` tags to be plain or have the `scoped` or `module` attribute",
-            categories: ["recommended", "vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/enforce-style-type.html",
-            suggestion: true,
-        },
-        fixable: null,
-        messages: {
-            add: "Add attribute `{{ attribute }}`.",
-            remove: "Remove attribute `{{ attribute }}`.",
-            removeMultiple: "Remove attributes {{ attributes }}.",
-            change: "Change `{{ fromAttribute }}` to `{{ toAttribute }}` attribute.",
-            forbiddenStyle: "`{{ attribute }}` attribute is forbidden.",
-            forbiddenPlain: "Missing attribute {{ attributes }}.",
-            forbiddenScopedModule:
-                "Cannot use both `scoped` and `module` attributes.",
-        },
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allows: {
-                        type: "array",
-                        minItems: 1,
-                        uniqueItems: true,
-                        items: {
-                            type: "string",
-                            enum: ["plain", "scoped", "module"],
-                        },
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        type: "suggestion",
-        hasSuggestions: true,
+  meta: {
+    docs: {
+      description:
+        "enforce the `<style>` tags to be plain or have the `scoped` or `module` attribute",
+      categories: ["recommended", "vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/enforce-style-type.html",
+      suggestion: true,
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context).filter(isValidStyleContext)
-        if (!styles.length) {
-            return {}
-        }
+    fixable: null,
+    messages: {
+      add: "Add attribute `{{ attribute }}`.",
+      remove: "Remove attribute `{{ attribute }}`.",
+      removeMultiple: "Remove attributes {{ attributes }}.",
+      change: "Change `{{ fromAttribute }}` to `{{ toAttribute }}` attribute.",
+      forbiddenStyle: "`{{ attribute }}` attribute is forbidden.",
+      forbiddenPlain: "Missing attribute {{ attributes }}.",
+      forbiddenScopedModule:
+        "Cannot use both `scoped` and `module` attributes.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allows: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+            items: {
+              type: "string",
+              enum: ["plain", "scoped", "module"],
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    type: "suggestion",
+    hasSuggestions: true,
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context).filter(isValidStyleContext);
+    if (!styles.length) {
+      return {};
+    }
 
-        const reporter = getCommentDirectivesReporter(context)
-        const tokenStore =
-            context.parserServices.getTemplateBodyTokenStore?.() as TokenStore
-        const { options } = context
+    const reporter = getCommentDirectivesReporter(context);
+    const tokenStore =
+      context.parserServices.getTemplateBodyTokenStore?.() as TokenStore;
+    const { options } = context;
 
-        const allows: AllowsOption = options[0]?.allows ?? ["scoped"]
-        const singleAllow = allows.length === 1 && allows[0]
+    const allows: AllowsOption = options[0]?.allows ?? ["scoped"];
+    const singleAllow = allows.length === 1 && allows[0];
 
-        /**
-         * Fixer util to remove an attribute/directive and whitespace
-         * @param {RuleFixer} fixer
-         * @param {AST.VElement | AST.VDirective} node
-         */
-        function removeAttr(
-            fixer: RuleFixer,
-            node: AST.VAttribute | AST.VDirective,
-        ) {
-            const { attributes } = node.parent
-            const prevToken = tokenStore.getTokenBefore(node)
-            const nextToken = tokenStore.getTokenAfter(node)
-            return [
-                // Remove whitespace + node (+ whitespace)
-                fixer.removeRange([
-                    prevToken.range[1],
-                    attributes.length === 1
-                        ? nextToken.range[0]
-                        : node.range[1],
-                ]),
-            ]
-        }
+    /**
+     * Fixer util to remove an attribute/directive and whitespace
+     * @param {RuleFixer} fixer
+     * @param {AST.VElement | AST.VDirective} node
+     */
+    function removeAttr(
+      fixer: RuleFixer,
+      node: AST.VAttribute | AST.VDirective
+    ) {
+      const { attributes } = node.parent;
+      const prevToken = tokenStore.getTokenBefore(node);
+      const nextToken = tokenStore.getTokenAfter(node);
+      return [
+        // Remove whitespace + node (+ whitespace)
+        fixer.removeRange([
+          prevToken.range[1],
+          attributes.length === 1 ? nextToken.range[0] : node.range[1],
+        ]),
+      ];
+    }
 
-        /**
-         * Reports the given node.
-         * @param {AST.VElement} node node to report
-         * @param {StyleTypes} attribute type of style
-         */
-        function reportForbiddenStyle(
-            node: AST.VElement,
-            attribute: StyleTypes,
-        ) {
-            const forbiddenAttr = node.startTag.attributes.find(
-                (attr) => attr.key.name === attribute,
-            )
-            const forbiddenAttrName = forbiddenAttr!.key.name as string
+    /**
+     * Reports the given node.
+     * @param {AST.VElement} node node to report
+     * @param {StyleTypes} attribute type of style
+     */
+    function reportForbiddenStyle(node: AST.VElement, attribute: StyleTypes) {
+      const forbiddenAttr = node.startTag.attributes.find(
+        (attr) => attr.key.name === attribute
+      );
+      const forbiddenAttrName = forbiddenAttr!.key.name as string;
 
-            reporter.report({
-                node: forbiddenAttr!,
-                messageId: "forbiddenStyle",
+      reporter.report({
+        node: forbiddenAttr!,
+        messageId: "forbiddenStyle",
+        data: {
+          attribute,
+        },
+        suggest: [
+          singleAllow && singleAllow !== "plain"
+            ? {
+                messageId: "change",
                 data: {
-                    attribute,
+                  fromAttribute: forbiddenAttrName,
+                  toAttribute: singleAllow,
                 },
-                suggest: [
-                    singleAllow && singleAllow !== "plain"
-                        ? {
-                              messageId: "change",
-                              data: {
-                                  fromAttribute: forbiddenAttrName,
-                                  toAttribute: singleAllow,
-                              },
-                              fix(fixer: RuleFixer) {
-                                  return fixer.replaceText(
-                                      forbiddenAttr,
-                                      singleAllow,
-                                  )
-                              },
-                          }
-                        : {
-                              messageId: "remove",
-                              data: {
-                                  attribute: forbiddenAttrName,
-                              },
-                              fix(fixer: RuleFixer) {
-                                  return removeAttr(fixer, forbiddenAttr!)
-                              },
-                          },
-                ],
-            })
-        }
+                fix(fixer: RuleFixer) {
+                  return fixer.replaceText(forbiddenAttr, singleAllow);
+                },
+              }
+            : {
+                messageId: "remove",
+                data: {
+                  attribute: forbiddenAttrName,
+                },
+                fix(fixer: RuleFixer) {
+                  return removeAttr(fixer, forbiddenAttr!);
+                },
+              },
+        ],
+      });
+    }
 
-        /**
-         * Reports the given node.
-         * @param {AST.VElement} node node to report
-         */
-        function reportForbiddenPlain(node: AST.VElement) {
-            reporter.report({
-                node: node.startTag,
-                messageId: "forbiddenPlain",
+    /**
+     * Reports the given node.
+     * @param {AST.VElement} node node to report
+     */
+    function reportForbiddenPlain(node: AST.VElement) {
+      reporter.report({
+        node: node.startTag,
+        messageId: "forbiddenPlain",
+        data: {
+          attributes: allows.map((allow) => `\`${allow}\``).join(" or "),
+        },
+        suggest: singleAllow
+          ? [
+              {
+                messageId: "add",
                 data: {
-                    attributes: allows
-                        .map((allow) => `\`${allow}\``)
-                        .join(" or "),
+                  attribute: singleAllow,
                 },
-                suggest: singleAllow
-                    ? [
-                          {
-                              messageId: "add",
-                              data: {
-                                  attribute: singleAllow,
-                              },
-                              fix(fixer: RuleFixer) {
-                                  const close = tokenStore.getLastToken(
-                                      node.startTag,
-                                  )
-                                  return (
-                                      close &&
-                                      fixer.insertTextBefore(
-                                          close,
-                                          ` ${singleAllow}`,
-                                      )
-                                  )
-                              },
-                          },
-                      ]
-                    : undefined,
-            })
-        }
+                fix(fixer: RuleFixer) {
+                  const close = tokenStore.getLastToken(node.startTag);
+                  return (
+                    close && fixer.insertTextBefore(close, ` ${singleAllow}`)
+                  );
+                },
+              },
+            ]
+          : undefined,
+      });
+    }
 
-        /**
-         * Reports the given node.
-         * @param {AST.VElement} node node to report
-         */
-        function reportForbiddenScopedModule(node: AST.VElement) {
-            const forbiddenAttrs = node.startTag.attributes.filter(
-                (attr) =>
-                    styleTypesAttrs.includes(
-                        attr.key.name as typeof styleTypesAttrs[number],
-                    ) && !allows.includes(attr.key.name as StyleTypes),
-            )
+    /**
+     * Reports the given node.
+     * @param {AST.VElement} node node to report
+     */
+    function reportForbiddenScopedModule(node: AST.VElement) {
+      const forbiddenAttrs = node.startTag.attributes.filter(
+        (attr) =>
+          styleTypesAttrs.includes(
+            attr.key.name as typeof styleTypesAttrs[number]
+          ) && !allows.includes(attr.key.name as StyleTypes)
+      );
 
-            reporter.report({
-                node: node.startTag,
-                messageId: "forbiddenScopedModule",
-                suggest: forbiddenAttrs.length
-                    ? [
-                          forbiddenAttrs.length === 1
-                              ? {
-                                    messageId: "remove",
-                                    data: {
-                                        attribute:
-                                            forbiddenAttrs[0].key.name.toString(),
-                                    },
-                                    fix(fixer: RuleFixer) {
-                                        return removeAttr(
-                                            fixer,
-                                            forbiddenAttrs[0],
-                                        )
-                                    },
-                                }
-                              : {
-                                    messageId: "removeMultiple",
-                                    data: {
-                                        attributes: forbiddenAttrs
-                                            .map(
-                                                (attr) =>
-                                                    `\`${attr.key.name}\``,
-                                            )
-                                            .join(", "),
-                                    },
-                                    fix(fixer: RuleFixer) {
-                                        return lodash.flatMap(
-                                            forbiddenAttrs,
-                                            (attr) => removeAttr(fixer, attr),
-                                        )
-                                    },
-                                },
-                      ]
-                    : undefined,
-            })
-        }
+      reporter.report({
+        node: node.startTag,
+        messageId: "forbiddenScopedModule",
+        suggest: forbiddenAttrs.length
+          ? [
+              forbiddenAttrs.length === 1
+                ? {
+                    messageId: "remove",
+                    data: {
+                      attribute: forbiddenAttrs[0].key.name.toString(),
+                    },
+                    fix(fixer: RuleFixer) {
+                      return removeAttr(fixer, forbiddenAttrs[0]);
+                    },
+                  }
+                : {
+                    messageId: "removeMultiple",
+                    data: {
+                      attributes: forbiddenAttrs
+                        .map((attr) => `\`${attr.key.name}\``)
+                        .join(", "),
+                    },
+                    fix(fixer: RuleFixer) {
+                      return lodash.flatMap(forbiddenAttrs, (attr) =>
+                        removeAttr(fixer, attr)
+                      );
+                    },
+                  },
+            ]
+          : undefined,
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    if (style.scoped && style.module) {
-                        reportForbiddenScopedModule(style.styleElement)
-                    } else if (style.scoped) {
-                        if (!allows.includes("scoped")) {
-                            reportForbiddenStyle(style.styleElement, "scoped")
-                        }
-                    } else if (style.module) {
-                        if (!allows.includes("module")) {
-                            reportForbiddenStyle(style.styleElement, "module")
-                        }
-                    } else {
-                        if (!allows.includes("plain")) {
-                            reportForbiddenPlain(style.styleElement)
-                        }
-                    }
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          if (style.scoped && style.module) {
+            reportForbiddenScopedModule(style.styleElement);
+          } else if (style.scoped) {
+            if (!allows.includes("scoped")) {
+              reportForbiddenStyle(style.styleElement, "scoped");
+            }
+          } else if (style.module) {
+            if (!allows.includes("module")) {
+              reportForbiddenStyle(style.styleElement, "module");
+            }
+          } else {
+            if (!allows.includes("plain")) {
+              reportForbiddenPlain(style.styleElement);
+            }
+          }
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/no-deprecated-deep-combinator.ts b/lib/rules/no-deprecated-deep-combinator.ts
index 31331a57..2e9f5ed1 100644
--- a/lib/rules/no-deprecated-deep-combinator.ts
+++ b/lib/rules/no-deprecated-deep-combinator.ts
@@ -1,88 +1,88 @@
-import type { ValidStyleContext } from "../styles/context"
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-    isValidStyleContext,
-} from "../styles/context"
-import type { VCSSSelectorCombinator } from "../styles/ast"
-import type { RuleContext, Rule, Range } from "../types"
-import { isDeepCombinator } from "../styles/utils/selectors"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+  isValidStyleContext,
+} from "../styles/context";
+import type { VCSSSelectorCombinator } from "../styles/ast";
+import type { RuleContext, Rule, Range } from "../types";
+import { isDeepCombinator } from "../styles/utils/selectors";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description: "disallow using deprecated deep combinators",
-            categories: ["vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-deprecated-deep-combinator.html",
-        },
-        fixable: "code",
-        messages: {
-            deprecated: "The deep combinator `{{value}}` is deprecated.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "disallow using deprecated deep combinators",
+      categories: ["vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-deprecated-deep-combinator.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: "code",
+    messages: {
+      deprecated: "The deep combinator `{{value}}` is deprecated.",
+    },
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VCSSSelectorCombinator) {
-            reporter.report({
-                node,
-                loc: node.loc,
-                messageId: "deprecated",
-                data: {
-                    value: node.value.trim(),
-                },
-                fix(fixer) {
-                    const sourceCodeText = context.getSourceCode().text
-                    const range = [...node.range] as Range
-                    let newText = "::v-deep"
-                    if (sourceCodeText[range[0] - 1]?.trim()) {
-                        newText = ` ${newText}`
-                    }
-                    if (sourceCodeText[range[1]]?.trim()) {
-                        newText = `${newText} `
-                    }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VCSSSelectorCombinator) {
+      reporter.report({
+        node,
+        loc: node.loc,
+        messageId: "deprecated",
+        data: {
+          value: node.value.trim(),
+        },
+        fix(fixer) {
+          const sourceCodeText = context.getSourceCode().text;
+          const range = [...node.range] as Range;
+          let newText = "::v-deep";
+          if (sourceCodeText[range[0] - 1]?.trim()) {
+            newText = ` ${newText}`;
+          }
+          if (sourceCodeText[range[1]]?.trim()) {
+            newText = `${newText} `;
+          }
 
-                    return fixer.replaceTextRange(range, newText)
-                },
-            })
-        }
+          return fixer.replaceTextRange(range, newText);
+        },
+      });
+    }
 
-        /**
-         * Verify the style
-         */
-        function verify(style: ValidStyleContext) {
-            style.traverseSelectorNodes({
-                enterNode(node) {
-                    if (isDeepCombinator(node)) {
-                        report(node)
-                    }
-                },
-            })
-        }
+    /**
+     * Verify the style
+     */
+    function verify(style: ValidStyleContext) {
+      style.traverseSelectorNodes({
+        enterNode(node) {
+          if (isDeepCombinator(node)) {
+            report(node);
+          }
+        },
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    verify(style)
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          verify(style);
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/no-deprecated-v-enter-v-leave-class.ts b/lib/rules/no-deprecated-v-enter-v-leave-class.ts
index 2876ebea..3a5b854c 100644
--- a/lib/rules/no-deprecated-v-enter-v-leave-class.ts
+++ b/lib/rules/no-deprecated-v-enter-v-leave-class.ts
@@ -1,280 +1,261 @@
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-    isValidStyleContext,
-} from "../styles/context"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+  isValidStyleContext,
+} from "../styles/context";
 import type {
-    VCSSSelectorNode,
-    VCSSNode,
-    VCSSClassSelector,
-} from "../styles/ast"
-import type { RuleContext, Rule, AST } from "../types"
+  VCSSSelectorNode,
+  VCSSNode,
+  VCSSClassSelector,
+} from "../styles/ast";
+import type { RuleContext, Rule, AST } from "../types";
 import {
-    getElements,
-    isTransitionElement,
-    isTransitionGroupElement,
-    findAttribute,
-} from "../utils/templates"
-import { getAttributeValueNodes } from "../styles/selectors/query/attribute-tracker"
-import { Template } from "../styles/template"
-import { isDeepCombinator, isVueSpecialPseudo } from "../styles/utils/selectors"
-import { isVCSSAtRule } from "../styles/utils/css-nodes"
+  getElements,
+  isTransitionElement,
+  isTransitionGroupElement,
+  findAttribute,
+} from "../utils/templates";
+import { getAttributeValueNodes } from "../styles/selectors/query/attribute-tracker";
+import { Template } from "../styles/template";
+import {
+  isDeepCombinator,
+  isVueSpecialPseudo,
+} from "../styles/utils/selectors";
+import { isVCSSAtRule } from "../styles/utils/css-nodes";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description: "disallow v-enter and v-leave classes.",
-            categories: [],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-deprecated-v-enter-v-leave-class.html",
-        },
-        fixable: null,
-        messages: {
-            deprecatedClass: "The `v-{{kind}}` class is renamed in Vue 3.",
-            deprecatedProps:
-                "The `{{kind}}-class` prop is renamed in Vue 3. Rename to `{{kind}}-from-class`.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "disallow v-enter and v-leave classes.",
+      categories: [],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-deprecated-v-enter-v-leave-class.html",
+    },
+    fixable: null,
+    messages: {
+      deprecatedClass: "The `v-{{kind}}` class is renamed in Vue 3.",
+      deprecatedProps:
+        "The `{{kind}}-class` prop is renamed in Vue 3. Rename to `{{kind}}-from-class`.",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        const reporter = getCommentDirectivesReporter(context)
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    const reporter = getCommentDirectivesReporter(context);
 
-        type Kind = "enter" | "leave"
-        const deprecatedClassNames = new Map<
-            string | Template,
-            { className: Template; kind: Kind }
-        >()
-        const renamedClassNames = new Map<
-            string | Template,
-            { className: Template }
-        >()
+    type Kind = "enter" | "leave";
+    const deprecatedClassNames = new Map<
+      string | Template,
+      { className: Template; kind: Kind }
+    >();
+    const renamedClassNames = new Map<
+      string | Template,
+      { className: Template }
+    >();
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(
-            node: VCSSSelectorNode | AST.VIdentifier | AST.VDirectiveKey,
-            messageId: "deprecatedClass" | "deprecatedProps",
-            kind: Kind,
-        ) {
-            reporter.report({
-                node,
-                loc: node.loc,
-                messageId,
-                data: { kind },
-            })
-        }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(
+      node: VCSSSelectorNode | AST.VIdentifier | AST.VDirectiveKey,
+      messageId: "deprecatedClass" | "deprecatedProps",
+      kind: Kind
+    ) {
+      reporter.report({
+        node,
+        loc: node.loc,
+        messageId,
+        data: { kind },
+      });
+    }
 
-        /**
-         * Add deprecated transition class name. e.g. v-enter
-         */
-        function addDeprecatedClassName(className: Template, kind: Kind) {
-            deprecatedClassNames.set(className.string || className, {
-                className,
-                kind,
-            })
-        }
+    /**
+     * Add deprecated transition class name. e.g. v-enter
+     */
+    function addDeprecatedClassName(className: Template, kind: Kind) {
+      deprecatedClassNames.set(className.string || className, {
+        className,
+        kind,
+      });
+    }
 
-        /**
-         * Add deprecated transition class name. e.g. v-enter-fron
-         */
-        function addRenamedClassName(className: Template) {
-            renamedClassNames.set(className.string || className, {
-                className,
-            })
-        }
+    /**
+     * Add deprecated transition class name. e.g. v-enter-fron
+     */
+    function addRenamedClassName(className: Template) {
+      renamedClassNames.set(className.string || className, {
+        className,
+      });
+    }
 
-        /**
-         * Verify for selector
-         * @returns {boolean} true if the child hierarchy needs to be processed.
-         */
-        function verifyCSSSelector(selector: VCSSSelectorNode[]): boolean {
-            const deprecatedClasses = new Map<VCSSClassSelector, Kind>()
-            const renamedClasses = new Set<string>()
-            let skipChild = false
+    /**
+     * Verify for selector
+     * @returns {boolean} true if the child hierarchy needs to be processed.
+     */
+    function verifyCSSSelector(selector: VCSSSelectorNode[]): boolean {
+      const deprecatedClasses = new Map<VCSSClassSelector, Kind>();
+      const renamedClasses = new Set<string>();
+      let skipChild = false;
 
-            verifyInternal(selector)
+      verifyInternal(selector);
 
-            for (const [node, kind] of deprecatedClasses) {
-                if (!renamedClasses.has(`${node.value}-from`)) {
-                    report(node, "deprecatedClass", kind)
-                }
-            }
+      for (const [node, kind] of deprecatedClasses) {
+        if (!renamedClasses.has(`${node.value}-from`)) {
+          report(node, "deprecatedClass", kind);
+        }
+      }
 
-            return !skipChild
+      return !skipChild;
 
-            /**
-             * Verify
-             */
-            function verifyInternal(nodes: VCSSSelectorNode[]) {
-                for (const node of nodes) {
-                    if (isDeepCombinator(node) || isVueSpecialPseudo(node)) {
-                        skipChild = true
-                        break
-                    }
-                    if (node.type === "VCSSClassSelector") {
-                        for (const {
-                            className,
-                            kind,
-                        } of deprecatedClassNames.values()) {
-                            if (className.matchString(node.value)) {
-                                deprecatedClasses.set(node, kind)
-                                break
-                            }
-                        }
-                        for (const {
-                            className,
-                        } of renamedClassNames.values()) {
-                            if (className.matchString(node.value)) {
-                                renamedClasses.add(node.value)
-                                break
-                            }
-                        }
-                    } else if (
-                        node.type === "VCSSSelectorPseudo" ||
-                        node.type === "VCSSSelector"
-                    ) {
-                        verifyInternal(node.nodes)
-                    }
-                }
-                return !skipChild
+      /**
+       * Verify
+       */
+      function verifyInternal(nodes: VCSSSelectorNode[]) {
+        for (const node of nodes) {
+          if (isDeepCombinator(node) || isVueSpecialPseudo(node)) {
+            skipChild = true;
+            break;
+          }
+          if (node.type === "VCSSClassSelector") {
+            for (const { className, kind } of deprecatedClassNames.values()) {
+              if (className.matchString(node.value)) {
+                deprecatedClasses.set(node, kind);
+                break;
+              }
             }
+            for (const { className } of renamedClassNames.values()) {
+              if (className.matchString(node.value)) {
+                renamedClasses.add(node.value);
+                break;
+              }
+            }
+          } else if (
+            node.type === "VCSSSelectorPseudo" ||
+            node.type === "VCSSSelector"
+          ) {
+            verifyInternal(node.nodes);
+          }
         }
+        return !skipChild;
+      }
+    }
 
-        /**
-         * Checks whether to ignore the processing of the given node.
-         */
-        function isIgnoreNode(node: VCSSNode) {
-            return (
-                isVCSSAtRule(node) &&
-                node.name === "keyframes" &&
-                node.identifier === "@"
-            )
-        }
+    /**
+     * Checks whether to ignore the processing of the given node.
+     */
+    function isIgnoreNode(node: VCSSNode) {
+      return (
+        isVCSSAtRule(node) &&
+        node.name === "keyframes" &&
+        node.identifier === "@"
+      );
+    }
 
-        /**
-         * Verify for CSSNode
-         */
-        function verifyCSSNode(node: VCSSNode) {
-            if (isIgnoreNode(node)) {
-                return
-            }
-            if (node.type === "VCSSStyleRule") {
-                if (!verifyCSSSelector(node.selectors)) {
-                    return
-                }
-                for (const child of node.nodes) {
-                    verifyCSSNode(child)
-                }
-            } else if (node.type === "VCSSAtRule") {
-                if (node.selectors) {
-                    if (!verifyCSSSelector(node.selectors)) {
-                        return
-                    }
-                }
-                for (const child of node.nodes) {
-                    verifyCSSNode(child)
-                }
-            }
+    /**
+     * Verify for CSSNode
+     */
+    function verifyCSSNode(node: VCSSNode) {
+      if (isIgnoreNode(node)) {
+        return;
+      }
+      if (node.type === "VCSSStyleRule") {
+        if (!verifyCSSSelector(node.selectors)) {
+          return;
+        }
+        for (const child of node.nodes) {
+          verifyCSSNode(child);
+        }
+      } else if (node.type === "VCSSAtRule") {
+        if (node.selectors) {
+          if (!verifyCSSSelector(node.selectors)) {
+            return;
+          }
         }
+        for (const child of node.nodes) {
+          verifyCSSNode(child);
+        }
+      }
+    }
+
+    /**
+     * Verify for transition element
+     */
+    function verifyTransitionElementNode(node: AST.VElement) {
+      const enterAttr = findAttribute(node, "enter-class");
+      const enterFromAttr = findAttribute(node, "enter-from-class");
+      if (enterAttr && !enterFromAttr) {
+        report(enterAttr.key, "deprecatedProps", "enter");
+      }
+      const leaveAttr = findAttribute(node, "leave-class");
+      const leaveFromAttr = findAttribute(node, "leave-from-class");
+      if (leaveAttr && !leaveFromAttr) {
+        report(leaveAttr.key, "deprecatedProps", "leave");
+      }
+      return {
+        hasEnterClass: enterAttr || enterFromAttr,
+        hasLeaveClass: leaveAttr || leaveFromAttr,
+      };
+    }
 
-        /**
-         * Verify for transition element
-         */
-        function verifyTransitionElementNode(node: AST.VElement) {
-            const enterAttr = findAttribute(node, "enter-class")
-            const enterFromAttr = findAttribute(node, "enter-from-class")
-            if (enterAttr && !enterFromAttr) {
-                report(enterAttr.key, "deprecatedProps", "enter")
+    return {
+      "Program:exit"() {
+        for (const transition of getElements(
+          context,
+          (element) =>
+            isTransitionElement(element) || isTransitionGroupElement(element)
+        )) {
+          const { hasEnterClass, hasLeaveClass } =
+            verifyTransitionElementNode(transition);
+          if (hasEnterClass && hasLeaveClass) {
+            continue;
+          }
+          const nodes = getAttributeValueNodes(transition, "name", context);
+          if (!nodes) {
+            // unknown
+            return;
+          }
+          if (!nodes.length) {
+            if (!hasEnterClass) {
+              addDeprecatedClassName(Template.of("v-enter"), "enter");
+              addRenamedClassName(Template.of("v-enter-from"));
             }
-            const leaveAttr = findAttribute(node, "leave-class")
-            const leaveFromAttr = findAttribute(node, "leave-from-class")
-            if (leaveAttr && !leaveFromAttr) {
-                report(leaveAttr.key, "deprecatedProps", "leave")
+            if (!hasLeaveClass) {
+              addDeprecatedClassName(Template.of("v-leave"), "leave");
+              addRenamedClassName(Template.of("v-leave-from"));
             }
-            return {
-                hasEnterClass: enterAttr || enterFromAttr,
-                hasLeaveClass: leaveAttr || leaveFromAttr,
+          } else {
+            for (const name of nodes) {
+              const value = Template.ofNode(name);
+              if (value == null) {
+                // Are identified by complex expressions.
+                return;
+              }
+              if (!hasEnterClass) {
+                addDeprecatedClassName(value.concat("-enter"), "enter");
+                addRenamedClassName(value.concat("-enter-from"));
+              }
+              if (!hasLeaveClass) {
+                addDeprecatedClassName(value.concat("-leave"), "leave");
+                addRenamedClassName(value.concat("-leave-from"));
+              }
             }
+          }
         }
 
-        return {
-            "Program:exit"() {
-                for (const transition of getElements(
-                    context,
-                    (element) =>
-                        isTransitionElement(element) ||
-                        isTransitionGroupElement(element),
-                )) {
-                    const { hasEnterClass, hasLeaveClass } =
-                        verifyTransitionElementNode(transition)
-                    if (hasEnterClass && hasLeaveClass) {
-                        continue
-                    }
-                    const nodes = getAttributeValueNodes(
-                        transition,
-                        "name",
-                        context,
-                    )
-                    if (!nodes) {
-                        // unknown
-                        return
-                    }
-                    if (!nodes.length) {
-                        if (!hasEnterClass) {
-                            addDeprecatedClassName(
-                                Template.of("v-enter"),
-                                "enter",
-                            )
-                            addRenamedClassName(Template.of("v-enter-from"))
-                        }
-                        if (!hasLeaveClass) {
-                            addDeprecatedClassName(
-                                Template.of("v-leave"),
-                                "leave",
-                            )
-                            addRenamedClassName(Template.of("v-leave-from"))
-                        }
-                    } else {
-                        for (const name of nodes) {
-                            const value = Template.ofNode(name)
-                            if (value == null) {
-                                // Are identified by complex expressions.
-                                return
-                            }
-                            if (!hasEnterClass) {
-                                addDeprecatedClassName(
-                                    value.concat("-enter"),
-                                    "enter",
-                                )
-                                addRenamedClassName(value.concat("-enter-from"))
-                            }
-                            if (!hasLeaveClass) {
-                                addDeprecatedClassName(
-                                    value.concat("-leave"),
-                                    "leave",
-                                )
-                                addRenamedClassName(value.concat("-leave-from"))
-                            }
-                        }
-                    }
-                }
-
-                for (const style of styles) {
-                    for (const node of style.cssNode.nodes) {
-                        verifyCSSNode(node)
-                    }
-                }
-            },
+        for (const style of styles) {
+          for (const node of style.cssNode.nodes) {
+            verifyCSSNode(node);
+          }
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/no-parent-of-v-global.ts b/lib/rules/no-parent-of-v-global.ts
index 49a7180c..01f74553 100644
--- a/lib/rules/no-parent-of-v-global.ts
+++ b/lib/rules/no-parent-of-v-global.ts
@@ -1,79 +1,78 @@
-import type { ValidStyleContext } from "../styles/context"
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-    isValidStyleContext,
-} from "../styles/context"
-import type { VCSSSelectorNode } from "../styles/ast"
-import type { RuleContext, Rule } from "../types"
-import { isVGlobalPseudo } from "../styles/utils/selectors"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+  isValidStyleContext,
+} from "../styles/context";
+import type { VCSSSelectorNode } from "../styles/ast";
+import type { RuleContext, Rule } from "../types";
+import { isVGlobalPseudo } from "../styles/utils/selectors";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "disallow parent selector for `::v-global` pseudo-element",
-            categories: ["vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-parent-of-v-global.html",
-        },
-        fixable: null,
-        messages: {
-            unexpected:
-                "The parent selector of the `::v-global()` pseudo-element is useless.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "disallow parent selector for `::v-global` pseudo-element",
+      categories: ["vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-parent-of-v-global.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: null,
+    messages: {
+      unexpected:
+        "The parent selector of the `::v-global()` pseudo-element is useless.",
+    },
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VCSSSelectorNode) {
-            reporter.report({
-                node,
-                loc: node.loc,
-                messageId: "unexpected",
-            })
-        }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VCSSSelectorNode) {
+      reporter.report({
+        node,
+        loc: node.loc,
+        messageId: "unexpected",
+      });
+    }
 
-        /**
-         * Verify the style
-         */
-        function verify(style: ValidStyleContext) {
-            style.traverseSelectorNodes({
-                enterNode(node) {
-                    if (!isVGlobalPseudo(node)) {
-                        return
-                    }
-                    const nodes = node.parent.nodes
-                    const selectorIndex = nodes.indexOf(node)
-                    if (selectorIndex > 0) {
-                        report(node)
-                    }
-                },
-            })
-        }
+    /**
+     * Verify the style
+     */
+    function verify(style: ValidStyleContext) {
+      style.traverseSelectorNodes({
+        enterNode(node) {
+          if (!isVGlobalPseudo(node)) {
+            return;
+          }
+          const nodes = node.parent.nodes;
+          const selectorIndex = nodes.indexOf(node);
+          if (selectorIndex > 0) {
+            report(node);
+          }
+        },
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    verify(style)
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          verify(style);
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/no-parsing-error.ts b/lib/rules/no-parsing-error.ts
index ce559eac..83486108 100644
--- a/lib/rules/no-parsing-error.ts
+++ b/lib/rules/no-parsing-error.ts
@@ -1,81 +1,81 @@
-import type { RuleContext, Rule } from "../types"
-import type { VCSSParsingError } from "../styles/ast"
-import type { InvalidStyleContext } from "../styles/context"
+import type { RuleContext, Rule } from "../types";
+import type { VCSSParsingError } from "../styles/ast";
+import type { InvalidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-} from "../styles/context"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+} from "../styles/context";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description: "disallow parsing errors in `<style>`",
-            categories: ["recommended", "vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-parsing-error.html",
-        },
-        fixable: null,
-        messages: {},
-        schema: [],
-        type: "problem",
+  meta: {
+    docs: {
+      description: "disallow parsing errors in `<style>`",
+      categories: ["recommended", "vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-parsing-error.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: null,
+    messages: {},
+    schema: [],
+    type: "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VCSSParsingError) {
-            reporter.report({
-                node,
-                loc: node.loc.start,
-                message: "Parsing error: {{message}}.",
-                data: {
-                    message: node.message.endsWith(".")
-                        ? node.message.slice(0, -1)
-                        : node.message,
-                },
-            })
-        }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VCSSParsingError) {
+      reporter.report({
+        node,
+        loc: node.loc.start,
+        message: "Parsing error: {{message}}.",
+        data: {
+          message: node.message.endsWith(".")
+            ? node.message.slice(0, -1)
+            : node.message,
+        },
+      });
+    }
 
-        /**
-         * Reports the given style
-         * @param {ASTNode} node node to report
-         */
-        function reportInvalidStyle(style: InvalidStyleContext) {
-            reporter.report({
-                node: style.styleElement,
-                loc: style.invalid.loc,
-                message: "Parsing error: {{message}}.",
-                data: {
-                    message: style.invalid.message,
-                },
-            })
-        }
+    /**
+     * Reports the given style
+     * @param {ASTNode} node node to report
+     */
+    function reportInvalidStyle(style: InvalidStyleContext) {
+      reporter.report({
+        node: style.styleElement,
+        loc: style.invalid.loc,
+        message: "Parsing error: {{message}}.",
+        data: {
+          message: style.invalid.message,
+        },
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    if (style.invalid != null) {
-                        if (style.invalid.needReport) {
-                            reportInvalidStyle(style)
-                        }
-                    } else {
-                        for (const node of style.cssNode?.errors || []) {
-                            report(node)
-                        }
-                    }
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          if (style.invalid != null) {
+            if (style.invalid.needReport) {
+              reportInvalidStyle(style);
+            }
+          } else {
+            for (const node of style.cssNode?.errors || []) {
+              report(node);
+            }
+          }
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/no-unused-keyframes.ts b/lib/rules/no-unused-keyframes.ts
index 85b2fe1b..a42aaf53 100644
--- a/lib/rules/no-unused-keyframes.ts
+++ b/lib/rules/no-unused-keyframes.ts
@@ -1,159 +1,148 @@
-import type { VCSSAtRule, VCSSDeclarationProperty } from "../styles/ast"
-import type { RuleContext, Rule } from "../types"
-import { Template } from "../styles/template"
-import type { ValidStyleContext } from "../styles/context"
+import type { VCSSAtRule, VCSSDeclarationProperty } from "../styles/ast";
+import type { RuleContext, Rule } from "../types";
+import { Template } from "../styles/template";
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-} from "../styles/context"
-import { isValidStyleContext } from "../styles/context/style"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+} from "../styles/context";
+import { isValidStyleContext } from "../styles/context/style";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description: "disallow `@keyframes` which don't use in Scoped CSS",
-            categories: ["recommended", "vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-unused-keyframes.html",
-        },
-        fixable: null,
-        messages: {
-            unused: "The @keyframes `{{params}}` is unused.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "disallow `@keyframes` which don't use in Scoped CSS",
+      categories: ["recommended", "vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-unused-keyframes.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
-        const sourceCode = context.getSourceCode()
+    fixable: null,
+    messages: {
+      unused: "The @keyframes `{{params}}` is unused.",
+    },
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
+    const sourceCode = context.getSourceCode();
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VCSSAtRule) {
-            const paramsStartIndex =
-                node.range[0] + // start index of at-rule
-                node.identifier.length + // `@`
-                node.name.length + // `nest`
-                (node.node.raws.afterName || "").length // comments and spaces
-            const paramsEndIndex = paramsStartIndex + node.rawParamsText.length
-            reporter.report({
-                node,
-                loc: {
-                    start: sourceCode.getLocFromIndex(paramsStartIndex),
-                    end: sourceCode.getLocFromIndex(paramsEndIndex),
-                },
-                messageId: "unused",
-                data: { params: node.paramsText },
-            })
-        }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VCSSAtRule) {
+      const paramsStartIndex =
+        node.range[0] + // start index of at-rule
+        node.identifier.length + // `@`
+        node.name.length + // `nest`
+        (node.node.raws.afterName || "").length; // comments and spaces
+      const paramsEndIndex = paramsStartIndex + node.rawParamsText.length;
+      reporter.report({
+        node,
+        loc: {
+          start: sourceCode.getLocFromIndex(paramsStartIndex),
+          end: sourceCode.getLocFromIndex(paramsEndIndex),
+        },
+        messageId: "unused",
+        data: { params: node.paramsText },
+      });
+    }
 
-        /**
-         * Extract nodes
-         */
-        function extract(style: ValidStyleContext): {
-            keyframes: { node: VCSSAtRule; params: Template }[]
-            animationNames: VCSSDeclarationProperty[]
-            animations: VCSSDeclarationProperty[]
-        } {
-            const keyframes: { node: VCSSAtRule; params: Template }[] = []
-            const animationNames: VCSSDeclarationProperty[] = []
-            const animations: VCSSDeclarationProperty[] = []
-            style.traverseNodes({
-                enterNode(node) {
-                    if (node.type === "VCSSAtRule") {
-                        if (
-                            /-?keyframes$/u.test(node.name) &&
-                            node.identifier === "@"
-                        ) {
-                            // register keyframes
-                            keyframes.push({
-                                params: Template.ofParams(node),
-                                node,
-                            })
-                        }
-                    } else if (node.type === "VCSSDeclarationProperty") {
-                        // individual animation-name declaration
-                        if (/^(?:-\w+-)?animation-name$/u.test(node.property)) {
-                            animationNames.push(node)
-                        }
-                        // shorthand
-                        if (/^(?:-\w+-)?animation$/u.test(node.property)) {
-                            animations.push(node)
-                        }
-                    }
-                },
-            })
-            return {
-                keyframes,
-                animationNames,
-                animations,
+    /**
+     * Extract nodes
+     */
+    function extract(style: ValidStyleContext): {
+      keyframes: { node: VCSSAtRule; params: Template }[];
+      animationNames: VCSSDeclarationProperty[];
+      animations: VCSSDeclarationProperty[];
+    } {
+      const keyframes: { node: VCSSAtRule; params: Template }[] = [];
+      const animationNames: VCSSDeclarationProperty[] = [];
+      const animations: VCSSDeclarationProperty[] = [];
+      style.traverseNodes({
+        enterNode(node) {
+          if (node.type === "VCSSAtRule") {
+            if (/-?keyframes$/u.test(node.name) && node.identifier === "@") {
+              // register keyframes
+              keyframes.push({
+                params: Template.ofParams(node),
+                node,
+              });
             }
-        }
-
-        /**
-         * Verify the style
-         */
-        function verify(style: ValidStyleContext) {
-            const { keyframes, animationNames, animations } = extract(style)
-
-            for (const decl of animationNames) {
-                for (const v of decl.value.split(",").map((s) => s.trim())) {
-                    const value = Template.ofDeclValue(v, decl.lang)
-                    for (
-                        let index = keyframes.length - 1;
-                        index >= 0;
-                        index--
-                    ) {
-                        const { params } = keyframes[index]
-                        if (value.match(params)) {
-                            keyframes.splice(index, 1)
-                        }
-                    }
-                }
+          } else if (node.type === "VCSSDeclarationProperty") {
+            // individual animation-name declaration
+            if (/^(?:-\w+-)?animation-name$/u.test(node.property)) {
+              animationNames.push(node);
             }
+            // shorthand
+            if (/^(?:-\w+-)?animation$/u.test(node.property)) {
+              animations.push(node);
+            }
+          }
+        },
+      });
+      return {
+        keyframes,
+        animationNames,
+        animations,
+      };
+    }
 
-            for (const decl of animations) {
-                for (const v of decl.value.split(",").map((s) => s.trim())) {
-                    const vals = v.trim().split(/\s+/u)
-                    for (const val of vals) {
-                        const value = Template.ofDeclValue(val, decl.lang)
-                        for (
-                            let index = keyframes.length - 1;
-                            index >= 0;
-                            index--
-                        ) {
-                            const { params } = keyframes[index]
-                            if (value.match(params)) {
-                                keyframes.splice(index, 1)
-                            }
-                        }
-                    }
-                }
+    /**
+     * Verify the style
+     */
+    function verify(style: ValidStyleContext) {
+      const { keyframes, animationNames, animations } = extract(style);
+
+      for (const decl of animationNames) {
+        for (const v of decl.value.split(",").map((s) => s.trim())) {
+          const value = Template.ofDeclValue(v, decl.lang);
+          for (let index = keyframes.length - 1; index >= 0; index--) {
+            const { params } = keyframes[index];
+            if (value.match(params)) {
+              keyframes.splice(index, 1);
             }
+          }
+        }
+      }
 
-            for (const { node } of keyframes) {
-                report(node)
+      for (const decl of animations) {
+        for (const v of decl.value.split(",").map((s) => s.trim())) {
+          const vals = v.trim().split(/\s+/u);
+          for (const val of vals) {
+            const value = Template.ofDeclValue(val, decl.lang);
+            for (let index = keyframes.length - 1; index >= 0; index--) {
+              const { params } = keyframes[index];
+              if (value.match(params)) {
+                keyframes.splice(index, 1);
+              }
             }
+          }
         }
+      }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    verify(style)
-                }
-            },
+      for (const { node } of keyframes) {
+        report(node);
+      }
+    }
+
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          verify(style);
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/no-unused-selector.ts b/lib/rules/no-unused-selector.ts
index c0ec2850..b7177edc 100644
--- a/lib/rules/no-unused-selector.ts
+++ b/lib/rules/no-unused-selector.ts
@@ -1,38 +1,38 @@
-import type { ResolvedSelector } from "../styles/selectors"
-import { getResolvedSelectors } from "../styles/selectors"
-import type { VCSSSelectorNode, VCSSSelectorCombinator } from "../styles/ast"
+import type { ResolvedSelector } from "../styles/selectors";
+import { getResolvedSelectors } from "../styles/selectors";
+import type { VCSSSelectorNode, VCSSSelectorCombinator } from "../styles/ast";
 import {
-    isTypeSelector,
-    isIDSelector,
-    isClassSelector,
-    isUniversalSelector,
-    isSelectorCombinator,
-    isChildCombinator,
-    isAdjacentSiblingCombinator,
-    isGeneralSiblingCombinator,
-    isDeepCombinator,
-    isVueSpecialPseudo,
-    isVDeepPseudo,
-    isVSlottedPseudo,
-    isVGlobalPseudo,
-    isDescendantCombinator,
-} from "../styles/utils/selectors"
-import type { QueryContext } from "../styles/selectors/query"
-import { createQueryContext } from "../styles/selectors/query"
-import { isRootElement } from "../styles/selectors/query/elements"
-import type { RuleContext, Rule } from "../types"
-import { parseQueryOptions } from "../options"
-import type { ValidStyleContext } from "../styles/context"
+  isTypeSelector,
+  isIDSelector,
+  isClassSelector,
+  isUniversalSelector,
+  isSelectorCombinator,
+  isChildCombinator,
+  isAdjacentSiblingCombinator,
+  isGeneralSiblingCombinator,
+  isDeepCombinator,
+  isVueSpecialPseudo,
+  isVDeepPseudo,
+  isVSlottedPseudo,
+  isVGlobalPseudo,
+  isDescendantCombinator,
+} from "../styles/utils/selectors";
+import type { QueryContext } from "../styles/selectors/query";
+import { createQueryContext } from "../styles/selectors/query";
+import { isRootElement } from "../styles/selectors/query/elements";
+import type { RuleContext, Rule } from "../types";
+import { parseQueryOptions } from "../options";
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-} from "../styles/context"
-import { hasTemplateBlock, isDefined } from "../utils/utils"
-import { isValidStyleContext } from "../styles/context/style"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+} from "../styles/context";
+import { hasTemplateBlock, isDefined } from "../utils/utils";
+import { isValidStyleContext } from "../styles/context/style";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 /**
  * Gets scoped selectors.
@@ -40,8 +40,8 @@ declare const module: {
  * @returns {VCSSSelectorNode[][]} selectors
  */
 function getScopedSelectors(style: ValidStyleContext): VCSSSelectorNode[][] {
-    const resolvedSelectors = getResolvedSelectors(style)
-    return resolvedSelectors.map(getScopedSelector).filter(isDefined)
+  const resolvedSelectors = getResolvedSelectors(style);
+  return resolvedSelectors.map(getScopedSelector).filter(isDefined);
 }
 
 /**
@@ -50,220 +50,212 @@ function getScopedSelectors(style: ValidStyleContext): VCSSSelectorNode[][] {
  * @returns scoped selector
  */
 function getScopedSelector(
-    resolvedSelector: ResolvedSelector,
+  resolvedSelector: ResolvedSelector
 ): VCSSSelectorNode[] | null {
-    const { selector } = resolvedSelector
-    const specialNodeIndex = selector.findIndex(
-        (s) => isDeepCombinator(s) || isVueSpecialPseudo(s),
-    )
-    let scopedCandidateSelector: VCSSSelectorNode[]
-    if (specialNodeIndex >= 0) {
-        const specialNode = selector[specialNodeIndex]
-        if (isDeepCombinator(specialNode) || isVDeepPseudo(specialNode)) {
-            scopedCandidateSelector = selector.slice(0, specialNodeIndex)
+  const { selector } = resolvedSelector;
+  const specialNodeIndex = selector.findIndex(
+    (s) => isDeepCombinator(s) || isVueSpecialPseudo(s)
+  );
+  let scopedCandidateSelector: VCSSSelectorNode[];
+  if (specialNodeIndex >= 0) {
+    const specialNode = selector[specialNodeIndex];
+    if (isDeepCombinator(specialNode) || isVDeepPseudo(specialNode)) {
+      scopedCandidateSelector = selector.slice(0, specialNodeIndex);
 
-            const last = scopedCandidateSelector.pop()
-            if (last && !isDescendantCombinator(last)) {
-                scopedCandidateSelector.push(last)
-            }
-        } else if (isVSlottedPseudo(specialNode)) {
-            scopedCandidateSelector = selector.slice(0, specialNodeIndex + 1)
-        } else if (isVGlobalPseudo(specialNode)) {
-            return null
-        } else {
-            scopedCandidateSelector = [...selector]
-        }
+      const last = scopedCandidateSelector.pop();
+      if (last && !isDescendantCombinator(last)) {
+        scopedCandidateSelector.push(last);
+      }
+    } else if (isVSlottedPseudo(specialNode)) {
+      scopedCandidateSelector = selector.slice(0, specialNodeIndex + 1);
+    } else if (isVGlobalPseudo(specialNode)) {
+      return null;
     } else {
-        scopedCandidateSelector = [...selector]
+      scopedCandidateSelector = [...selector];
     }
+  } else {
+    scopedCandidateSelector = [...selector];
+  }
 
-    const results = []
-    for (const sel of scopedCandidateSelector.reverse()) {
-        if (isSelectorCombinator(sel)) {
-            if (
-                !isChildCombinator(sel) &&
-                !isAdjacentSiblingCombinator(sel) &&
-                !isGeneralSiblingCombinator(sel)
-            ) {
-                break
-            }
-        }
-
-        results.push(sel)
+  const results = [];
+  for (const sel of scopedCandidateSelector.reverse()) {
+    if (isSelectorCombinator(sel)) {
+      if (
+        !isChildCombinator(sel) &&
+        !isAdjacentSiblingCombinator(sel) &&
+        !isGeneralSiblingCombinator(sel)
+      ) {
+        break;
+      }
     }
-    return results.reverse()
+
+    results.push(sel);
+  }
+  return results.reverse();
 }
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "disallow selectors defined in Scoped CSS that don't use in `<template>`",
-            categories: ["recommended", "vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-unused-selector.html",
-        },
-        fixable: null,
-        messages: {
-            unused: "The selector `{{selector}}` is unused.",
-        },
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignoreBEMModifier: {
-                        type: "boolean",
-                    },
-                    captureClassesFromDoc: {
-                        type: "array",
-                        items: [
-                            {
-                                type: "string",
-                            },
-                        ],
-                        minItems: 0,
-                        uniqueItems: true,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description:
+        "disallow selectors defined in Scoped CSS that don't use in `<template>`",
+      categories: ["recommended", "vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/no-unused-selector.html",
     },
-    create(context: RuleContext) {
-        if (!hasTemplateBlock(context)) {
-            return {}
-        }
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: null,
+    messages: {
+      unused: "The selector `{{selector}}` is unused.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreBEMModifier: {
+            type: "boolean",
+          },
+          captureClassesFromDoc: {
+            type: "array",
+            items: [
+              {
+                type: "string",
+              },
+            ],
+            minItems: 0,
+            uniqueItems: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    if (!hasTemplateBlock(context)) {
+      return {};
+    }
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        const reportedSet = new Set<VCSSSelectorNode>()
+    const reportedSet = new Set<VCSSSelectorNode>();
 
-        /**
-         * Reports the given nodes.
-         * @param {ASTNode} nodes nodes to report
-         */
-        function report(nodes: VCSSSelectorNode[]) {
-            if (!reportedSet.has(nodes[0])) {
-                reporter.report({
-                    loc: {
-                        start: nodes[0].loc.start,
-                        end: nodes[nodes.length - 1].loc.end,
-                    },
-                    messageId: "unused",
-                    data: {
-                        selector: nodes.map((n) => n.selector).join(""),
-                    },
-                })
-                reportedSet.add(nodes[0])
-            }
-        }
+    /**
+     * Reports the given nodes.
+     * @param {ASTNode} nodes nodes to report
+     */
+    function report(nodes: VCSSSelectorNode[]) {
+      if (!reportedSet.has(nodes[0])) {
+        reporter.report({
+          loc: {
+            start: nodes[0].loc.start,
+            end: nodes[nodes.length - 1].loc.end,
+          },
+          messageId: "unused",
+          data: {
+            selector: nodes.map((n) => n.selector).join(""),
+          },
+        });
+        reportedSet.add(nodes[0]);
+      }
+    }
 
-        /**
-         * Verify the selector
-         */
-        function verifySelector(
-            queryContext: QueryContext,
-            scopedSelector: VCSSSelectorNode[],
-        ) {
-            const reportSelectorNodes: VCSSSelectorNode[] = []
-            let targetsQueryContext = queryContext
-            let reverseVerifySelector = [...scopedSelector].reverse()
-            while (reverseVerifySelector.length) {
-                const combIndex =
-                    reverseVerifySelector.findIndex(isSelectorCombinator)
-                let comb: VCSSSelectorCombinator | null = null
-                let selectorBlock: VCSSSelectorNode[] = []
+    /**
+     * Verify the selector
+     */
+    function verifySelector(
+      queryContext: QueryContext,
+      scopedSelector: VCSSSelectorNode[]
+    ) {
+      const reportSelectorNodes: VCSSSelectorNode[] = [];
+      let targetsQueryContext = queryContext;
+      let reverseVerifySelector = [...scopedSelector].reverse();
+      while (reverseVerifySelector.length) {
+        const combIndex = reverseVerifySelector.findIndex(isSelectorCombinator);
+        let comb: VCSSSelectorCombinator | null = null;
+        let selectorBlock: VCSSSelectorNode[] = [];
 
-                if (combIndex >= 0) {
-                    // `> .a.b` -> comb=">" , selectorBlock=[".a", ".b"]
-                    comb = reverseVerifySelector[
-                        combIndex
-                    ] as VCSSSelectorCombinator
-                    selectorBlock = reverseVerifySelector.slice(0, combIndex)
+        if (combIndex >= 0) {
+          // `> .a.b` -> comb=">" , selectorBlock=[".a", ".b"]
+          comb = reverseVerifySelector[combIndex] as VCSSSelectorCombinator;
+          selectorBlock = reverseVerifySelector.slice(0, combIndex);
 
-                    // Setup the selectors to verify at the next.
-                    reverseVerifySelector = reverseVerifySelector.slice(
-                        combIndex + 1,
-                    )
-                } else {
-                    // `.a.b` -> comb=null , selectorBlock=[".a", ".b"]
-                    selectorBlock = reverseVerifySelector
+          // Setup the selectors to verify at the next.
+          reverseVerifySelector = reverseVerifySelector.slice(combIndex + 1);
+        } else {
+          // `.a.b` -> comb=null , selectorBlock=[".a", ".b"]
+          selectorBlock = reverseVerifySelector;
 
-                    // There is no selectors to verify at the next.
-                    reverseVerifySelector = []
-                }
+          // There is no selectors to verify at the next.
+          reverseVerifySelector = [];
+        }
 
-                const classSelectors = selectorBlock.filter(isClassSelector)
-                const notClassSelectors = selectorBlock.filter(
-                    (s) =>
-                        // Filter verify target selector
-                        // Other selectors are ignored because they are likely to be changed dynamically.
-                        isSelectorCombinator(s) ||
-                        isTypeSelector(s) ||
-                        isIDSelector(s) ||
-                        isUniversalSelector(s) ||
-                        isVueSpecialPseudo(s),
-                )
+        const classSelectors = selectorBlock.filter(isClassSelector);
+        const notClassSelectors = selectorBlock.filter(
+          (s) =>
+            // Filter verify target selector
+            // Other selectors are ignored because they are likely to be changed dynamically.
+            isSelectorCombinator(s) ||
+            isTypeSelector(s) ||
+            isIDSelector(s) ||
+            isUniversalSelector(s) ||
+            isVueSpecialPseudo(s)
+        );
 
-                for (const selectorNode of notClassSelectors) {
-                    targetsQueryContext =
-                        targetsQueryContext.reverseQueryStep(selectorNode)
-                }
+        for (const selectorNode of notClassSelectors) {
+          targetsQueryContext =
+            targetsQueryContext.reverseQueryStep(selectorNode);
+        }
 
-                const roots = targetsQueryContext.filter(isRootElement)
-                if (roots.elements.length) {
-                    // The root element can add classes by defining a parent.
-                    // The root element is considered to match if it matches at least one Class Selector.
-                    for (const selectorNode of classSelectors) {
-                        if (
-                            roots.reverseQueryStep(selectorNode).elements.length
-                        ) {
-                            return
-                        }
-                    }
-                }
-                for (const selectorNode of classSelectors) {
-                    targetsQueryContext =
-                        targetsQueryContext.reverseQueryStep(selectorNode)
-                }
-                reportSelectorNodes.push(...selectorBlock)
-                if (comb) {
-                    if (!targetsQueryContext.elements.length) {
-                        // to report
-                        break
-                    }
-                    if (targetsQueryContext.elements.some(isRootElement)) {
-                        return
-                    }
-                    targetsQueryContext =
-                        targetsQueryContext.reverseQueryStep(comb)
-                    reportSelectorNodes.push(comb)
-                }
-            }
-            if (!targetsQueryContext.elements.length) {
-                report(reportSelectorNodes.reverse())
+        const roots = targetsQueryContext.filter(isRootElement);
+        if (roots.elements.length) {
+          // The root element can add classes by defining a parent.
+          // The root element is considered to match if it matches at least one Class Selector.
+          for (const selectorNode of classSelectors) {
+            if (roots.reverseQueryStep(selectorNode).elements.length) {
+              return;
             }
+          }
+        }
+        for (const selectorNode of classSelectors) {
+          targetsQueryContext =
+            targetsQueryContext.reverseQueryStep(selectorNode);
+        }
+        reportSelectorNodes.push(...selectorBlock);
+        if (comb) {
+          if (!targetsQueryContext.elements.length) {
+            // to report
+            break;
+          }
+          if (targetsQueryContext.elements.some(isRootElement)) {
+            return;
+          }
+          targetsQueryContext = targetsQueryContext.reverseQueryStep(comb);
+          reportSelectorNodes.push(comb);
         }
+      }
+      if (!targetsQueryContext.elements.length) {
+        report(reportSelectorNodes.reverse());
+      }
+    }
 
-        return {
-            "Program:exit"() {
-                const queryContext = createQueryContext(
-                    context,
-                    parseQueryOptions(context.options[0]),
-                )
+    return {
+      "Program:exit"() {
+        const queryContext = createQueryContext(
+          context,
+          parseQueryOptions(context.options[0])
+        );
 
-                for (const style of styles) {
-                    for (const scopedSelector of getScopedSelectors(style)) {
-                        verifySelector(queryContext, scopedSelector)
-                    }
-                }
-            },
+        for (const style of styles) {
+          for (const scopedSelector of getScopedSelectors(style)) {
+            verifySelector(queryContext, scopedSelector);
+          }
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/require-scoped.ts b/lib/rules/require-scoped.ts
index b0cdee96..12ecd22c 100644
--- a/lib/rules/require-scoped.ts
+++ b/lib/rules/require-scoped.ts
@@ -1,104 +1,100 @@
-import type { RuleContext, AST, TokenStore, Rule, RuleFixer } from "../types"
+import type { RuleContext, AST, TokenStore, Rule, RuleFixer } from "../types";
 import {
-    getStyleContexts,
-    isValidStyleContext,
-    getCommentDirectivesReporter,
-} from "../styles/context"
+  getStyleContexts,
+  isValidStyleContext,
+  getCommentDirectivesReporter,
+} from "../styles/context";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        deprecated: true,
-        docs: {
-            description:
-                "enforce the `<style>` tags to has the `scoped` attribute",
-            categories: ["recommended", "vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-scoped.html",
-            suggestion: true,
-            replacedBy: ["enforce-style-type"],
-        },
-        fixable: null,
-        messages: {
-            missing: "Missing `scoped` attribute.",
-            forbidden: "`scoped` attribute are forbidden.",
-            add: "Add `scoped` attribute.",
-            remove: "Remove `scoped` attribute.",
-        },
-        schema: [{ enum: ["always", "never"] }],
-        type: "suggestion",
-        hasSuggestions: true,
+  meta: {
+    deprecated: true,
+    docs: {
+      description: "enforce the `<style>` tags to has the `scoped` attribute",
+      categories: ["recommended", "vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-scoped.html",
+      suggestion: true,
+      replacedBy: ["enforce-style-type"],
     },
-    create(context: RuleContext) {
-        const always = context.options[0] !== "never"
-        const styles = getStyleContexts(context).filter(isValidStyleContext)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
-        const tokenStore =
-            context.parserServices.getTemplateBodyTokenStore?.() as TokenStore
-
-        /**
-         * Reports the given node.
-         * @param {ASTNode} node node to report
-         */
-        function reportAlways(node: AST.VElement) {
-            reporter.report({
-                node: node.startTag,
-                messageId: "missing",
-                data: {},
-                suggest: [
-                    {
-                        messageId: "add",
-                        fix(fixer: RuleFixer) {
-                            const close = tokenStore.getLastToken(node.startTag)
-                            return (
-                                close &&
-                                fixer.insertTextBefore(close, " scoped")
-                            )
-                        },
-                    },
-                ],
-            })
-        }
+    fixable: null,
+    messages: {
+      missing: "Missing `scoped` attribute.",
+      forbidden: "`scoped` attribute are forbidden.",
+      add: "Add `scoped` attribute.",
+      remove: "Remove `scoped` attribute.",
+    },
+    schema: [{ enum: ["always", "never"] }],
+    type: "suggestion",
+    hasSuggestions: true,
+  },
+  create(context: RuleContext) {
+    const always = context.options[0] !== "never";
+    const styles = getStyleContexts(context).filter(isValidStyleContext);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
+    const tokenStore =
+      context.parserServices.getTemplateBodyTokenStore?.() as TokenStore;
 
-        /**
-         * Reports the given node.
-         * @param {ASTNode} node node to report
-         */
-        function reportNever(node: AST.VElement) {
-            const scopedAttr = node.startTag.attributes.find(
-                (attr) => attr.key.name === "scoped",
-            )
-            reporter.report({
-                node: scopedAttr!,
-                messageId: "forbidden",
-                data: {},
-                suggest: [
-                    {
-                        messageId: "remove",
-                        fix(fixer: RuleFixer) {
-                            return fixer.remove(scopedAttr)
-                        },
-                    },
-                ],
-            })
-        }
+    /**
+     * Reports the given node.
+     * @param {ASTNode} node node to report
+     */
+    function reportAlways(node: AST.VElement) {
+      reporter.report({
+        node: node.startTag,
+        messageId: "missing",
+        data: {},
+        suggest: [
+          {
+            messageId: "add",
+            fix(fixer: RuleFixer) {
+              const close = tokenStore.getLastToken(node.startTag);
+              return close && fixer.insertTextBefore(close, " scoped");
+            },
+          },
+        ],
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    if (always && !style.scoped) {
-                        reportAlways(style.styleElement)
-                    } else if (!always && style.scoped) {
-                        reportNever(style.styleElement)
-                    }
-                }
+    /**
+     * Reports the given node.
+     * @param {ASTNode} node node to report
+     */
+    function reportNever(node: AST.VElement) {
+      const scopedAttr = node.startTag.attributes.find(
+        (attr) => attr.key.name === "scoped"
+      );
+      reporter.report({
+        node: scopedAttr!,
+        messageId: "forbidden",
+        data: {},
+        suggest: [
+          {
+            messageId: "remove",
+            fix(fixer: RuleFixer) {
+              return fixer.remove(scopedAttr);
             },
+          },
+        ],
+      });
+    }
+
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          if (always && !style.scoped) {
+            reportAlways(style.styleElement);
+          } else if (!always && style.scoped) {
+            reportNever(style.styleElement);
+          }
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/require-selector-used-inside.ts b/lib/rules/require-selector-used-inside.ts
index 39b97848..56fe8727 100644
--- a/lib/rules/require-selector-used-inside.ts
+++ b/lib/rules/require-selector-used-inside.ts
@@ -1,34 +1,34 @@
-import type { ResolvedSelector } from "../styles/selectors"
-import { getResolvedSelectors } from "../styles/selectors"
+import type { ResolvedSelector } from "../styles/selectors";
+import { getResolvedSelectors } from "../styles/selectors";
 import {
-    isTypeSelector,
-    isIDSelector,
-    isClassSelector,
-    isUniversalSelector,
-    isSelectorCombinator,
-    isDeepCombinator,
-    isVDeepPseudo,
-    isVueSpecialPseudo,
-    isDescendantCombinator,
-    isVSlottedPseudo,
-    isVGlobalPseudo,
-} from "../styles/utils/selectors"
-import type { QueryContext } from "../styles/selectors/query"
-import { createQueryContext } from "../styles/selectors/query"
-import type { VCSSSelectorNode } from "../styles/ast"
-import type { RuleContext, Rule } from "../types"
-import type { ValidStyleContext } from "../styles/context"
+  isTypeSelector,
+  isIDSelector,
+  isClassSelector,
+  isUniversalSelector,
+  isSelectorCombinator,
+  isDeepCombinator,
+  isVDeepPseudo,
+  isVueSpecialPseudo,
+  isDescendantCombinator,
+  isVSlottedPseudo,
+  isVGlobalPseudo,
+} from "../styles/utils/selectors";
+import type { QueryContext } from "../styles/selectors/query";
+import { createQueryContext } from "../styles/selectors/query";
+import type { VCSSSelectorNode } from "../styles/ast";
+import type { RuleContext, Rule } from "../types";
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-} from "../styles/context"
-import { hasTemplateBlock, isDefined } from "../utils/utils"
-import { parseQueryOptions } from "../options"
-import { isValidStyleContext } from "../styles/context/style"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+} from "../styles/context";
+import { hasTemplateBlock, isDefined } from "../utils/utils";
+import { parseQueryOptions } from "../options";
+import { isValidStyleContext } from "../styles/context/style";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 /**
  * Gets scoped selectors.
@@ -36,8 +36,8 @@ declare const module: {
  * @returns {VCSSSelectorNode[][]} selectors
  */
 function getScopedSelectors(style: ValidStyleContext): VCSSSelectorNode[][] {
-    const resolvedSelectors = getResolvedSelectors(style)
-    return resolvedSelectors.map(getScopedSelector).filter(isDefined)
+  const resolvedSelectors = getResolvedSelectors(style);
+  return resolvedSelectors.map(getScopedSelector).filter(isDefined);
 }
 
 /**
@@ -46,149 +46,148 @@ function getScopedSelectors(style: ValidStyleContext): VCSSSelectorNode[][] {
  * @returns {VCSSSelectorNode[]} scoped selector
  */
 function getScopedSelector(
-    resolvedSelector: ResolvedSelector,
+  resolvedSelector: ResolvedSelector
 ): VCSSSelectorNode[] | null {
-    const { selector } = resolvedSelector
-    const specialNodeIndex = selector.findIndex(
-        (s) => isDeepCombinator(s) || isVueSpecialPseudo(s),
-    )
-    if (specialNodeIndex >= 0) {
-        const specialNode = selector[specialNodeIndex]
-        if (isDeepCombinator(specialNode) || isVDeepPseudo(specialNode)) {
-            const scopedCandidateSelector = selector.slice(0, specialNodeIndex)
+  const { selector } = resolvedSelector;
+  const specialNodeIndex = selector.findIndex(
+    (s) => isDeepCombinator(s) || isVueSpecialPseudo(s)
+  );
+  if (specialNodeIndex >= 0) {
+    const specialNode = selector[specialNodeIndex];
+    if (isDeepCombinator(specialNode) || isVDeepPseudo(specialNode)) {
+      const scopedCandidateSelector = selector.slice(0, specialNodeIndex);
 
-            const last = scopedCandidateSelector.pop()
-            if (last && !isDescendantCombinator(last)) {
-                scopedCandidateSelector.push(last)
-            }
-            return scopedCandidateSelector
-        } else if (isVSlottedPseudo(specialNode)) {
-            return selector.slice(0, specialNodeIndex + 1)
-        } else if (isVGlobalPseudo(specialNode)) {
-            return null
-        }
-        return [...selector]
+      const last = scopedCandidateSelector.pop();
+      if (last && !isDescendantCombinator(last)) {
+        scopedCandidateSelector.push(last);
+      }
+      return scopedCandidateSelector;
+    } else if (isVSlottedPseudo(specialNode)) {
+      return selector.slice(0, specialNodeIndex + 1);
+    } else if (isVGlobalPseudo(specialNode)) {
+      return null;
     }
-    return [...selector]
+    return [...selector];
+  }
+  return [...selector];
 }
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "disallow selectors defined that is not used inside `<template>`",
-            categories: [],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-selector-used-inside.html",
-        },
-        fixable: null,
-        messages: {
-            unused: "The selector `{{selector}}` is unused in the template.",
-        },
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignoreBEMModifier: {
-                        type: "boolean",
-                    },
-                    captureClassesFromDoc: {
-                        type: "array",
-                        items: [
-                            {
-                                type: "string",
-                            },
-                        ],
-                        minItems: 0,
-                        uniqueItems: true,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        type: "suggestion",
+  meta: {
+    docs: {
+      description:
+        "disallow selectors defined that is not used inside `<template>`",
+      categories: [],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-selector-used-inside.html",
     },
-    create(context: RuleContext) {
-        if (!hasTemplateBlock(context)) {
-            return {}
-        }
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: null,
+    messages: {
+      unused: "The selector `{{selector}}` is unused in the template.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreBEMModifier: {
+            type: "boolean",
+          },
+          captureClassesFromDoc: {
+            type: "array",
+            items: [
+              {
+                type: "string",
+              },
+            ],
+            minItems: 0,
+            uniqueItems: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    type: "suggestion",
+  },
+  create(context: RuleContext) {
+    if (!hasTemplateBlock(context)) {
+      return {};
+    }
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        const reportedSet = new Set<VCSSSelectorNode>()
+    const reportedSet = new Set<VCSSSelectorNode>();
 
-        /**
-         * Reports the given nodes.
-         * @param {ASTNode} nodes nodes to report
-         */
-        function report(nodes: VCSSSelectorNode[]) {
-            const last = nodes[nodes.length - 1]
-            if (!reportedSet.has(last)) {
-                reporter.report({
-                    loc: {
-                        start: nodes[0].loc.start,
-                        end: last.loc.end,
-                    },
-                    messageId: "unused",
-                    data: {
-                        selector: nodes.map((n) => n.selector).join(""),
-                    },
-                })
-                reportedSet.add(last)
-            }
-        }
+    /**
+     * Reports the given nodes.
+     * @param {ASTNode} nodes nodes to report
+     */
+    function report(nodes: VCSSSelectorNode[]) {
+      const last = nodes[nodes.length - 1];
+      if (!reportedSet.has(last)) {
+        reporter.report({
+          loc: {
+            start: nodes[0].loc.start,
+            end: last.loc.end,
+          },
+          messageId: "unused",
+          data: {
+            selector: nodes.map((n) => n.selector).join(""),
+          },
+        });
+        reportedSet.add(last);
+      }
+    }
 
-        /**
-         * Verify the selector
-         */
-        function verifySelector(
-            queryContext: QueryContext,
-            scopedSelector: VCSSSelectorNode[],
-        ) {
-            let targetsQueryContext = queryContext
-            const selectorNodes = scopedSelector
-                // Filter verify target selector
-                // Other selectors are ignored because they are likely to be changed dynamically.
-                .filter(
-                    (s) =>
-                        isSelectorCombinator(s) ||
-                        isTypeSelector(s) ||
-                        isIDSelector(s) ||
-                        isClassSelector(s) ||
-                        isUniversalSelector(s) ||
-                        isVueSpecialPseudo(s),
-                )
+    /**
+     * Verify the selector
+     */
+    function verifySelector(
+      queryContext: QueryContext,
+      scopedSelector: VCSSSelectorNode[]
+    ) {
+      let targetsQueryContext = queryContext;
+      const selectorNodes = scopedSelector
+        // Filter verify target selector
+        // Other selectors are ignored because they are likely to be changed dynamically.
+        .filter(
+          (s) =>
+            isSelectorCombinator(s) ||
+            isTypeSelector(s) ||
+            isIDSelector(s) ||
+            isClassSelector(s) ||
+            isUniversalSelector(s) ||
+            isVueSpecialPseudo(s)
+        );
 
-            for (let index = 0; index < selectorNodes.length; index++) {
-                const selectorNode = selectorNodes[index]
+      for (let index = 0; index < selectorNodes.length; index++) {
+        const selectorNode = selectorNodes[index];
 
-                targetsQueryContext =
-                    targetsQueryContext.queryStep(selectorNode)
-                if (!targetsQueryContext.elements.length) {
-                    report(selectorNodes.slice(0, index + 1))
-                    break
-                }
-            }
+        targetsQueryContext = targetsQueryContext.queryStep(selectorNode);
+        if (!targetsQueryContext.elements.length) {
+          report(selectorNodes.slice(0, index + 1));
+          break;
         }
+      }
+    }
 
-        return {
-            "Program:exit"() {
-                const queryContext = createQueryContext(
-                    context,
-                    parseQueryOptions(context.options[0]),
-                )
+    return {
+      "Program:exit"() {
+        const queryContext = createQueryContext(
+          context,
+          parseQueryOptions(context.options[0])
+        );
 
-                for (const style of styles) {
-                    for (const scopedSelector of getScopedSelectors(style)) {
-                        verifySelector(queryContext, scopedSelector)
-                    }
-                }
-            },
+        for (const style of styles) {
+          for (const scopedSelector of getScopedSelectors(style)) {
+            verifySelector(queryContext, scopedSelector);
+          }
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/require-v-deep-argument.ts b/lib/rules/require-v-deep-argument.ts
index ed67c0b1..6e643887 100644
--- a/lib/rules/require-v-deep-argument.ts
+++ b/lib/rules/require-v-deep-argument.ts
@@ -1,151 +1,149 @@
-import type { ValidStyleContext } from "../styles/context"
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-    isValidStyleContext,
-} from "../styles/context"
-import type { RuleContext, Rule, Range } from "../types"
-import type { VDeepPseudo } from "../styles/utils/selectors"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+  isValidStyleContext,
+} from "../styles/context";
+import type { RuleContext, Rule, Range } from "../types";
+import type { VDeepPseudo } from "../styles/utils/selectors";
 import {
-    isVDeepPseudoV2,
-    isVDeepPseudo,
-    isPseudoEmptyArguments,
-} from "../styles/utils/selectors"
-import type { VCSSSelectorNode, VCSSAtRule, VCSSStyleRule } from "../styles/ast"
+  isVDeepPseudoV2,
+  isVDeepPseudo,
+  isPseudoEmptyArguments,
+} from "../styles/utils/selectors";
+import type {
+  VCSSSelectorNode,
+  VCSSAtRule,
+  VCSSStyleRule,
+} from "../styles/ast";
 import {
-    hasSelectorNodes,
-    isVCSSAtRule,
-    isVCSSDeclarationProperty,
-    isVCSSComment,
-} from "../styles/utils/css-nodes"
+  hasSelectorNodes,
+  isVCSSAtRule,
+  isVCSSDeclarationProperty,
+  isVCSSComment,
+} from "../styles/utils/css-nodes";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "require selector argument to be passed to `::v-deep()`",
-            categories: ["vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-v-deep-argument.html",
-        },
-        fixable: "code",
-        messages: {
-            missingArguments:
-                "Need to pass argument to the `::v-deep` pseudo-element.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "require selector argument to be passed to `::v-deep()`",
+      categories: ["vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-v-deep-argument.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: "code",
+    messages: {
+      missingArguments:
+        "Need to pass argument to the `::v-deep` pseudo-element.",
+    },
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        /**
-         * Find VCSSStyleRule or nest VCSSAtRule
-         */
-        function findHasSelectorsNode(
-            node: VCSSSelectorNode,
-        ):
-            | (VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] })
-            | VCSSStyleRule
-            | null {
-            if (hasSelectorNodes(node.parent)) {
-                return node.parent
-            }
-            if (isVCSSAtRule(node.parent)) {
-                return null
-            }
-            return findHasSelectorsNode(node.parent)
-        }
+    /**
+     * Find VCSSStyleRule or nest VCSSAtRule
+     */
+    function findHasSelectorsNode(
+      node: VCSSSelectorNode
+    ):
+      | (VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] })
+      | VCSSStyleRule
+      | null {
+      if (hasSelectorNodes(node.parent)) {
+        return node.parent;
+      }
+      if (isVCSSAtRule(node.parent)) {
+        return null;
+      }
+      return findHasSelectorsNode(node.parent);
+    }
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VDeepPseudo) {
-            reporter.report({
-                node,
-                loc: node.loc,
-                messageId: "missingArguments",
-                fix(fixer) {
-                    if (!isVDeepPseudoV2(node)) {
-                        return null
-                    }
-                    const nodes = node.parent.nodes
-                    const selectorIndex = nodes.indexOf(node)
-                    const nextNode = nodes[selectorIndex + 1]
-                    if (!nextNode) {
-                        return null
-                    }
-                    const betweenRange: Range = [
-                        node.range[0] + node.value.length,
-                        nextNode.range[0],
-                    ]
-                    if (
-                        context
-                            .getSourceCode()
-                            .text.slice(...betweenRange)
-                            .trim()
-                    ) {
-                        // ::v-deep /* comment */ .foo
-                        return null
-                    }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VDeepPseudo) {
+      reporter.report({
+        node,
+        loc: node.loc,
+        messageId: "missingArguments",
+        fix(fixer) {
+          if (!isVDeepPseudoV2(node)) {
+            return null;
+          }
+          const nodes = node.parent.nodes;
+          const selectorIndex = nodes.indexOf(node);
+          const nextNode = nodes[selectorIndex + 1];
+          if (!nextNode) {
+            return null;
+          }
+          const betweenRange: Range = [
+            node.range[0] + node.value.length,
+            nextNode.range[0],
+          ];
+          if (
+            context
+              .getSourceCode()
+              .text.slice(...betweenRange)
+              .trim()
+          ) {
+            // ::v-deep /* comment */ .foo
+            return null;
+          }
 
-                    const ruleNode = findHasSelectorsNode(node)
-                    if (
-                        !ruleNode?.nodes.every(
-                            (n) =>
-                                isVCSSDeclarationProperty(n) ||
-                                isVCSSComment(n),
-                        )
-                    ) {
-                        // Maybe includes nesting
-                        return null
-                    }
+          const ruleNode = findHasSelectorsNode(node);
+          if (
+            !ruleNode?.nodes.every(
+              (n) => isVCSSDeclarationProperty(n) || isVCSSComment(n)
+            )
+          ) {
+            // Maybe includes nesting
+            return null;
+          }
 
-                    const last = nodes[nodes.length - 1]
-                    return [
-                        fixer.removeRange(betweenRange),
-                        fixer.insertTextAfterRange(betweenRange, "("),
-                        fixer.insertTextAfterRange(last.range, ")"),
-                    ]
-                },
-            })
-        }
+          const last = nodes[nodes.length - 1];
+          return [
+            fixer.removeRange(betweenRange),
+            fixer.insertTextAfterRange(betweenRange, "("),
+            fixer.insertTextAfterRange(last.range, ")"),
+          ];
+        },
+      });
+    }
 
-        /**
-         * Verify the style
-         */
-        function verify(style: ValidStyleContext) {
-            style.traverseSelectorNodes({
-                enterNode(node) {
-                    if (isVDeepPseudoV2(node)) {
-                        report(node)
-                    } else if (
-                        isVDeepPseudo(node) &&
-                        isPseudoEmptyArguments(node)
-                    ) {
-                        report(node)
-                    }
-                },
-            })
-        }
+    /**
+     * Verify the style
+     */
+    function verify(style: ValidStyleContext) {
+      style.traverseSelectorNodes({
+        enterNode(node) {
+          if (isVDeepPseudoV2(node)) {
+            report(node);
+          } else if (isVDeepPseudo(node) && isPseudoEmptyArguments(node)) {
+            report(node);
+          }
+        },
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    verify(style)
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          verify(style);
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/require-v-global-argument.ts b/lib/rules/require-v-global-argument.ts
index 7a971d2a..e061b673 100644
--- a/lib/rules/require-v-global-argument.ts
+++ b/lib/rules/require-v-global-argument.ts
@@ -1,77 +1,76 @@
-import type { ValidStyleContext } from "../styles/context"
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-    isValidStyleContext,
-} from "../styles/context"
-import type { RuleContext, Rule } from "../types"
-import type { VGlobalPseudo } from "../styles/utils/selectors"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+  isValidStyleContext,
+} from "../styles/context";
+import type { RuleContext, Rule } from "../types";
+import type { VGlobalPseudo } from "../styles/utils/selectors";
 import {
-    isPseudoEmptyArguments,
-    isVGlobalPseudo,
-} from "../styles/utils/selectors"
+  isPseudoEmptyArguments,
+  isVGlobalPseudo,
+} from "../styles/utils/selectors";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "require selector argument to be passed to `::v-global()`",
-            categories: ["vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-v-global-argument.html",
-        },
-        fixable: null,
-        messages: {
-            missingArguments:
-                "Need to pass argument to the `::v-global` pseudo-element.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "require selector argument to be passed to `::v-global()`",
+      categories: ["vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-v-global-argument.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: null,
+    messages: {
+      missingArguments:
+        "Need to pass argument to the `::v-global` pseudo-element.",
+    },
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VGlobalPseudo) {
-            reporter.report({
-                node,
-                loc: node.loc,
-                messageId: "missingArguments",
-            })
-        }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VGlobalPseudo) {
+      reporter.report({
+        node,
+        loc: node.loc,
+        messageId: "missingArguments",
+      });
+    }
 
-        /**
-         * Verify the style
-         */
-        function verify(style: ValidStyleContext) {
-            style.traverseSelectorNodes({
-                enterNode(node) {
-                    if (isVGlobalPseudo(node) && isPseudoEmptyArguments(node)) {
-                        report(node)
-                    }
-                },
-            })
-        }
+    /**
+     * Verify the style
+     */
+    function verify(style: ValidStyleContext) {
+      style.traverseSelectorNodes({
+        enterNode(node) {
+          if (isVGlobalPseudo(node) && isPseudoEmptyArguments(node)) {
+            report(node);
+          }
+        },
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    verify(style)
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          verify(style);
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/rules/require-v-slotted-argument.ts b/lib/rules/require-v-slotted-argument.ts
index 967517d4..34ad3269 100644
--- a/lib/rules/require-v-slotted-argument.ts
+++ b/lib/rules/require-v-slotted-argument.ts
@@ -1,80 +1,76 @@
-import type { ValidStyleContext } from "../styles/context"
+import type { ValidStyleContext } from "../styles/context";
 import {
-    getStyleContexts,
-    getCommentDirectivesReporter,
-    isValidStyleContext,
-} from "../styles/context"
-import type { RuleContext, Rule } from "../types"
-import type { VSlottedPseudo } from "../styles/utils/selectors"
+  getStyleContexts,
+  getCommentDirectivesReporter,
+  isValidStyleContext,
+} from "../styles/context";
+import type { RuleContext, Rule } from "../types";
+import type { VSlottedPseudo } from "../styles/utils/selectors";
 import {
-    isPseudoEmptyArguments,
-    isVSlottedPseudo,
-} from "../styles/utils/selectors"
+  isPseudoEmptyArguments,
+  isVSlottedPseudo,
+} from "../styles/utils/selectors";
 
 declare const module: {
-    exports: Rule
-}
+  exports: Rule;
+};
 
 module.exports = {
-    meta: {
-        docs: {
-            description:
-                "require selector argument to be passed to `::v-slotted()`",
-            categories: ["vue3-recommended"],
-            default: "warn",
-            url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-v-slotted-argument.html",
-        },
-        fixable: null,
-        messages: {
-            missingArguments:
-                "Need to pass argument to the `::v-slotted` pseudo-element.",
-        },
-        schema: [],
-        type: "suggestion", // "problem",
+  meta: {
+    docs: {
+      description: "require selector argument to be passed to `::v-slotted()`",
+      categories: ["vue3-recommended"],
+      default: "warn",
+      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/require-v-slotted-argument.html",
     },
-    create(context: RuleContext) {
-        const styles = getStyleContexts(context)
-            .filter(isValidStyleContext)
-            .filter((style) => style.scoped)
-        if (!styles.length) {
-            return {}
-        }
-        const reporter = getCommentDirectivesReporter(context)
+    fixable: null,
+    messages: {
+      missingArguments:
+        "Need to pass argument to the `::v-slotted` pseudo-element.",
+    },
+    schema: [],
+    type: "suggestion", // "problem",
+  },
+  create(context: RuleContext) {
+    const styles = getStyleContexts(context)
+      .filter(isValidStyleContext)
+      .filter((style) => style.scoped);
+    if (!styles.length) {
+      return {};
+    }
+    const reporter = getCommentDirectivesReporter(context);
 
-        /**
-         * Reports the given node
-         * @param {ASTNode} node node to report
-         */
-        function report(node: VSlottedPseudo) {
-            reporter.report({
-                node,
-                loc: node.loc,
-                messageId: "missingArguments",
-            })
-        }
+    /**
+     * Reports the given node
+     * @param {ASTNode} node node to report
+     */
+    function report(node: VSlottedPseudo) {
+      reporter.report({
+        node,
+        loc: node.loc,
+        messageId: "missingArguments",
+      });
+    }
 
-        /**
-         * Verify the style
-         */
-        function verify(style: ValidStyleContext) {
-            style.traverseSelectorNodes({
-                enterNode(node) {
-                    if (
-                        isVSlottedPseudo(node) &&
-                        isPseudoEmptyArguments(node)
-                    ) {
-                        report(node)
-                    }
-                },
-            })
-        }
+    /**
+     * Verify the style
+     */
+    function verify(style: ValidStyleContext) {
+      style.traverseSelectorNodes({
+        enterNode(node) {
+          if (isVSlottedPseudo(node) && isPseudoEmptyArguments(node)) {
+            report(node);
+          }
+        },
+      });
+    }
 
-        return {
-            "Program:exit"() {
-                for (const style of styles) {
-                    verify(style)
-                }
-            },
+    return {
+      "Program:exit"() {
+        for (const style of styles) {
+          verify(style);
         }
-    },
-}
+      },
+    };
+  },
+};
diff --git a/lib/styles/ast.ts b/lib/styles/ast.ts
index 71f224a5..70368b0c 100644
--- a/lib/styles/ast.ts
+++ b/lib/styles/ast.ts
@@ -1,1082 +1,1080 @@
 import type {
-    SourceLocation,
-    Range,
-    PostCSSNode,
-    PostCSSRule,
-    PostCSSDeclaration,
-    PostCSSAtRule,
-    PostCSSSPNode,
-    PostCSSSPTypeNode,
-    PostCSSSPIDNode,
-    PostCSSSPClassNameNode,
-    PostCSSSPNestingNode,
-    PostCSSSPUniversalNode,
-    PostCSSSPAttributeNode,
-    PostCSSSPPseudoNode,
-    PostCSSSPCombinatorNode,
-    PostCSSComment,
-    PostCSSSPCommentNode,
-    PostCSSRoot,
-} from "../types"
+  SourceLocation,
+  Range,
+  PostCSSNode,
+  PostCSSRule,
+  PostCSSDeclaration,
+  PostCSSAtRule,
+  PostCSSSPNode,
+  PostCSSSPTypeNode,
+  PostCSSSPIDNode,
+  PostCSSSPClassNameNode,
+  PostCSSSPNestingNode,
+  PostCSSSPUniversalNode,
+  PostCSSSPAttributeNode,
+  PostCSSSPPseudoNode,
+  PostCSSSPCombinatorNode,
+  PostCSSComment,
+  PostCSSSPCommentNode,
+  PostCSSRoot,
+} from "../types";
 
 type CopyProps = {
-    node?: PostCSSNode | PostCSSSPNode
-    loc?: SourceLocation
-    start?: number
-    end?: number
-}
+  node?: PostCSSNode | PostCSSSPNode;
+  loc?: SourceLocation;
+  start?: number;
+  end?: number;
+};
 /**
  * The node
  */
 class Node<T extends string> {
-    public readonly type: T
-
-    public readonly loc: SourceLocation
-
-    public start: number
-
-    public end: number
-
-    public range: Range
-
-    public readonly node: PostCSSNode | PostCSSSPNode
-
-    public readonly lang: string
-
-    /**
-     * constructor.
-     * @param  {PostCSSNode | PostCSSSPNode} node PostCSS node.
-     * @param  {string} type The token type.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    protected constructor(
-        node: PostCSSNode | PostCSSSPNode,
-        type: T,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        lang: string,
-    ) {
-        this.type = type
-        this.loc = loc
-        this.start = start
-        this.end = end
-        this.range = [start, end]
-        this.node = node
-        this.lang = lang
-    }
+  public readonly type: T;
+
+  public readonly loc: SourceLocation;
+
+  public start: number;
+
+  public end: number;
+
+  public range: Range;
+
+  public readonly node: PostCSSNode | PostCSSSPNode;
+
+  public readonly lang: string;
+
+  /**
+   * constructor.
+   * @param  {PostCSSNode | PostCSSSPNode} node PostCSS node.
+   * @param  {string} type The token type.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  protected constructor(
+    node: PostCSSNode | PostCSSSPNode,
+    type: T,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    lang: string
+  ) {
+    this.type = type;
+    this.loc = loc;
+    this.start = start;
+    this.end = end;
+    this.range = [start, end];
+    this.node = node;
+    this.lang = lang;
+  }
 }
 
 /**
  * The has parent node
  */
 class HasParentNode<
-    T extends string,
-    P extends VCSSContainerNode | VCSSSelector | VCSSSelectorPseudo,
+  T extends string,
+  P extends VCSSContainerNode | VCSSSelector | VCSSSelectorPseudo
 > extends Node<T> {
-    public readonly parent: P
-
-    protected constructor(
-        node: PostCSSNode | PostCSSSPNode,
-        type: T,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: P
-        },
-    ) {
-        super(node, type, loc, start, end, props.parent.lang)
-        this.parent = props.parent
+  public readonly parent: P;
+
+  protected constructor(
+    node: PostCSSNode | PostCSSSPNode,
+    type: T,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: P;
     }
+  ) {
+    super(node, type, loc, start, end, props.parent.lang);
+    this.parent = props.parent;
+  }
 }
 /**
  * The CSS Parsing Error.
  */
 export class VCSSParsingError extends Node<"VCSSParsingError"> {
-    public readonly message: string
-
-    /**
-     * constructor.
-     * @param  {PostCSSDeclaration} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSDeclaration,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            lang: string
-            message: string
-        },
-    ) {
-        super(node, "VCSSParsingError", loc, start, end, props.lang)
-        this.message = props.message
+  public readonly message: string;
+
+  /**
+   * constructor.
+   * @param  {PostCSSDeclaration} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSDeclaration,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      lang: string;
+      message: string;
     }
+  ) {
+    super(node, "VCSSParsingError", loc, start, end, props.lang);
+    this.message = props.message;
+  }
 }
 
 /**
  * The CSS root node.
  */
 export class VCSSStyleSheet extends Node<"VCSSStyleSheet"> {
-    public nodes: VCSSNode[]
-
-    public comments: VCSSCommentNode[]
-
-    public readonly errors: VCSSParsingError[]
-
-    /**
-     * constructor.
-     * @param  {PostCSSRoot} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSRoot,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            nodes?: VCSSNode[]
-            comments?: VCSSCommentNode[]
-            errors?: VCSSParsingError[]
-            lang: string
-        },
-    ) {
-        super(node, "VCSSStyleSheet", loc, start, end, props.lang)
-        this.nodes = props.nodes ?? []
-        this.comments = props.comments ?? []
-        this.errors = props.errors ?? []
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSStyleSheet} copy node
-     */
-    public copy(props?: CopyProps): VCSSStyleSheet {
-        return copyStdNode(this, props)
+  public nodes: VCSSNode[];
+
+  public comments: VCSSCommentNode[];
+
+  public readonly errors: VCSSParsingError[];
+
+  /**
+   * constructor.
+   * @param  {PostCSSRoot} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSRoot,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      nodes?: VCSSNode[];
+      comments?: VCSSCommentNode[];
+      errors?: VCSSParsingError[];
+      lang: string;
     }
+  ) {
+    super(node, "VCSSStyleSheet", loc, start, end, props.lang);
+    this.nodes = props.nodes ?? [];
+    this.comments = props.comments ?? [];
+    this.errors = props.errors ?? [];
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSStyleSheet} copy node
+   */
+  public copy(props?: CopyProps): VCSSStyleSheet {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Rule node.
  */
 export class VCSSStyleRule extends HasParentNode<
-    "VCSSStyleRule",
-    VCSSContainerNode
+  "VCSSStyleRule",
+  VCSSContainerNode
 > {
-    public nodes: VCSSNode[]
-
-    public readonly selectorText: string
-
-    public readonly rawSelectorText: string
-
-    public selectors: VCSSSelectorNode[]
-
-    /**
-     * constructor.
-     * @param  {AtRule} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSRule,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSContainerNode
-            selectorText?: string
-            rawSelectorText: string | null
-            selectors?: VCSSSelectorNode[]
-            nodes?: VCSSNode[]
-        },
-    ) {
-        super(node, "VCSSStyleRule", loc, start, end, props)
-
-        this.selectorText = props.selectorText ?? node.selector
-        if (props.rawSelectorText != null) {
-            this.rawSelectorText = props.rawSelectorText
-        } else {
-            const raws = node.raws
-            this.rawSelectorText = raws.selector
-                ? raws.selector.raw
-                : node.selector
-        }
-        this.selectors = props.selectors ?? []
-        this.nodes = props.nodes ?? []
+  public nodes: VCSSNode[];
+
+  public readonly selectorText: string;
+
+  public readonly rawSelectorText: string;
+
+  public selectors: VCSSSelectorNode[];
+
+  /**
+   * constructor.
+   * @param  {AtRule} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSRule,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSContainerNode;
+      selectorText?: string;
+      rawSelectorText: string | null;
+      selectors?: VCSSSelectorNode[];
+      nodes?: VCSSNode[];
     }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSStyleRule} copy node
-     */
-    public copy(props?: CopyProps): VCSSStyleRule {
-        return copyStdNode(this, props)
+  ) {
+    super(node, "VCSSStyleRule", loc, start, end, props);
+
+    this.selectorText = props.selectorText ?? node.selector;
+    if (props.rawSelectorText != null) {
+      this.rawSelectorText = props.rawSelectorText;
+    } else {
+      const raws = node.raws;
+      this.rawSelectorText = raws.selector ? raws.selector.raw : node.selector;
     }
+    this.selectors = props.selectors ?? [];
+    this.nodes = props.nodes ?? [];
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSStyleRule} copy node
+   */
+  public copy(props?: CopyProps): VCSSStyleRule {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Declaration Property node.
  */
 export class VCSSDeclarationProperty extends HasParentNode<
-    "VCSSDeclarationProperty",
-    VCSSContainerNode
+  "VCSSDeclarationProperty",
+  VCSSContainerNode
 > {
-    public readonly property: string
-
-    public readonly value: string
-
-    public readonly important: boolean
-
-    /**
-     * constructor.
-     * @param  {PostCSSDeclaration} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSDeclaration,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSContainerNode
-            property?: string
-            important?: boolean
-            value?: string
-        },
-    ) {
-        super(node, "VCSSDeclarationProperty", loc, start, end, props)
-
-        this.property = props.property ?? node.prop
-        this.value = getProp(props, node, "value")
-        this.important = props.important ?? Boolean(node.important)
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSDeclarationProperty} copy node
-     */
-    public copy(props?: CopyProps): VCSSDeclarationProperty {
-        return copyStdNode(this, props)
+  public readonly property: string;
+
+  public readonly value: string;
+
+  public readonly important: boolean;
+
+  /**
+   * constructor.
+   * @param  {PostCSSDeclaration} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSDeclaration,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSContainerNode;
+      property?: string;
+      important?: boolean;
+      value?: string;
     }
+  ) {
+    super(node, "VCSSDeclarationProperty", loc, start, end, props);
+
+    this.property = props.property ?? node.prop;
+    this.value = getProp(props, node, "value");
+    this.important = props.important ?? Boolean(node.important);
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSDeclarationProperty} copy node
+   */
+  public copy(props?: CopyProps): VCSSDeclarationProperty {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS At(@) Rule node.
  */
 export class VCSSAtRule extends HasParentNode<"VCSSAtRule", VCSSContainerNode> {
-    public nodes: VCSSNode[]
-
-    public readonly name: string
-
-    public readonly identifier: string
-
-    public readonly paramsText: string
-
-    public readonly rawParamsText: string
-
-    public rawSelectorText?: string
-
-    public selectors?: VCSSSelectorNode[]
-
-    public readonly node: PostCSSAtRule
-
-    /**
-     * constructor.
-     * @param  {PostCSSAtRule} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSAtRule,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSContainerNode
-            identifier: string
-            paramsText?: string
-            rawParamsText: string | null
-            selectors?: VCSSSelectorNode[]
-            nodes?: VCSSNode[]
-        },
-    ) {
-        super(node, "VCSSAtRule", loc, start, end, props)
-        this.node = node
-
-        this.name = getProp(props, node, "name")
-        this.identifier = props.identifier
-        this.paramsText = props.paramsText ?? node.params
-        if (props.rawParamsText != null) {
-            this.rawParamsText = props.rawParamsText
-        } else {
-            const raws = node.raws
-            this.rawParamsText = raws.params?.raw ?? node.params
-        }
-        this.selectors = props.selectors ?? undefined
-        this.nodes = props.nodes ?? []
+  public nodes: VCSSNode[];
+
+  public readonly name: string;
+
+  public readonly identifier: string;
+
+  public readonly paramsText: string;
+
+  public readonly rawParamsText: string;
+
+  public rawSelectorText?: string;
+
+  public selectors?: VCSSSelectorNode[];
+
+  public readonly node: PostCSSAtRule;
+
+  /**
+   * constructor.
+   * @param  {PostCSSAtRule} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSAtRule,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSContainerNode;
+      identifier: string;
+      paramsText?: string;
+      rawParamsText: string | null;
+      selectors?: VCSSSelectorNode[];
+      nodes?: VCSSNode[];
     }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSAtRule} copy node
-     */
-    public copy(props?: CopyProps): VCSSAtRule {
-        return copyStdNode(this, props)
+  ) {
+    super(node, "VCSSAtRule", loc, start, end, props);
+    this.node = node;
+
+    this.name = getProp(props, node, "name");
+    this.identifier = props.identifier;
+    this.paramsText = props.paramsText ?? node.params;
+    if (props.rawParamsText != null) {
+      this.rawParamsText = props.rawParamsText;
+    } else {
+      const raws = node.raws;
+      this.rawParamsText = raws.params?.raw ?? node.params;
     }
+    this.selectors = props.selectors ?? undefined;
+    this.nodes = props.nodes ?? [];
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSAtRule} copy node
+   */
+  public copy(props?: CopyProps): VCSSAtRule {
+    return copyStdNode(this, props);
+  }
 }
 
 /**
  * The CSS Unknown.
  */
 export class VCSSUnknown extends HasParentNode<
-    "VCSSUnknown",
-    VCSSContainerNode
+  "VCSSUnknown",
+  VCSSContainerNode
 > {
-    public nodes: VCSSNode[]
-
-    public unknownType?: string
-
-    /**
-     * constructor.
-     * @param  {PostCSSNode} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSContainerNode
-            nodes?: VCSSNode[]
-            unknownType?: string
-        },
-    ) {
-        super(node, "VCSSUnknown", loc, start, end, props)
-
-        this.nodes = props.nodes ?? []
-        this.unknownType = props.unknownType
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSUnknown} copy node
-     */
-    public copy(props?: CopyProps): VCSSUnknown {
-        return copyStdNode(this, props)
+  public nodes: VCSSNode[];
+
+  public unknownType?: string;
+
+  /**
+   * constructor.
+   * @param  {PostCSSNode} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSContainerNode;
+      nodes?: VCSSNode[];
+      unknownType?: string;
     }
+  ) {
+    super(node, "VCSSUnknown", loc, start, end, props);
+
+    this.nodes = props.nodes ?? [];
+    this.unknownType = props.unknownType;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSUnknown} copy node
+   */
+  public copy(props?: CopyProps): VCSSUnknown {
+    return copyStdNode(this, props);
+  }
 }
 
 /**
  * The CSS Selector node.
  */
 export class VCSSSelector extends HasParentNode<
-    "VCSSSelector",
-    VCSSStyleRule | VCSSAtRule | VCSSSelectorPseudo
+  "VCSSSelector",
+  VCSSStyleRule | VCSSAtRule | VCSSSelectorPseudo
 > {
-    public nodes: VCSSSelectorValueNode[]
-
-    public parent: VCSSStyleRule | VCSSAtRule | VCSSSelectorPseudo
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSStyleRule | VCSSAtRule | VCSSSelectorPseudo
-            nodes?: VCSSSelectorValueNode[]
-        },
-    ) {
-        super(node, "VCSSSelector", loc, start, end, props)
-
-        this.nodes = props.nodes ?? []
-        this.parent = props.parent
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSSelector} copy node
-     */
-    public copy(props?: CopyProps): VCSSSelector {
-        return copyStdNode(this, props)
-    }
-
-    public get selector(): string {
-        return this.nodes.map((n) => n.selector).join("")
+  public nodes: VCSSSelectorValueNode[];
+
+  public parent: VCSSStyleRule | VCSSAtRule | VCSSSelectorPseudo;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSStyleRule | VCSSAtRule | VCSSSelectorPseudo;
+      nodes?: VCSSSelectorValueNode[];
     }
+  ) {
+    super(node, "VCSSSelector", loc, start, end, props);
+
+    this.nodes = props.nodes ?? [];
+    this.parent = props.parent;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSSelector} copy node
+   */
+  public copy(props?: CopyProps): VCSSSelector {
+    return copyStdNode(this, props);
+  }
+
+  public get selector(): string {
+    return this.nodes.map((n) => n.selector).join("");
+  }
 }
 /**
  * The CSS Type Selector node.
  */
 export class VCSSTypeSelector extends HasParentNode<
-    "VCSSTypeSelector",
-    VCSSSelector
+  "VCSSTypeSelector",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPTypeNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSSelector
-            value?: string
-        },
-    ) {
-        super(node, "VCSSTypeSelector", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-        this.selector = this.value
+  public readonly value: string;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPTypeNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSSelector;
+      value?: string;
     }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSTypeSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSTypeSelector {
-        return copyStdNode(this, props)
+  ) {
+    super(node, "VCSSTypeSelector", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+    this.selector = this.value;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSTypeSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSTypeSelector {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS ID Selector node.
  */
 export class VCSSIDSelector extends HasParentNode<
-    "VCSSIDSelector",
-    VCSSSelector
+  "VCSSIDSelector",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPIDNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSSelector; value?: string },
-    ) {
-        super(node, "VCSSIDSelector", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-        this.selector = `#${this.value}`
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSIDSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSIDSelector {
-        return copyStdNode(this, props)
+  public readonly value: string;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPIDNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSSelector; value?: string }
+  ) {
+    super(node, "VCSSIDSelector", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+    this.selector = `#${this.value}`;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSIDSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSIDSelector {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Class Selector node.
  */
 export class VCSSClassSelector extends HasParentNode<
-    "VCSSClassSelector",
-    VCSSSelector
+  "VCSSClassSelector",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPClassNameNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSSelector; value?: string },
-    ) {
-        super(node, "VCSSClassSelector", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-        this.selector = `.${this.value}`
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSClassSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSClassSelector {
-        return copyStdNode(this, props)
+  public readonly value: string;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPClassNameNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSSelector; value?: string }
+  ) {
+    super(node, "VCSSClassSelector", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+    this.selector = `.${this.value}`;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSClassSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSClassSelector {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Nesting Selector node.
  */
 export class VCSSNestingSelector extends HasParentNode<
-    "VCSSNestingSelector",
-    VCSSSelector
+  "VCSSNestingSelector",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPNestingNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSSelector; value?: string },
-    ) {
-        super(node, "VCSSNestingSelector", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-        this.selector = this.value
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSNestingSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSNestingSelector {
-        return copyStdNode(this, props)
+  public readonly value: string;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPNestingNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSSelector; value?: string }
+  ) {
+    super(node, "VCSSNestingSelector", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+    this.selector = this.value;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSNestingSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSNestingSelector {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Universal Selector node.
  */
 export class VCSSUniversalSelector extends HasParentNode<
-    "VCSSUniversalSelector",
-    VCSSSelector
+  "VCSSUniversalSelector",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPUniversalNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSSelector; value?: string },
-    ) {
-        super(node, "VCSSUniversalSelector", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-        this.selector = this.value
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSUniversalSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSUniversalSelector {
-        return copyStdNode(this, props)
+  public readonly value: string;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPUniversalNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSSelector; value?: string }
+  ) {
+    super(node, "VCSSUniversalSelector", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+    this.selector = this.value;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSUniversalSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSUniversalSelector {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Attribuute Selector node.
  */
 export class VCSSAttributeSelector extends HasParentNode<
-    "VCSSAttributeSelector",
-    VCSSSelector
+  "VCSSAttributeSelector",
+  VCSSSelector
 > {
-    public readonly value: string | null
-
-    public readonly attribute: string
-
-    public readonly operator: string | null
-
-    public readonly quoteMark: string | null
-
-    public readonly insensitiveFlag: string | null
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPAttributeNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSSelector
-            value?: string
-            insensitiveFlag?: string
-        },
-    ) {
-        super(node, "VCSSAttributeSelector", loc, start, end, props)
-
-        this.attribute = getProp(props, node, "attribute")
-        const operator = getProp(props, node, "operator")
-        this.operator = operator ?? null
-        const value = getProp(props, node, "value")
-        this.value = value ?? null
-        const quoteMark = getProp(props, node, "quoteMark")
-        this.quoteMark = quoteMark ?? null
-
-        const raws = node.raws
-        if (props.insensitiveFlag != null) {
-            this.insensitiveFlag = props.insensitiveFlag
-        } else if (raws.insensitiveFlag != null) {
-            this.insensitiveFlag = raws.insensitiveFlag
-        } else if (node.insensitive) {
-            this.insensitiveFlag = "i"
-        } else {
-            this.insensitiveFlag = null
-        }
-        this.selector = this.refreshSelector()
+  public readonly value: string | null;
+
+  public readonly attribute: string;
+
+  public readonly operator: string | null;
+
+  public readonly quoteMark: string | null;
+
+  public readonly insensitiveFlag: string | null;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPAttributeNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSSelector;
+      value?: string;
+      insensitiveFlag?: string;
     }
-
-    private refreshSelector() {
-        let selector = `[${this.attribute}`
-        if (this.operator != null) {
-            selector += this.operator
-            if (this.value != null) {
-                selector += this.quoteMark
-                    ? this.quoteMark + this.value + this.quoteMark
-                    : this.value
-            }
-        }
-        if (this.insensitiveFlag != null) {
-            selector += ` ${this.insensitiveFlag}`
-        }
-        selector += "]"
-        return selector
+  ) {
+    super(node, "VCSSAttributeSelector", loc, start, end, props);
+
+    this.attribute = getProp(props, node, "attribute");
+    const operator = getProp(props, node, "operator");
+    this.operator = operator ?? null;
+    const value = getProp(props, node, "value");
+    this.value = value ?? null;
+    const quoteMark = getProp(props, node, "quoteMark");
+    this.quoteMark = quoteMark ?? null;
+
+    const raws = node.raws;
+    if (props.insensitiveFlag != null) {
+      this.insensitiveFlag = props.insensitiveFlag;
+    } else if (raws.insensitiveFlag != null) {
+      this.insensitiveFlag = raws.insensitiveFlag;
+    } else if (node.insensitive) {
+      this.insensitiveFlag = "i";
+    } else {
+      this.insensitiveFlag = null;
     }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSAttributeSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSAttributeSelector {
-        return copyStdNode(this, props)
+    this.selector = this.refreshSelector();
+  }
+
+  private refreshSelector() {
+    let selector = `[${this.attribute}`;
+    if (this.operator != null) {
+      selector += this.operator;
+      if (this.value != null) {
+        selector += this.quoteMark
+          ? this.quoteMark + this.value + this.quoteMark
+          : this.value;
+      }
+    }
+    if (this.insensitiveFlag != null) {
+      selector += ` ${this.insensitiveFlag}`;
+    }
+    selector += "]";
+    return selector;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSAttributeSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSAttributeSelector {
+    return copyStdNode(this, props);
+  }
 }
 /**
  * The CSS Pseudo node.
  */
 export class VCSSSelectorPseudo extends HasParentNode<
-    "VCSSSelectorPseudo",
-    VCSSSelector
+  "VCSSSelectorPseudo",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public nodes: VCSSSelector[]
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPPseudoNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSSelector
-            nodes?: VCSSSelector[]
-        },
-    ) {
-        super(node, "VCSSSelectorPseudo", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-
-        this.nodes = props.nodes ?? []
+  public readonly value: string;
+
+  public nodes: VCSSSelector[];
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPPseudoNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSSelector;
+      nodes?: VCSSSelector[];
     }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSSelectorPseudo} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSSelectorPseudo {
-        return copyStdNode(this, props)
+  ) {
+    super(node, "VCSSSelectorPseudo", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+
+    this.nodes = props.nodes ?? [];
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSSelectorPseudo} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSSelectorPseudo {
+    return copyStdNode(this, props);
+  }
 
-    public get selector(): string {
-        if (!this.nodes.length) {
-            return this.value
-        }
-        const params = this.nodes.map((n) => n.selector).join(",")
-        return `${this.value}(${params})`
+  public get selector(): string {
+    if (!this.nodes.length) {
+      return this.value;
     }
+    const params = this.nodes.map((n) => n.selector).join(",");
+    return `${this.value}(${params})`;
+  }
 }
 
 /**
  * The CSS Selector Combinator node.
  */
 export class VCSSSelectorCombinator extends HasParentNode<
-    "VCSSSelectorCombinator",
-    VCSSSelector
+  "VCSSSelectorCombinator",
+  VCSSSelector
 > {
-    public value: string
-
-    public selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPCombinatorNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSSelector; value?: string },
-    ) {
-        super(node, "VCSSSelectorCombinator", loc, start, end, props)
-        this.value = getProp(props, node, "value")
-        this.selector = this.value
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSSelectorCombinator} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSSelectorCombinator {
-        return copyStdNode(this, props)
+  public value: string;
+
+  public selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPCombinatorNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSSelector; value?: string }
+  ) {
+    super(node, "VCSSSelectorCombinator", loc, start, end, props);
+    this.value = getProp(props, node, "value");
+    this.selector = this.value;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSSelectorCombinator} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSSelectorCombinator {
+    return copyStdNode(this, props);
+  }
 }
 
 /**
  * The CSS Unknown Selector node.
  */
 export class VCSSUnknownSelector extends HasParentNode<
-    "VCSSUnknownSelector",
-    VCSSSelector
+  "VCSSUnknownSelector",
+  VCSSSelector
 > {
-    public readonly value: string
-
-    public readonly selector: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSSPNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: {
-            parent: VCSSSelector
-        },
-    ) {
-        super(node, "VCSSUnknownSelector", loc, start, end, props)
-        this.value = getProp(props, node, "value") || ""
-        this.selector = this.value
+  public readonly value: string;
+
+  public readonly selector: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSSPNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: {
+      parent: VCSSSelector;
     }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSUnknownSelector} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSSelector
-            value?: string
-        },
-    ): VCSSUnknownSelector {
-        return copyStdNode(this, props)
+  ) {
+    super(node, "VCSSUnknownSelector", loc, start, end, props);
+    this.value = getProp(props, node, "value") || "";
+    this.selector = this.value;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSUnknownSelector} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSSelector;
+      value?: string;
     }
+  ): VCSSUnknownSelector {
+    return copyStdNode(this, props);
+  }
 }
 
 /**
  * The CSS Comment node.
  */
 export class VCSSComment extends HasParentNode<
-    "VCSSComment",
-    VCSSContainerNode | VCSSSelector
+  "VCSSComment",
+  VCSSContainerNode | VCSSSelector
 > {
-    public readonly node: PostCSSComment | PostCSSSPCommentNode
-
-    public readonly text: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {string} text  The contents.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSComment | PostCSSSPCommentNode,
-        text: string,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSContainerNode | VCSSSelector },
-    ) {
-        super(node, "VCSSComment", loc, start, end, props)
-        this.node = node
-        this.text = text
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSComment} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSContainerNode | VCSSSelector
-            node?: PostCSSComment | PostCSSSPCommentNode
-            text?: string
-        },
-    ): VCSSComment {
-        const parent = props?.parent ?? this.parent
-        return new VCSSComment(
-            props?.node ?? this.node,
-            props?.text ?? this.text,
-            props?.loc ?? this.loc,
-            props?.start ?? this.start,
-            props?.end ?? this.end,
-            { ...this, ...props, parent },
-        )
+  public readonly node: PostCSSComment | PostCSSSPCommentNode;
+
+  public readonly text: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {string} text  The contents.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSComment | PostCSSSPCommentNode,
+    text: string,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSContainerNode | VCSSSelector }
+  ) {
+    super(node, "VCSSComment", loc, start, end, props);
+    this.node = node;
+    this.text = text;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSComment} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSContainerNode | VCSSSelector;
+      node?: PostCSSComment | PostCSSSPCommentNode;
+      text?: string;
     }
+  ): VCSSComment {
+    const parent = props?.parent ?? this.parent;
+    return new VCSSComment(
+      props?.node ?? this.node,
+      props?.text ?? this.text,
+      props?.loc ?? this.loc,
+      props?.start ?? this.start,
+      props?.end ?? this.end,
+      { ...this, ...props, parent }
+    );
+  }
 }
 /**
  * The CSS Inline Comment node.
  */
 export class VCSSInlineComment extends HasParentNode<
-    "VCSSInlineComment",
-    VCSSContainerNode | VCSSSelector
+  "VCSSInlineComment",
+  VCSSContainerNode | VCSSSelector
 > {
-    public readonly node: PostCSSComment | PostCSSSPCommentNode
-
-    public readonly text: string
-
-    /**
-     * constructor.
-     * @param  {object} node  The node.
-     * @param  {string} text  The contents.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {object} props  The optional property.
-     * @returns {void}
-     */
-    public constructor(
-        node: PostCSSComment | PostCSSSPCommentNode,
-        text: string,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        props: { parent: VCSSContainerNode | VCSSSelector },
-    ) {
-        super(node, "VCSSInlineComment", loc, start, end, props)
-        this.node = node
-        this.text = text
-    }
-
-    /**
-     * Copy
-     * @param  {object} props  The optional change property.
-     * @returns {VCSSInlineComment} copy node
-     */
-    public copy(
-        props?: CopyProps & {
-            parent?: VCSSContainerNode | VCSSSelector
-            node?: PostCSSComment | PostCSSSPCommentNode
-            text?: string
-        },
-    ): VCSSInlineComment {
-        const parent = props?.parent ?? this.parent
-        return new VCSSInlineComment(
-            props?.node ?? this.node,
-            props?.text ?? this.text,
-            props?.loc ?? this.loc,
-            props?.start ?? this.start,
-            props?.end ?? this.end,
-            { ...this, ...props, parent },
-        )
+  public readonly node: PostCSSComment | PostCSSSPCommentNode;
+
+  public readonly text: string;
+
+  /**
+   * constructor.
+   * @param  {object} node  The node.
+   * @param  {string} text  The contents.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {object} props  The optional property.
+   * @returns {void}
+   */
+  public constructor(
+    node: PostCSSComment | PostCSSSPCommentNode,
+    text: string,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    props: { parent: VCSSContainerNode | VCSSSelector }
+  ) {
+    super(node, "VCSSInlineComment", loc, start, end, props);
+    this.node = node;
+    this.text = text;
+  }
+
+  /**
+   * Copy
+   * @param  {object} props  The optional change property.
+   * @returns {VCSSInlineComment} copy node
+   */
+  public copy(
+    props?: CopyProps & {
+      parent?: VCSSContainerNode | VCSSSelector;
+      node?: PostCSSComment | PostCSSSPCommentNode;
+      text?: string;
     }
+  ): VCSSInlineComment {
+    const parent = props?.parent ?? this.parent;
+    return new VCSSInlineComment(
+      props?.node ?? this.node,
+      props?.text ?? this.text,
+      props?.loc ?? this.loc,
+      props?.start ?? this.start,
+      props?.end ?? this.end,
+      { ...this, ...props, parent }
+    );
+  }
 }
 
-export type VCSS = VCSSNode | VCSSSelectorNode
+export type VCSS = VCSSNode | VCSSSelectorNode;
 
 export type VCSSNode =
-    | VCSSContainerNode
-    | VCSSDeclarationProperty
-    | VCSSCommentNode
-export type VCSSCommentNode = VCSSInlineComment | VCSSComment
+  | VCSSContainerNode
+  | VCSSDeclarationProperty
+  | VCSSCommentNode;
+export type VCSSCommentNode = VCSSInlineComment | VCSSComment;
 export type VCSSContainerNode =
-    | VCSSStyleSheet
-    | VCSSStyleRule
-    | VCSSAtRule
-    | VCSSUnknown
+  | VCSSStyleSheet
+  | VCSSStyleRule
+  | VCSSAtRule
+  | VCSSUnknown;
 
 // selectors
 export type VCSSSelectorNode =
-    | VCSSSelector
-    | VCSSTypeSelector
-    | VCSSIDSelector
-    | VCSSClassSelector
-    | VCSSNestingSelector
-    | VCSSUniversalSelector
-    | VCSSAttributeSelector
-    | VCSSSelectorPseudo
-    | VCSSSelectorCombinator
-    | VCSSUnknownSelector
+  | VCSSSelector
+  | VCSSTypeSelector
+  | VCSSIDSelector
+  | VCSSClassSelector
+  | VCSSNestingSelector
+  | VCSSUniversalSelector
+  | VCSSAttributeSelector
+  | VCSSSelectorPseudo
+  | VCSSSelectorCombinator
+  | VCSSUnknownSelector;
 export type VCSSSelectorValueNode =
-    | VCSSTypeSelector
-    | VCSSIDSelector
-    | VCSSClassSelector
-    | VCSSNestingSelector
-    | VCSSUniversalSelector
-    | VCSSAttributeSelector
-    | VCSSSelectorPseudo
-    | VCSSSelectorCombinator
-    | VCSSUnknownSelector
+  | VCSSTypeSelector
+  | VCSSIDSelector
+  | VCSSClassSelector
+  | VCSSNestingSelector
+  | VCSSUniversalSelector
+  | VCSSAttributeSelector
+  | VCSSSelectorPseudo
+  | VCSSSelectorCombinator
+  | VCSSUnknownSelector;
 
 /**
  * Get property from given props or node
@@ -1085,16 +1083,16 @@ export type VCSSSelectorValueNode =
  * @param {string} name name of property
  */
 function getProp<N extends PostCSSNode | PostCSSSPNode, K extends keyof N>(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-    props: any,
-    node: N,
-    name: K,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+  props: any,
+  node: N,
+  name: K
 ): N[K] {
-    if (props?.[name] != null) {
-        const v = props[name]
-        return v
-    }
-    return node[name]
+  if (props?.[name] != null) {
+    const v = props[name];
+    return v;
+  }
+  return node[name];
 }
 
 /**
@@ -1103,16 +1101,16 @@ function getProp<N extends PostCSSNode | PostCSSSPNode, K extends keyof N>(
  * @param props The optional property.
  */
 function copyStdNode<N extends Node<T>, T extends string, CP extends CopyProps>(
-    astNode: N,
-    props?: CP,
+  astNode: N,
+  props?: CP
 ): N & Required<CP> {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-    const C = astNode.constructor as new (...args: any[]) => N & Required<CP>
-    return new C(
-        props?.node ?? astNode.node,
-        props?.loc ?? astNode.loc,
-        props?.start ?? astNode.start,
-        props?.end ?? astNode.end,
-        { ...astNode, ...props },
-    )
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+  const C = astNode.constructor as new (...args: any[]) => N & Required<CP>;
+  return new C(
+    props?.node ?? astNode.node,
+    props?.loc ?? astNode.loc,
+    props?.start ?? astNode.start,
+    props?.end ?? astNode.end,
+    { ...astNode, ...props }
+  );
 }
diff --git a/lib/styles/context/comment-directive/index.ts b/lib/styles/context/comment-directive/index.ts
index c925208e..0ac425ec 100644
--- a/lib/styles/context/comment-directive/index.ts
+++ b/lib/styles/context/comment-directive/index.ts
@@ -1,20 +1,20 @@
 import type {
-    LineAndColumnData,
-    ReportDescriptor,
-    RuleContext,
-    SourceLocation,
-    ReportDescriptorSourceLocation,
-} from "../../../types"
-import type { StyleContext } from "../style"
-import type { VCSSCommentNode } from "../../ast"
+  LineAndColumnData,
+  ReportDescriptor,
+  RuleContext,
+  SourceLocation,
+  ReportDescriptorSourceLocation,
+} from "../../../types";
+import type { StyleContext } from "../style";
+import type { VCSSCommentNode } from "../../ast";
 
 const COMMENT_DIRECTIVE_B =
-    /^\s*(eslint-(?:en|dis)able)(?:\s+(\S|\S[\s\S]*\S))?\s*$/u
+  /^\s*(eslint-(?:en|dis)able)(?:\s+(\S|\S[\s\S]*\S))?\s*$/u;
 const COMMENT_DIRECTIVE_L =
-    /^\s*(eslint-disable(?:-next)?-line)(?:\s+(\S|\S[\s\S]*\S))?\s*$/u
+  /^\s*(eslint-disable(?:-next)?-line)(?:\s+(\S|\S[\s\S]*\S))?\s*$/u;
 
-type ParsingResult = { type: string; rules: string[] }
-type BlockData = { loc: LineAndColumnData; disable: boolean }
+type ParsingResult = { type: string; rules: string[] };
+type BlockData = { loc: LineAndColumnData; disable: boolean };
 
 /**
  * Parse a given comment.
@@ -23,18 +23,18 @@ type BlockData = { loc: LineAndColumnData; disable: boolean }
  * @returns {({type:string,rules:string[]})|null} The parsing result.
  */
 function parse(pattern: RegExp, comment: string): ParsingResult | null {
-    const match = pattern.exec(comment)
-    if (match == null) {
-        return null
-    }
-
-    const type = match[1]
-    const rules = (match[2] || "")
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean)
-
-    return { type, rules }
+  const match = pattern.exec(comment);
+  if (match == null) {
+    return null;
+  }
+
+  const type = match[1];
+  const rules = (match[2] || "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  return { type, rules };
 }
 
 /**
@@ -45,15 +45,15 @@ function parse(pattern: RegExp, comment: string): ParsingResult | null {
  * @returns {void}
  */
 function enable(
-    commentDirectives: CommentDirectives,
-    loc: LineAndColumnData,
-    rules: string[],
+  commentDirectives: CommentDirectives,
+  loc: LineAndColumnData,
+  rules: string[]
 ) {
-    if (rules.length === 0) {
-        commentDirectives.enableAll(loc)
-    } else {
-        commentDirectives.enableRules(loc, rules)
-    }
+  if (rules.length === 0) {
+    commentDirectives.enableAll(loc);
+  } else {
+    commentDirectives.enableRules(loc, rules);
+  }
 }
 
 /**
@@ -64,15 +64,15 @@ function enable(
  * @returns {void}
  */
 function disable(
-    commentDirectives: CommentDirectives,
-    loc: LineAndColumnData,
-    rules: string[],
+  commentDirectives: CommentDirectives,
+  loc: LineAndColumnData,
+  rules: string[]
 ) {
-    if (rules.length === 0) {
-        commentDirectives.disableAll(loc)
-    } else {
-        commentDirectives.disableRules(loc, rules)
-    }
+  if (rules.length === 0) {
+    commentDirectives.disableAll(loc);
+  } else {
+    commentDirectives.disableRules(loc, rules);
+  }
 }
 
 /**
@@ -83,17 +83,17 @@ function disable(
  * @returns {void}
  */
 function processBlock(
-    commentDirectives: CommentDirectives,
-    comment: VCSSCommentNode,
+  commentDirectives: CommentDirectives,
+  comment: VCSSCommentNode
 ) {
-    const parsed = parse(COMMENT_DIRECTIVE_B, comment.text)
-    if (parsed != null) {
-        if (parsed.type === "eslint-disable") {
-            disable(commentDirectives, comment.loc.start, parsed.rules)
-        } else {
-            enable(commentDirectives, comment.loc.start, parsed.rules)
-        }
+  const parsed = parse(COMMENT_DIRECTIVE_B, comment.text);
+  if (parsed != null) {
+    if (parsed.type === "eslint-disable") {
+      disable(commentDirectives, comment.loc.start, parsed.rules);
+    } else {
+      enable(commentDirectives, comment.loc.start, parsed.rules);
     }
+  }
 }
 
 /**
@@ -104,179 +104,178 @@ function processBlock(
  * @returns {void}
  */
 function processLine(
-    commentDirectives: CommentDirectives,
-    comment: VCSSCommentNode,
+  commentDirectives: CommentDirectives,
+  comment: VCSSCommentNode
 ) {
-    const parsed = parse(COMMENT_DIRECTIVE_L, comment.text)
-    if (parsed != null && comment.loc.start.line === comment.loc.end.line) {
-        const line =
-            comment.loc.start.line +
-            (parsed.type === "eslint-disable-line" ? 0 : 1)
-        const column = -1
-        if (!parsed.rules.length) {
-            commentDirectives.disableLineAll({ line, column })
-        } else {
-            commentDirectives.disableLineRules({ line, column }, parsed.rules)
-        }
+  const parsed = parse(COMMENT_DIRECTIVE_L, comment.text);
+  if (parsed != null && comment.loc.start.line === comment.loc.end.line) {
+    const line =
+      comment.loc.start.line + (parsed.type === "eslint-disable-line" ? 0 : 1);
+    const column = -1;
+    if (!parsed.rules.length) {
+      commentDirectives.disableLineAll({ line, column });
+    } else {
+      commentDirectives.disableLineRules({ line, column }, parsed.rules);
     }
+  }
 }
 
 export class CommentDirectives {
-    private _disableLines: {
-        [key: number]: {
-            all: boolean
-            [key: string]: boolean
+  private _disableLines: {
+    [key: number]: {
+      all: boolean;
+      [key: string]: boolean;
+    };
+  };
+
+  private _disableBlocks: { [key: string]: BlockData[] };
+
+  /**
+   * constructor
+   * @param {StyleContext[]} styles The styles
+   * @returns {void}
+   */
+  public constructor(styles: StyleContext[]) {
+    this._disableLines = {};
+    this._disableBlocks = {};
+
+    for (const style of styles) {
+      const cssNode = style.cssNode;
+      if (cssNode != null) {
+        for (const comment of cssNode.comments) {
+          processBlock(this, comment);
+          processLine(this, comment);
         }
+        this.clear(cssNode.loc.end);
+      }
     }
 
-    private _disableBlocks: { [key: string]: BlockData[] }
-
-    /**
-     * constructor
-     * @param {StyleContext[]} styles The styles
-     * @returns {void}
-     */
-    public constructor(styles: StyleContext[]) {
-        this._disableLines = {}
-        this._disableBlocks = {}
-
-        for (const style of styles) {
-            const cssNode = style.cssNode
-            if (cssNode != null) {
-                for (const comment of cssNode.comments) {
-                    processBlock(this, comment)
-                    processLine(this, comment)
-                }
-                this.clear(cssNode.loc.end)
-            }
-        }
-
-        for (const rule of Object.keys(this._disableBlocks)) {
-            this._disableBlocks[rule].sort((a, b) => compareLoc(a.loc, b.loc))
-        }
+    for (const rule of Object.keys(this._disableBlocks)) {
+      this._disableBlocks[rule].sort((a, b) => compareLoc(a.loc, b.loc));
     }
-
-    public disableLineAll(loc: LineAndColumnData): void {
-        const disableLine =
-            this._disableLines[loc.line] ||
-            (this._disableLines[loc.line] = { all: true })
-        disableLine.all = true
+  }
+
+  public disableLineAll(loc: LineAndColumnData): void {
+    const disableLine =
+      this._disableLines[loc.line] ||
+      (this._disableLines[loc.line] = { all: true });
+    disableLine.all = true;
+  }
+
+  public disableLineRules(loc: LineAndColumnData, rules: string[]): void {
+    const disableLine =
+      this._disableLines[loc.line] ||
+      (this._disableLines[loc.line] = { all: false });
+    for (const rule of rules) {
+      disableLine[rule] = true;
     }
-
-    public disableLineRules(loc: LineAndColumnData, rules: string[]): void {
-        const disableLine =
-            this._disableLines[loc.line] ||
-            (this._disableLines[loc.line] = { all: false })
-        for (const rule of rules) {
-            disableLine[rule] = true
-        }
+  }
+
+  public disableAll(loc: LineAndColumnData): void {
+    const disableBlock =
+      this._disableBlocks.all || (this._disableBlocks.all = []);
+    disableBlock.push({ loc, disable: true });
+  }
+
+  public disableRules(loc: LineAndColumnData, rules: string[]): void {
+    for (const rule of rules) {
+      const disableBlock =
+        this._disableBlocks[rule] || (this._disableBlocks[rule] = []);
+      disableBlock.push({ loc, disable: true });
     }
-
-    public disableAll(loc: LineAndColumnData): void {
-        const disableBlock =
-            this._disableBlocks.all || (this._disableBlocks.all = [])
-        disableBlock.push({ loc, disable: true })
+  }
+
+  public enableAll(loc: LineAndColumnData): void {
+    const disableBlock =
+      this._disableBlocks.all || (this._disableBlocks.all = []);
+    disableBlock.push({ loc, disable: false });
+  }
+
+  public enableRules(loc: LineAndColumnData, rules: string[]): void {
+    for (const rule of rules) {
+      const disableBlock =
+        this._disableBlocks[rule] || (this._disableBlocks[rule] = []);
+      disableBlock.push({ loc, disable: false });
     }
+  }
 
-    public disableRules(loc: LineAndColumnData, rules: string[]): void {
-        for (const rule of rules) {
-            const disableBlock =
-                this._disableBlocks[rule] || (this._disableBlocks[rule] = [])
-            disableBlock.push({ loc, disable: true })
-        }
+  public clear(loc: LineAndColumnData): void {
+    for (const rule of Object.keys(this._disableBlocks)) {
+      this._disableBlocks[rule].push({ loc, disable: false });
     }
-
-    public enableAll(loc: LineAndColumnData): void {
-        const disableBlock =
-            this._disableBlocks.all || (this._disableBlocks.all = [])
-        disableBlock.push({ loc, disable: false })
+  }
+
+  /**
+   * Checks if rule is enabled or not
+   * @param {string} rule
+   * @param {ReportDescriptor} descriptor ESLint report descriptor
+   * @returns {boolean} `true` if rule is enabled
+   */
+  public isEnabled(rule: string, descriptor: ReportDescriptor): boolean {
+    const loc = hasSourceLocation(descriptor)
+      ? descriptor.loc
+      : descriptor.node?.loc;
+    if (!loc) {
+      return false;
     }
+    const locStart = (loc as SourceLocation).start || loc;
 
-    public enableRules(loc: LineAndColumnData, rules: string[]): void {
-        for (const rule of rules) {
-            const disableBlock =
-                this._disableBlocks[rule] || (this._disableBlocks[rule] = [])
-            disableBlock.push({ loc, disable: false })
-        }
+    const disableLine = this._disableLines[locStart.line];
+    if (disableLine) {
+      if (disableLine.all || disableLine[rule]) {
+        return false;
+      }
     }
 
-    public clear(loc: LineAndColumnData): void {
-        for (const rule of Object.keys(this._disableBlocks)) {
-            this._disableBlocks[rule].push({ loc, disable: false })
+    for (const ruleId of [rule, "all"]) {
+      const disableBlock = this._disableBlocks[ruleId];
+      if (disableBlock) {
+        let disableState = false;
+        for (const block of disableBlock) {
+          if (compareLoc(locStart, block.loc) < 0) {
+            break;
+          }
+          disableState = block.disable;
         }
-    }
-
-    /**
-     * Checks if rule is enabled or not
-     * @param {string} rule
-     * @param {ReportDescriptor} descriptor ESLint report descriptor
-     * @returns {boolean} `true` if rule is enabled
-     */
-    public isEnabled(rule: string, descriptor: ReportDescriptor): boolean {
-        const loc = hasSourceLocation(descriptor)
-            ? descriptor.loc
-            : descriptor.node?.loc
-        if (!loc) {
-            return false
-        }
-        const locStart = (loc as SourceLocation).start || loc
-
-        const disableLine = this._disableLines[locStart.line]
-        if (disableLine) {
-            if (disableLine.all || disableLine[rule]) {
-                return false
-            }
-        }
-
-        for (const ruleId of [rule, "all"]) {
-            const disableBlock = this._disableBlocks[ruleId]
-            if (disableBlock) {
-                let disableState = false
-                for (const block of disableBlock) {
-                    if (compareLoc(locStart, block.loc) < 0) {
-                        break
-                    }
-                    disableState = block.disable
-                }
-                if (disableState) {
-                    return false
-                }
-            }
+        if (disableState) {
+          return false;
         }
-
-        return true
+      }
     }
+
+    return true;
+  }
 }
 
 export class CommentDirectivesReporter {
-    private readonly context: RuleContext
-
-    private readonly commentDirectives: CommentDirectives
-
-    /**
-     * constructor
-     * @param {RuleContext} context ESLint rule context
-     * @param {CommentDirectives} commentDirectives The comment directives context.
-     * @returns {void}
-     */
-    public constructor(
-        context: RuleContext,
-        commentDirectives: CommentDirectives,
-    ) {
-        this.context = context
-        this.commentDirectives = commentDirectives
-    }
+  private readonly context: RuleContext;
 
-    /**
-     * Reports a problem in the code.
-     * @param {ReportDescriptor} descriptor ESLint report descriptor
-     * @returns {void}
-     */
-    public report(descriptor: ReportDescriptor): void {
-        if (this.commentDirectives.isEnabled(this.context.id, descriptor)) {
-            this.context.report(descriptor)
-        }
+  private readonly commentDirectives: CommentDirectives;
+
+  /**
+   * constructor
+   * @param {RuleContext} context ESLint rule context
+   * @param {CommentDirectives} commentDirectives The comment directives context.
+   * @returns {void}
+   */
+  public constructor(
+    context: RuleContext,
+    commentDirectives: CommentDirectives
+  ) {
+    this.context = context;
+    this.commentDirectives = commentDirectives;
+  }
+
+  /**
+   * Reports a problem in the code.
+   * @param {ReportDescriptor} descriptor ESLint report descriptor
+   * @returns {void}
+   */
+  public report(descriptor: ReportDescriptor): void {
+    if (this.commentDirectives.isEnabled(this.context.id, descriptor)) {
+      this.context.report(descriptor);
     }
+  }
 }
 
 /**
@@ -286,9 +285,9 @@ export class CommentDirectivesReporter {
  * @returns {CommentDirectives} the comment directives context
  */
 export function createCommentDirectives(
-    styleContexts: StyleContext[],
+  styleContexts: StyleContext[]
 ): CommentDirectives {
-    return new CommentDirectives(styleContexts)
+  return new CommentDirectives(styleContexts);
 }
 
 /**
@@ -298,10 +297,10 @@ export function createCommentDirectives(
  * @returns {CommentDirectivesReporter} the comment directives
  */
 export function createCommentDirectivesReporter(
-    context: RuleContext,
-    commentDirectives: CommentDirectives,
+  context: RuleContext,
+  commentDirectives: CommentDirectives
 ): CommentDirectivesReporter {
-    return new CommentDirectivesReporter(context, commentDirectives)
+  return new CommentDirectivesReporter(context, commentDirectives);
 }
 
 /**
@@ -310,12 +309,12 @@ export function createCommentDirectivesReporter(
  * @param {*} b The second value
  */
 function compare(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check compare
-    a: any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check compare
-    b: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check compare
+  a: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check compare
+  b: any
 ) {
-    return a === b ? 0 : a > b ? 1 : -1
+  return a === b ? 0 : a > b ? 1 : -1;
 }
 
 /**
@@ -324,18 +323,18 @@ function compare(
  * @param {*} b The second value
  */
 function compareLoc(a: LineAndColumnData, b: LineAndColumnData) {
-    const lc = compare(a.line, b.line)
-    if (lc !== 0) {
-        return lc
-    }
-    return compare(a.column, b.column)
+  const lc = compare(a.line, b.line);
+  if (lc !== 0) {
+    return lc;
+  }
+  return compare(a.column, b.column);
 }
 
 /**
  * Checks whether the given descriptor has loc property
  */
 function hasSourceLocation(
-    descriptor: ReportDescriptor,
+  descriptor: ReportDescriptor
 ): descriptor is ReportDescriptor & ReportDescriptorSourceLocation {
-    return (descriptor as ReportDescriptorSourceLocation).loc != null
+  return (descriptor as ReportDescriptorSourceLocation).loc != null;
 }
diff --git a/lib/styles/context/index.ts b/lib/styles/context/index.ts
index 00f13c29..4bd7e05e 100644
--- a/lib/styles/context/index.ts
+++ b/lib/styles/context/index.ts
@@ -1,45 +1,45 @@
 import {
-    createStyleContexts,
-    StyleContext,
-    isValidStyleContext,
-    ValidStyleContext,
-    InvalidStyleContext,
-} from "./style"
-import type { CommentDirectives } from "./comment-directive"
+  createStyleContexts,
+  StyleContext,
+  isValidStyleContext,
+  ValidStyleContext,
+  InvalidStyleContext,
+} from "./style";
+import type { CommentDirectives } from "./comment-directive";
 import {
-    CommentDirectivesReporter,
-    createCommentDirectivesReporter,
-    createCommentDirectives,
-} from "./comment-directive"
-import type { RuleContext } from "../../types"
-import type { AST } from "vue-eslint-parser"
+  CommentDirectivesReporter,
+  createCommentDirectivesReporter,
+  createCommentDirectives,
+} from "./comment-directive";
+import type { RuleContext } from "../../types";
+import type { AST } from "vue-eslint-parser";
 import {
-    VueComponentContext,
-    createVueComponentContext,
-} from "./vue-components"
+  VueComponentContext,
+  createVueComponentContext,
+} from "./vue-components";
 
 type CacheValue = {
-    styles?: StyleContext[]
-    comment?: CommentDirectives
-    vueComponent?: VueComponentContext | null
-}
+  styles?: StyleContext[];
+  comment?: CommentDirectives;
+  vueComponent?: VueComponentContext | null;
+};
 /**
  * @type {WeakMap<Program, CacheValue>}
  */
-const CACHE = new WeakMap<AST.ESLintProgram, CacheValue>()
+const CACHE = new WeakMap<AST.ESLintProgram, CacheValue>();
 
 /**
  * Gets the cache.
  */
 function getCache(context: RuleContext): CacheValue {
-    const sourceCode = context.getSourceCode()
-    const { ast } = sourceCode
-    if (CACHE.has(ast)) {
-        return CACHE.get(ast) as CacheValue
-    }
-    const cache = {}
-    CACHE.set(ast, cache)
-    return cache
+  const sourceCode = context.getSourceCode();
+  const { ast } = sourceCode;
+  if (CACHE.has(ast)) {
+    return CACHE.get(ast) as CacheValue;
+  }
+  const cache = {};
+  CACHE.set(ast, cache);
+  return cache;
 }
 
 /**
@@ -48,11 +48,11 @@ function getCache(context: RuleContext): CacheValue {
  * @returns {StyleContext[]} the style contexts
  */
 export function getStyleContexts(context: RuleContext): StyleContext[] {
-    const cache = getCache(context)
-    if (cache.styles) {
-        return cache.styles
-    }
-    return (cache.styles = createStyleContexts(context))
+  const cache = getCache(context);
+  if (cache.styles) {
+    return cache.styles;
+  }
+  return (cache.styles = createStyleContexts(context));
 }
 /**
  * Gets the comment directive reporter from given rule context.
@@ -60,12 +60,12 @@ export function getStyleContexts(context: RuleContext): StyleContext[] {
  * @returns {CommentDirectivesReporter} the comment directives
  */
 export function getCommentDirectivesReporter(
-    context: RuleContext,
+  context: RuleContext
 ): CommentDirectivesReporter {
-    return createCommentDirectivesReporter(
-        context,
-        getCommentDirectives(context),
-    )
+  return createCommentDirectivesReporter(
+    context,
+    getCommentDirectives(context)
+  );
 }
 
 /**
@@ -74,22 +74,22 @@ export function getCommentDirectivesReporter(
  * @returns {VueComponentContext} the Vue component context
  */
 export function getVueComponentContext(
-    context: RuleContext,
+  context: RuleContext
 ): VueComponentContext | null {
-    const cache = getCache(context)
-    if (cache.vueComponent) {
-        return cache.vueComponent
-    }
-    return (cache.vueComponent = createVueComponentContext(context))
+  const cache = getCache(context);
+  if (cache.vueComponent) {
+    return cache.vueComponent;
+  }
+  return (cache.vueComponent = createVueComponentContext(context));
 }
 export {
-    StyleContext,
-    ValidStyleContext,
-    InvalidStyleContext,
-    CommentDirectivesReporter,
-    VueComponentContext,
-    isValidStyleContext,
-}
+  StyleContext,
+  ValidStyleContext,
+  InvalidStyleContext,
+  CommentDirectivesReporter,
+  VueComponentContext,
+  isValidStyleContext,
+};
 
 /**
  * Gets the comment directive context from given rule context.
@@ -97,9 +97,9 @@ export {
  * @returns {CommentDirectivesReporter} the comment directives
  */
 function getCommentDirectives(context: RuleContext): CommentDirectives {
-    const cache = getCache(context)
-    if (cache.comment) {
-        return cache.comment
-    }
-    return (cache.comment = createCommentDirectives(getStyleContexts(context)))
+  const cache = getCache(context);
+  if (cache.comment) {
+    return cache.comment;
+  }
+  return (cache.comment = createCommentDirectives(getStyleContexts(context)));
 }
diff --git a/lib/styles/context/style/index.ts b/lib/styles/context/style/index.ts
index cda2d7de..4f29453a 100644
--- a/lib/styles/context/style/index.ts
+++ b/lib/styles/context/style/index.ts
@@ -1,59 +1,58 @@
-import { parse } from "../../parser"
+import { parse } from "../../parser";
 import type {
-    AST,
-    SourceCode,
-    RuleContext,
-    LineAndColumnData,
-} from "../../../types"
-import type { VCSSStyleSheet, VCSSNode, VCSSSelectorNode } from "../../ast"
-import { isVCSSContainerNode, hasSelectorNodes } from "../../utils/css-nodes"
+  AST,
+  SourceCode,
+  RuleContext,
+  LineAndColumnData,
+} from "../../../types";
+import type { VCSSStyleSheet, VCSSNode, VCSSSelectorNode } from "../../ast";
+import { isVCSSContainerNode, hasSelectorNodes } from "../../utils/css-nodes";
 
 /**
  * Check whether the program has invalid EOF or not.
  */
 function getInvalidEOFError(
-    context: RuleContext,
-    style: AST.VElement,
+  context: RuleContext,
+  style: AST.VElement
 ): {
-    inDocumentFragment: boolean
-    error: AST.ParseError
+  inDocumentFragment: boolean;
+  error: AST.ParseError;
 } | null {
-    const node = context.getSourceCode().ast
-    const body = node.templateBody
-    let errors = body?.errors
-    let inDocumentFragment = false
-    if (errors == null) {
-        /* istanbul ignore if */
-        if (!context.parserServices.getDocumentFragment) {
-            return null
-        }
-        const df = context.parserServices.getDocumentFragment()
-        inDocumentFragment = true
-        errors = df?.errors
-        /* istanbul ignore if */
-        if (errors == null) {
-            return null
-        }
+  const node = context.getSourceCode().ast;
+  const body = node.templateBody;
+  let errors = body?.errors;
+  let inDocumentFragment = false;
+  if (errors == null) {
+    /* istanbul ignore if */
+    if (!context.parserServices.getDocumentFragment) {
+      return null;
     }
-    const error =
-        errors.find(
-            (err) =>
-                typeof err.code === "string" &&
-                err.code.startsWith("eof-") &&
-                style.range[0] <= err.index &&
-                err.index < style.range[1],
-        ) ||
-        errors.find(
-            (err) =>
-                typeof err.code === "string" && err.code.startsWith("eof-"),
-        )
-    if (!error) {
-        return null
-    }
-    return {
-        error,
-        inDocumentFragment,
+    const df = context.parserServices.getDocumentFragment();
+    inDocumentFragment = true;
+    errors = df?.errors;
+    /* istanbul ignore if */
+    if (errors == null) {
+      return null;
     }
+  }
+  const error =
+    errors.find(
+      (err) =>
+        typeof err.code === "string" &&
+        err.code.startsWith("eof-") &&
+        style.range[0] <= err.index &&
+        err.index < style.range[1]
+    ) ||
+    errors.find(
+      (err) => typeof err.code === "string" && err.code.startsWith("eof-")
+    );
+  if (!error) {
+    return null;
+  }
+  return {
+    error,
+    inDocumentFragment,
+  };
 }
 
 /**
@@ -62,25 +61,25 @@ function getInvalidEOFError(
  * @returns {VElement[]} the array of `<style>` nodes.
  */
 function getStyleElements(context: RuleContext): AST.VElement[] {
-    let document: AST.VDocumentFragment | null = null
-    if (context.parserServices.getDocumentFragment) {
-        // vue-eslint-parser v7.0.0
-        document = context.parserServices.getDocumentFragment()
-    } else {
-        const sourceCode = context.getSourceCode()
-        const { ast } = sourceCode
-        const templateBody = ast.templateBody as AST.ESLintProgram | undefined
-        /* istanbul ignore if */
-        if (templateBody) {
-            document = templateBody.parent as AST.VDocumentFragment
-        }
-    }
-    if (document) {
-        return document.children
-            .filter(isVElement)
-            .filter((element) => element.name === "style")
+  let document: AST.VDocumentFragment | null = null;
+  if (context.parserServices.getDocumentFragment) {
+    // vue-eslint-parser v7.0.0
+    document = context.parserServices.getDocumentFragment();
+  } else {
+    const sourceCode = context.getSourceCode();
+    const { ast } = sourceCode;
+    const templateBody = ast.templateBody as AST.ESLintProgram | undefined;
+    /* istanbul ignore if */
+    if (templateBody) {
+      document = templateBody.parent as AST.VDocumentFragment;
     }
-    return []
+  }
+  if (document) {
+    return document.children
+      .filter(isVElement)
+      .filter((element) => element.name === "style");
+  }
+  return [];
 }
 
 /**
@@ -89,8 +88,8 @@ function getStyleElements(context: RuleContext): AST.VElement[] {
  * @returns {boolean} `true` if it has invalid EOF.
  */
 function isScoped(style: AST.VElement): boolean {
-    const { startTag } = style
-    return startTag.attributes.some((attr) => attr.key.name === "scoped")
+  const { startTag } = style;
+  return startTag.attributes.some((attr) => attr.key.name === "scoped");
 }
 
 /**
@@ -99,8 +98,8 @@ function isScoped(style: AST.VElement): boolean {
  * @returns {boolean} `true` if it has invalid EOF.
  */
 function isCssModule(style: AST.VElement): boolean {
-    const { startTag } = style
-    return startTag.attributes.some((attr) => attr.key.name === "module")
+  const { startTag } = style;
+  return startTag.attributes.some((attr) => attr.key.name === "module");
 }
 
 /**
@@ -109,147 +108,147 @@ function isCssModule(style: AST.VElement): boolean {
  * @returns {string} the language of `<style>`
  */
 function getLang(style: AST.VElement) {
-    const { startTag } = style
-    const lang =
-        startTag.attributes.find((attr) => attr.key.name === "lang") || null
-    return (
-        lang?.type === "VAttribute" &&
-        lang.value?.type === "VLiteral" &&
-        lang.value.value
-    )
+  const { startTag } = style;
+  const lang =
+    startTag.attributes.find((attr) => attr.key.name === "lang") || null;
+  return (
+    lang?.type === "VAttribute" &&
+    lang.value?.type === "VLiteral" &&
+    lang.value.value
+  );
 }
 
 interface VisitorVCSSNode {
-    exit?: boolean
-    break?: boolean
-    enterNode(node: VCSSNode): void
-    leaveNode?(node: VCSSNode): void
+  exit?: boolean;
+  break?: boolean;
+  enterNode(node: VCSSNode): void;
+  leaveNode?(node: VCSSNode): void;
 }
 interface VisitorVCSSSelectorNode {
-    exit?: boolean
-    break?: boolean
-    enterNode(node: VCSSSelectorNode): void
-    leaveNode?(node: VCSSSelectorNode): void
+  exit?: boolean;
+  break?: boolean;
+  enterNode(node: VCSSSelectorNode): void;
+  leaveNode?(node: VCSSSelectorNode): void;
 }
 
 interface BaseStyleContext {
-    readonly styleElement: AST.VElement
-    readonly sourceCode: SourceCode
-    readonly scoped: boolean
-    readonly module: boolean
-    readonly lang: string
-    traverseNodes(visitor: VisitorVCSSNode): void
-    traverseSelectorNodes(visitor: VisitorVCSSSelectorNode): void
+  readonly styleElement: AST.VElement;
+  readonly sourceCode: SourceCode;
+  readonly scoped: boolean;
+  readonly module: boolean;
+  readonly lang: string;
+  traverseNodes(visitor: VisitorVCSSNode): void;
+  traverseSelectorNodes(visitor: VisitorVCSSSelectorNode): void;
 }
 
 export interface ValidStyleContext extends BaseStyleContext {
-    readonly invalid: null
-    readonly cssNode: VCSSStyleSheet
+  readonly invalid: null;
+  readonly cssNode: VCSSStyleSheet;
 }
 export interface InvalidStyleContext extends BaseStyleContext {
-    readonly invalid: {
-        message: string
-        needReport: boolean
-        loc: LineAndColumnData
-    }
-    readonly cssNode: null
+  readonly invalid: {
+    message: string;
+    needReport: boolean;
+    loc: LineAndColumnData;
+  };
+  readonly cssNode: null;
 }
 
-export type StyleContext = InvalidStyleContext | ValidStyleContext
+export type StyleContext = InvalidStyleContext | ValidStyleContext;
 /**
  * Checks whether the given context is valid
  */
 export function isValidStyleContext(
-    context: StyleContext,
+  context: StyleContext
 ): context is ValidStyleContext {
-    return !context.invalid
+  return !context.invalid;
 }
 
 /**
  * Style context
  */
 export class StyleContextImpl {
-    public readonly styleElement: AST.VElement
-
-    public readonly sourceCode: SourceCode
-
-    public readonly invalid: {
-        message: string
-        needReport: boolean
-        loc: LineAndColumnData
-    } | null
-
-    public readonly scoped: boolean
-
-    public readonly module: boolean
-
-    public readonly lang: string
-
-    private readonly cssText: string | null
-
-    public readonly cssNode: VCSSStyleSheet | null
-
-    public constructor(style: AST.VElement, context: RuleContext) {
-        const sourceCode = context.getSourceCode()
-        this.styleElement = style
-        this.sourceCode = sourceCode
-
-        const { startTag, endTag } = style
-        this.invalid = null
-        const eof = getInvalidEOFError(context, style)
-        if (eof) {
-            this.invalid = {
-                message: eof.error.message,
-                needReport: eof.inDocumentFragment,
-                loc: { line: eof.error.lineNumber, column: eof.error.column },
-            }
-        } else if (endTag == null && !startTag.selfClosing) {
-            this.invalid = {
-                message: "Missing end tag",
-                needReport: true,
-                loc: startTag.loc.end,
-            }
-        }
-
-        this.scoped = Boolean(style && isScoped(style))
-
-        this.module = Boolean(style && isCssModule(style))
-
-        this.lang = ((style && getLang(style)) || "css").toLowerCase()
-
-        if (!this.invalid) {
-            this.cssText = endTag
-                ? sourceCode.text.slice(startTag.range[1], endTag.range[0])
-                : ""
-            this.cssNode = parse(
-                sourceCode,
-                startTag.loc.end,
-                this.cssText,
-                this.lang,
-            )
-        } else {
-            this.cssText = null
-            this.cssNode = null
-        }
+  public readonly styleElement: AST.VElement;
+
+  public readonly sourceCode: SourceCode;
+
+  public readonly invalid: {
+    message: string;
+    needReport: boolean;
+    loc: LineAndColumnData;
+  } | null;
+
+  public readonly scoped: boolean;
+
+  public readonly module: boolean;
+
+  public readonly lang: string;
+
+  private readonly cssText: string | null;
+
+  public readonly cssNode: VCSSStyleSheet | null;
+
+  public constructor(style: AST.VElement, context: RuleContext) {
+    const sourceCode = context.getSourceCode();
+    this.styleElement = style;
+    this.sourceCode = sourceCode;
+
+    const { startTag, endTag } = style;
+    this.invalid = null;
+    const eof = getInvalidEOFError(context, style);
+    if (eof) {
+      this.invalid = {
+        message: eof.error.message,
+        needReport: eof.inDocumentFragment,
+        loc: { line: eof.error.lineNumber, column: eof.error.column },
+      };
+    } else if (endTag == null && !startTag.selfClosing) {
+      this.invalid = {
+        message: "Missing end tag",
+        needReport: true,
+        loc: startTag.loc.end,
+      };
     }
 
-    public traverseNodes(visitor: VisitorVCSSNode): void {
-        if (this.cssNode) {
-            traverseNodes(this.cssNode, visitor)
-        }
+    this.scoped = Boolean(style && isScoped(style));
+
+    this.module = Boolean(style && isCssModule(style));
+
+    this.lang = ((style && getLang(style)) || "css").toLowerCase();
+
+    if (!this.invalid) {
+      this.cssText = endTag
+        ? sourceCode.text.slice(startTag.range[1], endTag.range[0])
+        : "";
+      this.cssNode = parse(
+        sourceCode,
+        startTag.loc.end,
+        this.cssText,
+        this.lang
+      );
+    } else {
+      this.cssText = null;
+      this.cssNode = null;
     }
+  }
 
-    public traverseSelectorNodes(visitor: VisitorVCSSSelectorNode): void {
-        this.traverseNodes({
-            enterNode(node) {
-                if (hasSelectorNodes(node)) {
-                    for (const sel of node.selectors) {
-                        traverseSelectorNodes(sel, visitor)
-                    }
-                }
-            },
-        })
+  public traverseNodes(visitor: VisitorVCSSNode): void {
+    if (this.cssNode) {
+      traverseNodes(this.cssNode, visitor);
     }
+  }
+
+  public traverseSelectorNodes(visitor: VisitorVCSSSelectorNode): void {
+    this.traverseNodes({
+      enterNode(node) {
+        if (hasSelectorNodes(node)) {
+          for (const sel of node.selectors) {
+            traverseSelectorNodes(sel, visitor);
+          }
+        }
+      },
+    });
+  }
 }
 
 /**
@@ -258,25 +257,25 @@ export class StyleContextImpl {
  * @param visitor The node visitor.
  */
 function traverseNodes(node: VCSSNode, visitor: VisitorVCSSNode): void {
-    visitor.break = false
-    visitor.enterNode(node)
-    if (visitor.exit || visitor.break) {
-        return
+  visitor.break = false;
+  visitor.enterNode(node);
+  if (visitor.exit || visitor.break) {
+    return;
+  }
+
+  if (isVCSSContainerNode(node)) {
+    for (const child of node.nodes) {
+      traverseNodes(child, visitor);
+      if (visitor.break) {
+        break;
+      }
+      if (visitor.exit) {
+        return;
+      }
     }
+  }
 
-    if (isVCSSContainerNode(node)) {
-        for (const child of node.nodes) {
-            traverseNodes(child, visitor)
-            if (visitor.break) {
-                break
-            }
-            if (visitor.exit) {
-                return
-            }
-        }
-    }
-
-    visitor.leaveNode?.(node)
+  visitor.leaveNode?.(node);
 }
 
 /**
@@ -285,28 +284,28 @@ function traverseNodes(node: VCSSNode, visitor: VisitorVCSSNode): void {
  * @param visitor The node visitor.
  */
 function traverseSelectorNodes(
-    node: VCSSSelectorNode,
-    visitor: VisitorVCSSSelectorNode,
+  node: VCSSSelectorNode,
+  visitor: VisitorVCSSSelectorNode
 ): void {
-    visitor.break = false
-    visitor.enterNode(node)
-    if (visitor.exit || visitor.break) {
-        return
-    }
-
-    if (node.type === "VCSSSelector" || node.type === "VCSSSelectorPseudo") {
-        for (const child of node.nodes) {
-            traverseSelectorNodes(child, visitor)
-            if (visitor.break) {
-                break
-            }
-            if (visitor.exit) {
-                return
-            }
-        }
+  visitor.break = false;
+  visitor.enterNode(node);
+  if (visitor.exit || visitor.break) {
+    return;
+  }
+
+  if (node.type === "VCSSSelector" || node.type === "VCSSSelectorPseudo") {
+    for (const child of node.nodes) {
+      traverseSelectorNodes(child, visitor);
+      if (visitor.break) {
+        break;
+      }
+      if (visitor.exit) {
+        return;
+      }
     }
+  }
 
-    visitor.leaveNode?.(node)
+  visitor.leaveNode?.(node);
 }
 
 /**
@@ -315,11 +314,11 @@ function traverseSelectorNodes(
  * @returns {StyleContext[]} the style contexts
  */
 export function createStyleContexts(context: RuleContext): StyleContext[] {
-    const styles = getStyleElements(context)
+  const styles = getStyleElements(context);
 
-    return styles.map(
-        (style) => new StyleContextImpl(style, context) as StyleContext,
-    )
+  return styles.map(
+    (style) => new StyleContextImpl(style, context) as StyleContext
+  );
 }
 
 /**
@@ -327,7 +326,7 @@ export function createStyleContexts(context: RuleContext): StyleContext[] {
  * @param node node to check
  */
 function isVElement(
-    node: AST.VElement | AST.VText | AST.VExpressionContainer,
+  node: AST.VElement | AST.VText | AST.VExpressionContainer
 ): node is AST.VElement {
-    return node?.type === "VElement"
+  return node?.type === "VElement";
 }
diff --git a/lib/styles/context/vue-components/find-vue.ts b/lib/styles/context/vue-components/find-vue.ts
index cf6305d5..a6ea05d6 100644
--- a/lib/styles/context/vue-components/find-vue.ts
+++ b/lib/styles/context/vue-components/find-vue.ts
@@ -1,58 +1,58 @@
-import { AST } from "vue-eslint-parser"
-import type { ASTNode, RuleContext } from "../../../types"
-import { unwrapTypesExpression } from "../../utils/nodes"
+import { AST } from "vue-eslint-parser";
+import type { ASTNode, RuleContext } from "../../../types";
+import { unwrapTypesExpression } from "../../utils/nodes";
 
-const traverseNodes = AST.traverseNodes
+const traverseNodes = AST.traverseNodes;
 
 /**
  * If the given node is a Vue component, returns an Object that defines the Vue component.
  * @param node Node to check
  */
 function getVueComponentObject(
-    node: ASTNode,
+  node: ASTNode
 ): AST.ESLintObjectExpression | null {
-    if (node.type !== "ExportDefaultDeclaration") {
-        return null
-    }
-    const declaration = unwrapTypesExpression(node.declaration)
-    if (declaration.type === "ObjectExpression") {
-        return declaration
-    }
-    if (
-        declaration.type === "CallExpression" &&
-        declaration.arguments.length >= 1
-    ) {
-        const callee = declaration.callee
+  if (node.type !== "ExportDefaultDeclaration") {
+    return null;
+  }
+  const declaration = unwrapTypesExpression(node.declaration);
+  if (declaration.type === "ObjectExpression") {
+    return declaration;
+  }
+  if (
+    declaration.type === "CallExpression" &&
+    declaration.arguments.length >= 1
+  ) {
+    const callee = declaration.callee;
 
-        if (callee.type === "MemberExpression") {
-            const calleeObject = unwrapTypesExpression(callee.object)
+    if (callee.type === "MemberExpression") {
+      const calleeObject = unwrapTypesExpression(callee.object);
 
-            if (
-                calleeObject.type === "Identifier" &&
-                calleeObject.name === "Vue" &&
-                callee.property.type === "Identifier" &&
-                callee.property.name === "extend"
-            ) {
-                // for Vue.js 2.x
-                // Vue.extend({})
-                const object = unwrapTypesExpression(declaration.arguments[0])
-                if (object.type === "ObjectExpression") {
-                    return object
-                }
-            }
+      if (
+        calleeObject.type === "Identifier" &&
+        calleeObject.name === "Vue" &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "extend"
+      ) {
+        // for Vue.js 2.x
+        // Vue.extend({})
+        const object = unwrapTypesExpression(declaration.arguments[0]);
+        if (object.type === "ObjectExpression") {
+          return object;
         }
-        if (callee.type === "Identifier") {
-            if (callee.name === "defineComponent") {
-                // for Vue.js 3.x
-                // defineComponent({})
-                const object = unwrapTypesExpression(declaration.arguments[0])
-                if (object.type === "ObjectExpression") {
-                    return object
-                }
-            }
+      }
+    }
+    if (callee.type === "Identifier") {
+      if (callee.name === "defineComponent") {
+        // for Vue.js 3.x
+        // defineComponent({})
+        const object = unwrapTypesExpression(declaration.arguments[0]);
+        if (object.type === "ObjectExpression") {
+          return object;
         }
+      }
     }
-    return null
+  }
+  return null;
 }
 
 /**
@@ -61,66 +61,64 @@ function getVueComponentObject(
  * @returns {ASTNode|null} Vue component
  */
 function findVueComponent(
-    context: RuleContext,
+  context: RuleContext
 ): AST.ESLintObjectExpression | null {
-    const sourceCode = context.getSourceCode()
-    const componentComments = sourceCode
-        .getAllComments()
-        .filter((comment) => comment.value.includes("@vue/component"))
-    const foundNodes: ASTNode[] = []
+  const sourceCode = context.getSourceCode();
+  const componentComments = sourceCode
+    .getAllComments()
+    .filter((comment) => comment.value.includes("@vue/component"));
+  const foundNodes: ASTNode[] = [];
+
+  /**
+   * Checks whether the given node is duplicate.
+   * @param {object} node the node to check
+   * @returns {boolean} `true` if the given node is duplicate.
+   */
+  function isDuplicateNode(node: ASTNode) {
+    if (foundNodes.some((el) => el.loc.start.line === node.loc.start.line)) {
+      return true;
+    }
+    foundNodes.push(node);
+    return false;
+  }
 
-    /**
-     * Checks whether the given node is duplicate.
-     * @param {object} node the node to check
-     * @returns {boolean} `true` if the given node is duplicate.
-     */
-    function isDuplicateNode(node: ASTNode) {
+  let result:
+    | AST.ESLintObjectExpression
+    | AST.ESLintDeclaration
+    | AST.ESLintSpreadElement
+    | null = null;
+  let breakNode = false;
+  traverseNodes(sourceCode.ast, {
+    visitorKeys: sourceCode.visitorKeys,
+    enterNode(node) {
+      if (breakNode) {
+        return;
+      }
+      if (node.type === "ObjectExpression") {
         if (
-            foundNodes.some((el) => el.loc.start.line === node.loc.start.line)
+          !componentComments.some(
+            (el) => el.loc.end.line === node.loc.start.line - 1
+          ) ||
+          isDuplicateNode(node)
         ) {
-            return true
+          return;
         }
-        foundNodes.push(node)
-        return false
-    }
-
-    let result:
-        | AST.ESLintObjectExpression
-        | AST.ESLintDeclaration
-        | AST.ESLintSpreadElement
-        | null = null
-    let breakNode = false
-    traverseNodes(sourceCode.ast, {
-        visitorKeys: sourceCode.visitorKeys,
-        enterNode(node) {
-            if (breakNode) {
-                return
-            }
-            if (node.type === "ObjectExpression") {
-                if (
-                    !componentComments.some(
-                        (el) => el.loc.end.line === node.loc.start.line - 1,
-                    ) ||
-                    isDuplicateNode(node)
-                ) {
-                    return
-                }
-                result = node
-            } else if (node.type === "ExportDefaultDeclaration") {
-                // export default {} in .vue
-                const vueNode = getVueComponentObject(node)
-                if (!vueNode || isDuplicateNode(vueNode)) {
-                    return
-                }
-                result = vueNode
-                breakNode = Boolean(node)
-            }
-        },
-        leaveNode() {
-            // noop
-        },
-    })
-    return result
+        result = node;
+      } else if (node.type === "ExportDefaultDeclaration") {
+        // export default {} in .vue
+        const vueNode = getVueComponentObject(node);
+        if (!vueNode || isDuplicateNode(vueNode)) {
+          return;
+        }
+        result = vueNode;
+        breakNode = Boolean(node);
+      }
+    },
+    leaveNode() {
+      // noop
+    },
+  });
+  return result;
 }
 
-export default findVueComponent
+export default findVueComponent;
diff --git a/lib/styles/context/vue-components/index.ts b/lib/styles/context/vue-components/index.ts
index 513ecc1e..ceef76ea 100644
--- a/lib/styles/context/vue-components/index.ts
+++ b/lib/styles/context/vue-components/index.ts
@@ -1,100 +1,93 @@
-import { AST as vueAST } from "vue-eslint-parser"
+import { AST as vueAST } from "vue-eslint-parser";
 
-import findVueComponent from "./find-vue"
-import type { RuleContext, ASTNode, AST } from "../../../types"
-import type { Template } from "../../template"
-import { isDefined } from "../../../utils/utils"
+import findVueComponent from "./find-vue";
+import type { RuleContext, ASTNode, AST } from "../../../types";
+import type { Template } from "../../template";
+import { isDefined } from "../../../utils/utils";
 
-const traverseNodes = vueAST.traverseNodes
+const traverseNodes = vueAST.traverseNodes;
 
-const UNKNOWN = Symbol("unknown")
+const UNKNOWN = Symbol("unknown");
 
-type DataPropertyNode = AST.ESLintExpression | AST.ESLintPattern
-type ComputedPropertyNode = AST.ESLintExpression | AST.ESLintPattern
+type DataPropertyNode = AST.ESLintExpression | AST.ESLintPattern;
+type ComputedPropertyNode = AST.ESLintExpression | AST.ESLintPattern;
 type Properties = {
-    data:
-        | {
-              [key: string]: DataPropertyNode[]
-              [UNKNOWN]?: true
-          }
-        | typeof UNKNOWN
-    computed:
-        | {
-              [key: string]: ComputedPropertyNode[]
-              [UNKNOWN]?: true
-          }
-        | typeof UNKNOWN
-    [UNKNOWN]?: boolean
-}
+  data:
+    | {
+        [key: string]: DataPropertyNode[];
+        [UNKNOWN]?: true;
+      }
+    | typeof UNKNOWN;
+  computed:
+    | {
+        [key: string]: ComputedPropertyNode[];
+        [UNKNOWN]?: true;
+      }
+    | typeof UNKNOWN;
+  [UNKNOWN]?: boolean;
+};
 
 export class VueComponentContext {
-    private readonly node: AST.ESLintObjectExpression
+  private readonly node: AST.ESLintObjectExpression;
 
-    private readonly context: RuleContext
+  private readonly context: RuleContext;
 
-    private properties: Properties | null = null
+  private properties: Properties | null = null;
 
-    public constructor(node: AST.ESLintObjectExpression, context: RuleContext) {
-        this.node = node
-        this.context = context
-    }
+  public constructor(node: AST.ESLintObjectExpression, context: RuleContext) {
+    this.node = node;
+    this.context = context;
+  }
 
-    /**
-     * Find property and get property value nodes, of Vue component.
-     * @param {string} name property name
-     * @returns {ASTNode[]} the Vue component property value nodes
-     */
-    public findVueComponentProperty(
-        name: string,
-    ):
-        | (
-              | AST.ESLintBlockStatement
-              | AST.ESLintExpression
-              | AST.ESLintPattern
-          )[]
-        | null {
-        const properties =
-            this.properties ||
-            (this.properties = extractVueComponentPropertes(
-                this.node,
-                this.context,
-            ))
+  /**
+   * Find property and get property value nodes, of Vue component.
+   * @param {string} name property name
+   * @returns {ASTNode[]} the Vue component property value nodes
+   */
+  public findVueComponentProperty(
+    name: string
+  ):
+    | (AST.ESLintBlockStatement | AST.ESLintExpression | AST.ESLintPattern)[]
+    | null {
+    const properties =
+      this.properties ||
+      (this.properties = extractVueComponentPropertes(this.node, this.context));
 
-        if (properties[UNKNOWN]) {
-            return null
-        }
-        if (properties.data === UNKNOWN || properties.data[UNKNOWN]) {
-            return null
-        }
-        if (properties.computed === UNKNOWN || properties.computed[UNKNOWN]) {
-            return null
-        }
-        if (properties.data[name]) {
-            return properties.data[name]
-        }
-        if (properties.computed[name]) {
-            return properties.computed[name]
-        }
-        return null
+    if (properties[UNKNOWN]) {
+      return null;
     }
-
-    /**
-     * Get the classes operated by `classList`.
-     * @param {string[] | null} refNames `ref` names
-     * @param {boolean} isRoot give `true` if the element to be checked is a root.
-     * @returns {(AST.ESLintExpression | AST.ESLintSpreadElement)[]} classes nodes
-     */
-    public getClassesOperatedByClassList(
-        refNames: Template[] | null,
-        isRoot: boolean,
-    ): (AST.ESLintExpression | AST.ESLintSpreadElement)[] {
-        return getClassesOperatedByClassList(
-            this.node,
-            refNames,
-            isRoot,
-            this.context,
-        )
+    if (properties.data === UNKNOWN || properties.data[UNKNOWN]) {
+      return null;
     }
+    if (properties.computed === UNKNOWN || properties.computed[UNKNOWN]) {
+      return null;
+    }
+    if (properties.data[name]) {
+      return properties.data[name];
+    }
+    if (properties.computed[name]) {
+      return properties.computed[name];
+    }
+    return null;
+  }
+
+  /**
+   * Get the classes operated by `classList`.
+   * @param {string[] | null} refNames `ref` names
+   * @param {boolean} isRoot give `true` if the element to be checked is a root.
+   * @returns {(AST.ESLintExpression | AST.ESLintSpreadElement)[]} classes nodes
+   */
+  public getClassesOperatedByClassList(
+    refNames: Template[] | null,
+    isRoot: boolean
+  ): (AST.ESLintExpression | AST.ESLintSpreadElement)[] {
+    return getClassesOperatedByClassList(
+      this.node,
+      refNames,
+      isRoot,
+      this.context
+    );
+  }
 }
 
 /**
@@ -103,181 +96,178 @@ export class VueComponentContext {
  * @returns the component context
  */
 export function createVueComponentContext(
-    context: RuleContext,
+  context: RuleContext
 ): VueComponentContext | null {
-    const node = findVueComponent(context)
-    if (!node) {
-        return null
-    }
-    return new VueComponentContext(node, context)
+  const node = findVueComponent(context);
+  if (!node) {
+    return null;
+  }
+  return new VueComponentContext(node, context);
 }
 
 /**
  *  Extract properties and properties value nodes, of Vue component.
  */
 function extractVueComponentPropertes(
-    vueNode: AST.ESLintObjectExpression,
-    context: RuleContext,
+  vueNode: AST.ESLintObjectExpression,
+  context: RuleContext
 ): Properties {
-    const result: Properties = {
-        data: {},
-        computed: {},
+  const result: Properties = {
+    data: {},
+    computed: {},
+  };
+  for (const p of vueNode.properties) {
+    if (p.type !== "Property") {
+      result[UNKNOWN] = true;
+      continue;
     }
-    for (const p of vueNode.properties) {
-        if (p.type !== "Property") {
-            result[UNKNOWN] = true
-            continue
-        }
-        const keyName = getPropertyOrIdentifierName(p)
-        if (keyName === "data") {
-            result.data = extractVueComponentData(p.value, context)
-        } else if (keyName === "computed") {
-            result.computed = extractVueComponentComputed(p.value, context)
-        }
+    const keyName = getPropertyOrIdentifierName(p);
+    if (keyName === "data") {
+      result.data = extractVueComponentData(p.value, context);
+    } else if (keyName === "computed") {
+      result.computed = extractVueComponentComputed(p.value, context);
     }
-    return result
+  }
+  return result;
 }
 
 /**
  *  Extract data, of Vue component.
  */
 function extractVueComponentData(
-    dataNode: AST.ESLintExpression | AST.ESLintPattern,
-    context: RuleContext,
+  dataNode: AST.ESLintExpression | AST.ESLintPattern,
+  context: RuleContext
 ):
-    | {
-          [key: string]: DataPropertyNode[]
-          [UNKNOWN]?: true
+  | {
+      [key: string]: DataPropertyNode[];
+      [UNKNOWN]?: true;
+    }
+  | typeof UNKNOWN {
+  const dataNodes: (AST.ESLintBlockStatement | AST.ESLintExpression)[] = [];
+  if (
+    (dataNode.type === "ArrowFunctionExpression" &&
+      dataNode.body.type === "BlockStatement") ||
+    dataNode.type === "FunctionExpression"
+  ) {
+    // `data: () => { return ...}
+    // `data() { return ...}
+    // `data: function () { return ...}
+    for (const returnStatement of getReturnStatements(dataNode.body, context)) {
+      if (returnStatement.argument) {
+        dataNodes.push(returnStatement.argument);
       }
-    | typeof UNKNOWN {
-    const dataNodes: (AST.ESLintBlockStatement | AST.ESLintExpression)[] = []
-    if (
-        (dataNode.type === "ArrowFunctionExpression" &&
-            dataNode.body.type === "BlockStatement") ||
-        dataNode.type === "FunctionExpression"
-    ) {
-        // `data: () => { return ...}
-        // `data() { return ...}
-        // `data: function () { return ...}
-        for (const returnStatement of getReturnStatements(
-            dataNode.body,
-            context,
-        )) {
-            if (returnStatement.argument) {
-                dataNodes.push(returnStatement.argument)
-            }
-        }
-    } else if (
-        dataNode.type === "ArrowFunctionExpression" &&
-        dataNode.body.type !== "BlockStatement"
-    ) {
-        // `data: () => ({...})
-        dataNodes.push(dataNode.body)
-    } else if (dataNode.type === "ObjectExpression") {
-        // `data: {...}
-        dataNodes.push(dataNode)
-    } else {
-        // unknown `data`
-        return UNKNOWN
     }
-    const data: {
-        [key: string]: DataPropertyNode[]
-        [UNKNOWN]?: true
-    } = {}
-    for (const dataObj of dataNodes) {
-        if (dataObj.type !== "ObjectExpression") {
-            // unknown `data`
-            data[UNKNOWN] = true
-            continue
-        }
-        for (const prop of dataObj.properties) {
-            if (prop.type === "Property") {
-                const keyName = getPropertyOrIdentifierName(prop)
-                if (keyName == null) {
-                    // Can not identify the key name.
-                    data[UNKNOWN] = true
-                } else {
-                    const values = data[keyName] || (data[keyName] = [])
-                    values.push(prop.value)
-                }
-            } else {
-                // Can not identify the key name.
-                data[UNKNOWN] = true
-            }
+  } else if (
+    dataNode.type === "ArrowFunctionExpression" &&
+    dataNode.body.type !== "BlockStatement"
+  ) {
+    // `data: () => ({...})
+    dataNodes.push(dataNode.body);
+  } else if (dataNode.type === "ObjectExpression") {
+    // `data: {...}
+    dataNodes.push(dataNode);
+  } else {
+    // unknown `data`
+    return UNKNOWN;
+  }
+  const data: {
+    [key: string]: DataPropertyNode[];
+    [UNKNOWN]?: true;
+  } = {};
+  for (const dataObj of dataNodes) {
+    if (dataObj.type !== "ObjectExpression") {
+      // unknown `data`
+      data[UNKNOWN] = true;
+      continue;
+    }
+    for (const prop of dataObj.properties) {
+      if (prop.type === "Property") {
+        const keyName = getPropertyOrIdentifierName(prop);
+        if (keyName == null) {
+          // Can not identify the key name.
+          data[UNKNOWN] = true;
+        } else {
+          const values = data[keyName] || (data[keyName] = []);
+          values.push(prop.value);
         }
+      } else {
+        // Can not identify the key name.
+        data[UNKNOWN] = true;
+      }
     }
-    return data
+  }
+  return data;
 }
 
 /**
  *  Extract computed properties, of Vue component.
  */
 function extractVueComponentComputed(
-    computedNode: AST.ESLintExpression | AST.ESLintPattern,
-    context: RuleContext,
+  computedNode: AST.ESLintExpression | AST.ESLintPattern,
+  context: RuleContext
 ):
-    | {
-          [key: string]: ComputedPropertyNode[]
-          [UNKNOWN]?: true
-      }
-    | typeof UNKNOWN {
-    if (computedNode.type !== "ObjectExpression") {
-        // Can not identify the key name.
-        return UNKNOWN
+  | {
+      [key: string]: ComputedPropertyNode[];
+      [UNKNOWN]?: true;
     }
+  | typeof UNKNOWN {
+  if (computedNode.type !== "ObjectExpression") {
+    // Can not identify the key name.
+    return UNKNOWN;
+  }
 
-    const computed: {
-        [key: string]: ComputedPropertyNode[]
-        [UNKNOWN]?: true
-    } = {}
-    for (const p of computedNode.properties) {
-        if (p.type !== "Property") {
-            // Can not identify the key name.
-            computed[UNKNOWN] = true
-            continue
-        }
-        const keyName = getPropertyOrIdentifierName(p)
-        if (!keyName) {
-            // Can not identify the key name.
-            computed[UNKNOWN] = true
-            continue
-        }
-        const values = computed[keyName] || (computed[keyName] = [])
-        const { value } = p
-        let func: AST.ESLintExpression | AST.ESLintPattern = value
+  const computed: {
+    [key: string]: ComputedPropertyNode[];
+    [UNKNOWN]?: true;
+  } = {};
+  for (const p of computedNode.properties) {
+    if (p.type !== "Property") {
+      // Can not identify the key name.
+      computed[UNKNOWN] = true;
+      continue;
+    }
+    const keyName = getPropertyOrIdentifierName(p);
+    if (!keyName) {
+      // Can not identify the key name.
+      computed[UNKNOWN] = true;
+      continue;
+    }
+    const values = computed[keyName] || (computed[keyName] = []);
+    const { value } = p;
+    let func: AST.ESLintExpression | AST.ESLintPattern = value;
 
-        if (value.type === "ObjectExpression") {
-            const get = value.properties
-                .filter(isProperty)
-                .find((prop) => getPropertyOrIdentifierName(prop) === "get")
-            if (get) {
-                func = get.value
-            }
-        }
-        if (
-            (func.type === "ArrowFunctionExpression" &&
-                func.body.type === "BlockStatement") ||
-            func.type === "FunctionExpression"
-        ) {
-            // `prop: () => { return ...}
-            // `prop() { return ...}
-            // `prop: function () { return ...}
-            const exprs = getReturnStatements(func.body, context)
-                .map((r) => r.argument)
-                .filter(isDefined)
-            values.push(...exprs)
-        } else if (
-            func.type === "ArrowFunctionExpression" &&
-            func.body.type !== "BlockStatement"
-        ) {
-            // `prop: () => ({...})
-            values.push(func.body as never)
-        } else {
-            // Unknown computed property.
-            computed[UNKNOWN] = true
-        }
+    if (value.type === "ObjectExpression") {
+      const get = value.properties
+        .filter(isProperty)
+        .find((prop) => getPropertyOrIdentifierName(prop) === "get");
+      if (get) {
+        func = get.value;
+      }
     }
-    return computed
+    if (
+      (func.type === "ArrowFunctionExpression" &&
+        func.body.type === "BlockStatement") ||
+      func.type === "FunctionExpression"
+    ) {
+      // `prop: () => { return ...}
+      // `prop() { return ...}
+      // `prop: function () { return ...}
+      const exprs = getReturnStatements(func.body, context)
+        .map((r) => r.argument)
+        .filter(isDefined);
+      values.push(...exprs);
+    } else if (
+      func.type === "ArrowFunctionExpression" &&
+      func.body.type !== "BlockStatement"
+    ) {
+      // `prop: () => ({...})
+      values.push(func.body as never);
+    } else {
+      // Unknown computed property.
+      computed[UNKNOWN] = true;
+    }
+  }
+  return computed;
 }
 
 /**
@@ -288,169 +278,169 @@ function extractVueComponentComputed(
  * @returns {string[]} classes
  */
 function getClassesOperatedByClassList(
-    vueNode: AST.ESLintObjectExpression,
-    refNames: Template[] | null,
-    isRoot: boolean,
-    context: RuleContext,
+  vueNode: AST.ESLintObjectExpression,
+  refNames: Template[] | null,
+  isRoot: boolean,
+  context: RuleContext
 ): (AST.ESLintExpression | AST.ESLintSpreadElement)[] {
-    const results: (AST.ESLintExpression | AST.ESLintSpreadElement)[] = []
-    traverseNodes(vueNode, {
-        visitorKeys: context.getSourceCode().visitorKeys,
-        enterNode(node) {
-            if (
-                node.type !== "CallExpression" ||
-                node.callee.type !== "MemberExpression"
-            ) {
-                return
-            }
-            const o = node.callee.object
-            if (getPropertyOrIdentifierName(o) !== "classList") {
-                return
-            }
+  const results: (AST.ESLintExpression | AST.ESLintSpreadElement)[] = [];
+  traverseNodes(vueNode, {
+    visitorKeys: context.getSourceCode().visitorKeys,
+    enterNode(node) {
+      if (
+        node.type !== "CallExpression" ||
+        node.callee.type !== "MemberExpression"
+      ) {
+        return;
+      }
+      const o = node.callee.object;
+      if (getPropertyOrIdentifierName(o) !== "classList") {
+        return;
+      }
 
-            if (
-                o.type === "MemberExpression" &&
-                getPropertyOrIdentifierName(o.object) === "$el"
-            ) {
-                // `class` operations are performed on the root element.
-                if (!isRoot) {
-                    // If it is not the root element, it will not match.
-                    return
-                }
-            }
-            if (refNames != null) {
-                const $refName =
-                    o.type === "MemberExpression" && o.object.type !== "Super"
-                        ? get$RefName(o.object)
-                        : null
+      if (
+        o.type === "MemberExpression" &&
+        getPropertyOrIdentifierName(o.object) === "$el"
+      ) {
+        // `class` operations are performed on the root element.
+        if (!isRoot) {
+          // If it is not the root element, it will not match.
+          return;
+        }
+      }
+      if (refNames != null) {
+        const $refName =
+          o.type === "MemberExpression" && o.object.type !== "Super"
+            ? get$RefName(o.object)
+            : null;
 
-                if ($refName != null) {
-                    if (!refNames.some((r) => r.matchString($refName))) {
-                        // The ref name can be identified.
-                        // It is also clear that there is no match.
-                        return
-                    }
-                }
-            }
+        if ($refName != null) {
+          if (!refNames.some((r) => r.matchString($refName))) {
+            // The ref name can be identified.
+            // It is also clear that there is no match.
+            return;
+          }
+        }
+      }
 
-            const argumentNodes = getClassesArguments(node)
+      const argumentNodes = getClassesArguments(node);
 
-            results.push(...argumentNodes)
-        },
-        leaveNode() {
-            // noop
-        },
-    })
-    return results
+      results.push(...argumentNodes);
+    },
+    leaveNode() {
+      // noop
+    },
+  });
+  return results;
 }
 
 /**
  * Gets the Return statements from given body
  */
 function getReturnStatements(
-    body: AST.ESLintBlockStatement,
-    context: RuleContext,
+  body: AST.ESLintBlockStatement,
+  context: RuleContext
 ): AST.ESLintReturnStatement[] {
-    const returnStatements: AST.ESLintReturnStatement[] = []
-    const skipNodes: (
-        | AST.ESLintArrowFunctionExpression
-        | AST.ESLintFunctionExpression
-        | AST.ESLintFunctionDeclaration
-    )[] = []
-    traverseNodes(body, {
-        visitorKeys: context.getSourceCode().visitorKeys,
-        enterNode(node) {
-            if (skipNodes.length) {
-                return
-            }
-            if (
-                node.type === "ArrowFunctionExpression" ||
-                node.type === "FunctionExpression" ||
-                node.type === "FunctionDeclaration"
-            ) {
-                skipNodes.unshift(node)
-            } else if (node.type === "ReturnStatement") {
-                returnStatements.push(node)
-            }
-        },
-        leaveNode(node) {
-            if (skipNodes[0] === node) {
-                skipNodes.shift()
-            }
-        },
-    })
-    return returnStatements
+  const returnStatements: AST.ESLintReturnStatement[] = [];
+  const skipNodes: (
+    | AST.ESLintArrowFunctionExpression
+    | AST.ESLintFunctionExpression
+    | AST.ESLintFunctionDeclaration
+  )[] = [];
+  traverseNodes(body, {
+    visitorKeys: context.getSourceCode().visitorKeys,
+    enterNode(node) {
+      if (skipNodes.length) {
+        return;
+      }
+      if (
+        node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression" ||
+        node.type === "FunctionDeclaration"
+      ) {
+        skipNodes.unshift(node);
+      } else if (node.type === "ReturnStatement") {
+        returnStatements.push(node);
+      }
+    },
+    leaveNode(node) {
+      if (skipNodes[0] === node) {
+        skipNodes.shift();
+      }
+    },
+  });
+  return returnStatements;
 }
 
 /**
  * Gets the property or identifier name from given node
  */
 function getPropertyOrIdentifierName(node: ASTNode): string | null {
-    if (node.type === "Identifier") {
-        return node.name
-    } else if (node.type === "MemberExpression") {
-        if (node.property.type === "Identifier" && !node.computed) {
-            // `o.a` / not `o[a]`
-            return node.property.name
-        } else if (node.property.type === "Literal" && node.computed) {
-            // `o['a']`
-            return getLiteralString(node.property)
-        }
-    } else if (node.type === "Property") {
-        if (node.key.type === "Identifier" && !node.computed) {
-            // `{ a: ... }` / not `{ [a]: ... }`
-            return node.key.name
-        } else if (node.key.type === "Literal") {
-            // `{ 'a': ... }` or `{ ['a']: ... }`
-            return getLiteralString(node.key)
-        }
+  if (node.type === "Identifier") {
+    return node.name;
+  } else if (node.type === "MemberExpression") {
+    if (node.property.type === "Identifier" && !node.computed) {
+      // `o.a` / not `o[a]`
+      return node.property.name;
+    } else if (node.property.type === "Literal" && node.computed) {
+      // `o['a']`
+      return getLiteralString(node.property);
+    }
+  } else if (node.type === "Property") {
+    if (node.key.type === "Identifier" && !node.computed) {
+      // `{ a: ... }` / not `{ [a]: ... }`
+      return node.key.name;
+    } else if (node.key.type === "Literal") {
+      // `{ 'a': ... }` or `{ ['a']: ... }`
+      return getLiteralString(node.key);
     }
-    return null
+  }
+  return null;
 }
 
 /**
  * Gets the ref name from given expression
  */
 function get$RefName(expr: AST.ESLintExpression): string | null {
-    if (expr.type !== "MemberExpression") {
-        return null
-    }
+  if (expr.type !== "MemberExpression") {
+    return null;
+  }
 
-    // Check if it belongs to `$refs`.
-    const { object } = expr
-    const name = getPropertyOrIdentifierName(object)
-    if (name !== "$refs") {
-        return null
-    }
-    // get the `ref` name
-    return getPropertyOrIdentifierName(expr)
+  // Check if it belongs to `$refs`.
+  const { object } = expr;
+  const name = getPropertyOrIdentifierName(object);
+  if (name !== "$refs") {
+    return null;
+  }
+  // get the `ref` name
+  return getPropertyOrIdentifierName(expr);
 }
 
 /**
  * Get the class name arguments for the given node.
  */
 function getClassesArguments(
-    node: AST.ESLintCallExpression,
+  node: AST.ESLintCallExpression
 ): (AST.ESLintExpression | AST.ESLintSpreadElement)[] {
-    const methodName = getPropertyOrIdentifierName(node.callee)
-    if (methodName === "add" || methodName === "remove") {
-        return node.arguments
-    } else if (methodName === "toggle" || methodName === "contains") {
-        return [node.arguments[0]]
-    } else if (methodName === "replace") {
-        return [node.arguments[0], node.arguments[1]]
-    }
-    return []
+  const methodName = getPropertyOrIdentifierName(node.callee);
+  if (methodName === "add" || methodName === "remove") {
+    return node.arguments;
+  } else if (methodName === "toggle" || methodName === "contains") {
+    return [node.arguments[0]];
+  } else if (methodName === "replace") {
+    return [node.arguments[0], node.arguments[1]];
+  }
+  return [];
 }
 
 /**
  * Get the string from given Literal
  */
 function getLiteralString(node: AST.ESLintLiteral): string {
-    if (typeof node.value === "string") {
-        return node.value
-    }
-    return `${node.value}`
+  if (typeof node.value === "string") {
+    return node.value;
+  }
+  return `${node.value}`;
 }
 
 /**
@@ -458,10 +448,10 @@ function getLiteralString(node: AST.ESLintLiteral): string {
  * @param node node to check
  */
 function isProperty(
-    node:
-        | AST.ESLintProperty
-        | AST.ESLintSpreadElement
-        | AST.ESLintLegacySpreadProperty,
+  node:
+    | AST.ESLintProperty
+    | AST.ESLintSpreadElement
+    | AST.ESLintLegacySpreadProperty
 ): node is AST.ESLintProperty {
-    return node.type === "Property"
+  return node.type === "Property";
 }
diff --git a/lib/styles/parser/css-parser.ts b/lib/styles/parser/css-parser.ts
index a512858f..b8b566ec 100644
--- a/lib/styles/parser/css-parser.ts
+++ b/lib/styles/parser/css-parser.ts
@@ -1,477 +1,447 @@
-import * as postcss from "postcss"
-import postcssSafeParser from "postcss-safe-parser"
-import { CSSSelectorParser } from "./selector/css-selector-parser"
-import type { VCSSCommentNode, VCSSNode, VCSSContainerNode } from "../ast"
+import * as postcss from "postcss";
+import postcssSafeParser from "postcss-safe-parser";
+import { CSSSelectorParser } from "./selector/css-selector-parser";
+import type { VCSSCommentNode, VCSSNode, VCSSContainerNode } from "../ast";
 import {
-    VCSSStyleSheet,
-    VCSSStyleRule,
-    VCSSDeclarationProperty,
-    VCSSAtRule,
-    VCSSComment,
-    VCSSParsingError,
-    VCSSUnknown,
-} from "../ast"
+  VCSSStyleSheet,
+  VCSSStyleRule,
+  VCSSDeclarationProperty,
+  VCSSAtRule,
+  VCSSComment,
+  VCSSParsingError,
+  VCSSUnknown,
+} from "../ast";
 import type {
-    SourceCode,
-    LineAndColumnData,
-    PostCSSNode,
-    PostCSSRoot,
-    SourceLocation,
-    PostCSSLoc,
-    PostCSSRule,
-    PostCSSAtRule,
-    PostCSSDeclaration,
-    PostCSSComment,
-} from "../../types"
-import { isPostCSSContainer } from "./utils"
-import { isVCSSContainerNode } from "../utils/css-nodes"
-import { isDefined } from "../../utils/utils"
+  SourceCode,
+  LineAndColumnData,
+  PostCSSNode,
+  PostCSSRoot,
+  SourceLocation,
+  PostCSSLoc,
+  PostCSSRule,
+  PostCSSAtRule,
+  PostCSSDeclaration,
+  PostCSSComment,
+} from "../../types";
+import { isPostCSSContainer } from "./utils";
+import { isVCSSContainerNode } from "../utils/css-nodes";
+import { isDefined } from "../../utils/utils";
 
 /**
  * CSS Parser
  */
 export class CSSParser {
-    protected readonly sourceCode: SourceCode
-
-    protected commentContainer: VCSSCommentNode[]
-
-    private _selectorParser: CSSSelectorParser | null = null
-
-    private readonly lang: string
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- errors
-    private anyErrors: any[] = []
-
-    /**
-     * constructor.
-     * @param {SourceCode} sourceCode the SourceCode object that you can use to work with the source that was passed to ESLint.
-     */
-    public constructor(sourceCode: SourceCode, lang: string) {
-        this.sourceCode = sourceCode
-        this.commentContainer = []
-        this.lang = lang
-    }
-
-    /**
-     * Parse the CSS.
-     * @param {string} css the CSS to parse
-     * @param {LineAndColumnData} offsetLocation start location of css.
-     * @return {VCSSStyleSheet} parsed result
-     */
-    public parse(
-        css: string,
-        offsetLocation: LineAndColumnData,
-    ): VCSSStyleSheet {
-        const { sourceCode } = this
-
-        this.commentContainer = []
-        this._selectorParser = this.createSelectorParser()
-        this.anyErrors = []
-
-        try {
-            const postcssRoot = this.parseInternal(css) as PostCSSRoot
-
-            const rootNode = this._postcssNodeToASTNode(
-                offsetLocation,
-                postcssRoot,
-            )
-            rootNode.comments = this.commentContainer
-            rootNode.errors.push(
-                ...this.collectErrors(this.anyErrors, offsetLocation),
-            )
-
-            return rootNode
-        } catch (e) {
-            const startIndex = sourceCode.getIndexFromLoc(offsetLocation)
-            const endIndex = startIndex + css.length
-            const styleLoc = {
-                start: offsetLocation,
-                end: sourceCode.getLocFromIndex(endIndex),
-            }
-            return new VCSSStyleSheet(
-                null as never,
-                styleLoc,
-                startIndex,
-                endIndex,
-                {
-                    errors: this.collectErrors(
-                        [...this.anyErrors, e],
-                        offsetLocation,
-                    ),
-                    lang: this.lang,
-                },
-            )
-        }
+  protected readonly sourceCode: SourceCode;
+
+  protected commentContainer: VCSSCommentNode[];
+
+  private _selectorParser: CSSSelectorParser | null = null;
+
+  private readonly lang: string;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- errors
+  private anyErrors: any[] = [];
+
+  /**
+   * constructor.
+   * @param {SourceCode} sourceCode the SourceCode object that you can use to work with the source that was passed to ESLint.
+   */
+  public constructor(sourceCode: SourceCode, lang: string) {
+    this.sourceCode = sourceCode;
+    this.commentContainer = [];
+    this.lang = lang;
+  }
+
+  /**
+   * Parse the CSS.
+   * @param {string} css the CSS to parse
+   * @param {LineAndColumnData} offsetLocation start location of css.
+   * @return {VCSSStyleSheet} parsed result
+   */
+  public parse(css: string, offsetLocation: LineAndColumnData): VCSSStyleSheet {
+    const { sourceCode } = this;
+
+    this.commentContainer = [];
+    this._selectorParser = this.createSelectorParser();
+    this.anyErrors = [];
+
+    try {
+      const postcssRoot = this.parseInternal(css) as PostCSSRoot;
+
+      const rootNode = this._postcssNodeToASTNode(offsetLocation, postcssRoot);
+      rootNode.comments = this.commentContainer;
+      rootNode.errors.push(
+        ...this.collectErrors(this.anyErrors, offsetLocation)
+      );
+
+      return rootNode;
+    } catch (e) {
+      const startIndex = sourceCode.getIndexFromLoc(offsetLocation);
+      const endIndex = startIndex + css.length;
+      const styleLoc = {
+        start: offsetLocation,
+        end: sourceCode.getLocFromIndex(endIndex),
+      };
+      return new VCSSStyleSheet(null as never, styleLoc, startIndex, endIndex, {
+        errors: this.collectErrors([...this.anyErrors, e], offsetLocation),
+        lang: this.lang,
+      });
     }
-
-    private addError(error: Error) {
-        this.anyErrors.push(error)
-    }
-
-    private collectErrors(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-        errors: any[],
-        offsetLocation: LineAndColumnData,
-    ): VCSSParsingError[] {
-        const errorNodes = []
-        const duplicate = new Set<string>()
-        for (const error of errors) {
-            const errorLoc =
-                error.line != null && error.column != null
-                    ? getESLintLineAndColumnFromPostCSSPosition(
-                          offsetLocation,
-                          error,
-                      )
-                    : offsetLocation
-            const message = error.reason || error.message
-
-            const key = `[${errorLoc.line}:${errorLoc.column}]: ${message}`
-            if (duplicate.has(key)) {
-                continue
-            }
-            duplicate.add(key)
-            const errorIndex = this.sourceCode.getIndexFromLoc(errorLoc)
-            errorNodes.push(
-                new VCSSParsingError(
-                    null as never,
-                    {
-                        start: errorLoc,
-                        end: errorLoc,
-                    },
-                    errorIndex,
-                    errorIndex,
-                    {
-                        lang: this.lang,
-                        message,
-                    },
-                ),
-            )
-        }
-        return errorNodes
-    }
-
-    protected get selectorParser(): CSSSelectorParser {
-        return (
-            this._selectorParser ||
-            (this._selectorParser = this.createSelectorParser())
+  }
+
+  private addError(error: Error) {
+    this.anyErrors.push(error);
+  }
+
+  private collectErrors(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+    errors: any[],
+    offsetLocation: LineAndColumnData
+  ): VCSSParsingError[] {
+    const errorNodes = [];
+    const duplicate = new Set<string>();
+    for (const error of errors) {
+      const errorLoc =
+        error.line != null && error.column != null
+          ? getESLintLineAndColumnFromPostCSSPosition(offsetLocation, error)
+          : offsetLocation;
+      const message = error.reason || error.message;
+
+      const key = `[${errorLoc.line}:${errorLoc.column}]: ${message}`;
+      if (duplicate.has(key)) {
+        continue;
+      }
+      duplicate.add(key);
+      const errorIndex = this.sourceCode.getIndexFromLoc(errorLoc);
+      errorNodes.push(
+        new VCSSParsingError(
+          null as never,
+          {
+            start: errorLoc,
+            end: errorLoc,
+          },
+          errorIndex,
+          errorIndex,
+          {
+            lang: this.lang,
+            message,
+          }
         )
+      );
     }
+    return errorNodes;
+  }
+
+  protected get selectorParser(): CSSSelectorParser {
+    return (
+      this._selectorParser ||
+      (this._selectorParser = this.createSelectorParser())
+    );
+  }
+
+  /**
+   * Convert PostCSS node to node that can be handled by ESLint.
+   * @param {LineAndColumnData} offsetLocation start location of css.
+   * @param {object} node the PostCSS node to convert
+   * @param {Node?} parent parent node
+   * @return {Node|null} converted node.
+   */
+  private _postcssNodeToASTNode(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSRoot
+  ): VCSSStyleSheet;
 
-    /**
-     * Convert PostCSS node to node that can be handled by ESLint.
-     * @param {LineAndColumnData} offsetLocation start location of css.
-     * @param {object} node the PostCSS node to convert
-     * @param {Node?} parent parent node
-     * @return {Node|null} converted node.
-     */
-    private _postcssNodeToASTNode(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSRoot,
-    ): VCSSStyleSheet
-
-    private _postcssNodeToASTNode(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSNode,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null
-
-    private _postcssNodeToASTNode(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSNode,
-        parent?: VCSSContainerNode,
-    ): VCSSNode | null {
-        const { sourceCode } = this
-        const startLoc = getESLintLineAndColumnFromPostCSSNode(
-            offsetLocation,
-            node,
-            "start",
-        ) || { line: 0, column: 1 }
-        const start = sourceCode.getIndexFromLoc(startLoc)
-        const endLoc =
-            getESLintLineAndColumnFromPostCSSNode(
-                offsetLocation,
-                node,
-                "end",
-            ) ||
-            // for node type: `root`
-            sourceCode.getLocFromIndex(
-                sourceCode.getIndexFromLoc(offsetLocation) +
-                    (node as PostCSSRoot).source.input.css.length,
-            )
-        const end = sourceCode.getIndexFromLoc(endLoc)
-        const loc: SourceLocation = {
-            start: startLoc,
-            end: endLoc,
-        }
-
-        const astNode = this[typeToConvertMethodName(node.type)](
-            node as never,
-            loc,
-            start,
-            end,
-            parent as never,
-        )
-
-        if (astNode == null) {
-            return null
-        }
-        if (isPostCSSContainer(node) && isVCSSContainerNode(astNode)) {
-            astNode.nodes = node.nodes
-                .map((n) =>
-                    this._postcssNodeToASTNode(offsetLocation, n, astNode),
-                )
-                .filter(isDefined)
-        }
-        return astNode
-    }
-
-    protected parseInternal(css: string): postcss.Root {
-        try {
-            return postcss.parse(css)
-        } catch (e: any) {
-            this.addError(e)
-            return postcssSafeParser(css)
-        }
-    }
-
-    protected createSelectorParser(): CSSSelectorParser {
-        return new CSSSelectorParser(this.sourceCode, this.commentContainer)
-    }
-
-    /**
-     * Convert root Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSStyleSheet}
-     */
-    protected convertRootNode(
-        node: PostCSSRoot,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-    ): VCSSNode | null {
-        return new VCSSStyleSheet(node, loc, start, end, { lang: this.lang })
-    }
-
-    /**
-     * Convert rule Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSStyleRule}
-     */
-    protected convertRuleNode(
-        node: PostCSSRule,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        const astNode = new VCSSStyleRule(node, loc, start, end, {
-            parent,
-            rawSelectorText: this.getRaw(node, "selector")?.raw ?? null,
-        })
-        astNode.selectors = this.selectorParser.parse(
-            astNode.rawSelectorText,
-            astNode.loc.start,
-            astNode,
-        )
-
-        if (this.getRaw(node, "between")?.trim()) {
-            this.parseRuleRawsBetween(node, astNode)
-        }
+  private _postcssNodeToASTNode(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSNode,
+    parent: VCSSContainerNode
+  ): VCSSNode | null;
 
-        return astNode
+  private _postcssNodeToASTNode(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSNode,
+    parent?: VCSSContainerNode
+  ): VCSSNode | null {
+    const { sourceCode } = this;
+    const startLoc = getESLintLineAndColumnFromPostCSSNode(
+      offsetLocation,
+      node,
+      "start"
+    ) || { line: 0, column: 1 };
+    const start = sourceCode.getIndexFromLoc(startLoc);
+    const endLoc =
+      getESLintLineAndColumnFromPostCSSNode(offsetLocation, node, "end") ||
+      // for node type: `root`
+      sourceCode.getLocFromIndex(
+        sourceCode.getIndexFromLoc(offsetLocation) +
+          (node as PostCSSRoot).source.input.css.length
+      );
+    const end = sourceCode.getIndexFromLoc(endLoc);
+    const loc: SourceLocation = {
+      start: startLoc,
+      end: endLoc,
+    };
+
+    const astNode = this[typeToConvertMethodName(node.type)](
+      node as never,
+      loc,
+      start,
+      end,
+      parent as never
+    );
+
+    if (astNode == null) {
+      return null;
     }
-
-    protected parseRuleRawsBetween(node: PostCSSRule, astNode: VCSSNode): void {
-        const between = this.getRaw(node, "between")
-        const rawSelector = this.getRaw(node, "selector")?.raw ?? node.selector
-        const betweenStart = astNode.range[0] + rawSelector.length
-        const postcssRoot = this.parseInternal(between || "") as PostCSSRoot
-
-        this._postcssNodeToASTNode(
-            this.sourceCode.getLocFromIndex(betweenStart),
-            postcssRoot,
-        )
+    if (isPostCSSContainer(node) && isVCSSContainerNode(astNode)) {
+      astNode.nodes = node.nodes
+        .map((n) => this._postcssNodeToASTNode(offsetLocation, n, astNode))
+        .filter(isDefined);
     }
-
-    /**
-     * Convert atrule Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSAtRule}
-     */
-    protected convertAtruleNode(
-        node: PostCSSAtRule,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        const astNode = new VCSSAtRule(node, loc, start, end, {
-            parent,
-            rawParamsText: this.getRaw(node, "params")?.raw ?? null,
-            identifier: this.getRaw(node as never, "identifier") ?? "@",
-        })
-        if (node.name === "nest") {
-            // The parameters following `@nest` are parsed as selectors.
-            const paramsStartIndex =
-                astNode.range[0] + // start index of at-rule
-                astNode.identifier.length + // `@`
-                astNode.name.length + // `nest`
-                (this.getRaw(node, "afterName") || "").length // comments and spaces
-
-            astNode.selectors = this.selectorParser.parse(
-                astNode.rawParamsText,
-                this.sourceCode.getLocFromIndex(paramsStartIndex),
-                astNode,
-            )
-        }
-
-        if (this.getRaw(node, "afterName")?.trim()) {
-            this.parseAtruleRawsAfterName(node, astNode)
-        }
-        if (this.getRaw(node, "between")?.trim()) {
-            this.parseAtruleRawsBetween(node, astNode)
-        }
-
-        return astNode
+    return astNode;
+  }
+
+  protected parseInternal(css: string): postcss.Root {
+    try {
+      return postcss.parse(css);
+    } catch (e: any) {
+      this.addError(e);
+      return postcssSafeParser(css);
     }
-
-    private parseAtruleRawsAfterName(node: PostCSSAtRule, astNode: VCSSAtRule) {
-        const afterName = this.getRaw(node, "afterName")
-
-        const afterNameStart =
-            astNode.range[0] + // start index of at-rule
-            astNode.identifier.length + // `@`
-            astNode.name.length // `nest`
-        const postcssRoot = this.parseInternal(afterName || "") as PostCSSRoot
-
-        this._postcssNodeToASTNode(
-            this.sourceCode.getLocFromIndex(afterNameStart),
-            postcssRoot,
-        )
+  }
+
+  protected createSelectorParser(): CSSSelectorParser {
+    return new CSSSelectorParser(this.sourceCode, this.commentContainer);
+  }
+
+  /**
+   * Convert root Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSStyleSheet}
+   */
+  protected convertRootNode(
+    node: PostCSSRoot,
+    loc: SourceLocation,
+    start: number,
+    end: number
+  ): VCSSNode | null {
+    return new VCSSStyleSheet(node, loc, start, end, { lang: this.lang });
+  }
+
+  /**
+   * Convert rule Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSStyleRule}
+   */
+  protected convertRuleNode(
+    node: PostCSSRule,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    const astNode = new VCSSStyleRule(node, loc, start, end, {
+      parent,
+      rawSelectorText: this.getRaw(node, "selector")?.raw ?? null,
+    });
+    astNode.selectors = this.selectorParser.parse(
+      astNode.rawSelectorText,
+      astNode.loc.start,
+      astNode
+    );
+
+    if (this.getRaw(node, "between")?.trim()) {
+      this.parseRuleRawsBetween(node, astNode);
     }
 
-    private parseAtruleRawsBetween(node: PostCSSAtRule, astNode: VCSSAtRule) {
-        const between = this.getRaw(node, "between")
-
-        const rawParams = this.getRaw(node, "params")?.raw ?? node.params
-        const betweenStart =
-            astNode.range[0] + // start index of at-rule
-            astNode.identifier.length + // `@`
-            astNode.name.length + // `nest`
-            (this.getRaw(node, "afterName") || "").length + // comments and spaces
-            rawParams.length
-
-        const postcssRoot = this.parseInternal(between || "") as PostCSSRoot
-        this._postcssNodeToASTNode(
-            this.sourceCode.getLocFromIndex(betweenStart),
-            postcssRoot,
-        )
+    return astNode;
+  }
+
+  protected parseRuleRawsBetween(node: PostCSSRule, astNode: VCSSNode): void {
+    const between = this.getRaw(node, "between");
+    const rawSelector = this.getRaw(node, "selector")?.raw ?? node.selector;
+    const betweenStart = astNode.range[0] + rawSelector.length;
+    const postcssRoot = this.parseInternal(between || "") as PostCSSRoot;
+
+    this._postcssNodeToASTNode(
+      this.sourceCode.getLocFromIndex(betweenStart),
+      postcssRoot
+    );
+  }
+
+  /**
+   * Convert atrule Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSAtRule}
+   */
+  protected convertAtruleNode(
+    node: PostCSSAtRule,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    const astNode = new VCSSAtRule(node, loc, start, end, {
+      parent,
+      rawParamsText: this.getRaw(node, "params")?.raw ?? null,
+      identifier: this.getRaw(node as never, "identifier") ?? "@",
+    });
+    if (node.name === "nest") {
+      // The parameters following `@nest` are parsed as selectors.
+      const paramsStartIndex =
+        astNode.range[0] + // start index of at-rule
+        astNode.identifier.length + // `@`
+        astNode.name.length + // `nest`
+        (this.getRaw(node, "afterName") || "").length; // comments and spaces
+
+      astNode.selectors = this.selectorParser.parse(
+        astNode.rawParamsText,
+        this.sourceCode.getLocFromIndex(paramsStartIndex),
+        astNode
+      );
     }
 
-    /**
-     * Convert decl Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSDeclarationProperty}
-     */
-    protected convertDeclNode(
-        node: PostCSSDeclaration,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        // adjust star hack
-        // `*color: red`
-        //  ^
-        let property = node.prop
-        let starLength = 1
-        let textProp = this.sourceCode.text.slice(
-            start,
-            start + property.length,
-        )
-        while (property !== textProp) {
-            property = textProp.slice(0, starLength) + node.prop
-
-            starLength++
-            textProp = this.sourceCode.text.slice(
-                start,
-                start + property.length,
-            )
-        }
-
-        return new VCSSDeclarationProperty(node, loc, start, end, {
-            parent,
-            property,
-        })
+    if (this.getRaw(node, "afterName")?.trim()) {
+      this.parseAtruleRawsAfterName(node, astNode);
     }
-
-    /**
-     * Convert comment Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {void}
-     */
-    protected convertCommentNode(
-        node: PostCSSComment,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        this.commentContainer.push(
-            new VCSSComment(node, node.text, loc, start, end, { parent }),
-        )
-        return null
+    if (this.getRaw(node, "between")?.trim()) {
+      this.parseAtruleRawsBetween(node, astNode);
     }
 
-    /**
-     * Convert unknown Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {Node}
-     */
-    protected convertUnknownTypeNode(
-        node: PostCSSNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        return new VCSSUnknown(node, loc, start, end, {
-            parent,
-            unknownType: node.type,
-        })
+    return astNode;
+  }
+
+  private parseAtruleRawsAfterName(node: PostCSSAtRule, astNode: VCSSAtRule) {
+    const afterName = this.getRaw(node, "afterName");
+
+    const afterNameStart =
+      astNode.range[0] + // start index of at-rule
+      astNode.identifier.length + // `@`
+      astNode.name.length; // `nest`
+    const postcssRoot = this.parseInternal(afterName || "") as PostCSSRoot;
+
+    this._postcssNodeToASTNode(
+      this.sourceCode.getLocFromIndex(afterNameStart),
+      postcssRoot
+    );
+  }
+
+  private parseAtruleRawsBetween(node: PostCSSAtRule, astNode: VCSSAtRule) {
+    const between = this.getRaw(node, "between");
+
+    const rawParams = this.getRaw(node, "params")?.raw ?? node.params;
+    const betweenStart =
+      astNode.range[0] + // start index of at-rule
+      astNode.identifier.length + // `@`
+      astNode.name.length + // `nest`
+      (this.getRaw(node, "afterName") || "").length + // comments and spaces
+      rawParams.length;
+
+    const postcssRoot = this.parseInternal(between || "") as PostCSSRoot;
+    this._postcssNodeToASTNode(
+      this.sourceCode.getLocFromIndex(betweenStart),
+      postcssRoot
+    );
+  }
+
+  /**
+   * Convert decl Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSDeclarationProperty}
+   */
+  protected convertDeclNode(
+    node: PostCSSDeclaration,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    // adjust star hack
+    // `*color: red`
+    //  ^
+    let property = node.prop;
+    let starLength = 1;
+    let textProp = this.sourceCode.text.slice(start, start + property.length);
+    while (property !== textProp) {
+      property = textProp.slice(0, starLength) + node.prop;
+
+      starLength++;
+      textProp = this.sourceCode.text.slice(start, start + property.length);
     }
 
-    protected getRaw<N extends PostCSSNode, K extends keyof N["raws"] & string>(
-        node: N,
-        keyName: K,
-    ): N["raws"][K] {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-        return (node.raws as any)[keyName]
-    }
+    return new VCSSDeclarationProperty(node, loc, start, end, {
+      parent,
+      property,
+    });
+  }
+
+  /**
+   * Convert comment Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {void}
+   */
+  protected convertCommentNode(
+    node: PostCSSComment,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    this.commentContainer.push(
+      new VCSSComment(node, node.text, loc, start, end, { parent })
+    );
+    return null;
+  }
+
+  /**
+   * Convert unknown Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {Node}
+   */
+  protected convertUnknownTypeNode(
+    node: PostCSSNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    return new VCSSUnknown(node, loc, start, end, {
+      parent,
+      unknownType: node.type,
+    });
+  }
+
+  protected getRaw<N extends PostCSSNode, K extends keyof N["raws"] & string>(
+    node: N,
+    keyName: K
+  ): N["raws"][K] {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+    return (node.raws as any)[keyName];
+  }
 }
 
 /**
@@ -481,18 +451,18 @@ export class CSSParser {
  * @return {LineAndColumnData} converted location.
  */
 function getESLintLineAndColumnFromPostCSSPosition(
-    offsetLocation: LineAndColumnData,
-    loc: PostCSSLoc,
+  offsetLocation: LineAndColumnData,
+  loc: PostCSSLoc
 ) {
-    let { line } = loc
-    let column = loc.column - 1 // Change to 0 base.
-    if (line === 1) {
-        line = offsetLocation.line
-        column = offsetLocation.column + column
-    } else {
-        line = offsetLocation.line + line - 1
-    }
-    return { line, column }
+  let { line } = loc;
+  let column = loc.column - 1; // Change to 0 base.
+  if (line === 1) {
+    line = offsetLocation.line;
+    column = offsetLocation.column + column;
+  } else {
+    line = offsetLocation.line + line - 1;
+  }
+  return { line, column };
 }
 
 /**
@@ -503,45 +473,45 @@ function getESLintLineAndColumnFromPostCSSPosition(
  * @return {LineAndColumnData} converted location.
  */
 function getESLintLineAndColumnFromPostCSSNode(
-    offsetLocation: LineAndColumnData,
-    node: PostCSSNode,
-    locName: "start" | "end",
+  offsetLocation: LineAndColumnData,
+  node: PostCSSNode,
+  locName: "start" | "end"
 ): LineAndColumnData | null {
-    const sourceLoc = node.source[locName]
-    if (!sourceLoc) {
-        return null
-    }
-    const { line, column } = getESLintLineAndColumnFromPostCSSPosition(
-        offsetLocation,
-        sourceLoc,
-    )
-    if (locName === "end") {
-        // End column is shifted by one.
-        return { line, column: column + 1 }
-    }
-    return { line, column }
+  const sourceLoc = node.source[locName];
+  if (!sourceLoc) {
+    return null;
+  }
+  const { line, column } = getESLintLineAndColumnFromPostCSSPosition(
+    offsetLocation,
+    sourceLoc
+  );
+  if (locName === "end") {
+    // End column is shifted by one.
+    return { line, column: column + 1 };
+  }
+  return { line, column };
 }
 
 interface ConvertNodeTypes {
-    root: "convertRootNode"
-    atrule: "convertAtruleNode"
-    rule: "convertRuleNode"
-    decl: "convertDeclNode"
-    comment: "convertCommentNode"
+  root: "convertRootNode";
+  atrule: "convertAtruleNode";
+  rule: "convertRuleNode";
+  decl: "convertDeclNode";
+  comment: "convertCommentNode";
 }
 const convertNodeTypes: ConvertNodeTypes = {
-    root: "convertRootNode",
-    atrule: "convertAtruleNode",
-    rule: "convertRuleNode",
-    decl: "convertDeclNode",
-    comment: "convertCommentNode",
-}
+  root: "convertRootNode",
+  atrule: "convertAtruleNode",
+  rule: "convertRuleNode",
+  decl: "convertDeclNode",
+  comment: "convertCommentNode",
+};
 
 /**
  * Get convert method name from given type
  */
 function typeToConvertMethodName(
-    type: keyof ConvertNodeTypes,
+  type: keyof ConvertNodeTypes
 ): "convertUnknownTypeNode" | ConvertNodeTypes[keyof ConvertNodeTypes] {
-    return convertNodeTypes[type] || "convertUnknownTypeNode"
+  return convertNodeTypes[type] || "convertUnknownTypeNode";
 }
diff --git a/lib/styles/parser/index.ts b/lib/styles/parser/index.ts
index e5cb0583..6f3024fe 100644
--- a/lib/styles/parser/index.ts
+++ b/lib/styles/parser/index.ts
@@ -1,15 +1,15 @@
-import { CSSParser } from "./css-parser"
-import { SCSSParser } from "./scss-parser"
-import { StylusParser } from "./stylus-parser"
-import type { SourceCode, LineAndColumnData } from "../../types"
-import type { VCSSStyleSheet } from "../ast"
-import { isSupportedStyleLang } from "../utils"
+import { CSSParser } from "./css-parser";
+import { SCSSParser } from "./scss-parser";
+import { StylusParser } from "./stylus-parser";
+import type { SourceCode, LineAndColumnData } from "../../types";
+import type { VCSSStyleSheet } from "../ast";
+import { isSupportedStyleLang } from "../utils";
 
 const PARSERS = {
-    scss: SCSSParser,
-    css: CSSParser,
-    stylus: StylusParser,
-}
+  scss: SCSSParser,
+  css: CSSParser,
+  stylus: StylusParser,
+};
 
 /**
  * Parse the CSS.
@@ -20,13 +20,13 @@ const PARSERS = {
  * @return {VCSSStyleSheet} parsed result
  */
 export function parse(
-    sourceCode: SourceCode,
-    offsetLocation: LineAndColumnData,
-    css: string,
-    lang: string,
+  sourceCode: SourceCode,
+  offsetLocation: LineAndColumnData,
+  css: string,
+  lang: string
 ): VCSSStyleSheet {
-    // eslint-disable-next-line @typescript-eslint/naming-convention -- class
-    const Parser = isSupportedStyleLang(lang) ? PARSERS[lang] : CSSParser
-    const parser = new Parser(sourceCode, lang)
-    return parser.parse(css, offsetLocation)
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- class
+  const Parser = isSupportedStyleLang(lang) ? PARSERS[lang] : CSSParser;
+  const parser = new Parser(sourceCode, lang);
+  return parser.parse(css, offsetLocation);
 }
diff --git a/lib/styles/parser/scss-parser.ts b/lib/styles/parser/scss-parser.ts
index 6fe8d0f1..5e1fba02 100644
--- a/lib/styles/parser/scss-parser.ts
+++ b/lib/styles/parser/scss-parser.ts
@@ -1,66 +1,66 @@
-import postcssScss from "postcss-scss"
-import type * as postcss from "postcss"
-import { CSSParser } from "./css-parser"
-import type { VCSSContainerNode, VCSSNode } from "../ast"
-import { VCSSInlineComment } from "../ast"
-import type { SourceLocation, PostCSSComment, PostCSSNode } from "../../types"
-import { SCSSSelectorParser } from "./selector/scss-selector-parser"
+import postcssScss from "postcss-scss";
+import type * as postcss from "postcss";
+import { CSSParser } from "./css-parser";
+import type { VCSSContainerNode, VCSSNode } from "../ast";
+import { VCSSInlineComment } from "../ast";
+import type { SourceLocation, PostCSSComment, PostCSSNode } from "../../types";
+import { SCSSSelectorParser } from "./selector/scss-selector-parser";
 /**
  * SCSS Parser
  */
 export class SCSSParser extends CSSParser {
-    protected parseInternal(css: string): postcss.Root {
-        return postcssScss.parse(css) as postcss.Root
-    }
+  protected parseInternal(css: string): postcss.Root {
+    return postcssScss.parse(css) as postcss.Root;
+  }
 
-    protected createSelectorParser(): SCSSSelectorParser {
-        return new SCSSSelectorParser(this.sourceCode, this.commentContainer)
-    }
+  protected createSelectorParser(): SCSSSelectorParser {
+    return new SCSSSelectorParser(this.sourceCode, this.commentContainer);
+  }
 
-    /**
-     * Convert comment Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {void}
-     */
-    protected convertCommentNode(
-        node: PostCSSComment,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        if (node.raws?.inline) {
-            this.commentContainer.push(
-                new VCSSInlineComment(node, node.text, loc, start, end, {
-                    parent,
-                }),
-            )
-            return null
-        }
-        return super.convertCommentNode(node, loc, start, end, parent)
+  /**
+   * Convert comment Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {void}
+   */
+  protected convertCommentNode(
+    node: PostCSSComment,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    if (node.raws?.inline) {
+      this.commentContainer.push(
+        new VCSSInlineComment(node, node.text, loc, start, end, {
+          parent,
+        })
+      );
+      return null;
     }
+    return super.convertCommentNode(node, loc, start, end, parent);
+  }
 
-    protected getRaw<N extends PostCSSNode, K extends keyof N["raws"] & string>(
-        node: N,
-        keyName: K,
-    ): N["raws"][K] {
-        const raw = super.getRaw(node, keyName)
-        if (raw != null) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check scss node
-            const scss = (raw as any).scss
-            if (scss != null) {
-                return {
-                    raw: scss,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- scss node
-                    value: (raw as any).value,
-                } as never
-            }
-        }
-
-        return raw
+  protected getRaw<N extends PostCSSNode, K extends keyof N["raws"] & string>(
+    node: N,
+    keyName: K
+  ): N["raws"][K] {
+    const raw = super.getRaw(node, keyName);
+    if (raw != null) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check scss node
+      const scss = (raw as any).scss;
+      if (scss != null) {
+        return {
+          raw: scss,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- scss node
+          value: (raw as any).value,
+        } as never;
+      }
     }
+
+    return raw;
+  }
 }
diff --git a/lib/styles/parser/selector/css-selector-parser.ts b/lib/styles/parser/selector/css-selector-parser.ts
index 69e9e460..ab8c6058 100644
--- a/lib/styles/parser/selector/css-selector-parser.ts
+++ b/lib/styles/parser/selector/css-selector-parser.ts
@@ -1,577 +1,559 @@
-import selectorParser from "postcss-selector-parser"
+import selectorParser from "postcss-selector-parser";
 import type {
-    VCSSCommentNode,
-    VCSSStyleRule,
-    VCSSAtRule,
-    VCSSSelectorNode,
-    VCSSNode,
-    VCSSContainerNode,
-    VCSSSelectorValueNode,
-} from "../../ast"
+  VCSSCommentNode,
+  VCSSStyleRule,
+  VCSSAtRule,
+  VCSSSelectorNode,
+  VCSSNode,
+  VCSSContainerNode,
+  VCSSSelectorValueNode,
+} from "../../ast";
 import {
-    VCSSSelector,
-    VCSSTypeSelector,
-    VCSSIDSelector,
-    VCSSClassSelector,
-    VCSSNestingSelector,
-    VCSSUniversalSelector,
-    VCSSAttributeSelector,
-    VCSSSelectorPseudo,
-    VCSSSelectorCombinator,
-    VCSSUnknownSelector,
-    VCSSComment,
-} from "../../ast"
+  VCSSSelector,
+  VCSSTypeSelector,
+  VCSSIDSelector,
+  VCSSClassSelector,
+  VCSSNestingSelector,
+  VCSSUniversalSelector,
+  VCSSAttributeSelector,
+  VCSSSelectorPseudo,
+  VCSSSelectorCombinator,
+  VCSSUnknownSelector,
+  VCSSComment,
+} from "../../ast";
 import {
-    isSelectorCombinator,
-    isDescendantCombinator,
-    isVueSpecialPseudo,
-    normalizePseudoParams,
-    isVDeepPseudoV2,
-} from "../../utils/selectors"
+  isSelectorCombinator,
+  isDescendantCombinator,
+  isVueSpecialPseudo,
+  normalizePseudoParams,
+  isVDeepPseudoV2,
+} from "../../utils/selectors";
 import type {
-    SourceCode,
-    LineAndColumnData,
-    SourceLocation,
-    PostCSSSPNode,
-    PostCSSSPContainer,
-    PostCSSSPStringNode,
-    PostCSSSPSelector,
-    PostCSSSPTypeNode,
-    PostCSSSPClassNameNode,
-    PostCSSSPNestingNode,
-    PostCSSSPUniversalNode,
-    PostCSSSPAttributeNode,
-    PostCSSSPPseudoNode,
-    PostCSSSPCombinatorNode,
-    PostCSSSPCommentNode,
-    PostCSSSPIDNode,
-    PostCSSSPRootNode,
-} from "../../../types"
-import { isPostCSSSPContainer } from "../utils"
-import { isDefined } from "../../../utils/utils"
+  SourceCode,
+  LineAndColumnData,
+  SourceLocation,
+  PostCSSSPNode,
+  PostCSSSPContainer,
+  PostCSSSPStringNode,
+  PostCSSSPSelector,
+  PostCSSSPTypeNode,
+  PostCSSSPClassNameNode,
+  PostCSSSPNestingNode,
+  PostCSSSPUniversalNode,
+  PostCSSSPAttributeNode,
+  PostCSSSPPseudoNode,
+  PostCSSSPCombinatorNode,
+  PostCSSSPCommentNode,
+  PostCSSSPIDNode,
+  PostCSSSPRootNode,
+} from "../../../types";
+import { isPostCSSSPContainer } from "../utils";
+import { isDefined } from "../../../utils/utils";
 
 export class CSSSelectorParser {
-    private readonly sourceCode: SourceCode
-
-    protected commentContainer: VCSSCommentNode[]
-
-    protected lang = "css"
-
-    /**
-     * constructor.
-     * @param {SourceCode} sourceCode the SourceCode object that you can use to work with the source that was passed to ESLint.
-     * @param {Node[]} commentContainer comment nodes container
-     */
-    public constructor(
-        sourceCode: SourceCode,
-        commentContainer: VCSSCommentNode[],
-    ) {
-        this.sourceCode = sourceCode
-        this.commentContainer = commentContainer
-    }
+  private readonly sourceCode: SourceCode;
 
-    /**
-     * Parse CSS selector.
-     * @param {string} rawSelector `<style>` node
-     * @param {LineAndColumnData} offsetLocation start location of selector.
-     * @param {Node} parent parent node
-     * @return {Node[]} parsed result
-     */
-    public parse(
-        rawSelector: string,
-        offsetLocation: LineAndColumnData,
-        parent: VCSSStyleRule | VCSSAtRule,
-    ): VCSSSelectorNode[] {
-        const selectorParserRoot = this.parseInternal(rawSelector)
-
-        return this._postcssSelectorParserNodeChiildrenToASTNodes(
-            offsetLocation,
-            selectorParserRoot,
-            parent,
-        )
-    }
+  protected commentContainer: VCSSCommentNode[];
 
-    protected parseInternal(selector: string): PostCSSSPRootNode {
-        return selectorParser().astSync(selector)
-    }
-
-    protected parseCommentsInternal(selector: string): PostCSSSPRootNode {
-        return selectorParser().astSync(selector)
-    }
+  protected lang = "css";
 
-    /**
-     * Convert `postcss-selector-parser` node to node that can be handled by ESLint.
-     * @param {LineAndColumnData} offsetLocation start location of selector.
-     * @param {object} node the `postcss-selector-parser` node to comvert
-     * @param {Node} parent parent node
-     * @return {Node[]} converted nodes.
-     */
-    private _postcssSelectorParserNodeChiildrenToASTNodes(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSSPRootNode,
-        parent: VCSSStyleRule | VCSSAtRule,
-    ): VCSSSelector[]
-
-    private _postcssSelectorParserNodeChiildrenToASTNodes(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSSPContainer,
-        parent: VCSSSelector,
-    ): VCSSSelectorValueNode[]
-
-    private _postcssSelectorParserNodeChiildrenToASTNodes(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSSPPseudoNode,
-        parent: VCSSSelectorPseudo,
-    ): VCSSSelector[]
-
-    private _postcssSelectorParserNodeChiildrenToASTNodes(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSSPContainer | PostCSSSPPseudoNode,
-        parent: VCSSStyleRule | VCSSAtRule | VCSSSelector | VCSSSelectorPseudo,
-    ): VCSSSelectorNode[] {
-        const astNodes = removeInvalidDescendantCombinator(
-            node.nodes
-                .map((child) =>
-                    this._postcssSelectorParserNodeToASTNode(
-                        offsetLocation,
-                        child,
-                        parent,
-                    ),
-                )
-                .filter(isDefined),
-        )
-        if (astNodes.length !== node.nodes.length) {
-            // adjust locations
-            if (node.type === "selector") {
-                // adjust start location
-                const firstAstNode = astNodes[0]
-                parent.loc.start = { ...firstAstNode.loc.start }
-                parent.start = firstAstNode.start
-                parent.range = [firstAstNode.start, parent.range[1]]
-            }
-            if (node.type === "selector") {
-                // adjust end location
-                const lastAstNode = astNodes[astNodes.length - 1]
-                parent.loc.end = { ...lastAstNode.loc.end }
-                parent.end = lastAstNode.end
-                parent.range = [parent.range[0], lastAstNode.end]
-            }
-        }
-        return astNodes
-    }
-
-    /**
-     * Convert `postcss-selector-parser` node to node that can be handled by ESLint.
-     * @param {LineAndColumnData} offsetLocation start location of selector.
-     * @param {object} node the `postcss-selector-parser` node to convert
-     * @param {Node} parent parent node
-     * @return {Node} converted node.
-     */
-    private _postcssSelectorParserNodeToASTNode(
-        offsetLocation: LineAndColumnData,
-        node: PostCSSSPNode,
-        parent: VCSSStyleRule | VCSSAtRule | VCSSSelector | VCSSSelectorPseudo,
-    ): VCSSSelectorNode | null {
-        const { sourceCode } = this
-
-        const loc = {
-            start: getESLintLineAndColumnFromPostCSSSelectorParserNode(
-                offsetLocation,
-                node,
-                "start",
-            ),
-            end: getESLintLineAndColumnFromPostCSSSelectorParserNode(
-                offsetLocation,
-                node,
-                "end",
-            ),
-        }
-        const start = sourceCode.getIndexFromLoc(loc.start)
-        const end = sourceCode.getIndexFromLoc(loc.end)
-
-        const astNode = this[typeToConvertMethodName(node.type)](
-            node as never,
-            loc,
-            start,
-            end,
-            parent as never,
-        )
-
-        if (astNode == null) {
-            return null
-        }
-
-        this.parseRawsSpaces(astNode, node, parent)
-
-        if (isPostCSSSPContainer(node)) {
-            if (astNode.type === "VCSSSelectorPseudo") {
-                astNode.nodes = normalizePseudoParams(
-                    astNode,
-                    this._postcssSelectorParserNodeChiildrenToASTNodes(
-                        offsetLocation,
-                        node as PostCSSSPPseudoNode,
-                        astNode,
-                    ),
-                )
-            } else if (astNode.type === "VCSSSelector") {
-                astNode.nodes =
-                    this._postcssSelectorParserNodeChiildrenToASTNodes(
-                        offsetLocation,
-                        node,
-                        astNode,
-                    )
-            }
-        }
-
-        return astNode
-    }
+  /**
+   * constructor.
+   * @param {SourceCode} sourceCode the SourceCode object that you can use to work with the source that was passed to ESLint.
+   * @param {Node[]} commentContainer comment nodes container
+   */
+  public constructor(
+    sourceCode: SourceCode,
+    commentContainer: VCSSCommentNode[]
+  ) {
+    this.sourceCode = sourceCode;
+    this.commentContainer = commentContainer;
+  }
+
+  /**
+   * Parse CSS selector.
+   * @param {string} rawSelector `<style>` node
+   * @param {LineAndColumnData} offsetLocation start location of selector.
+   * @param {Node} parent parent node
+   * @return {Node[]} parsed result
+   */
+  public parse(
+    rawSelector: string,
+    offsetLocation: LineAndColumnData,
+    parent: VCSSStyleRule | VCSSAtRule
+  ): VCSSSelectorNode[] {
+    const selectorParserRoot = this.parseInternal(rawSelector);
+
+    return this._postcssSelectorParserNodeChiildrenToASTNodes(
+      offsetLocation,
+      selectorParserRoot,
+      parent
+    );
+  }
+
+  protected parseInternal(selector: string): PostCSSSPRootNode {
+    return selectorParser().astSync(selector);
+  }
+
+  protected parseCommentsInternal(selector: string): PostCSSSPRootNode {
+    return selectorParser().astSync(selector);
+  }
+
+  /**
+   * Convert `postcss-selector-parser` node to node that can be handled by ESLint.
+   * @param {LineAndColumnData} offsetLocation start location of selector.
+   * @param {object} node the `postcss-selector-parser` node to comvert
+   * @param {Node} parent parent node
+   * @return {Node[]} converted nodes.
+   */
+  private _postcssSelectorParserNodeChiildrenToASTNodes(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSSPRootNode,
+    parent: VCSSStyleRule | VCSSAtRule
+  ): VCSSSelector[];
 
-    protected parseRawsSpaces(
-        astNode: VCSSSelectorNode,
-        node: PostCSSSPNode,
-        parent: VCSSStyleRule | VCSSAtRule | VCSSSelector | VCSSSelectorPseudo,
-    ): void {
-        if (!hasRaws(node) || !node.raws.spaces) {
-            return
-        }
-        const { after, before } = node.raws.spaces
-        if (after?.trim()) {
-            const selectorParserRoot = this.parseCommentsInternal(after)
-            selectorParserRoot.walkComments((comment) => {
-                this._postcssSelectorParserNodeToASTNode(
-                    astNode.loc.end,
-                    comment,
-                    parent,
-                )
-            })
-        }
-        if (before?.trim()) {
-            const startLoc = this.sourceCode.getLocFromIndex(
-                astNode.range[0] - before.length,
-            )
-            const selectorParserRoot = this.parseCommentsInternal(before)
-            selectorParserRoot.walkComments((comment) => {
-                this._postcssSelectorParserNodeToASTNode(
-                    startLoc,
-                    comment,
-                    parent,
-                )
-            })
-        }
-    }
+  private _postcssSelectorParserNodeChiildrenToASTNodes(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSSPContainer,
+    parent: VCSSSelector
+  ): VCSSSelectorValueNode[];
 
-    /**
-     * Convert selector Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSSelector}
-     */
-    protected convertSelectorNode(
-        node: PostCSSSPSelector,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSNode,
-    ): VCSSSelectorNode | null {
-        let source = this.sourceCode.text.slice(start, end)
-        const beforeSpaces = /^\s+/u.exec(source)
-        if (beforeSpaces?.[0]) {
-            // adjust before spaces
-            // `.foo, .bar`
-            //       ^
-
-            // eslint-disable-next-line no-param-reassign -- ignore
-            start = start + beforeSpaces[0].length
-            loc.start = this.sourceCode.getLocFromIndex(start)
-            source = source.slice(beforeSpaces[0].length)
-        }
-        const afterSpaces = /\s+$/u.exec(source)
-        if (afterSpaces?.[0]) {
-            // adjust after spaces
-
-            // eslint-disable-next-line no-param-reassign -- ignore
-            end = end - afterSpaces[0].length
-            loc.end = this.sourceCode.getLocFromIndex(end)
-            source = source.slice(0, -afterSpaces[0].length)
-        }
-        const beforeTrivials = /^\(\s*/u.exec(source)
-        const afterTrivials = /\s*\)$/u.exec(source)
-        if (beforeTrivials?.[0] && afterTrivials?.[0]) {
-            // adjust before trivial tokens
-            // `:not(.bar)`
-            //      ^    ^
-
-            // eslint-disable-next-line no-param-reassign -- ignore
-            start = start + beforeTrivials[0].length
-            loc.start = this.sourceCode.getLocFromIndex(start)
-            // eslint-disable-next-line no-param-reassign -- ignore
-            end = end - afterTrivials[0].length
-            loc.end = this.sourceCode.getLocFromIndex(end)
-            source = source.slice(
-                beforeTrivials[0].length,
-                -afterTrivials[0].length,
-            )
-        }
-        return new VCSSSelector(node, loc, start, end, {
-            parent: parent as VCSSStyleRule | VCSSAtRule,
-        })
-    }
+  private _postcssSelectorParserNodeChiildrenToASTNodes(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSSPPseudoNode,
+    parent: VCSSSelectorPseudo
+  ): VCSSSelector[];
 
-    /**
-     * Convert tag Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSTypeSelector}
-     */
-    protected convertTagNode(
-        node: PostCSSSPTypeNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSTypeSelector(node, loc, start, end, {
-            parent,
-        })
+  private _postcssSelectorParserNodeChiildrenToASTNodes(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSSPContainer | PostCSSSPPseudoNode,
+    parent: VCSSStyleRule | VCSSAtRule | VCSSSelector | VCSSSelectorPseudo
+  ): VCSSSelectorNode[] {
+    const astNodes = removeInvalidDescendantCombinator(
+      node.nodes
+        .map((child) =>
+          this._postcssSelectorParserNodeToASTNode(
+            offsetLocation,
+            child,
+            parent
+          )
+        )
+        .filter(isDefined)
+    );
+    if (astNodes.length !== node.nodes.length) {
+      // adjust locations
+      if (node.type === "selector") {
+        // adjust start location
+        const firstAstNode = astNodes[0];
+        parent.loc.start = { ...firstAstNode.loc.start };
+        parent.start = firstAstNode.start;
+        parent.range = [firstAstNode.start, parent.range[1]];
+      }
+      if (node.type === "selector") {
+        // adjust end location
+        const lastAstNode = astNodes[astNodes.length - 1];
+        parent.loc.end = { ...lastAstNode.loc.end };
+        parent.end = lastAstNode.end;
+        parent.range = [parent.range[0], lastAstNode.end];
+      }
     }
-
-    /**
-     * Convert id Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSIDSelector}
-     */
-    protected convertIdNode(
-        node: PostCSSSPIDNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSIDSelector(node, loc, start, end, {
-            parent,
-        })
+    return astNodes;
+  }
+
+  /**
+   * Convert `postcss-selector-parser` node to node that can be handled by ESLint.
+   * @param {LineAndColumnData} offsetLocation start location of selector.
+   * @param {object} node the `postcss-selector-parser` node to convert
+   * @param {Node} parent parent node
+   * @return {Node} converted node.
+   */
+  private _postcssSelectorParserNodeToASTNode(
+    offsetLocation: LineAndColumnData,
+    node: PostCSSSPNode,
+    parent: VCSSStyleRule | VCSSAtRule | VCSSSelector | VCSSSelectorPseudo
+  ): VCSSSelectorNode | null {
+    const { sourceCode } = this;
+
+    const loc = {
+      start: getESLintLineAndColumnFromPostCSSSelectorParserNode(
+        offsetLocation,
+        node,
+        "start"
+      ),
+      end: getESLintLineAndColumnFromPostCSSSelectorParserNode(
+        offsetLocation,
+        node,
+        "end"
+      ),
+    };
+    const start = sourceCode.getIndexFromLoc(loc.start);
+    const end = sourceCode.getIndexFromLoc(loc.end);
+
+    const astNode = this[typeToConvertMethodName(node.type)](
+      node as never,
+      loc,
+      start,
+      end,
+      parent as never
+    );
+
+    if (astNode == null) {
+      return null;
     }
 
-    /**
-     * Convert class Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSClassSelector}
-     */
-    protected convertClassNode(
-        node: PostCSSSPClassNameNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSClassSelector(node, loc, start, end, {
-            parent,
-        })
-    }
+    this.parseRawsSpaces(astNode, node, parent);
 
-    /**
-     * Convert nesting Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSNestingSelector}
-     */
-    protected convertNestingNode(
-        node: PostCSSSPNestingNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSNestingSelector(node, loc, start, end, {
-            parent,
-        })
+    if (isPostCSSSPContainer(node)) {
+      if (astNode.type === "VCSSSelectorPseudo") {
+        astNode.nodes = normalizePseudoParams(
+          astNode,
+          this._postcssSelectorParserNodeChiildrenToASTNodes(
+            offsetLocation,
+            node as PostCSSSPPseudoNode,
+            astNode
+          )
+        );
+      } else if (astNode.type === "VCSSSelector") {
+        astNode.nodes = this._postcssSelectorParserNodeChiildrenToASTNodes(
+          offsetLocation,
+          node,
+          astNode
+        );
+      }
     }
 
-    /**
-     * Convert universal Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSUniversalSelector}
-     */
-    protected convertUniversalNode(
-        node: PostCSSSPUniversalNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSUniversalSelector(node, loc, start, end, {
-            parent,
-        })
-    }
+    return astNode;
+  }
 
-    /**
-     * Convert attribute Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSAttributeSelector}
-     */
-    protected convertAttributeNode(
-        node: PostCSSSPAttributeNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSAttributeSelector(node, loc, start, end, {
-            parent,
-        })
+  protected parseRawsSpaces(
+    astNode: VCSSSelectorNode,
+    node: PostCSSSPNode,
+    parent: VCSSStyleRule | VCSSAtRule | VCSSSelector | VCSSSelectorPseudo
+  ): void {
+    if (!hasRaws(node) || !node.raws.spaces) {
+      return;
     }
-
-    /**
-     * Convert pseudo Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSSelectorPseudo}
-     */
-    protected convertPseudoNode(
-        node: PostCSSSPPseudoNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        return new VCSSSelectorPseudo(node, loc, start, end, {
-            parent,
-        })
+    const { after, before } = node.raws.spaces;
+    if (after?.trim()) {
+      const selectorParserRoot = this.parseCommentsInternal(after);
+      selectorParserRoot.walkComments((comment) => {
+        this._postcssSelectorParserNodeToASTNode(
+          astNode.loc.end,
+          comment,
+          parent
+        );
+      });
     }
-
-    /**
-     * Convert combinator Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSSelectorCombinator}
-     */
-    protected convertCombinatorNode(
-        node: PostCSSSPCombinatorNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        const astNode = new VCSSSelectorCombinator(node, loc, start, end, {
-            parent,
-        })
-        // The end index of Deep Combinator may be invalid, so adjust it.
-        adjustEndLocation(
-            astNode,
-            start + astNode.value.length,
-            this.sourceCode,
-        )
-        return astNode
+    if (before?.trim()) {
+      const startLoc = this.sourceCode.getLocFromIndex(
+        astNode.range[0] - before.length
+      );
+      const selectorParserRoot = this.parseCommentsInternal(before);
+      selectorParserRoot.walkComments((comment) => {
+        this._postcssSelectorParserNodeToASTNode(startLoc, comment, parent);
+      });
     }
-
-    /**
-     * Convert string Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {VCSSSelectorCombinator}
-     */
-    protected convertStringNode(
-        node: PostCSSSPStringNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        // unknown string
-        const astNode = new VCSSUnknownSelector(node, loc, start, end, {
-            parent,
-        })
-        // The end index may be invalid, so adjust it.
-        adjustEndLocation(
-            astNode,
-            start + astNode.value.length,
-            this.sourceCode,
-        )
-        return astNode
+  }
+
+  /**
+   * Convert selector Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSSelector}
+   */
+  protected convertSelectorNode(
+    node: PostCSSSPSelector,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSNode
+  ): VCSSSelectorNode | null {
+    let source = this.sourceCode.text.slice(start, end);
+    const beforeSpaces = /^\s+/u.exec(source);
+    if (beforeSpaces?.[0]) {
+      // adjust before spaces
+      // `.foo, .bar`
+      //       ^
+
+      // eslint-disable-next-line no-param-reassign -- ignore
+      start = start + beforeSpaces[0].length;
+      loc.start = this.sourceCode.getLocFromIndex(start);
+      source = source.slice(beforeSpaces[0].length);
     }
-
-    /**
-     * Convert comment Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {null}
-     */
-    protected convertCommentNode(
-        node: PostCSSSPCommentNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        const text = node.value
-            .replace(/^\s*\/\*/u, "")
-            .replace(/\*\/\s*$/u, "")
-        this.commentContainer.push(
-            new VCSSComment(node, text, loc, start, end, {
-                parent,
-            }),
-        )
-
-        return null
+    const afterSpaces = /\s+$/u.exec(source);
+    if (afterSpaces?.[0]) {
+      // adjust after spaces
+
+      // eslint-disable-next-line no-param-reassign -- ignore
+      end = end - afterSpaces[0].length;
+      loc.end = this.sourceCode.getLocFromIndex(end);
+      source = source.slice(0, -afterSpaces[0].length);
     }
-
-    /**
-     * Convert unknown Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {Node}
-     */
-    protected convertUnknownTypeNode(
-        node: PostCSSSPNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSUnknownSelector {
-        return new VCSSUnknownSelector(node, loc, start, end, {
-            parent,
-        })
+    const beforeTrivials = /^\(\s*/u.exec(source);
+    const afterTrivials = /\s*\)$/u.exec(source);
+    if (beforeTrivials?.[0] && afterTrivials?.[0]) {
+      // adjust before trivial tokens
+      // `:not(.bar)`
+      //      ^    ^
+
+      // eslint-disable-next-line no-param-reassign -- ignore
+      start = start + beforeTrivials[0].length;
+      loc.start = this.sourceCode.getLocFromIndex(start);
+      // eslint-disable-next-line no-param-reassign -- ignore
+      end = end - afterTrivials[0].length;
+      loc.end = this.sourceCode.getLocFromIndex(end);
+      source = source.slice(beforeTrivials[0].length, -afterTrivials[0].length);
     }
+    return new VCSSSelector(node, loc, start, end, {
+      parent: parent as VCSSStyleRule | VCSSAtRule,
+    });
+  }
+
+  /**
+   * Convert tag Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSTypeSelector}
+   */
+  protected convertTagNode(
+    node: PostCSSSPTypeNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSTypeSelector(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert id Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSIDSelector}
+   */
+  protected convertIdNode(
+    node: PostCSSSPIDNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSIDSelector(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert class Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSClassSelector}
+   */
+  protected convertClassNode(
+    node: PostCSSSPClassNameNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSClassSelector(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert nesting Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSNestingSelector}
+   */
+  protected convertNestingNode(
+    node: PostCSSSPNestingNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSNestingSelector(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert universal Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSUniversalSelector}
+   */
+  protected convertUniversalNode(
+    node: PostCSSSPUniversalNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSUniversalSelector(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert attribute Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSAttributeSelector}
+   */
+  protected convertAttributeNode(
+    node: PostCSSSPAttributeNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSAttributeSelector(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert pseudo Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSSelectorPseudo}
+   */
+  protected convertPseudoNode(
+    node: PostCSSSPPseudoNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    return new VCSSSelectorPseudo(node, loc, start, end, {
+      parent,
+    });
+  }
+
+  /**
+   * Convert combinator Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSSelectorCombinator}
+   */
+  protected convertCombinatorNode(
+    node: PostCSSSPCombinatorNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    const astNode = new VCSSSelectorCombinator(node, loc, start, end, {
+      parent,
+    });
+    // The end index of Deep Combinator may be invalid, so adjust it.
+    adjustEndLocation(astNode, start + astNode.value.length, this.sourceCode);
+    return astNode;
+  }
+
+  /**
+   * Convert string Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {VCSSSelectorCombinator}
+   */
+  protected convertStringNode(
+    node: PostCSSSPStringNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    // unknown string
+    const astNode = new VCSSUnknownSelector(node, loc, start, end, {
+      parent,
+    });
+    // The end index may be invalid, so adjust it.
+    adjustEndLocation(astNode, start + astNode.value.length, this.sourceCode);
+    return astNode;
+  }
+
+  /**
+   * Convert comment Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {null}
+   */
+  protected convertCommentNode(
+    node: PostCSSSPCommentNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    const text = node.value.replace(/^\s*\/\*/u, "").replace(/\*\/\s*$/u, "");
+    this.commentContainer.push(
+      new VCSSComment(node, text, loc, start, end, {
+        parent,
+      })
+    );
+
+    return null;
+  }
+
+  /**
+   * Convert unknown Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {Node}
+   */
+  protected convertUnknownTypeNode(
+    node: PostCSSSPNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSUnknownSelector {
+    return new VCSSUnknownSelector(node, loc, start, end, {
+      parent,
+    });
+  }
 }
 
 /**
@@ -582,143 +564,142 @@ export class CSSSelectorParser {
  * @return {LineAndColumnData} converted location.
  */
 function getESLintLineAndColumnFromPostCSSSelectorParserNode(
-    offsetLocation: LineAndColumnData,
-    node: PostCSSSPNode,
-    locName: "start" | "end",
+  offsetLocation: LineAndColumnData,
+  node: PostCSSSPNode,
+  locName: "start" | "end"
 ) {
-    const sourceLoc = (node.source && node.source[locName]) || {
-        line: 0,
-        column: 1,
-    }
-    let { line } = sourceLoc
-    let column = sourceLoc.column - 1 // Change to 0 base.
-    if (line === 1) {
-        line = offsetLocation.line
-        column = offsetLocation.column + column
-    } else {
-        line = offsetLocation.line + line - 1
-    }
-    if (locName === "end") {
-        // End column is shifted by one.
-        column++
-    }
-    return { line, column }
+  const sourceLoc = (node.source && node.source[locName]) || {
+    line: 0,
+    column: 1,
+  };
+  let { line } = sourceLoc;
+  let column = sourceLoc.column - 1; // Change to 0 base.
+  if (line === 1) {
+    line = offsetLocation.line;
+    column = offsetLocation.column + column;
+  } else {
+    line = offsetLocation.line + line - 1;
+  }
+  if (locName === "end") {
+    // End column is shifted by one.
+    column++;
+  }
+  return { line, column };
 }
 
 /**
  * Adjust end location
  */
 function adjustEndLocation(
-    astNode: VCSSSelectorCombinator | VCSSUnknownSelector,
-    endIndex: number,
-    sourceCode: SourceCode,
+  astNode: VCSSSelectorCombinator | VCSSUnknownSelector,
+  endIndex: number,
+  sourceCode: SourceCode
 ) {
-    if (astNode.range[1] === endIndex) {
-        return
-    }
-    astNode.range[1] = endIndex
-    astNode.end = endIndex
-    astNode.loc.end = sourceCode.getLocFromIndex(endIndex)
-
-    // update parent locations
-    let p: VCSSContainerNode | VCSSSelector | VCSSSelectorPseudo =
-        astNode.parent
-    while (p && p.end < endIndex) {
-        p.end = endIndex
-        p.range[1] = endIndex
-        p.loc.end = { ...astNode.loc.end }
-
-        p = p.parent
-    }
+  if (astNode.range[1] === endIndex) {
+    return;
+  }
+  astNode.range[1] = endIndex;
+  astNode.end = endIndex;
+  astNode.loc.end = sourceCode.getLocFromIndex(endIndex);
+
+  // update parent locations
+  let p: VCSSContainerNode | VCSSSelector | VCSSSelectorPseudo = astNode.parent;
+  while (p && p.end < endIndex) {
+    p.end = endIndex;
+    p.range[1] = endIndex;
+    p.loc.end = { ...astNode.loc.end };
+
+    p = p.parent;
+  }
 }
 
 /**
  * Remove invalid descendant combinators
  */
 function removeInvalidDescendantCombinator(
-    nodes: VCSSSelectorNode[],
+  nodes: VCSSSelectorNode[]
 ): VCSSSelectorNode[] {
-    const results = []
-
-    let prev = null
-    for (let index = 0; index < nodes.length; index++) {
-        const node = nodes[index]
-        if (isDescendantCombinator(node)) {
-            if (results.length === 0) {
-                continue
-            }
-            if (isSelectorCombinator(prev) || isVDeepPseudoV2(prev)) {
-                continue
-            }
-            const next = nodes[index + 1]
-            if (isSelectorCombinator(next)) {
-                continue
-            }
-        } else if (isVueSpecialPseudo(node)) {
-            if (prev && !isSelectorCombinator(prev)) {
-                results.push(
-                    new VCSSSelectorCombinator(
-                        node.node as never,
-                        node.loc,
-                        node.start,
-                        node.end,
-                        { parent: node.parent, value: " " },
-                    ),
-                )
-            }
-        }
-        results.push(node)
-        prev = node
+  const results = [];
+
+  let prev = null;
+  for (let index = 0; index < nodes.length; index++) {
+    const node = nodes[index];
+    if (isDescendantCombinator(node)) {
+      if (results.length === 0) {
+        continue;
+      }
+      if (isSelectorCombinator(prev) || isVDeepPseudoV2(prev)) {
+        continue;
+      }
+      const next = nodes[index + 1];
+      if (isSelectorCombinator(next)) {
+        continue;
+      }
+    } else if (isVueSpecialPseudo(node)) {
+      if (prev && !isSelectorCombinator(prev)) {
+        results.push(
+          new VCSSSelectorCombinator(
+            node.node as never,
+            node.loc,
+            node.start,
+            node.end,
+            { parent: node.parent, value: " " }
+          )
+        );
+      }
     }
+    results.push(node);
+    prev = node;
+  }
 
-    return results
+  return results;
 }
 
 interface ConvertNodeTypes {
-    tag: "convertTagNode"
-    string: "convertStringNode"
-    selector: "convertSelectorNode"
-    pseudo: "convertPseudoNode"
-    nesting: "convertNestingNode"
-    id: "convertIdNode"
-    comment: "convertCommentNode"
-    combinator: "convertCombinatorNode"
-    class: "convertClassNode"
-    attribute: "convertAttributeNode"
-    universal: "convertUniversalNode"
+  tag: "convertTagNode";
+  string: "convertStringNode";
+  selector: "convertSelectorNode";
+  pseudo: "convertPseudoNode";
+  nesting: "convertNestingNode";
+  id: "convertIdNode";
+  comment: "convertCommentNode";
+  combinator: "convertCombinatorNode";
+  class: "convertClassNode";
+  attribute: "convertAttributeNode";
+  universal: "convertUniversalNode";
 }
 const convertNodeTypes: ConvertNodeTypes = {
-    tag: "convertTagNode",
-    string: "convertStringNode",
-    selector: "convertSelectorNode",
-    pseudo: "convertPseudoNode",
-    nesting: "convertNestingNode",
-    id: "convertIdNode",
-    comment: "convertCommentNode",
-    combinator: "convertCombinatorNode",
-    class: "convertClassNode",
-    attribute: "convertAttributeNode",
-    universal: "convertUniversalNode",
-}
+  tag: "convertTagNode",
+  string: "convertStringNode",
+  selector: "convertSelectorNode",
+  pseudo: "convertPseudoNode",
+  nesting: "convertNestingNode",
+  id: "convertIdNode",
+  comment: "convertCommentNode",
+  combinator: "convertCombinatorNode",
+  class: "convertClassNode",
+  attribute: "convertAttributeNode",
+  universal: "convertUniversalNode",
+};
 
 /**
  * Get convert method name from given type
  */
 function typeToConvertMethodName(
-    type: keyof ConvertNodeTypes | "root",
+  type: keyof ConvertNodeTypes | "root"
 ): "convertUnknownTypeNode" | ConvertNodeTypes[keyof ConvertNodeTypes] {
-    if (type === "root") {
-        return "convertUnknownTypeNode"
-    }
-    return convertNodeTypes[type] || "convertUnknownTypeNode"
+  if (type === "root") {
+    return "convertUnknownTypeNode";
+  }
+  return convertNodeTypes[type] || "convertUnknownTypeNode";
 }
 
 /**
  * Checks whether has raws
  */
 function hasRaws(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check to prop
-    node: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check to prop
+  node: any
 ): node is { raws: { spaces: { after?: string; before?: string } } } {
-    return node.raws != null
+  return node.raws != null;
 }
diff --git a/lib/styles/parser/selector/replace-utils.ts b/lib/styles/parser/selector/replace-utils.ts
index 11be40d8..63b40312 100644
--- a/lib/styles/parser/selector/replace-utils.ts
+++ b/lib/styles/parser/selector/replace-utils.ts
@@ -1,274 +1,272 @@
-import lodash from "lodash"
-import type { LineAndColumnData, PostCSSSPNode } from "../../../types"
-import { isPostCSSSPContainer } from "../utils"
+import lodash from "lodash";
+import type { LineAndColumnData, PostCSSSPNode } from "../../../types";
+import { isPostCSSSPContainer } from "../utils";
 
 class SourceCodeLocationResolver {
-    private readonly text: string
+  private readonly text: string;
 
-    private readonly lineStartIndices: number[]
+  private readonly lineStartIndices: number[];
 
-    /**
-     * constructor
-     */
-    public constructor(code: string) {
-        const lineStartIndices = [0]
+  /**
+   * constructor
+   */
+  public constructor(code: string) {
+    const lineStartIndices = [0];
 
-        let match = undefined
-        const lineEndingPattern = /\r\n|[\n\r\u2028\u2029]/gu
-        while ((match = lineEndingPattern.exec(code))) {
-            lineStartIndices.push(match.index + match[0].length)
-        }
-        this.text = code
-        this.lineStartIndices = lineStartIndices
-    }
-
-    /**
-     * Converts a source text index into a (line, column) pair.
-     * @param {number} index The index of a character in a file
-     * @returns {object} A {line, column} location object with a 0-indexed column
-     */
-    public getLocFromIndex(index: number): LineAndColumnData {
-        const code = this.text
-        const lineStartIndices = this.lineStartIndices
-        if (index === code.length) {
-            return {
-                line: lineStartIndices.length,
-                column: index - lineStartIndices[lineStartIndices.length - 1],
-            }
-        }
-        const lineNumber = lodash.sortedLastIndex(lineStartIndices, index)
-
-        return {
-            line: lineNumber,
-            column: index - lineStartIndices[lineNumber - 1],
-        }
+    let match = undefined;
+    const lineEndingPattern = /\r\n|[\n\r\u2028\u2029]/gu;
+    while ((match = lineEndingPattern.exec(code))) {
+      lineStartIndices.push(match.index + match[0].length);
     }
-
-    /**
-     * Converts a (line, column) pair into a range index.
-     * @param {Object} loc A line/column location
-     * @param {number} loc.line The line number of the location (1-indexed)
-     * @param {number} loc.column The column number of the location (0-indexed)
-     * @returns {number} The range index of the location in the file.
-     * @public
-     */
-    public getIndexFromLoc(loc: LineAndColumnData): number {
-        const lineStartIndices = this.lineStartIndices
-        const lineStartIndex = lineStartIndices[loc.line - 1]
-        const positionIndex = lineStartIndex + loc.column
-
-        return positionIndex
+    this.text = code;
+    this.lineStartIndices = lineStartIndices;
+  }
+
+  /**
+   * Converts a source text index into a (line, column) pair.
+   * @param {number} index The index of a character in a file
+   * @returns {object} A {line, column} location object with a 0-indexed column
+   */
+  public getLocFromIndex(index: number): LineAndColumnData {
+    const code = this.text;
+    const lineStartIndices = this.lineStartIndices;
+    if (index === code.length) {
+      return {
+        line: lineStartIndices.length,
+        column: index - lineStartIndices[lineStartIndices.length - 1],
+      };
     }
+    const lineNumber = lodash.sortedLastIndex(lineStartIndices, index);
+
+    return {
+      line: lineNumber,
+      column: index - lineStartIndices[lineNumber - 1],
+    };
+  }
+
+  /**
+   * Converts a (line, column) pair into a range index.
+   * @param {Object} loc A line/column location
+   * @param {number} loc.line The line number of the location (1-indexed)
+   * @param {number} loc.column The column number of the location (0-indexed)
+   * @returns {number} The range index of the location in the file.
+   * @public
+   */
+  public getIndexFromLoc(loc: LineAndColumnData): number {
+    const lineStartIndices = this.lineStartIndices;
+    const lineStartIndex = lineStartIndices[loc.line - 1];
+    const positionIndex = lineStartIndex + loc.column;
+
+    return positionIndex;
+  }
 }
 
 class RemapIndexContext {
-    private readonly mappers: {
-        org: [number, number]
-        new: [number, number]
-    }[] = []
-
-    private orgIndex = 0
-
-    private newIndex = 0
-
-    private batchLengthOrg = 0
+  private readonly mappers: {
+    org: [number, number];
+    new: [number, number];
+  }[] = [];
 
-    private batchLengthNew = 0
+  private orgIndex = 0;
 
-    public applyEq(length: number) {
-        if (length <= 0) {
-            return
-        }
-        this.flush()
-        const newEnd = this.newIndex + length
-        const orgEnd = this.orgIndex + length
-        this.addMap([this.orgIndex, orgEnd], [this.newIndex, newEnd])
-        this.newIndex = newEnd
-        this.orgIndex = orgEnd
-    }
+  private newIndex = 0;
 
-    public applyIns(length: number) {
-        this.batchLengthNew += length
-    }
+  private batchLengthOrg = 0;
 
-    public applyDel(length: number) {
-        this.batchLengthOrg += length
-    }
+  private batchLengthNew = 0;
 
-    public flush() {
-        if (this.batchLengthNew || this.batchLengthOrg) {
-            const newEnd = this.newIndex + this.batchLengthNew
-            const orgEnd = this.orgIndex + this.batchLengthOrg
-            this.addMap([this.orgIndex, orgEnd], [this.newIndex, newEnd])
-            this.newIndex = newEnd
-            this.orgIndex = orgEnd
-            this.batchLengthOrg = 0
-            this.batchLengthNew = 0
-        }
+  public applyEq(length: number) {
+    if (length <= 0) {
+      return;
     }
-
-    private addMap(orgRange: [number, number], newRange: [number, number]) {
-        if (orgRange[0] === newRange[0] && orgRange[1] === newRange[1]) {
-            return
-        }
-        this.mappers.unshift({
-            org: orgRange,
-            new: newRange,
-        })
+    this.flush();
+    const newEnd = this.newIndex + length;
+    const orgEnd = this.orgIndex + length;
+    this.addMap([this.orgIndex, orgEnd], [this.newIndex, newEnd]);
+    this.newIndex = newEnd;
+    this.orgIndex = orgEnd;
+  }
+
+  public applyIns(length: number) {
+    this.batchLengthNew += length;
+  }
+
+  public applyDel(length: number) {
+    this.batchLengthOrg += length;
+  }
+
+  public flush() {
+    if (this.batchLengthNew || this.batchLengthOrg) {
+      const newEnd = this.newIndex + this.batchLengthNew;
+      const orgEnd = this.orgIndex + this.batchLengthOrg;
+      this.addMap([this.orgIndex, orgEnd], [this.newIndex, newEnd]);
+      this.newIndex = newEnd;
+      this.orgIndex = orgEnd;
+      this.batchLengthOrg = 0;
+      this.batchLengthNew = 0;
     }
+  }
 
-    public hasMapping() {
-        return this.mappers.length > 0
+  private addMap(orgRange: [number, number], newRange: [number, number]) {
+    if (orgRange[0] === newRange[0] && orgRange[1] === newRange[1]) {
+      return;
     }
-
-    public remapIndex(index: number) {
-        for (const mapper of this.mappers) {
-            if (mapper.new[0] <= index && index < mapper.new[1]) {
-                const offset = index - mapper.new[0]
-                return Math.min(mapper.org[0] + offset, mapper.org[1] - 1)
-            }
-            if (index === mapper.new[1]) {
-                return mapper.org[1]
-            }
-        }
-        return index
+    this.mappers.unshift({
+      org: orgRange,
+      new: newRange,
+    });
+  }
+
+  public hasMapping() {
+    return this.mappers.length > 0;
+  }
+
+  public remapIndex(index: number) {
+    for (const mapper of this.mappers) {
+      if (mapper.new[0] <= index && index < mapper.new[1]) {
+        const offset = index - mapper.new[0];
+        return Math.min(mapper.org[0] + offset, mapper.org[1] - 1);
+      }
+      if (index === mapper.new[1]) {
+        return mapper.org[1];
+      }
     }
+    return index;
+  }
 }
 
 interface ReplaceInfo {
-    start: number
+  start: number;
+  original: string;
+  random: string;
+  replace: string;
+  restore?: (
+    node: PostCSSSPNode,
+    random: string,
     original: string
-    random: string
-    replace: string
-    restore?: (
-        node: PostCSSSPNode,
-        random: string,
-        original: string,
-    ) => PostCSSSPNode | null
+  ) => PostCSSSPNode | null;
 }
 
 class Pattern {
-    public readonly name: string
+  public readonly name: string;
 
-    private readonly pattern: RegExp
+  private readonly pattern: RegExp;
 
-    private finished = false
+  private finished = false;
 
-    private lastResult: RegExpExecArray | null = null
+  private lastResult: RegExpExecArray | null = null;
 
-    public constructor(name: string, pattern: RegExp) {
-        this.name = name
-        if (!pattern.flags.includes("g")) {
-            throw new Error("'pattern' should contains 'g' flag.")
-        }
-        this.pattern = pattern
+  public constructor(name: string, pattern: RegExp) {
+    this.name = name;
+    if (!pattern.flags.includes("g")) {
+      throw new Error("'pattern' should contains 'g' flag.");
     }
+    this.pattern = pattern;
+  }
 
-    public exec(str: string, index: number): RegExpExecArray | null {
-        if (this.finished) {
-            return null
-        }
-        const { lastResult, pattern } = this
-        if (lastResult && lastResult.index >= index) {
-            return lastResult
-        }
-        pattern.lastIndex = index
-        const r = (this.lastResult = pattern.exec(str))
-        if (!r) {
-            this.finished = true
-        }
-        return r
+  public exec(str: string, index: number): RegExpExecArray | null {
+    if (this.finished) {
+      return null;
+    }
+    const { lastResult, pattern } = this;
+    if (lastResult && lastResult.index >= index) {
+      return lastResult;
     }
+    pattern.lastIndex = index;
+    const r = (this.lastResult = pattern.exec(str));
+    if (!r) {
+      this.finished = true;
+    }
+    return r;
+  }
 }
 
 /**
  * Define generator to search patterns.
  */
 export function* definePatternsSearchGenerator<
-    REGS extends { [name: string]: RegExp },
+  REGS extends { [name: string]: RegExp }
 >(
-    regexps: REGS,
-    str: string,
+  regexps: REGS,
+  str: string
 ): Generator<{
-    name: keyof REGS & string
-    result: RegExpExecArray
+  name: keyof REGS & string;
+  result: RegExpExecArray;
 }> {
-    const patterns = Object.entries(regexps).map(
-        ([name, reg]) => new Pattern(name, reg),
-    )
-    let start = 0
-    while (true) {
-        let result: RegExpExecArray | null = null
-        let name = ""
-        for (const pattern of patterns) {
-            const res = pattern.exec(str, start)
-            if (res && (!result || res.index < result.index)) {
-                result = res
-                name = pattern.name
-            }
-        }
-        if (!result) {
-            return
-        }
-        start = result.index + result[0].length
-        yield {
-            name,
-            result,
-        }
+  const patterns = Object.entries(regexps).map(
+    ([name, reg]) => new Pattern(name, reg)
+  );
+  let start = 0;
+  while (true) {
+    let result: RegExpExecArray | null = null;
+    let name = "";
+    for (const pattern of patterns) {
+      const res = pattern.exec(str, start);
+      if (res && (!result || res.index < result.index)) {
+        result = res;
+        name = pattern.name;
+      }
+    }
+    if (!result) {
+      return;
     }
+    start = result.index + result[0].length;
+    yield {
+      name,
+      result,
+    };
+  }
 }
 
 export class ReplaceSelectorContext {
-    public readonly cssSelector: string
+  public readonly cssSelector: string;
 
-    public readonly remapContext: RemapIndexContext
+  public readonly remapContext: RemapIndexContext;
 
-    public readonly replaces: ReplaceInfo[]
+  public readonly replaces: ReplaceInfo[];
 
-    public readonly comments: ReplaceInfo[]
+  public readonly comments: ReplaceInfo[];
 
-    public readonly cssSourceCode: SourceCodeLocationResolver
+  public readonly cssSourceCode: SourceCodeLocationResolver;
 
-    public readonly originalSourceCode: SourceCodeLocationResolver
+  public readonly originalSourceCode: SourceCodeLocationResolver;
 
-    public constructor(
-        cssSelector: string,
-        originalSelector: string,
-        remapContext: RemapIndexContext,
-        replaces: ReplaceInfo[],
-        comments: ReplaceInfo[],
-    ) {
-        this.cssSelector = cssSelector
-        this.remapContext = remapContext
-        this.replaces = replaces
-        this.comments = comments
-        this.cssSourceCode = new SourceCodeLocationResolver(cssSelector)
-        this.originalSourceCode = new SourceCodeLocationResolver(
-            originalSelector,
-        )
-    }
-
-    public hasReplace(): boolean {
-        return (
-            this.remapContext.hasMapping() ||
-            Boolean(this.replaces.length || this.comments.length)
-        )
-    }
+  public constructor(
+    cssSelector: string,
+    originalSelector: string,
+    remapContext: RemapIndexContext,
+    replaces: ReplaceInfo[],
+    comments: ReplaceInfo[]
+  ) {
+    this.cssSelector = cssSelector;
+    this.remapContext = remapContext;
+    this.replaces = replaces;
+    this.comments = comments;
+    this.cssSourceCode = new SourceCodeLocationResolver(cssSelector);
+    this.originalSourceCode = new SourceCodeLocationResolver(originalSelector);
+  }
+
+  public hasReplace(): boolean {
+    return (
+      this.remapContext.hasMapping() ||
+      Boolean(this.replaces.length || this.comments.length)
+    );
+  }
 }
 
 export type SelectorReplacer = {
-    regexp: RegExp
-    replace: (
-        result: RegExpExecArray,
-        random: string,
-        info: { beforeCss: string[] },
-    ) => string
-    restore?: (
-        node: PostCSSSPNode,
-        random: string,
-        original: string,
-    ) => PostCSSSPNode | null
-}
+  regexp: RegExp;
+  replace: (
+    result: RegExpExecArray,
+    random: string,
+    info: { beforeCss: string[] }
+  ) => string;
+  restore?: (
+    node: PostCSSSPNode,
+    random: string,
+    original: string
+  ) => PostCSSSPNode | null;
+};
 /**
  * Replace selector
  * @param selector selector
@@ -276,303 +274,298 @@ export type SelectorReplacer = {
  * @param commentRegexps comment regexps
  */
 export function replaceSelector(
-    selector: string,
-    regexps: SelectorReplacer[],
-    commentRegexps: SelectorReplacer[] = [],
-    trivialRegexps: SelectorReplacer[] = [],
+  selector: string,
+  regexps: SelectorReplacer[],
+  commentRegexps: SelectorReplacer[] = [],
+  trivialRegexps: SelectorReplacer[] = []
 ): ReplaceSelectorContext {
-    const remapContext = new RemapIndexContext()
-    const replaces: ReplaceInfo[] = []
-    const comments: ReplaceInfo[] = []
-
-    const cssSelector: string[] = []
-    let start = 0
-    for (const { name, result: res } of definePatternsSearchGenerator(
-        {
-            block: /\/\*[\s\S]+?\*\//gu, // block comment
-            dstr: /"(?:[^"\\]|\\.)*"/gu, // string
-            sstr: /'(?:[^'\\]|\\.)*'/gu, // string
-            ...commentRegexps.reduce((o, r, i) => {
-                o[`${i}comment`] = r.regexp
-                return o
-            }, {} as { [name: string]: RegExp }), // inline comment
-            ...regexps.reduce((o, r, i) => {
-                o[`${i}text`] = r.regexp
-                return o
-            }, {} as { [name: string]: RegExp }), // interpolation
-            ...trivialRegexps.reduce((o, r, i) => {
-                o[`${i}trivial`] = r.regexp
-                return o
-            }, {} as { [name: string]: RegExp }), // trivial
-        } as { [name: string]: RegExp },
-        selector,
-    )) {
-        const plain = selector.slice(start, res.index)
-        const text = res[0]
-        if (
-            name === "block" || // block comment
-            name === "dstr" || // string
-            name === "sstr" // string
-        ) {
-            cssSelector.push(plain)
-            cssSelector.push(text)
-            remapContext.applyEq(plain.length)
-            remapContext.applyEq(text.length)
-            start = res.index + text.length
-            continue
-        }
-        let replacers: SelectorReplacer[], container: ReplaceInfo[]
-        if (name.endsWith("comment")) {
-            // inline comment
-            replacers = commentRegexps
-            container = comments
-        } else if (name.endsWith("text")) {
-            // interpolate
-            replacers = regexps
-            container = replaces
-        } else {
-            // trivial
-            replacers = trivialRegexps
-            container = []
-        }
-        const index = parseInt(name, 10)
-        const genFunction = replacers[index].replace
-        let random = randomStr()
-        while (cssSelector.includes(random) || selector.includes(random)) {
-            random = randomStr()
-        }
-
-        cssSelector.push(plain)
-
-        const replace = genFunction(res, random, {
-            beforeCss: cssSelector,
-        })
-
-        container.push({
-            start: res.index,
-            original: text,
-            random,
-            replace,
-            restore: replacers[index].restore,
-        })
-
-        cssSelector.push(replace)
-
-        remapContext.applyEq(plain.length)
-        remapContext.applyIns(replace.length)
-        remapContext.applyDel(text.length)
-
-        start = res.index + text.length
+  const remapContext = new RemapIndexContext();
+  const replaces: ReplaceInfo[] = [];
+  const comments: ReplaceInfo[] = [];
+
+  const cssSelector: string[] = [];
+  let start = 0;
+  for (const { name, result: res } of definePatternsSearchGenerator(
+    {
+      block: /\/\*[\s\S]+?\*\//gu, // block comment
+      dstr: /"(?:[^"\\]|\\.)*"/gu, // string
+      sstr: /'(?:[^'\\]|\\.)*'/gu, // string
+      ...commentRegexps.reduce((o, r, i) => {
+        o[`${i}comment`] = r.regexp;
+        return o;
+      }, {} as { [name: string]: RegExp }), // inline comment
+      ...regexps.reduce((o, r, i) => {
+        o[`${i}text`] = r.regexp;
+        return o;
+      }, {} as { [name: string]: RegExp }), // interpolation
+      ...trivialRegexps.reduce((o, r, i) => {
+        o[`${i}trivial`] = r.regexp;
+        return o;
+      }, {} as { [name: string]: RegExp }), // trivial
+    } as { [name: string]: RegExp },
+    selector
+  )) {
+    const plain = selector.slice(start, res.index);
+    const text = res[0];
+    if (
+      name === "block" || // block comment
+      name === "dstr" || // string
+      name === "sstr" // string
+    ) {
+      cssSelector.push(plain);
+      cssSelector.push(text);
+      remapContext.applyEq(plain.length);
+      remapContext.applyEq(text.length);
+      start = res.index + text.length;
+      continue;
     }
-    const plain = selector.slice(start)
-    cssSelector.push(plain)
-    remapContext.applyEq(plain.length)
-    remapContext.flush()
-    return new ReplaceSelectorContext(
-        cssSelector.join(""),
-        selector,
-        remapContext,
-        replaces,
-        comments,
-    )
+    let replacers: SelectorReplacer[], container: ReplaceInfo[];
+    if (name.endsWith("comment")) {
+      // inline comment
+      replacers = commentRegexps;
+      container = comments;
+    } else if (name.endsWith("text")) {
+      // interpolate
+      replacers = regexps;
+      container = replaces;
+    } else {
+      // trivial
+      replacers = trivialRegexps;
+      container = [];
+    }
+    const index = parseInt(name, 10);
+    const genFunction = replacers[index].replace;
+    let random = randomStr();
+    while (cssSelector.includes(random) || selector.includes(random)) {
+      random = randomStr();
+    }
+
+    cssSelector.push(plain);
+
+    const replace = genFunction(res, random, {
+      beforeCss: cssSelector,
+    });
+
+    container.push({
+      start: res.index,
+      original: text,
+      random,
+      replace,
+      restore: replacers[index].restore,
+    });
+
+    cssSelector.push(replace);
+
+    remapContext.applyEq(plain.length);
+    remapContext.applyIns(replace.length);
+    remapContext.applyDel(text.length);
+
+    start = res.index + text.length;
+  }
+  const plain = selector.slice(start);
+  cssSelector.push(plain);
+  remapContext.applyEq(plain.length);
+  remapContext.flush();
+  return new ReplaceSelectorContext(
+    cssSelector.join(""),
+    selector,
+    remapContext,
+    replaces,
+    comments
+  );
 }
 
 /**
  * Restore each node's the location and the replaced interpolation and replaced inline comments.
  */
 export function restoreReplacedSelector(
-    orgNode: PostCSSSPNode,
-    replaceSelectorContext: ReplaceSelectorContext,
+  orgNode: PostCSSSPNode,
+  replaceSelectorContext: ReplaceSelectorContext
 ): PostCSSSPNode {
-    let node = orgNode
-    const {
-        remapContext,
-        replaces,
-        comments,
-        originalSourceCode,
-        cssSourceCode,
-        cssSelector,
-    } = replaceSelectorContext
-
-    if (node.source) {
-        let cssStartIndex: number | null = null
-        let cssEndIndex: number | null = null
-        if (node.source.start) {
-            const cssLoc = node.source.start
-            const index = cssSourceCode.getIndexFromLoc({
-                line: cssLoc.line,
-                column: cssLoc.column - 1,
-            })
-            const originalIndex = remapContext.remapIndex(index)
-            const originalLoc =
-                originalSourceCode.getLocFromIndex(originalIndex)
-            originalLoc.column++
-            node.source.start = originalLoc
-            cssStartIndex = index
-        }
-        if (node.source.end) {
-            const cssLoc = node.source.end
-            const index = cssSourceCode.getIndexFromLoc({
-                line: cssLoc.line,
-                column: cssLoc.column,
-            })
-            const originalIndex = remapContext.remapIndex(index)
-            node.source.end = originalSourceCode.getLocFromIndex(originalIndex)
-            cssEndIndex = index
-        }
-        const cssText =
-            cssStartIndex != null && cssEndIndex != null
-                ? cssSelector.slice(cssStartIndex, cssEndIndex)
-                : null
-        let n
-        while ((n = restoreReplaceds(node, replaces, cssText))) {
-            // loop
-            node = n
-        }
-        while (restoreComments(node, comments, cssText)) {
-            // loop
-        }
+  let node = orgNode;
+  const {
+    remapContext,
+    replaces,
+    comments,
+    originalSourceCode,
+    cssSourceCode,
+    cssSelector,
+  } = replaceSelectorContext;
+
+  if (node.source) {
+    let cssStartIndex: number | null = null;
+    let cssEndIndex: number | null = null;
+    if (node.source.start) {
+      const cssLoc = node.source.start;
+      const index = cssSourceCode.getIndexFromLoc({
+        line: cssLoc.line,
+        column: cssLoc.column - 1,
+      });
+      const originalIndex = remapContext.remapIndex(index);
+      const originalLoc = originalSourceCode.getLocFromIndex(originalIndex);
+      originalLoc.column++;
+      node.source.start = originalLoc;
+      cssStartIndex = index;
     }
-    if (isPostCSSSPContainer(node)) {
-        for (let index = 0; index < node.nodes.length; index++) {
-            node.nodes[index] = restoreReplacedSelector(
-                node.nodes[index],
-                replaceSelectorContext,
-            )
-        }
+    if (node.source.end) {
+      const cssLoc = node.source.end;
+      const index = cssSourceCode.getIndexFromLoc({
+        line: cssLoc.line,
+        column: cssLoc.column,
+      });
+      const originalIndex = remapContext.remapIndex(index);
+      node.source.end = originalSourceCode.getLocFromIndex(originalIndex);
+      cssEndIndex = index;
+    }
+    const cssText =
+      cssStartIndex != null && cssEndIndex != null
+        ? cssSelector.slice(cssStartIndex, cssEndIndex)
+        : null;
+    let n;
+    while ((n = restoreReplaceds(node, replaces, cssText))) {
+      // loop
+      node = n;
     }
-    return node
+    while (restoreComments(node, comments, cssText)) {
+      // loop
+    }
+  }
+  if (isPostCSSSPContainer(node)) {
+    for (let index = 0; index < node.nodes.length; index++) {
+      node.nodes[index] = restoreReplacedSelector(
+        node.nodes[index],
+        replaceSelectorContext
+      );
+    }
+  }
+  return node;
 }
 
 /**
  * Restore interpolation for given node
  */
 function restoreReplaceds(
-    node: PostCSSSPNode,
-    replaces: ReplaceInfo[],
-    cssText: string | null,
+  node: PostCSSSPNode,
+  replaces: ReplaceInfo[],
+  cssText: string | null
 ): PostCSSSPNode | null {
-    if (!replaces.length) {
-        return null
-    }
-    const targetProperties = []
-    if (
-        node.type === "tag" ||
-        node.type === "class" ||
-        node.type === "id" ||
-        node.type === "combinator" ||
-        node.type === "pseudo" ||
-        node.type === "string"
-    ) {
-        targetProperties.push("value")
-    } else if (node.type === "attribute") {
-        targetProperties.push("attribute")
-        targetProperties.push("value")
+  if (!replaces.length) {
+    return null;
+  }
+  const targetProperties = [];
+  if (
+    node.type === "tag" ||
+    node.type === "class" ||
+    node.type === "id" ||
+    node.type === "combinator" ||
+    node.type === "pseudo" ||
+    node.type === "string"
+  ) {
+    targetProperties.push("value");
+  } else if (node.type === "attribute") {
+    targetProperties.push("attribute");
+    targetProperties.push("value");
+  }
+
+  for (let index = 0; index < replaces.length; index++) {
+    const replace = replaces[index];
+    if (cssText != null && !cssText.includes(replace.random)) {
+      continue;
     }
-
-    for (let index = 0; index < replaces.length; index++) {
-        const replace = replaces[index]
-        if (cssText != null && !cssText.includes(replace.random)) {
-            continue
-        }
-        for (const prop of targetProperties) {
-            if (replace.restore) {
-                const newNode = replace.restore(
-                    node,
-                    replace.random,
-                    replace.original,
-                )
-                if (newNode) {
-                    replaces.splice(index, 1)
-                    return newNode
-                }
-            }
-            if (restoreReplaceNodeProp(node, prop, replace)) {
-                replaces.splice(index, 1)
-                return node
-            }
+    for (const prop of targetProperties) {
+      if (replace.restore) {
+        const newNode = replace.restore(node, replace.random, replace.original);
+        if (newNode) {
+          replaces.splice(index, 1);
+          return newNode;
         }
+      }
+      if (restoreReplaceNodeProp(node, prop, replace)) {
+        replaces.splice(index, 1);
+        return node;
+      }
     }
+  }
 
-    return null
+  return null;
 }
 
 /**
  * Restore inline comments for given node
  */
 function restoreComments(
-    node: PostCSSSPNode,
-    comments: ReplaceInfo[],
-    cssText: string | null,
+  node: PostCSSSPNode,
+  comments: ReplaceInfo[],
+  cssText: string | null
 ) {
-    if (!comments.length) {
-        return false
-    }
-    const targetProperties = []
-    if (node.type === "comment") {
-        targetProperties.push("value")
+  if (!comments.length) {
+    return false;
+  }
+  const targetProperties = [];
+  if (node.type === "comment") {
+    targetProperties.push("value");
+  }
+  if (hasRaws(node)) {
+    targetProperties.push("raws.spaces.after");
+    targetProperties.push("raws.spaces.before");
+  }
+
+  for (let index = 0; index < comments.length; index++) {
+    const comment = comments[index];
+    if (
+      node.type === "comment" &&
+      cssText != null &&
+      !cssText.includes(comment.random)
+    ) {
+      continue;
     }
-    if (hasRaws(node)) {
-        targetProperties.push("raws.spaces.after")
-        targetProperties.push("raws.spaces.before")
+    for (const prop of targetProperties) {
+      if (restoreReplaceNodeProp(node, prop, comment)) {
+        comments.splice(index, 1);
+        return true;
+      }
     }
-
-    for (let index = 0; index < comments.length; index++) {
-        const comment = comments[index]
-        if (
-            node.type === "comment" &&
-            cssText != null &&
-            !cssText.includes(comment.random)
-        ) {
-            continue
-        }
-        for (const prop of targetProperties) {
-            if (restoreReplaceNodeProp(node, prop, comment)) {
-                comments.splice(index, 1)
-                return true
-            }
-        }
-    }
-    return false
+  }
+  return false;
 }
 
 /**
  * Restore replaced text
  */
 function restoreReplaceNodeProp(
-    node: PostCSSSPNode,
-    prop: string,
-    replaceInfo: ReplaceInfo,
+  node: PostCSSSPNode,
+  prop: string,
+  replaceInfo: ReplaceInfo
 ): boolean {
-    const text = `${lodash.get(node, prop, "") || ""}`
-    if (text.includes(replaceInfo.replace)) {
-        const newText = text.replace(replaceInfo.replace, replaceInfo.original)
-        lodash.set(node, prop, newText)
-        if (!prop.startsWith("raws")) {
-            lodash.set(node, `raws.${prop}`, newText)
-        }
-        return true
+  const text = `${lodash.get(node, prop, "") || ""}`;
+  if (text.includes(replaceInfo.replace)) {
+    const newText = text.replace(replaceInfo.replace, replaceInfo.original);
+    lodash.set(node, prop, newText);
+    if (!prop.startsWith("raws")) {
+      lodash.set(node, `raws.${prop}`, newText);
     }
-    return false
+    return true;
+  }
+  return false;
 }
 
 /**
  * Checks whether has raws
  */
 function hasRaws(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check to prop
-    node: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check to prop
+  node: any
 ): node is { raws: { spaces: { after?: string; before?: string } } } {
-    return node.raws != null
+  return node.raws != null;
 }
 
 /**
  * @return Returns the random string.
  */
 function randomStr(): string {
-    const S = "abcdefghijklmnopqrstuvwxyz0123456789"
-    const N = 16
-    return Array.from(Array(N))
-        .map(() => S[Math.floor(Math.random() * S.length)])
-        .join("")
+  const S = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const N = 16;
+  return Array.from(Array(N))
+    .map(() => S[Math.floor(Math.random() * S.length)])
+    .join("");
 }
diff --git a/lib/styles/parser/selector/scss-selector-parser.ts b/lib/styles/parser/selector/scss-selector-parser.ts
index 41740a37..f9ca36e9 100644
--- a/lib/styles/parser/selector/scss-selector-parser.ts
+++ b/lib/styles/parser/selector/scss-selector-parser.ts
@@ -1,74 +1,74 @@
 import type {
-    PostCSSSPRootNode,
-    SourceLocation,
-    PostCSSSPCommentNode,
-} from "../../../types"
-import { CSSSelectorParser } from "./css-selector-parser"
-import selectorParser from "postcss-selector-parser"
-import type { VCSSSelectorNode, VCSSSelector } from "../../ast"
-import { VCSSInlineComment } from "../../ast"
-import { replaceSelector, restoreReplacedSelector } from "./replace-utils"
+  PostCSSSPRootNode,
+  SourceLocation,
+  PostCSSSPCommentNode,
+} from "../../../types";
+import { CSSSelectorParser } from "./css-selector-parser";
+import selectorParser from "postcss-selector-parser";
+import type { VCSSSelectorNode, VCSSSelector } from "../../ast";
+import { VCSSInlineComment } from "../../ast";
+import { replaceSelector, restoreReplacedSelector } from "./replace-utils";
 
 export class SCSSSelectorParser extends CSSSelectorParser {
-    protected parseInternal(selector: string): PostCSSSPRootNode {
-        const replaceSelectorContext = replaceSelector(
-            selector,
-            [
-                {
-                    regexp: /#\{[\s\S]+?\}/gu, // interpolation
-                    replace: (_res, random) => `_${random}_`,
-                },
-            ],
-            [
-                {
-                    regexp: /\/\/[^\n\r\u2028\u2029]*/gu, // inline comment
-                    replace: (_res, random) => `/*${random}*/`,
-                },
-            ],
-        )
+  protected parseInternal(selector: string): PostCSSSPRootNode {
+    const replaceSelectorContext = replaceSelector(
+      selector,
+      [
+        {
+          regexp: /#\{[\s\S]+?\}/gu, // interpolation
+          replace: (_res, random) => `_${random}_`,
+        },
+      ],
+      [
+        {
+          regexp: /\/\/[^\n\r\u2028\u2029]*/gu, // inline comment
+          replace: (_res, random) => `/*${random}*/`,
+        },
+      ]
+    );
 
-        const result: PostCSSSPRootNode = selectorParser().astSync(
-            replaceSelectorContext.cssSelector,
-        )
-        if (!replaceSelectorContext.hasReplace()) {
-            return result
-        }
-        return restoreReplacedSelector(
-            result,
-            replaceSelectorContext,
-        ) as PostCSSSPRootNode
+    const result: PostCSSSPRootNode = selectorParser().astSync(
+      replaceSelectorContext.cssSelector
+    );
+    if (!replaceSelectorContext.hasReplace()) {
+      return result;
     }
+    return restoreReplacedSelector(
+      result,
+      replaceSelectorContext
+    ) as PostCSSSPRootNode;
+  }
 
-    protected parseCommentsInternal(selector: string): PostCSSSPRootNode {
-        return this.parseInternal(selector)
-    }
+  protected parseCommentsInternal(selector: string): PostCSSSPRootNode {
+    return this.parseInternal(selector);
+  }
 
-    /**
-     * Convert comment Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {null}
-     */
-    protected convertCommentNode(
-        node: PostCSSSPCommentNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        if (node.value.startsWith("//")) {
-            // inline comment
-            const text = node.value.replace(/^\s*\/\//u, "")
-            this.commentContainer.push(
-                new VCSSInlineComment(node, text, loc, start, end, {
-                    parent,
-                }),
-            )
-            return null
-        }
-        return super.convertCommentNode(node, loc, start, end, parent)
+  /**
+   * Convert comment Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {null}
+   */
+  protected convertCommentNode(
+    node: PostCSSSPCommentNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    if (node.value.startsWith("//")) {
+      // inline comment
+      const text = node.value.replace(/^\s*\/\//u, "");
+      this.commentContainer.push(
+        new VCSSInlineComment(node, text, loc, start, end, {
+          parent,
+        })
+      );
+      return null;
     }
+    return super.convertCommentNode(node, loc, start, end, parent);
+  }
 }
diff --git a/lib/styles/parser/selector/stylus-selector-parser.ts b/lib/styles/parser/selector/stylus-selector-parser.ts
index c63abe18..232a80ce 100644
--- a/lib/styles/parser/selector/stylus-selector-parser.ts
+++ b/lib/styles/parser/selector/stylus-selector-parser.ts
@@ -1,163 +1,157 @@
 import type {
-    PostCSSSPRootNode,
-    SourceLocation,
-    PostCSSSPCommentNode,
-    PostCSSSPNode,
-    PostCSSSPNestingNode,
-} from "../../../types"
-import { CSSSelectorParser } from "./css-selector-parser"
-import selectorParser from "postcss-selector-parser"
-import type { VCSSSelectorNode, VCSSSelector } from "../../ast"
-import { VCSSInlineComment } from "../../ast"
-import { replaceSelector, restoreReplacedSelector } from "./replace-utils"
+  PostCSSSPRootNode,
+  SourceLocation,
+  PostCSSSPCommentNode,
+  PostCSSSPNode,
+  PostCSSSPNestingNode,
+} from "../../../types";
+import { CSSSelectorParser } from "./css-selector-parser";
+import selectorParser from "postcss-selector-parser";
+import type { VCSSSelectorNode, VCSSSelector } from "../../ast";
+import { VCSSInlineComment } from "../../ast";
+import { replaceSelector, restoreReplacedSelector } from "./replace-utils";
 
 /**
  * Replace stylus nesting node
  */
 function replaceStylusNesting(
-    _result: RegExpExecArray,
-    random: string,
+  _result: RegExpExecArray,
+  random: string
 ): string {
-    return `[${random}]`
+  return `[${random}]`;
 }
 
 /**
  * Restore stylus nesting node
  */
 function restoreStylusNesting(
-    attribute: PostCSSSPNode,
-    random: string,
-    original: string,
+  attribute: PostCSSSPNode,
+  random: string,
+  original: string
 ): PostCSSSPNestingNode | null {
-    if (attribute.type !== "attribute") {
-        return null
-    }
-    if (!attribute.attribute.includes(random)) {
-        return null
-    }
-    const node = selectorParser.nesting({ ...attribute })
-    node.value = original
-    return node
+  if (attribute.type !== "attribute") {
+    return null;
+  }
+  if (!attribute.attribute.includes(random)) {
+    return null;
+  }
+  const node = selectorParser.nesting({ ...attribute });
+  node.value = original;
+  return node;
 }
 
 export class StylusSelectorParser extends CSSSelectorParser {
-    protected parseInternal(selector: string): PostCSSSPRootNode {
-        const replaceSelectorContext = replaceSelector(
-            selector,
-            [
-                {
-                    regexp: /\{[\s\S]+?\}/gu, // interpolation
-                    replace: (_res, random) => `_${random}_`,
-                },
-                {
-                    regexp: /\^\[[\s\S]+?\]/gu, // partial reference
-                    replace: replaceStylusNesting,
-                    restore: restoreStylusNesting,
-                },
-                {
-                    regexp: /~\//gu, // initial reference
-                    replace: replaceStylusNesting,
-                    restore: restoreStylusNesting,
-                },
-                {
-                    regexp: /(?:\.\.\/)+/gu, // relative reference
-                    replace: replaceStylusNesting,
-                    restore: restoreStylusNesting,
-                },
-                {
-                    regexp: /\//gu, // root reference
-                    replace: replaceStylusNesting,
-                    restore: restoreStylusNesting,
-                },
-            ],
-            [
-                {
-                    regexp: /\/\/[^\n\r\u2028\u2029]*/gu, // inline comment
-                    replace: (_res, random) => `/*${random}*/`,
-                },
-            ],
-            [
-                {
-                    regexp: /([\n\r\u2028\u2029])(\s*)/gu, // comma
-                    replace(res, _random, { beforeCss }) {
-                        const before = [...beforeCss]
-                        let prev = before.pop()
-                        while (
-                            prev != null &&
-                            (prev.startsWith("/*") || !prev.trim())
-                        ) {
-                            // skip comments
-                            prev = before.pop()
-                        }
-                        if (prev?.trim().endsWith(",")) {
-                            return res[0]
-                        }
-                        let after = selector.slice(res.index)
-                        let next
-                        while (
-                            (next = after
-                                .replace(
-                                    /^\s*\/\/[^\n\r\u2028\u2029]*\s*/gu,
-                                    "",
-                                )
-                                .replace(/^\s*\/\*[\s\S]+?\*\/\s*/gu, "")
-                                .trim()) &&
-                            next !== after
-                        ) {
-                            // skip comments
-                            after = next
-                        }
-                        if (after.startsWith(",")) {
-                            return res[0]
-                        }
-                        return `${res[1]},${res[2]}`
-                    },
-                },
-            ],
-        )
+  protected parseInternal(selector: string): PostCSSSPRootNode {
+    const replaceSelectorContext = replaceSelector(
+      selector,
+      [
+        {
+          regexp: /\{[\s\S]+?\}/gu, // interpolation
+          replace: (_res, random) => `_${random}_`,
+        },
+        {
+          regexp: /\^\[[\s\S]+?\]/gu, // partial reference
+          replace: replaceStylusNesting,
+          restore: restoreStylusNesting,
+        },
+        {
+          regexp: /~\//gu, // initial reference
+          replace: replaceStylusNesting,
+          restore: restoreStylusNesting,
+        },
+        {
+          regexp: /(?:\.\.\/)+/gu, // relative reference
+          replace: replaceStylusNesting,
+          restore: restoreStylusNesting,
+        },
+        {
+          regexp: /\//gu, // root reference
+          replace: replaceStylusNesting,
+          restore: restoreStylusNesting,
+        },
+      ],
+      [
+        {
+          regexp: /\/\/[^\n\r\u2028\u2029]*/gu, // inline comment
+          replace: (_res, random) => `/*${random}*/`,
+        },
+      ],
+      [
+        {
+          regexp: /([\n\r\u2028\u2029])(\s*)/gu, // comma
+          replace(res, _random, { beforeCss }) {
+            const before = [...beforeCss];
+            let prev = before.pop();
+            while (prev != null && (prev.startsWith("/*") || !prev.trim())) {
+              // skip comments
+              prev = before.pop();
+            }
+            if (prev?.trim().endsWith(",")) {
+              return res[0];
+            }
+            let after = selector.slice(res.index);
+            let next;
+            while (
+              (next = after
+                .replace(/^\s*\/\/[^\n\r\u2028\u2029]*\s*/gu, "")
+                .replace(/^\s*\/\*[\s\S]+?\*\/\s*/gu, "")
+                .trim()) &&
+              next !== after
+            ) {
+              // skip comments
+              after = next;
+            }
+            if (after.startsWith(",")) {
+              return res[0];
+            }
+            return `${res[1]},${res[2]}`;
+          },
+        },
+      ]
+    );
 
-        const result: PostCSSSPRootNode = selectorParser().astSync(
-            replaceSelectorContext.cssSelector,
-        )
-        if (!replaceSelectorContext.hasReplace()) {
-            return result
-        }
-        return restoreReplacedSelector(
-            result,
-            replaceSelectorContext,
-        ) as PostCSSSPRootNode
+    const result: PostCSSSPRootNode = selectorParser().astSync(
+      replaceSelectorContext.cssSelector
+    );
+    if (!replaceSelectorContext.hasReplace()) {
+      return result;
     }
+    return restoreReplacedSelector(
+      result,
+      replaceSelectorContext
+    ) as PostCSSSPRootNode;
+  }
 
-    protected parseCommentsInternal(selector: string): PostCSSSPRootNode {
-        return this.parseInternal(selector)
-    }
+  protected parseCommentsInternal(selector: string): PostCSSSPRootNode {
+    return this.parseInternal(selector);
+  }
 
-    /**
-     * Convert comment Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {null}
-     */
-    protected convertCommentNode(
-        node: PostCSSSPCommentNode,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSSelector,
-    ): VCSSSelectorNode | null {
-        if (node.value.startsWith("//")) {
-            // inline comment
-            const text = node.value.replace(/^\s*\/\//u, "")
-            this.commentContainer.push(
-                new VCSSInlineComment(node, text, loc, start, end, {
-                    parent,
-                }),
-            )
-            return null
-        }
-        return super.convertCommentNode(node, loc, start, end, parent)
+  /**
+   * Convert comment Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {null}
+   */
+  protected convertCommentNode(
+    node: PostCSSSPCommentNode,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSSelector
+  ): VCSSSelectorNode | null {
+    if (node.value.startsWith("//")) {
+      // inline comment
+      const text = node.value.replace(/^\s*\/\//u, "");
+      this.commentContainer.push(
+        new VCSSInlineComment(node, text, loc, start, end, {
+          parent,
+        })
+      );
+      return null;
     }
+    return super.convertCommentNode(node, loc, start, end, parent);
+  }
 }
diff --git a/lib/styles/parser/stylus-parser.ts b/lib/styles/parser/stylus-parser.ts
index f2087007..faeb5fb1 100644
--- a/lib/styles/parser/stylus-parser.ts
+++ b/lib/styles/parser/stylus-parser.ts
@@ -1,79 +1,75 @@
-import postcssStyl from "postcss-styl"
-import type * as postcss from "postcss"
-import { CSSParser } from "./css-parser"
-import type { VCSSContainerNode, VCSSNode } from "../ast"
-import { VCSSInlineComment } from "../ast"
-import type { SourceLocation, PostCSSComment, PostCSSNode } from "../../types"
-import { StylusSelectorParser } from "./selector/stylus-selector-parser"
+import postcssStyl from "postcss-styl";
+import type * as postcss from "postcss";
+import { CSSParser } from "./css-parser";
+import type { VCSSContainerNode, VCSSNode } from "../ast";
+import { VCSSInlineComment } from "../ast";
+import type { SourceLocation, PostCSSComment, PostCSSNode } from "../../types";
+import { StylusSelectorParser } from "./selector/stylus-selector-parser";
 /**
  * Stylus Parser
  */
 export class StylusParser extends CSSParser {
-    protected parseInternal(css: string): postcss.Root {
-        return postcssStyl.parse(css) as postcss.Root
-    }
+  protected parseInternal(css: string): postcss.Root {
+    return postcssStyl.parse(css) as postcss.Root;
+  }
 
-    protected createSelectorParser(): StylusSelectorParser {
-        return new StylusSelectorParser(this.sourceCode, this.commentContainer)
-    }
+  protected createSelectorParser(): StylusSelectorParser {
+    return new StylusSelectorParser(this.sourceCode, this.commentContainer);
+  }
 
-    /**
-     * Convert comment Node
-     * @param  {object} node  The node.
-     * @param  {SourceLocation} loc  The location.
-     * @param  {number} start  The index of start.
-     * @param  {number} end  The index of end.
-     * @param  {Node} parent  The parent node.
-     * @returns {void}
-     */
-    protected convertCommentNode(
-        node: PostCSSComment,
-        loc: SourceLocation,
-        start: number,
-        end: number,
-        parent: VCSSContainerNode,
-    ): VCSSNode | null {
-        if (node.raws?.inline) {
-            this.commentContainer.push(
-                new VCSSInlineComment(node, node.text, loc, start, end, {
-                    parent,
-                }),
-            )
-            return null
-        }
-        return super.convertCommentNode(node, loc, start, end, parent)
+  /**
+   * Convert comment Node
+   * @param  {object} node  The node.
+   * @param  {SourceLocation} loc  The location.
+   * @param  {number} start  The index of start.
+   * @param  {number} end  The index of end.
+   * @param  {Node} parent  The parent node.
+   * @returns {void}
+   */
+  protected convertCommentNode(
+    node: PostCSSComment,
+    loc: SourceLocation,
+    start: number,
+    end: number,
+    parent: VCSSContainerNode
+  ): VCSSNode | null {
+    if (node.raws?.inline) {
+      this.commentContainer.push(
+        new VCSSInlineComment(node, node.text, loc, start, end, {
+          parent,
+        })
+      );
+      return null;
     }
+    return super.convertCommentNode(node, loc, start, end, parent);
+  }
 
-    protected getRaw<N extends PostCSSNode, K extends keyof N["raws"] & string>(
-        node: N,
-        keyName: K,
-    ): N["raws"][K] {
-        if (
-            keyName === "between" ||
-            keyName === "before" ||
-            keyName === "after"
-        ) {
-            const stylus = super.getRaw(
-                node as never,
-                `stylus${keyName[0].toUpperCase()}${keyName.slice(1)}`,
-            )
-            if (stylus) {
-                return stylus
-            }
-        }
-        const raw = super.getRaw(node, keyName)
-        if (raw != null) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check stylus
-            const stylus = (raw as any).stylus
-            if (stylus != null) {
-                return {
-                    raw: stylus,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- stylus
-                    value: (raw as any).value,
-                } as never
-            }
-        }
-
-        return raw
+  protected getRaw<N extends PostCSSNode, K extends keyof N["raws"] & string>(
+    node: N,
+    keyName: K
+  ): N["raws"][K] {
+    if (keyName === "between" || keyName === "before" || keyName === "after") {
+      const stylus = super.getRaw(
+        node as never,
+        `stylus${keyName[0].toUpperCase()}${keyName.slice(1)}`
+      );
+      if (stylus) {
+        return stylus;
+      }
     }
+    const raw = super.getRaw(node, keyName);
+    if (raw != null) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- check stylus
+      const stylus = (raw as any).stylus;
+      if (stylus != null) {
+        return {
+          raw: stylus,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- stylus
+          value: (raw as any).value,
+        } as never;
+      }
+    }
+
+    return raw;
+  }
 }
diff --git a/lib/styles/parser/utils.ts b/lib/styles/parser/utils.ts
index a5bd26a5..c4df8389 100644
--- a/lib/styles/parser/utils.ts
+++ b/lib/styles/parser/utils.ts
@@ -1,24 +1,24 @@
 import type {
-    PostCSSNode,
-    PostCSSContainer,
-    PostCSSSPNode,
-    PostCSSSPContainer,
-} from "../../types"
+  PostCSSNode,
+  PostCSSContainer,
+  PostCSSSPNode,
+  PostCSSSPContainer,
+} from "../../types";
 
 /**
  * Checks if the given node has nodes property.
  */
 export function isPostCSSContainer(
-    node: PostCSSNode,
+  node: PostCSSNode
 ): node is PostCSSContainer {
-    return (node as PostCSSContainer).nodes != null
+  return (node as PostCSSContainer).nodes != null;
 }
 
 /**
  * Checks if the given node has nodes property.
  */
 export function isPostCSSSPContainer(
-    node: PostCSSSPNode,
+  node: PostCSSSPNode
 ): node is PostCSSSPContainer {
-    return (node as PostCSSSPContainer).nodes != null
+  return (node as PostCSSSPContainer).nodes != null;
 }
diff --git a/lib/styles/selectors/index.ts b/lib/styles/selectors/index.ts
index 94351343..83f5945f 100644
--- a/lib/styles/selectors/index.ts
+++ b/lib/styles/selectors/index.ts
@@ -1,18 +1,18 @@
-import type { ValidStyleContext } from "../context"
-import type { ResolvedSelectors } from "./resolver/css-selector-resolver"
+import type { ValidStyleContext } from "../context";
+import type { ResolvedSelectors } from "./resolver/css-selector-resolver";
 import {
-    CSSSelectorResolver,
-    ResolvedSelector,
-} from "./resolver/css-selector-resolver"
-import { SCSSSelectorResolver } from "./resolver/scss-selector-resolver"
-import { StylusSelectorResolver } from "./resolver/stylus-selector-resolver"
-import { isSupportedStyleLang } from "../utils"
+  CSSSelectorResolver,
+  ResolvedSelector,
+} from "./resolver/css-selector-resolver";
+import { SCSSSelectorResolver } from "./resolver/scss-selector-resolver";
+import { StylusSelectorResolver } from "./resolver/stylus-selector-resolver";
+import { isSupportedStyleLang } from "../utils";
 
 const RESOLVERS = {
-    scss: SCSSSelectorResolver,
-    css: CSSSelectorResolver,
-    stylus: StylusSelectorResolver,
-}
+  scss: SCSSSelectorResolver,
+  css: CSSSelectorResolver,
+  stylus: StylusSelectorResolver,
+};
 
 /**
  * Get the selector that resolved the nesting.
@@ -20,29 +20,29 @@ const RESOLVERS = {
  * @returns {ResolvedSelectors[]} the selector that resolved the nesting.
  */
 export function getResolvedSelectors(
-    style: ValidStyleContext,
+  style: ValidStyleContext
 ): ResolvedSelector[] {
-    const lang = style.lang
-    // eslint-disable-next-line @typescript-eslint/naming-convention -- classes
-    const Resolver = isSupportedStyleLang(lang)
-        ? RESOLVERS[lang]
-        : CSSSelectorResolver
-    return extractSelectors(new Resolver().resolveSelectors(style.cssNode))
+  const lang = style.lang;
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- classes
+  const Resolver = isSupportedStyleLang(lang)
+    ? RESOLVERS[lang]
+    : CSSSelectorResolver;
+  return extractSelectors(new Resolver().resolveSelectors(style.cssNode));
 }
 
-export { ResolvedSelector }
+export { ResolvedSelector };
 
 /**
  * Extracts the selectors from the given resolved selectors.
  */
 function extractSelectors(
-    resolvedSelectorsList: ResolvedSelectors[],
+  resolvedSelectorsList: ResolvedSelectors[]
 ): ResolvedSelector[] {
-    const result: ResolvedSelector[] = []
-    for (const resolvedSelectors of resolvedSelectorsList) {
-        result.push(...resolvedSelectors.selectors)
-        result.push(...extractSelectors(resolvedSelectors.children))
-    }
+  const result: ResolvedSelector[] = [];
+  for (const resolvedSelectors of resolvedSelectorsList) {
+    result.push(...resolvedSelectors.selectors);
+    result.push(...extractSelectors(resolvedSelectors.children));
+  }
 
-    return result
+  return result;
 }
diff --git a/lib/styles/selectors/query/attribute-tracker.ts b/lib/styles/selectors/query/attribute-tracker.ts
index 826e0c12..82eef795 100644
--- a/lib/styles/selectors/query/attribute-tracker.ts
+++ b/lib/styles/selectors/query/attribute-tracker.ts
@@ -1,6 +1,6 @@
-import { getVueComponentContext } from "../../context"
-import type { RuleContext, AST } from "../../../types"
-import { isVDirective, isVBind, getArgument } from "../../../utils/templates"
+import { getVueComponentContext } from "../../context";
+import type { RuleContext, AST } from "../../../types";
+import { isVDirective, isVBind, getArgument } from "../../../utils/templates";
 
 /**
  * Gets the value nodes of attribute of given name as Array. Returns `null` If the given name can not be identified.
@@ -10,53 +10,53 @@ import { isVDirective, isVBind, getArgument } from "../../../utils/templates"
  * @returns {ASTNode[]} the value nodes of attribute of given name as Array. `null` If the given name can not be identified.
  */
 export function getAttributeValueNodes(
-    element: AST.VElement,
-    name: string,
-    context: RuleContext,
+  element: AST.VElement,
+  name: string,
+  context: RuleContext
 ): AttributeValueExpressions[] | null {
-    const results: AttributeValueExpressions[] = []
-    const { startTag } = element
-    for (const attr of startTag.attributes) {
-        if (!isVDirective(attr)) {
-            const { key, value } = attr
-            if (value == null) {
-                continue
-            }
-            if (key.name === name) {
-                results.push(value)
-            }
-        } else {
-            const { key, value } = attr
-            if (value == null) {
-                continue
-            }
-            if (!isVBind(key)) {
-                continue
-            }
-            const bindArg = getArgument(key)
-            if (bindArg == null) {
-                // bind name is unknown.
-                return null
-            }
-            if (bindArg !== name) {
-                continue
-            }
-            const { expression } = value
-            if (expression == null) {
-                // empty or syntax error
-                continue
-            }
-            const expressions = getReferenceExpressions(expression, context)
-            if (!expressions) {
-                // Expressions not found.
-                return null
-            }
-            for (const e of expressions) {
-                results.push(e)
-            }
-        }
+  const results: AttributeValueExpressions[] = [];
+  const { startTag } = element;
+  for (const attr of startTag.attributes) {
+    if (!isVDirective(attr)) {
+      const { key, value } = attr;
+      if (value == null) {
+        continue;
+      }
+      if (key.name === name) {
+        results.push(value);
+      }
+    } else {
+      const { key, value } = attr;
+      if (value == null) {
+        continue;
+      }
+      if (!isVBind(key)) {
+        continue;
+      }
+      const bindArg = getArgument(key);
+      if (bindArg == null) {
+        // bind name is unknown.
+        return null;
+      }
+      if (bindArg !== name) {
+        continue;
+      }
+      const { expression } = value;
+      if (expression == null) {
+        // empty or syntax error
+        continue;
+      }
+      const expressions = getReferenceExpressions(expression, context);
+      if (!expressions) {
+        // Expressions not found.
+        return null;
+      }
+      for (const e of expressions) {
+        results.push(e);
+      }
     }
-    return results
+  }
+  return results;
 }
 
 /**
@@ -66,36 +66,36 @@ export function getAttributeValueNodes(
  * @returns {ASTNode[]} reference expressions.
  */
 export function getReferenceExpressions(
-    expression: AttrExpressions,
-    context: RuleContext,
+  expression: AttrExpressions,
+  context: RuleContext
 ): ReferenceExpressions[] | null {
-    if (expression.type !== "Identifier") {
-        return [expression]
-    }
-    const vueComponent = getVueComponentContext(context)
-    if (!vueComponent) {
-        return null
-    }
-    // Identify expression references from Vue's `data` and `computed`.
-    const props = vueComponent.findVueComponentProperty(expression.name)
-    if (props == null) {
-        // Property not found.
-        return null
-    }
-    return props
+  if (expression.type !== "Identifier") {
+    return [expression];
+  }
+  const vueComponent = getVueComponentContext(context);
+  if (!vueComponent) {
+    return null;
+  }
+  // Identify expression references from Vue's `data` and `computed`.
+  const props = vueComponent.findVueComponentProperty(expression.name);
+  if (props == null) {
+    // Property not found.
+    return null;
+  }
+  return props;
 }
 
 export type ReferenceExpressions =
-    | AST.ESLintBlockStatement
-    | AST.ESLintExpression
-    | AST.ESLintPattern
-    | AttrExpressions
+  | AST.ESLintBlockStatement
+  | AST.ESLintExpression
+  | AST.ESLintPattern
+  | AttrExpressions;
 
 type AttrExpressions =
-    | AST.ESLintExpression
-    | AST.VFilterSequenceExpression
-    | AST.VForExpression
-    | AST.VOnExpression
-    | AST.VSlotScopeExpression
+  | AST.ESLintExpression
+  | AST.VFilterSequenceExpression
+  | AST.VForExpression
+  | AST.VOnExpression
+  | AST.VSlotScopeExpression;
 
-export type AttributeValueExpressions = ReferenceExpressions | AST.VLiteral
+export type AttributeValueExpressions = ReferenceExpressions | AST.VLiteral;
diff --git a/lib/styles/selectors/query/elements.ts b/lib/styles/selectors/query/elements.ts
index 2246b015..e3e16e2a 100644
--- a/lib/styles/selectors/query/elements.ts
+++ b/lib/styles/selectors/query/elements.ts
@@ -1,8 +1,8 @@
-import type { AST } from "../../../types"
+import type { AST } from "../../../types";
 import {
-    isTransitionElement,
-    isTransitionGroupElement,
-} from "../../../utils/templates"
+  isTransitionElement,
+  isTransitionGroupElement,
+} from "../../../utils/templates";
 
 /**
  * Checks whether the given element is the root element.
@@ -10,11 +10,11 @@ import {
  * @returns {boolean} `true` if the given element is the root element.
  */
 export function isRootElement(
-    element: AST.VElement | AST.VDocumentFragment,
+  element: AST.VElement | AST.VDocumentFragment
 ): element is AST.VElement & {
-    parent: AST.VDocumentFragment
+  parent: AST.VDocumentFragment;
 } {
-    return element.type === "VElement" && isRootTemplate(element.parent)
+  return element.type === "VElement" && isRootTemplate(element.parent);
 }
 
 /**
@@ -23,16 +23,16 @@ export function isRootElement(
  * @returns {boolean} `true` if the given element is the root `<template>` element.
  */
 function isRootTemplate(
-    element: AST.VElement | AST.VDocumentFragment,
+  element: AST.VElement | AST.VDocumentFragment
 ): element is AST.VElement & {
-    name: "template"
-    parent: AST.VDocumentFragment
+  name: "template";
+  parent: AST.VDocumentFragment;
 } {
-    return (
-        element.type === "VElement" &&
-        element.name === "template" &&
-        element.parent.type === "VDocumentFragment"
-    )
+  return (
+    element.type === "VElement" &&
+    element.name === "template" &&
+    element.parent.type === "VDocumentFragment"
+  );
 }
 
 /**
@@ -41,12 +41,12 @@ function isRootTemplate(
  * @returns {boolean} `true` if the given element is the skip element.
  */
 export function isSkipElement(
-    element: AST.VElement | AST.VDocumentFragment,
+  element: AST.VElement | AST.VDocumentFragment
 ): boolean {
-    return (
-        element.type === "VElement" &&
-        (element.name === "template" || isTransitionElement(element))
-    )
+  return (
+    element.type === "VElement" &&
+    (element.name === "template" || isTransitionElement(element))
+  );
 }
 
 /**
@@ -55,9 +55,9 @@ export function isSkipElement(
  * @returns {boolean} `true` if the given element is the slot element.
  */
 export function isSlotElement(
-    element: AST.VElement | AST.VDocumentFragment,
+  element: AST.VElement | AST.VDocumentFragment
 ): element is AST.VElement & { name: "slot" } {
-    return element.type === "VElement" && element.name === "slot"
+  return element.type === "VElement" && element.name === "slot";
 }
 
 /**
@@ -66,19 +66,19 @@ export function isSlotElement(
  * @returns {VElement} the wrapper `<transition>` element.
  */
 export function getWrapperTransition(
-    element: AST.VElement,
+  element: AST.VElement
 ): AST.VElement | null {
-    let parent: AST.VElement | AST.VDocumentFragment | null = element.parent
-    while (parent.type === "VElement") {
-        if (isTransitionElement(parent) || isTransitionGroupElement(parent)) {
-            return parent
-        }
-        if (!isSlotElement(parent) && !isSkipElement(parent)) {
-            return null
-        }
-        parent = parent.parent
+  let parent: AST.VElement | AST.VDocumentFragment | null = element.parent;
+  while (parent.type === "VElement") {
+    if (isTransitionElement(parent) || isTransitionGroupElement(parent)) {
+      return parent;
     }
-    return null
+    if (!isSlotElement(parent) && !isSkipElement(parent)) {
+      return null;
+    }
+    parent = parent.parent;
+  }
+  return null;
 }
 
 /**
@@ -87,7 +87,7 @@ export function getWrapperTransition(
  * @returns {VElement} `true` the given element is wrapped in the `<transition>` or `<transition-group>`.
  */
 export function isElementWrappedInTransition(element: AST.VElement): boolean {
-    return Boolean(getWrapperTransition(element))
+  return Boolean(getWrapperTransition(element));
 }
 
 /**
@@ -96,15 +96,15 @@ export function isElementWrappedInTransition(element: AST.VElement): boolean {
  * @returns {VElement} the parent element.
  */
 export function getParentElement(element: AST.VElement): AST.VElement | null {
-    if (isRootElement(element)) {
-        return null
-    }
-    let parent: AST.VElement | AST.VDocumentFragment | null = element.parent
-    while (parent && (isSkipElement(parent) || isSlotElement(parent))) {
-        if (isRootElement(parent)) {
-            return null
-        }
-        parent = parent.parent
+  if (isRootElement(element)) {
+    return null;
+  }
+  let parent: AST.VElement | AST.VDocumentFragment | null = element.parent;
+  while (parent && (isSkipElement(parent) || isSlotElement(parent))) {
+    if (isRootElement(parent)) {
+      return null;
     }
-    return parent?.type === "VElement" ? parent : null
+    parent = parent.parent;
+  }
+  return parent?.type === "VElement" ? parent : null;
 }
diff --git a/lib/styles/selectors/query/index.ts b/lib/styles/selectors/query/index.ts
index e02627a7..6e7f863a 100644
--- a/lib/styles/selectors/query/index.ts
+++ b/lib/styles/selectors/query/index.ts
@@ -1,197 +1,197 @@
 import {
-    isTypeSelector,
-    isIDSelector,
-    isClassSelector,
-    isUniversalSelector,
-    isSelectorCombinator,
-    isDescendantCombinator,
-    isChildCombinator,
-    isAdjacentSiblingCombinator,
-    isGeneralSiblingCombinator,
-    isDeepCombinator,
-    isVDeepPseudo,
-    isVSlottedPseudo,
-    isVGlobalPseudo,
-    normalizePseudoParams,
-} from "../../utils/selectors"
+  isTypeSelector,
+  isIDSelector,
+  isClassSelector,
+  isUniversalSelector,
+  isSelectorCombinator,
+  isDescendantCombinator,
+  isChildCombinator,
+  isAdjacentSiblingCombinator,
+  isGeneralSiblingCombinator,
+  isDeepCombinator,
+  isVDeepPseudo,
+  isVSlottedPseudo,
+  isVGlobalPseudo,
+  normalizePseudoParams,
+} from "../../utils/selectors";
 import {
-    getParentElement,
-    isSkipElement,
-    isElementWrappedInTransition,
-    getWrapperTransition,
-    isRootElement,
-    isSlotElement,
-} from "./elements"
+  getParentElement,
+  isSkipElement,
+  isElementWrappedInTransition,
+  getWrapperTransition,
+  isRootElement,
+  isSlotElement,
+} from "./elements";
 import type {
-    VCSSSelectorNode,
-    VCSSSelector,
-    VCSSSelectorValueNode,
-} from "../../ast"
-import type { AST, RuleContext, ASTNode } from "../../../types"
-import type { ParsedQueryOptions } from "../../../options"
-import type { ReferenceExpressions } from "./attribute-tracker"
+  VCSSSelectorNode,
+  VCSSSelector,
+  VCSSSelectorValueNode,
+} from "../../ast";
+import type { AST, RuleContext, ASTNode } from "../../../types";
+import type { ParsedQueryOptions } from "../../../options";
+import type { ReferenceExpressions } from "./attribute-tracker";
 import {
-    getAttributeValueNodes,
-    getReferenceExpressions,
-} from "./attribute-tracker"
-import type { ValidStyleContext } from "../../context"
-import { getVueComponentContext, getStyleContexts } from "../../context"
-import { getStringFromNode } from "../../utils/nodes"
-import { Template } from "../../template"
-import { isVElement, isTransitionElement } from "../../../utils/templates"
-import { isValidStyleContext } from "../../context/style"
+  getAttributeValueNodes,
+  getReferenceExpressions,
+} from "./attribute-tracker";
+import type { ValidStyleContext } from "../../context";
+import { getVueComponentContext, getStyleContexts } from "../../context";
+import { getStringFromNode } from "../../utils/nodes";
+import { Template } from "../../template";
+import { isVElement, isTransitionElement } from "../../../utils/templates";
+import { isValidStyleContext } from "../../context/style";
 
 const TRANSITION_CLASS_BASES = [
-    "enter",
-    "enter-from",
-    "enter-active",
-    "enter-to",
-    "leave",
-    "leave-from",
-    "leave-active",
-    "leave-to",
-]
-const TRANSITION_GROUP_CLASS_BASES = [...TRANSITION_CLASS_BASES, "move"]
+  "enter",
+  "enter-from",
+  "enter-active",
+  "enter-to",
+  "leave",
+  "leave-from",
+  "leave-active",
+  "leave-to",
+];
+const TRANSITION_GROUP_CLASS_BASES = [...TRANSITION_CLASS_BASES, "move"];
 
 /**
  * Context to execute the query and retrieve the target elements.
  */
 export class QueryContext {
-    public elements: AST.VElement[] = []
+  public elements: AST.VElement[] = [];
 
-    protected readonly document: VueDocumentQueryContext
+  protected readonly document: VueDocumentQueryContext;
 
-    protected constructor(document?: VueDocumentQueryContext) {
-        this.document = document || (this as never)
-    }
+  protected constructor(document?: VueDocumentQueryContext) {
+    this.document = document || (this as never);
+  }
 
-    /**
-     * Execute a one-step query and return contexts of the matched elements.
-     * @param {Node} selectorNode selector node
-     * @returns {ElementsQueryContext} elements
-     */
-    public queryStep(selectorNode: VCSSSelectorNode): ElementsQueryContext {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
-        return new ElementsQueryContext(
-            queryStep(this.elements, selectorNode, this.document),
-            this.document,
-        )
-    }
+  /**
+   * Execute a one-step query and return contexts of the matched elements.
+   * @param {Node} selectorNode selector node
+   * @returns {ElementsQueryContext} elements
+   */
+  public queryStep(selectorNode: VCSSSelectorNode): ElementsQueryContext {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
+    return new ElementsQueryContext(
+      queryStep(this.elements, selectorNode, this.document),
+      this.document
+    );
+  }
 
-    /**
-     * Execute a one-step query in the reverse direction and return contexts of the matched elements.
-     * @param {Node} selectorNode selector node
-     * @returns {ElementsQueryContext} elements
-     */
-    public reverseQueryStep(
-        selectorNode: VCSSSelectorNode,
-    ): ElementsQueryContext {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
-        return new ElementsQueryContext(
-            reverseQueryStep(this.elements, selectorNode, this.document),
-            this.document,
-        )
-    }
+  /**
+   * Execute a one-step query in the reverse direction and return contexts of the matched elements.
+   * @param {Node} selectorNode selector node
+   * @returns {ElementsQueryContext} elements
+   */
+  public reverseQueryStep(
+    selectorNode: VCSSSelectorNode
+  ): ElementsQueryContext {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
+    return new ElementsQueryContext(
+      reverseQueryStep(this.elements, selectorNode, this.document),
+      this.document
+    );
+  }
 
-    /**
-     * Filter elements
-     * @param {function} predicate filter function.
-     * @returns {ElementsQueryContext} elements
-     */
-    public filter<S extends AST.VElement>(
-        predicate: (value: AST.VElement) => value is S,
-    ): ElementsQueryContext {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
-        return new ElementsQueryContext(
-            this.elements.filter(predicate),
-            this.document,
-        )
-    }
+  /**
+   * Filter elements
+   * @param {function} predicate filter function.
+   * @returns {ElementsQueryContext} elements
+   */
+  public filter<S extends AST.VElement>(
+    predicate: (value: AST.VElement) => value is S
+  ): ElementsQueryContext {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
+    return new ElementsQueryContext(
+      this.elements.filter(predicate),
+      this.document
+    );
+  }
 
-    /**
-     * Split elements
-     * @returns {ElementsQueryContext[]} element contexts
-     */
-    public split(): ElementsQueryContext[] {
-        return this.elements.map(
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
-            (e) => new ElementsQueryContext([e], this.document),
-        )
-    }
+  /**
+   * Split elements
+   * @returns {ElementsQueryContext[]} element contexts
+   */
+  public split(): ElementsQueryContext[] {
+    return this.elements.map(
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- ignore
+      (e) => new ElementsQueryContext([e], this.document)
+    );
+  }
 }
 
 /**
  * QueryContext that as the Vue document.
  */
 class VueDocumentQueryContext extends QueryContext {
-    public context: RuleContext
+  public context: RuleContext;
 
-    public options: ParsedQueryOptions
+  public options: ParsedQueryOptions;
 
-    public docsModifiers: string[]
+  public docsModifiers: string[];
 
-    public constructor(context: RuleContext, options: ParsedQueryOptions) {
-        super()
-        const sourceCode = context.getSourceCode()
-        const { ast } = sourceCode
-        this.elements = ast.templateBody
-            ? [...genDescendantElements([ast.templateBody])]
-            : []
-        this.context = context
-        this.options = options
+  public constructor(context: RuleContext, options: ParsedQueryOptions) {
+    super();
+    const sourceCode = context.getSourceCode();
+    const { ast } = sourceCode;
+    this.elements = ast.templateBody
+      ? [...genDescendantElements([ast.templateBody])]
+      : [];
+    this.context = context;
+    this.options = options;
 
-        if (options.captureClassesFromDoc.length > 0) {
-            this.docsModifiers = getStyleContexts(context)
-                .filter(isValidStyleContext)
-                .filter((style) => style.scoped)
-                .map((style) =>
-                    extractClassesFromDoc(style, options.captureClassesFromDoc),
-                )
-                .reduce((r, a) => r.concat(a), [])
-        } else {
-            this.docsModifiers = []
-        }
+    if (options.captureClassesFromDoc.length > 0) {
+      this.docsModifiers = getStyleContexts(context)
+        .filter(isValidStyleContext)
+        .filter((style) => style.scoped)
+        .map((style) =>
+          extractClassesFromDoc(style, options.captureClassesFromDoc)
+        )
+        .reduce((r, a) => r.concat(a), []);
+    } else {
+      this.docsModifiers = [];
     }
+  }
 }
 
 /**
  * Extract class names documented in the comment.
  */
 function extractClassesFromDoc(
-    style: ValidStyleContext,
-    captureClassesFromDoc: RegExp[],
+  style: ValidStyleContext,
+  captureClassesFromDoc: RegExp[]
 ): string[] {
-    const results = new Set<string>()
-    for (const comment of style.cssNode.comments) {
-        for (const regexp of captureClassesFromDoc) {
-            // Get all captures
-            regexp.lastIndex = 0
-            let re
-            while ((re = regexp.exec(comment.text))) {
-                if (re.length > 1) {
-                    for (const s of re.slice(1)) {
-                        results.add(s)
-                    }
-                } else {
-                    results.add(re[0])
-                }
-            }
+  const results = new Set<string>();
+  for (const comment of style.cssNode.comments) {
+    for (const regexp of captureClassesFromDoc) {
+      // Get all captures
+      regexp.lastIndex = 0;
+      let re;
+      while ((re = regexp.exec(comment.text))) {
+        if (re.length > 1) {
+          for (const s of re.slice(1)) {
+            results.add(s);
+          }
+        } else {
+          results.add(re[0]);
         }
+      }
     }
-    return [...results]
+  }
+  return [...results];
 }
 
 /**
  * QueryContext as elements.
  */
 class ElementsQueryContext extends QueryContext {
-    public constructor(
-        elements: AST.VElement[] | IterableIterator<AST.VElement>,
-        document: VueDocumentQueryContext,
-    ) {
-        super(document)
-        this.elements = [...elements]
-    }
+  public constructor(
+    elements: AST.VElement[] | IterableIterator<AST.VElement>,
+    document: VueDocumentQueryContext
+  ) {
+    super(document);
+    this.elements = [...elements];
+  }
 }
 
 /**
@@ -201,10 +201,10 @@ class ElementsQueryContext extends QueryContext {
  * @returns {VueDocumentQueryContext} the context
  */
 export function createQueryContext(
-    context: RuleContext,
-    options: ParsedQueryOptions,
+  context: RuleContext,
+  options: ParsedQueryOptions
 ): QueryContext {
-    return new VueDocumentQueryContext(context, options)
+  return new VueDocumentQueryContext(context, options);
 }
 
 /**
@@ -214,90 +214,89 @@ export function createQueryContext(
  * @param {object} document document
  */
 function* queryStep(
-    elements: AST.VElement[],
-    selectorNode: VCSSSelectorNode,
-    document: VueDocumentQueryContext,
+  elements: AST.VElement[],
+  selectorNode: VCSSSelectorNode,
+  document: VueDocumentQueryContext
 ): IterableIterator<AST.VElement> {
-    if (isSelectorCombinator(selectorNode)) {
-        if (isChildCombinator(selectorNode)) {
-            yield* genChildElements(elements)
-            return
-        } else if (
-            isDescendantCombinator(selectorNode) ||
-            isDeepCombinator(selectorNode)
-        ) {
-            yield* genDescendantElements(elements)
-            return
-        } else if (isAdjacentSiblingCombinator(selectorNode)) {
-            yield* genAdjacentSiblingElements(elements)
-            return
-        } else if (isGeneralSiblingCombinator(selectorNode)) {
-            yield* genGeneralSiblingElements(elements)
-            return
-        }
-    } else if (isVDeepPseudo(selectorNode)) {
-        yield* genVDeepElements(
-            elements,
-            normalizePseudoParams(selectorNode, selectorNode.nodes),
-            query,
-        )
-        return
-    } else if (isVSlottedPseudo(selectorNode)) {
-        yield* genVSlottedElements(
-            elements,
-            normalizePseudoParams(selectorNode, selectorNode.nodes),
-            query,
-        )
-        return
-    } else if (isVGlobalPseudo(selectorNode)) {
-        yield* genVGlobalElements(
-            elements,
-            normalizePseudoParams(selectorNode, selectorNode.nodes),
-            document,
-            query,
-        )
-        return
+  if (isSelectorCombinator(selectorNode)) {
+    if (isChildCombinator(selectorNode)) {
+      yield* genChildElements(elements);
+      return;
+    } else if (
+      isDescendantCombinator(selectorNode) ||
+      isDeepCombinator(selectorNode)
+    ) {
+      yield* genDescendantElements(elements);
+      return;
+    } else if (isAdjacentSiblingCombinator(selectorNode)) {
+      yield* genAdjacentSiblingElements(elements);
+      return;
+    } else if (isGeneralSiblingCombinator(selectorNode)) {
+      yield* genGeneralSiblingElements(elements);
+      return;
     }
+  } else if (isVDeepPseudo(selectorNode)) {
+    yield* genVDeepElements(
+      elements,
+      normalizePseudoParams(selectorNode, selectorNode.nodes),
+      query
+    );
+    return;
+  } else if (isVSlottedPseudo(selectorNode)) {
+    yield* genVSlottedElements(
+      elements,
+      normalizePseudoParams(selectorNode, selectorNode.nodes),
+      query
+    );
+    return;
+  } else if (isVGlobalPseudo(selectorNode)) {
+    yield* genVGlobalElements(
+      elements,
+      normalizePseudoParams(selectorNode, selectorNode.nodes),
+      document,
+      query
+    );
+    return;
+  }
 
-    if (isTypeSelector(selectorNode)) {
-        yield* genElementsByTagName(elements, Template.ofSelector(selectorNode))
-        return
-    } else if (isIDSelector(selectorNode)) {
-        yield* genElementsById(
-            elements,
-            Template.ofSelector(selectorNode),
-            document,
-        )
-        return
-    } else if (isClassSelector(selectorNode)) {
-        yield* genElementsByClassName(
-            elements,
-            Template.ofSelector(selectorNode),
-            document,
-        )
-        return
-    } else if (isUniversalSelector(selectorNode)) {
-        yield* elements
-        return
-    }
-    // Other selectors are ignored because they are likely to be changed dynamically.
-    yield* elements
+  if (isTypeSelector(selectorNode)) {
+    yield* genElementsByTagName(elements, Template.ofSelector(selectorNode));
+    return;
+  } else if (isIDSelector(selectorNode)) {
+    yield* genElementsById(
+      elements,
+      Template.ofSelector(selectorNode),
+      document
+    );
+    return;
+  } else if (isClassSelector(selectorNode)) {
+    yield* genElementsByClassName(
+      elements,
+      Template.ofSelector(selectorNode),
+      document
+    );
+    return;
+  } else if (isUniversalSelector(selectorNode)) {
+    yield* elements;
+    return;
+  }
+  // Other selectors are ignored because they are likely to be changed dynamically.
+  yield* elements;
 
-    /**
-     * Query for ::v-xxx pseudo
-     */
-    function query(
-        els: AST.VElement[],
-        selList: VCSSSelectorValueNode[],
-    ): AST.VElement[] {
-        return selList.reduce(
-            (
-                res: AST.VElement[],
-                sel: VCSSSelectorValueNode,
-            ): AST.VElement[] => [...queryStep(res, sel, document)],
-            els,
-        )
-    }
+  /**
+   * Query for ::v-xxx pseudo
+   */
+  function query(
+    els: AST.VElement[],
+    selList: VCSSSelectorValueNode[]
+  ): AST.VElement[] {
+    return selList.reduce(
+      (res: AST.VElement[], sel: VCSSSelectorValueNode): AST.VElement[] => [
+        ...queryStep(res, sel, document),
+      ],
+      els
+    );
+  }
 }
 
 /**
@@ -307,772 +306,761 @@ function* queryStep(
  * @param {object} document document
  */
 function* reverseQueryStep(
-    elements: AST.VElement[],
-    selectorNode: VCSSSelectorNode,
-    document: VueDocumentQueryContext,
+  elements: AST.VElement[],
+  selectorNode: VCSSSelectorNode,
+  document: VueDocumentQueryContext
 ): IterableIterator<AST.VElement> {
-    if (isSelectorCombinator(selectorNode)) {
-        if (isChildCombinator(selectorNode)) {
-            yield* genParentElements(elements)
-            return
-        } else if (
-            isDescendantCombinator(selectorNode) ||
-            isDeepCombinator(selectorNode)
-        ) {
-            yield* genAncestorElements(elements)
-            return
-        } else if (isAdjacentSiblingCombinator(selectorNode)) {
-            yield* genPrevAdjacentSiblingElements(elements)
-            return
-        } else if (isGeneralSiblingCombinator(selectorNode)) {
-            yield* genPrevGeneralSiblingElements(elements)
-            return
-        }
-    } else if (isVDeepPseudo(selectorNode)) {
-        yield* genVDeepElements(
-            elements,
-            normalizePseudoParams(selectorNode, selectorNode.nodes),
-            query,
-        )
-        return
-    } else if (isVSlottedPseudo(selectorNode)) {
-        yield* genVSlottedElements(
-            elements,
-            normalizePseudoParams(selectorNode, selectorNode.nodes),
-            query,
-        )
-        return
-    } else if (isVGlobalPseudo(selectorNode)) {
-        yield* genVGlobalElements(
-            elements,
-            normalizePseudoParams(selectorNode, selectorNode.nodes),
-            document,
-            query,
-        )
-        return
+  if (isSelectorCombinator(selectorNode)) {
+    if (isChildCombinator(selectorNode)) {
+      yield* genParentElements(elements);
+      return;
+    } else if (
+      isDescendantCombinator(selectorNode) ||
+      isDeepCombinator(selectorNode)
+    ) {
+      yield* genAncestorElements(elements);
+      return;
+    } else if (isAdjacentSiblingCombinator(selectorNode)) {
+      yield* genPrevAdjacentSiblingElements(elements);
+      return;
+    } else if (isGeneralSiblingCombinator(selectorNode)) {
+      yield* genPrevGeneralSiblingElements(elements);
+      return;
     }
-    yield* queryStep(elements, selectorNode, document)
+  } else if (isVDeepPseudo(selectorNode)) {
+    yield* genVDeepElements(
+      elements,
+      normalizePseudoParams(selectorNode, selectorNode.nodes),
+      query
+    );
+    return;
+  } else if (isVSlottedPseudo(selectorNode)) {
+    yield* genVSlottedElements(
+      elements,
+      normalizePseudoParams(selectorNode, selectorNode.nodes),
+      query
+    );
+    return;
+  } else if (isVGlobalPseudo(selectorNode)) {
+    yield* genVGlobalElements(
+      elements,
+      normalizePseudoParams(selectorNode, selectorNode.nodes),
+      document,
+      query
+    );
+    return;
+  }
+  yield* queryStep(elements, selectorNode, document);
 
-    /**
-     * Query for ::v-xxx pseudo
-     */
-    function query(
-        els: AST.VElement[],
-        selList: VCSSSelectorValueNode[],
-    ): AST.VElement[] {
-        return selList.reduceRight(
-            (
-                res: AST.VElement[],
-                sel: VCSSSelectorValueNode,
-            ): AST.VElement[] => [...reverseQueryStep(res, sel, document)],
-            els,
-        )
-    }
+  /**
+   * Query for ::v-xxx pseudo
+   */
+  function query(
+    els: AST.VElement[],
+    selList: VCSSSelectorValueNode[]
+  ): AST.VElement[] {
+    return selList.reduceRight(
+      (res: AST.VElement[], sel: VCSSSelectorValueNode): AST.VElement[] => [
+        ...reverseQueryStep(res, sel, document),
+      ],
+      els
+    );
+  }
 }
 
 /**
  * Get the descendant elements.
  */
 function* genDescendantElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    const found = new Set<AST.VElement>()
-    for (const e of genChildElements(elements)) {
-        if (!found.has(e)) {
-            yield e
-            found.add(e)
-            for (const p of genDescendantElements([e])) {
-                if (!found.has(p)) {
-                    yield p
-                    found.add(p)
-                }
-            }
+  const found = new Set<AST.VElement>();
+  for (const e of genChildElements(elements)) {
+    if (!found.has(e)) {
+      yield e;
+      found.add(e);
+      for (const p of genDescendantElements([e])) {
+        if (!found.has(p)) {
+          yield p;
+          found.add(p);
         }
+      }
     }
+  }
 }
 
 /**
  * Get the ancestor elements.
  */
 function* genAncestorElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    const found = new Set<AST.VElement>()
-    for (const e of genParentElements(elements)) {
-        yield e
-        found.add(e)
-        for (const a of genAncestorElements([e])) {
-            if (!found.has(a)) {
-                yield a
-                found.add(a)
-            }
-        }
+  const found = new Set<AST.VElement>();
+  for (const e of genParentElements(elements)) {
+    yield e;
+    found.add(e);
+    for (const a of genAncestorElements([e])) {
+      if (!found.has(a)) {
+        yield a;
+        found.add(a);
+      }
     }
+  }
 }
 
 /**
  * Get the child elements.
  */
 function* genChildElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    /**
-     * Get the child elements.
-     */
-    function* genChildren(elm: AST.VElement): IterableIterator<AST.VElement> {
-        for (const e of elm.children.filter(isVElement)) {
-            if (isSkipElement(e)) {
-                yield* genChildren(e)
-            } else if (isSlotElement(e)) {
-                yield e
-                yield* genChildren(e)
-            } else {
-                yield e
-            }
-        }
+  /**
+   * Get the child elements.
+   */
+  function* genChildren(elm: AST.VElement): IterableIterator<AST.VElement> {
+    for (const e of elm.children.filter(isVElement)) {
+      if (isSkipElement(e)) {
+        yield* genChildren(e);
+      } else if (isSlotElement(e)) {
+        yield e;
+        yield* genChildren(e);
+      } else {
+        yield e;
+      }
     }
+  }
 
-    for (const element of elements) {
-        if (isSlotElement(element)) {
-            continue
-        }
-        yield* genChildren(element)
+  for (const element of elements) {
+    if (isSlotElement(element)) {
+      continue;
     }
+    yield* genChildren(element);
+  }
 }
 
 /**
  * Get the parent elements.
  */
 function genParentElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const element of elements) {
-            yield getParentElement(element)
-        }
-    })
+  return iterateUnique(function* () {
+    for (const element of elements) {
+      yield getParentElement(element);
+    }
+  });
 }
 
 /**
  * Get the adjacent sibling elements.
  */
 function genAdjacentSiblingElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const element of elements) {
-            if (hasVFor(element)) {
-                yield element
-            }
-            const vForTemplate = getVForTemplate(element)
-            if (vForTemplate) {
-                const children = [...genChildElements([vForTemplate])]
-                const index = children.indexOf(element)
-                yield children[index + 1] || children[0]
-            }
-            const parent = getParentElement(element)
-            if (parent) {
-                const children = [...genChildElements([parent])]
-                const index = children.indexOf(element)
-                yield children[index + 1]
-            }
-        }
-    })
+  return iterateUnique(function* () {
+    for (const element of elements) {
+      if (hasVFor(element)) {
+        yield element;
+      }
+      const vForTemplate = getVForTemplate(element);
+      if (vForTemplate) {
+        const children = [...genChildElements([vForTemplate])];
+        const index = children.indexOf(element);
+        yield children[index + 1] || children[0];
+      }
+      const parent = getParentElement(element);
+      if (parent) {
+        const children = [...genChildElements([parent])];
+        const index = children.indexOf(element);
+        yield children[index + 1];
+      }
+    }
+  });
 }
 
 /**
  * Gets the previous adjacent sibling elements.
  */
 function genPrevAdjacentSiblingElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const element of elements) {
-            if (hasVFor(element)) {
-                yield element
-            }
-            const vForTemplate = getVForTemplate(element)
-            if (vForTemplate) {
-                const children = [...genChildElements([vForTemplate])]
-                const index = children.indexOf(element)
-                yield children[index - 1] || children[children.length - 1]
-            }
-            const parent = getParentElement(element)
-            if (parent) {
-                const children = [...genChildElements([parent])]
-                const index = children.indexOf(element)
-                yield children[index - 1]
-            }
-        }
-    })
+  return iterateUnique(function* () {
+    for (const element of elements) {
+      if (hasVFor(element)) {
+        yield element;
+      }
+      const vForTemplate = getVForTemplate(element);
+      if (vForTemplate) {
+        const children = [...genChildElements([vForTemplate])];
+        const index = children.indexOf(element);
+        yield children[index - 1] || children[children.length - 1];
+      }
+      const parent = getParentElement(element);
+      if (parent) {
+        const children = [...genChildElements([parent])];
+        const index = children.indexOf(element);
+        yield children[index - 1];
+      }
+    }
+  });
 }
 
 /**
  * Gets the general sibling elements.
  */
 function genGeneralSiblingElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const element of elements) {
-            if (hasVFor(element)) {
-                yield element
-            }
-            const vForTemplate = getVForTemplate(element)
-            if (vForTemplate) {
-                yield* genChildElements([vForTemplate])
-            }
-            const parent = getParentElement(element)
-            if (parent) {
-                const children = [...genChildElements([parent])]
-                const index = children.indexOf(element)
-                yield* children.slice(index + 1)
-            }
-        }
-    })
+  return iterateUnique(function* () {
+    for (const element of elements) {
+      if (hasVFor(element)) {
+        yield element;
+      }
+      const vForTemplate = getVForTemplate(element);
+      if (vForTemplate) {
+        yield* genChildElements([vForTemplate]);
+      }
+      const parent = getParentElement(element);
+      if (parent) {
+        const children = [...genChildElements([parent])];
+        const index = children.indexOf(element);
+        yield* children.slice(index + 1);
+      }
+    }
+  });
 }
 
 /**
  * Gets the previous general sibling elements.
  */
 function genPrevGeneralSiblingElements(
-    elements: AST.VElement[],
+  elements: AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const element of elements) {
-            if (hasVFor(element)) {
-                yield element
-            }
-            const vForTemplate = getVForTemplate(element)
-            if (vForTemplate) {
-                yield* genChildElements([vForTemplate])
-            }
-            const parent = getParentElement(element)
-            if (parent) {
-                const children = [...genChildElements([parent])]
-                const index = children.indexOf(element)
-                yield* children.slice(0, index)
-            }
-        }
-    })
+  return iterateUnique(function* () {
+    for (const element of elements) {
+      if (hasVFor(element)) {
+        yield element;
+      }
+      const vForTemplate = getVForTemplate(element);
+      if (vForTemplate) {
+        yield* genChildElements([vForTemplate]);
+      }
+      const parent = getParentElement(element);
+      if (parent) {
+        const children = [...genChildElements([parent])];
+        const index = children.indexOf(element);
+        yield* children.slice(0, index);
+      }
+    }
+  });
 }
 
 /**
  * Gets the v-deep elements
  */
 function* genVDeepElements(
-    elements: AST.VElement[],
-    params: VCSSSelector[],
-    query: (
-        els: AST.VElement[],
-        selList: VCSSSelectorValueNode[],
-    ) => AST.VElement[],
+  elements: AST.VElement[],
+  params: VCSSSelector[],
+  query: (
+    els: AST.VElement[],
+    selList: VCSSSelectorValueNode[]
+  ) => AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    if (params.length) {
-        yield* iterateUnique(function* () {
-            for (const node of params) {
-                yield* query(elements, node.nodes)
-            }
-        })
-    } else {
-        yield* elements
-    }
+  if (params.length) {
+    yield* iterateUnique(function* () {
+      for (const node of params) {
+        yield* query(elements, node.nodes);
+      }
+    });
+  } else {
+    yield* elements;
+  }
 }
 
 /**
  * Gets the v-slotted elements
  */
 function genVSlottedElements(
-    elements: AST.VElement[],
-    params: VCSSSelector[],
-    query: (
-        els: AST.VElement[],
-        selList: VCSSSelectorValueNode[],
-    ) => AST.VElement[],
+  elements: AST.VElement[],
+  params: VCSSSelector[],
+  query: (
+    els: AST.VElement[],
+    selList: VCSSSelectorValueNode[]
+  ) => AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const element of elements) {
-            if (isSlotElement(element)) {
-                yield element
-            }
-        }
+  return iterateUnique(function* () {
+    for (const element of elements) {
+      if (isSlotElement(element)) {
+        yield element;
+      }
+    }
 
-        for (const node of params) {
-            const els = query(elements, node.nodes)
-            for (const e of els) {
-                if (inSlot(e)) {
-                    yield e
-                }
-            }
+    for (const node of params) {
+      const els = query(elements, node.nodes);
+      for (const e of els) {
+        if (inSlot(e)) {
+          yield e;
         }
-    })
+      }
+    }
+  });
 
-    /**
-     * Checks if givin element within slot
-     */
-    function inSlot(e: AST.VElement | AST.VDocumentFragment): boolean {
-        if (isSlotElement(e)) {
-            return true
-        }
-        return Boolean(e && e.parent && inSlot(e.parent))
+  /**
+   * Checks if givin element within slot
+   */
+  function inSlot(e: AST.VElement | AST.VDocumentFragment): boolean {
+    if (isSlotElement(e)) {
+      return true;
     }
+    return Boolean(e && e.parent && inSlot(e.parent));
+  }
 }
 
 /**
  * Gets the v-global elements
  */
 function genVGlobalElements(
-    _elements: AST.VElement[],
-    params: VCSSSelector[],
-    document: VueDocumentQueryContext,
-    query: (
-        els: AST.VElement[],
-        selList: VCSSSelectorValueNode[],
-    ) => AST.VElement[],
+  _elements: AST.VElement[],
+  params: VCSSSelector[],
+  document: VueDocumentQueryContext,
+  query: (
+    els: AST.VElement[],
+    selList: VCSSSelectorValueNode[]
+  ) => AST.VElement[]
 ): IterableIterator<AST.VElement> {
-    return iterateUnique(function* () {
-        for (const node of params) {
-            yield* query(document.elements, node.nodes)
-        }
-    })
+  return iterateUnique(function* () {
+    for (const node of params) {
+      yield* query(document.elements, node.nodes);
+    }
+  });
 }
 
 /**
  * Gets the elements with the given tag name.
  */
 function* genElementsByTagName(
-    elements: AST.VElement[],
-    tagName: Template,
+  elements: AST.VElement[],
+  tagName: Template
 ): IterableIterator<AST.VElement> {
-    for (const element of elements) {
-        if (element.name === "component" || element.name === "slot") {
-            // The `component` tag is considered to match all elements because the element can not be identified.
-            yield element
-        } else if (tagName.toLowerCase().matchString(element.name)) {
-            yield element
-        }
+  for (const element of elements) {
+    if (element.name === "component" || element.name === "slot") {
+      // The `component` tag is considered to match all elements because the element can not be identified.
+      yield element;
+    } else if (tagName.toLowerCase().matchString(element.name)) {
+      yield element;
     }
+  }
 }
 
 /**
  * Gets the elements with the given id.
  */
 function* genElementsById(
-    elements: AST.VElement[],
-    id: Template,
-    document: VueDocumentQueryContext,
+  elements: AST.VElement[],
+  id: Template,
+  document: VueDocumentQueryContext
 ): IterableIterator<AST.VElement> {
-    for (const element of elements) {
-        if (matchId(element, id, document)) {
-            yield element
-        }
+  for (const element of elements) {
+    if (matchId(element, id, document)) {
+      yield element;
     }
+  }
 }
 
 /**
  * Gets the elements with the given class name.
  */
 function* genElementsByClassName(
-    elements: AST.VElement[],
-    className: Template,
-    document: VueDocumentQueryContext,
+  elements: AST.VElement[],
+  className: Template,
+  document: VueDocumentQueryContext
 ): IterableIterator<AST.VElement> {
-    let removeModifierClassName = null
+  let removeModifierClassName = null;
 
-    // ignoreBEMModifier option
-    if (document.options.ignoreBEMModifier) {
-        if (className.hasString("--")) {
-            const list = className.divide("--")
-            list.pop()
-            if (list.length) {
-                removeModifierClassName = list.reduce((r, a) => r.concat(a))
-            }
-        }
+  // ignoreBEMModifier option
+  if (document.options.ignoreBEMModifier) {
+    if (className.hasString("--")) {
+      const list = className.divide("--");
+      list.pop();
+      if (list.length) {
+        removeModifierClassName = list.reduce((r, a) => r.concat(a));
+      }
     }
+  }
 
-    // captureClassesFromDoc option
-    for (const docMod of document.docsModifiers) {
-        if (docMod.startsWith(":")) {
-            continue
-        }
-        const modClassName: string = docMod.startsWith(".")
-            ? docMod.slice(1)
-            : docMod
-        if (className.matchString(modClassName)) {
-            // If the class name is documented, it is considered to match all elements.
-            yield* elements
-            return
-        } else if (removeModifierClassName) {
-            if (removeModifierClassName.matchString(modClassName)) {
-                // If the class name is documented, it is considered to match all elements.
-                yield* elements
-                return
-            }
-        }
+  // captureClassesFromDoc option
+  for (const docMod of document.docsModifiers) {
+    if (docMod.startsWith(":")) {
+      continue;
+    }
+    const modClassName: string = docMod.startsWith(".")
+      ? docMod.slice(1)
+      : docMod;
+    if (className.matchString(modClassName)) {
+      // If the class name is documented, it is considered to match all elements.
+      yield* elements;
+      return;
+    } else if (removeModifierClassName) {
+      if (removeModifierClassName.matchString(modClassName)) {
+        // If the class name is documented, it is considered to match all elements.
+        yield* elements;
+        return;
+      }
     }
+  }
 
-    for (const element of elements) {
-        if (matchClassName(element, className, document)) {
-            yield element
-        } else if (
-            removeModifierClassName &&
-            matchClassName(element, removeModifierClassName, document)
-        ) {
-            yield element
-        }
+  for (const element of elements) {
+    if (matchClassName(element, className, document)) {
+      yield element;
+    } else if (
+      removeModifierClassName &&
+      matchClassName(element, removeModifierClassName, document)
+    ) {
+      yield element;
     }
+  }
 }
 
 /**
  * Checks whether the given element matches the given ID.
  */
 function matchId(
-    element: AST.VElement,
-    id: Template,
-    document: VueDocumentQueryContext,
+  element: AST.VElement,
+  id: Template,
+  document: VueDocumentQueryContext
 ): boolean {
-    const nodes = getAttributeValueNodes(element, "id", document.context)
-    if (nodes == null) {
-        return true
+  const nodes = getAttributeValueNodes(element, "id", document.context);
+  if (nodes == null) {
+    return true;
+  }
+  for (const node of nodes) {
+    const value = Template.ofNode(node);
+    if (value == null) {
+      // Are identified by complex expressions.
+      return true;
     }
-    for (const node of nodes) {
-        const value = Template.ofNode(node)
-        if (value == null) {
-            // Are identified by complex expressions.
-            return true
-        }
-        if (value.match(id)) {
-            return true
-        }
+    if (value.match(id)) {
+      return true;
     }
-    return false
+  }
+  return false;
 }
 
 /**
  * Checks whether the given element matches the given class name.
  */
 function matchClassName(
-    element: AST.VElement,
-    className: Template,
-    document: VueDocumentQueryContext,
+  element: AST.VElement,
+  className: Template,
+  document: VueDocumentQueryContext
 ): boolean {
-    if (isElementWrappedInTransition(element)) {
-        const transition = getWrapperTransition(element)
-        if (
-            transition != null &&
-            matchTransitionClassName(transition, className, document)
-        ) {
-            return true
-        }
-    }
-    const nodes = getAttributeValueNodes(element, "class", document.context)
-    if (nodes == null) {
-        return true
-    }
-    for (const node of nodes) {
-        if (node.type === "VLiteral") {
-            if (includesClassName(node.value, className)) {
-                return true
-            }
-        } else if (matchClassNameExpression(node, className, document)) {
-            return true
-        }
-    }
-
-    const refNames = getRefNames(element, document)
-    const vueComponent = getVueComponentContext(document.context)
+  if (isElementWrappedInTransition(element)) {
+    const transition = getWrapperTransition(element);
     if (
-        vueComponent &&
-        vueComponent
-            .getClassesOperatedByClassList(refNames, isRootElement(element))
-            .filter(
-                ((n) => n.type === "Literal") as (
-                    n: ASTNode,
-                ) => n is AST.ESLintLiteral,
-            )
-            .some((n) => matchClassNameExpression(n, className, document))
+      transition != null &&
+      matchTransitionClassName(transition, className, document)
     ) {
-        return true
+      return true;
+    }
+  }
+  const nodes = getAttributeValueNodes(element, "class", document.context);
+  if (nodes == null) {
+    return true;
+  }
+  for (const node of nodes) {
+    if (node.type === "VLiteral") {
+      if (includesClassName(node.value, className)) {
+        return true;
+      }
+    } else if (matchClassNameExpression(node, className, document)) {
+      return true;
     }
+  }
 
-    return false
+  const refNames = getRefNames(element, document);
+  const vueComponent = getVueComponentContext(document.context);
+  if (
+    vueComponent &&
+    vueComponent
+      .getClassesOperatedByClassList(refNames, isRootElement(element))
+      .filter(
+        ((n) => n.type === "Literal") as (n: ASTNode) => n is AST.ESLintLiteral
+      )
+      .some((n) => matchClassNameExpression(n, className, document))
+  ) {
+    return true;
+  }
+
+  return false;
 }
 
 /**
  * Gets the ref name.
  */
 function getRefNames(
-    element: AST.VElement,
-    document: VueDocumentQueryContext,
+  element: AST.VElement,
+  document: VueDocumentQueryContext
 ): Template[] | null {
-    const refNameNodes = getAttributeValueNodes(
-        element,
-        "ref",
-        document.context,
-    )
-    if (refNameNodes == null) {
-        return null
-    }
-    const refNames = []
-    for (const refNameNode of refNameNodes) {
-        const refName = Template.ofNode(refNameNode)
-        if (refName == null) {
-            // The ref name cannot be identified.
-            return null
-        }
-        refNames.push(refName)
+  const refNameNodes = getAttributeValueNodes(element, "ref", document.context);
+  if (refNameNodes == null) {
+    return null;
+  }
+  const refNames = [];
+  for (const refNameNode of refNameNodes) {
+    const refName = Template.ofNode(refNameNode);
+    if (refName == null) {
+      // The ref name cannot be identified.
+      return null;
     }
+    refNames.push(refName);
+  }
 
-    return refNames
+  return refNames;
 }
 
 /**
  * Check whether the given class name matches the `<transition>` element.
  */
 function matchTransitionClassName(
-    element: AST.VElement,
-    className: Template,
-    document: VueDocumentQueryContext,
+  element: AST.VElement,
+  className: Template,
+  document: VueDocumentQueryContext
 ): boolean {
-    const classBases = isTransitionElement(element)
-        ? TRANSITION_CLASS_BASES
-        : TRANSITION_GROUP_CLASS_BASES
-    const nameNodes = getAttributeValueNodes(element, "name", document.context)
+  const classBases = isTransitionElement(element)
+    ? TRANSITION_CLASS_BASES
+    : TRANSITION_GROUP_CLASS_BASES;
+  const nameNodes = getAttributeValueNodes(element, "name", document.context);
 
-    for (const classBase of classBases) {
-        const classNameNodes = getAttributeValueNodes(
-            element,
-            `${classBase}-class`,
-            document.context,
-        )
-        if (classNameNodes == null) {
-            // Unknown attribute are found
-            // So the class is considered a match.
-            return true
+  for (const classBase of classBases) {
+    const classNameNodes = getAttributeValueNodes(
+      element,
+      `${classBase}-class`,
+      document.context
+    );
+    if (classNameNodes == null) {
+      // Unknown attribute are found
+      // So the class is considered a match.
+      return true;
+    }
+    if (classNameNodes.length) {
+      for (const classNameNode of classNameNodes) {
+        const value = Template.ofNode(classNameNode);
+        if (value == null) {
+          // Are identified by complex expressions.
+          return true;
         }
-        if (classNameNodes.length) {
-            for (const classNameNode of classNameNodes) {
-                const value = Template.ofNode(classNameNode)
-                if (value == null) {
-                    // Are identified by complex expressions.
-                    return true
-                }
-                if (value.match(className)) {
-                    return true
-                }
-            }
-        } else if (nameNodes == null) {
-            if (className.endsWith(`-${classBase}`)) {
-                return true
-            }
-        } else if (nameNodes.length === 0) {
-            if (className.matchString(`v-${classBase}`)) {
-                return true
-            }
-        } else {
-            for (const nameNode of nameNodes) {
-                const name = Template.ofNode(nameNode)
-                if (name == null) {
-                    // Are identified by complex expressions.
-                    return true
-                }
-                if (className.match(name.concat(`-${classBase}`))) {
-                    return true
-                }
-            }
+        if (value.match(className)) {
+          return true;
+        }
+      }
+    } else if (nameNodes == null) {
+      if (className.endsWith(`-${classBase}`)) {
+        return true;
+      }
+    } else if (nameNodes.length === 0) {
+      if (className.matchString(`v-${classBase}`)) {
+        return true;
+      }
+    } else {
+      for (const nameNode of nameNodes) {
+        const name = Template.ofNode(nameNode);
+        if (name == null) {
+          // Are identified by complex expressions.
+          return true;
         }
+        if (className.match(name.concat(`-${classBase}`))) {
+          return true;
+        }
+      }
     }
-    return false
+  }
+  return false;
 }
 
 /**
  * Check whether the given class name matches the expression node.
  */
 function matchClassNameExpression(
-    expression: ReferenceExpressions,
-    className: Template,
-    document: VueDocumentQueryContext,
+  expression: ReferenceExpressions,
+  className: Template,
+  document: VueDocumentQueryContext
 ): boolean {
-    const literal = Template.ofNode(expression)
-    if (literal != null) {
-        if (includesClassName(literal, className)) {
-            return true
-        }
-    } else if (expression.type === "Identifier") {
-        const string = getStringFromNode(expression, document.context)
-        if (string == null) {
-            // Class names are identified by complex expressions.
-            // So the class is considered a match.
-            return true
-        }
-        if (includesClassName(string, className)) {
-            return true
-        }
-    } else if (expression.type === "ArrayExpression") {
-        if (matchClassNameForArrayExpression(expression, className, document)) {
-            return true
-        }
-    } else if (expression.type === "ObjectExpression") {
-        if (
-            matchClassNameForObjectExpression(expression, className, document)
-        ) {
-            return true
-        }
-    } else {
-        // Class names are identified by complex expressions.
-        // So the class is considered a match.
-        return true
+  const literal = Template.ofNode(expression);
+  if (literal != null) {
+    if (includesClassName(literal, className)) {
+      return true;
+    }
+  } else if (expression.type === "Identifier") {
+    const string = getStringFromNode(expression, document.context);
+    if (string == null) {
+      // Class names are identified by complex expressions.
+      // So the class is considered a match.
+      return true;
     }
+    if (includesClassName(string, className)) {
+      return true;
+    }
+  } else if (expression.type === "ArrayExpression") {
+    if (matchClassNameForArrayExpression(expression, className, document)) {
+      return true;
+    }
+  } else if (expression.type === "ObjectExpression") {
+    if (matchClassNameForObjectExpression(expression, className, document)) {
+      return true;
+    }
+  } else {
+    // Class names are identified by complex expressions.
+    // So the class is considered a match.
+    return true;
+  }
 
-    return false
+  return false;
 }
 
 /**
  * Check whether the given class name matches the array expression node.
  */
 function matchClassNameForArrayExpression(
-    expression: AST.ESLintArrayExpression,
-    className: Template,
-    document: VueDocumentQueryContext,
+  expression: AST.ESLintArrayExpression,
+  className: Template,
+  document: VueDocumentQueryContext
 ): boolean {
-    for (const e of expression.elements) {
-        if (e.type === "Identifier") {
-            if (withinTemplate(e, document)) {
-                const expressions = getReferenceExpressions(e, document.context)
-                if (expressions) {
-                    for (const e2 of expressions) {
-                        if (matchClassNameExpression(e2, className, document)) {
-                            return true
-                        }
-                    }
-                }
-            } else {
-                if (matchClassNameExpression(e, className, document)) {
-                    return true
-                }
+  for (const e of expression.elements) {
+    if (e.type === "Identifier") {
+      if (withinTemplate(e, document)) {
+        const expressions = getReferenceExpressions(e, document.context);
+        if (expressions) {
+          for (const e2 of expressions) {
+            if (matchClassNameExpression(e2, className, document)) {
+              return true;
             }
-        } else if (e.type === "SpreadElement") {
-            if (matchClassNameExpression(e.argument, className, document)) {
-                return true
-            }
-        } else if (matchClassNameExpression(e, className, document)) {
-            return true
+          }
+        }
+      } else {
+        if (matchClassNameExpression(e, className, document)) {
+          return true;
         }
+      }
+    } else if (e.type === "SpreadElement") {
+      if (matchClassNameExpression(e.argument, className, document)) {
+        return true;
+      }
+    } else if (matchClassNameExpression(e, className, document)) {
+      return true;
     }
-    return false
+  }
+  return false;
 }
 
 /**
  * Check whether the given class name matches the object expression node.
  */
 function matchClassNameForObjectExpression(
-    expression: AST.ESLintObjectExpression,
-    className: Template,
-    document: VueDocumentQueryContext,
+  expression: AST.ESLintObjectExpression,
+  className: Template,
+  document: VueDocumentQueryContext
 ): boolean {
-    for (const prop of expression.properties) {
-        if (prop.type !== "Property") {
-            // Can not identify the key name.
-            // So the class is considered a match.
-            return true
+  for (const prop of expression.properties) {
+    if (prop.type !== "Property") {
+      // Can not identify the key name.
+      // So the class is considered a match.
+      return true;
+    }
+    if (prop.computed) {
+      // { [key]: value }
+      if (
+        prop.key.type === "Identifier" ||
+        prop.key.type === "Literal" ||
+        prop.key.type === "TemplateLiteral" ||
+        prop.key.type === "BinaryExpression"
+      ) {
+        if (matchClassNameExpression(prop.key, className, document)) {
+          return true;
         }
-        if (prop.computed) {
-            // { [key]: value }
-            if (
-                prop.key.type === "Identifier" ||
-                prop.key.type === "Literal" ||
-                prop.key.type === "TemplateLiteral" ||
-                prop.key.type === "BinaryExpression"
-            ) {
-                if (matchClassNameExpression(prop.key, className, document)) {
-                    return true
-                }
-            } else {
-                // Can not identify the key name.
-                // So the class is considered a match.
-                return true
-            }
-        } else {
-            if (prop.key.type === "Identifier") {
-                // { key: value }
-                if (includesClassName(prop.key.name, className)) {
-                    return true
-                }
-            } else if (prop.key.type === "Literal") {
-                // { 'key': value }
-                if (includesClassName(`${prop.key.value}`, className)) {
-                    return true
-                }
-            }
+      } else {
+        // Can not identify the key name.
+        // So the class is considered a match.
+        return true;
+      }
+    } else {
+      if (prop.key.type === "Identifier") {
+        // { key: value }
+        if (includesClassName(prop.key.name, className)) {
+          return true;
         }
+      } else if (prop.key.type === "Literal") {
+        // { 'key': value }
+        if (includesClassName(`${prop.key.value}`, className)) {
+          return true;
+        }
+      }
     }
-    return false
+  }
+  return false;
 }
 
 /**
  * Checks if the given className is included in the class definition
  */
 function includesClassName(
-    value: string | Template,
-    className: Template,
+  value: string | Template,
+  className: Template
 ): boolean {
-    if (typeof value === "string") {
-        return value.split(/\s+/u).some((s) => className.matchString(s))
-    }
-    return value.divide(/\s+/u).some((s) => className.match(s))
+  if (typeof value === "string") {
+    return value.split(/\s+/u).some((s) => className.matchString(s));
+  }
+  return value.divide(/\s+/u).some((s) => className.match(s));
 }
 
 /**
  * Checks whether the given node within `<template>`
  */
 function withinTemplate(
-    expr: AST.ESLintIdentifier,
-    document: VueDocumentQueryContext,
+  expr: AST.ESLintIdentifier,
+  document: VueDocumentQueryContext
 ) {
-    const templateBody = document.context.getSourceCode().ast.templateBody
-    const templateRange = templateBody?.range ?? [0, 0]
-    return (
-        templateRange[0] <= expr.range[0] && expr.range[1] <= templateRange[1]
-    )
+  const templateBody = document.context.getSourceCode().ast.templateBody;
+  const templateRange = templateBody?.range ?? [0, 0];
+  return templateRange[0] <= expr.range[0] && expr.range[1] <= templateRange[1];
 }
 
 /**
  * Iterate unique items
  */
 function* iterateUnique<T>(
-    gen: () => IterableIterator<T | null>,
+  gen: () => IterableIterator<T | null>
 ): IterableIterator<T> {
-    const found = new Set<T>()
-    for (const e of gen()) {
-        if (e != null && !found.has(e)) {
-            yield e
-            found.add(e)
-        }
+  const found = new Set<T>();
+  for (const e of gen()) {
+    if (e != null && !found.has(e)) {
+      yield e;
+      found.add(e);
     }
+  }
 }
 
 /**
  * Checks if givin element has v-for
  */
 function hasVFor(element: AST.VElement) {
-    return element.startTag.attributes.some(
-        (attr) => attr.directive && attr.key.name.name === "for",
-    )
+  return element.startTag.attributes.some(
+    (attr) => attr.directive && attr.key.name.name === "for"
+  );
 }
 
 /**
  * Get the <template v-for> from givin element within
  */
 function getVForTemplate(element: AST.VElement) {
-    let parent = element.parent
-    while (parent) {
-        if (parent.type !== "VElement" || parent.name !== "template") {
-            return null
-        }
-        if (hasVFor(parent)) {
-            return parent
-        }
-        parent = parent.parent
+  let parent = element.parent;
+  while (parent) {
+    if (parent.type !== "VElement" || parent.name !== "template") {
+      return null;
+    }
+    if (hasVFor(parent)) {
+      return parent;
     }
-    return null
+    parent = parent.parent;
+  }
+  return null;
 }
diff --git a/lib/styles/selectors/resolver/css-selector-resolver.ts b/lib/styles/selectors/resolver/css-selector-resolver.ts
index 217608de..f06df4ad 100644
--- a/lib/styles/selectors/resolver/css-selector-resolver.ts
+++ b/lib/styles/selectors/resolver/css-selector-resolver.ts
@@ -1,485 +1,460 @@
-import type { NestingInfo } from "../../utils/selectors"
+import type { NestingInfo } from "../../utils/selectors";
 import {
-    isNestingSelector,
-    isNestingAtRule,
-    isTypeSelector,
-    hasNodesSelector,
-    isSelectorCombinator,
-    findNestingSelector,
-    isDescendantCombinator,
-} from "../../utils/selectors"
+  isNestingSelector,
+  isNestingAtRule,
+  isTypeSelector,
+  hasNodesSelector,
+  isSelectorCombinator,
+  findNestingSelector,
+  isDescendantCombinator,
+} from "../../utils/selectors";
 import type {
-    VCSSStyleSheet,
-    VCSSNode,
-    VCSSSelectorNode,
-    VCSSTypeSelector,
-    VCSSNestingSelector,
-    VCSSSelectorValueNode,
-    VCSSAtRule,
-    VCSSStyleRule,
-    VCSSSelector,
-    VCSSSelectorPseudo,
-} from "../../ast"
+  VCSSStyleSheet,
+  VCSSNode,
+  VCSSSelectorNode,
+  VCSSTypeSelector,
+  VCSSNestingSelector,
+  VCSSSelectorValueNode,
+  VCSSAtRule,
+  VCSSStyleRule,
+  VCSSSelector,
+  VCSSSelectorPseudo,
+} from "../../ast";
 import {
-    isVCSSAtRule,
-    isVCSSContainerNode,
-    hasSelectorNodes,
-} from "../../utils/css-nodes"
+  isVCSSAtRule,
+  isVCSSContainerNode,
+  hasSelectorNodes,
+} from "../../utils/css-nodes";
 
 export class ResolvedSelectors {
-    public readonly container:
-        | (VCSSAtRule & { selectors: VCSSSelectorNode[] })
-        | VCSSStyleRule
-
-    public readonly selectors: ResolvedSelector[] = []
-
-    public readonly level: number
-
-    public readonly parent: ResolvedSelectors | null
-
-    public readonly children: ResolvedSelectors[] = []
-
-    /**
-     * constructor
-     * @param {Node[]} selector the selector
-     * @param {Node} container the container node
-     */
-    public constructor(
-        container:
-            | (VCSSAtRule & { selectors: VCSSSelectorNode[] })
-            | VCSSStyleRule,
-        parent: ResolvedSelectors | null,
-    ) {
-        this.container = container
-        this.parent = parent
-        this.level = (parent?.level ?? -1) + 1
-    }
+  public readonly container:
+    | (VCSSAtRule & { selectors: VCSSSelectorNode[] })
+    | VCSSStyleRule;
+
+  public readonly selectors: ResolvedSelector[] = [];
+
+  public readonly level: number;
+
+  public readonly parent: ResolvedSelectors | null;
+
+  public readonly children: ResolvedSelectors[] = [];
+
+  /**
+   * constructor
+   * @param {Node[]} selector the selector
+   * @param {Node} container the container node
+   */
+  public constructor(
+    container: (VCSSAtRule & { selectors: VCSSSelectorNode[] }) | VCSSStyleRule,
+    parent: ResolvedSelectors | null
+  ) {
+    this.container = container;
+    this.parent = parent;
+    this.level = (parent?.level ?? -1) + 1;
+  }
 }
 
 export class ResolvedSelector {
-    public readonly owner: ResolvedSelectors
-
-    public readonly selector: VCSSSelectorNode[]
-
-    /**
-     * constructor
-     * @param {Node[]} selector the selector
-     * @param {Node} container the container node
-     */
-    public constructor(owner: ResolvedSelectors, selector: VCSSSelectorNode[]) {
-        this.owner = owner
-        this.selector = selector
-    }
+  public readonly owner: ResolvedSelectors;
+
+  public readonly selector: VCSSSelectorNode[];
+
+  /**
+   * constructor
+   * @param {Node[]} selector the selector
+   * @param {Node} container the container node
+   */
+  public constructor(owner: ResolvedSelectors, selector: VCSSSelectorNode[]) {
+    this.owner = owner;
+    this.selector = selector;
+  }
 }
 
 export class CSSSelectorResolver {
-    /**
-     * Get the selector that resolved the nesting.
-     * @param {VCSSStyleSheet} rootStyle The style node
-     * @returns {ResolvedSelector[]} the selector that resolved the nesting.
-     */
-    public resolveSelectors(rootStyle: VCSSStyleSheet): ResolvedSelectors[] {
-        return this.resolveNodesSelectors(rootStyle.nodes, null)
-    }
-
-    /**
-     * Get the selector that resolved the nesting.
-     * @param {Node[]} nodes the nodes
-     * @param {ResolvedSelector[]|null} parentSelectors
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    private resolveNodesSelectors(
-        nodes: VCSSNode[],
-        parentSelector: ResolvedSelectors | null,
-    ): ResolvedSelectors[] {
-        const results: ResolvedSelectors[] = []
-        for (const node of nodes) {
-            if (this.isIgnoreNode(node)) {
-                continue
-            }
-
-            if (hasSelectorNodes(node)) {
-                results.push(this.resolveNodeSelectors(node, parentSelector))
-            } else {
-                if (isVCSSContainerNode(node)) {
-                    results.push(
-                        ...this.resolveNodesSelectors(
-                            node.nodes,
-                            parentSelector,
-                        ),
-                    )
-                }
-            }
-        }
-        return results
-    }
-
-    /**
-     * Get the selector that resolved the nesting.
-     * @param {VCSSStyleSheet} rootStyle The style node
-     * @returns {ResolvedSelector[]} the selector that resolved the nesting.
-     */
-    private resolveNodeSelectors(
-        node:
-            | (VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] })
-            | VCSSStyleRule,
-        parentSelector: ResolvedSelectors | null,
-    ): ResolvedSelectors {
-        const selectorNodes = node.selectors.filter(hasNodesSelector)
-        const resolved = new ResolvedSelectors(node, parentSelector)
-        if (!parentSelector) {
-            resolved.selectors.push(
-                ...selectorNodes.map(
-                    (selectorNode) =>
-                        new ResolvedSelector(resolved, selectorNode.nodes),
-                ),
-            )
-        } else {
-            for (const selectorNode of selectorNodes.filter(hasNodesSelector)) {
-                resolved.selectors.push(
-                    ...this.resolveNestingSelectors(
-                        resolved,
-                        selectorNode.nodes,
-                        parentSelector,
-                        node,
-                    ),
-                )
-            }
-        }
-
+  /**
+   * Get the selector that resolved the nesting.
+   * @param {VCSSStyleSheet} rootStyle The style node
+   * @returns {ResolvedSelector[]} the selector that resolved the nesting.
+   */
+  public resolveSelectors(rootStyle: VCSSStyleSheet): ResolvedSelectors[] {
+    return this.resolveNodesSelectors(rootStyle.nodes, null);
+  }
+
+  /**
+   * Get the selector that resolved the nesting.
+   * @param {Node[]} nodes the nodes
+   * @param {ResolvedSelector[]|null} parentSelectors
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  private resolveNodesSelectors(
+    nodes: VCSSNode[],
+    parentSelector: ResolvedSelectors | null
+  ): ResolvedSelectors[] {
+    const results: ResolvedSelectors[] = [];
+    for (const node of nodes) {
+      if (this.isIgnoreNode(node)) {
+        continue;
+      }
+
+      if (hasSelectorNodes(node)) {
+        results.push(this.resolveNodeSelectors(node, parentSelector));
+      } else {
         if (isVCSSContainerNode(node)) {
-            resolved.children.push(
-                ...this.resolveNodesSelectors(node.nodes, resolved),
-            )
+          results.push(
+            ...this.resolveNodesSelectors(node.nodes, parentSelector)
+          );
         }
-        return resolved
+      }
     }
-
-    private isIgnoreNode(node: VCSSNode) {
-        return (
-            isVCSSAtRule(node) &&
-            node.name === "keyframes" &&
-            node.identifier === "@"
+    return results;
+  }
+
+  /**
+   * Get the selector that resolved the nesting.
+   * @param {VCSSStyleSheet} rootStyle The style node
+   * @returns {ResolvedSelector[]} the selector that resolved the nesting.
+   */
+  private resolveNodeSelectors(
+    node:
+      | (VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] })
+      | VCSSStyleRule,
+    parentSelector: ResolvedSelectors | null
+  ): ResolvedSelectors {
+    const selectorNodes = node.selectors.filter(hasNodesSelector);
+    const resolved = new ResolvedSelectors(node, parentSelector);
+    if (!parentSelector) {
+      resolved.selectors.push(
+        ...selectorNodes.map(
+          (selectorNode) => new ResolvedSelector(resolved, selectorNode.nodes)
         )
+      );
+    } else {
+      for (const selectorNode of selectorNodes.filter(hasNodesSelector)) {
+        resolved.selectors.push(
+          ...this.resolveNestingSelectors(
+            resolved,
+            selectorNode.nodes,
+            parentSelector,
+            node
+          )
+        );
+      }
     }
 
-    /**
-     * Resolve nesting selector
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    protected resolveNestingSelectors(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorNode[],
-        parentSelectors: ResolvedSelectors | null,
-        container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        if (isNestingAtRule(container)) {
-            return this.resolveSelectorForNestContaining(
-                owner,
-                selectorNodes,
-                findNestingSelector(selectorNodes),
-                parentSelectors,
-                container,
-            )
-        }
-        const nestingIndex = selectorNodes.findIndex(isNestingSelector)
-
-        if (nestingIndex === 0) {
-            return this.resolveSelectorForNestPrefixed(
-                owner,
-                selectorNodes,
-                parentSelectors,
-                container,
-            )
-        }
-        return [new ResolvedSelector(owner, selectorNodes)]
+    if (isVCSSContainerNode(node)) {
+      resolved.children.push(
+        ...this.resolveNodesSelectors(node.nodes, resolved)
+      );
     }
-
-    /**
-     * Resolve selectors that a nesting selector on the first.
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    private resolveSelectorForNestPrefixed(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorNode[],
-        parentSelectors: ResolvedSelectors | null,
-        container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        if (!selectorNodes.length || !isNestingSelector(selectorNodes[0])) {
-            // To be nest-prefixed, a nesting selector must be the first simple selector in the first compound selector of the selector.
-            return [new ResolvedSelector(owner, selectorNodes)]
-        }
-        const after = selectorNodes.slice(1)
-
-        return this.resolveSelectorForNestConcat(
-            owner,
-            after,
-            parentSelectors,
-            container,
-        )
+    return resolved;
+  }
+
+  private isIgnoreNode(node: VCSSNode) {
+    return (
+      isVCSSAtRule(node) && node.name === "keyframes" && node.identifier === "@"
+    );
+  }
+
+  /**
+   * Resolve nesting selector
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  protected resolveNestingSelectors(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorNode[],
+    parentSelectors: ResolvedSelectors | null,
+    container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    if (isNestingAtRule(container)) {
+      return this.resolveSelectorForNestContaining(
+        owner,
+        selectorNodes,
+        findNestingSelector(selectorNodes),
+        parentSelectors,
+        container
+      );
     }
-
-    /**
-     * Resolves selectors that concatenate nested selectors.
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    protected resolveSelectorForNestConcat(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorNode[],
-        parentSelectors: ResolvedSelectors | null,
-        _container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        if (!parentSelectors) {
-            const nodes = [...selectorNodes]
-            if (isDescendantCombinator(nodes[0])) {
-                nodes.shift()
-            }
-            if (isDescendantCombinator(nodes[nodes.length - 1])) {
-                nodes.pop()
-            }
-            return [new ResolvedSelector(owner, [...nodes])]
-        }
-
-        return parentSelectors.selectors.map((parentSelector) => {
-            const nodes = [...selectorNodes]
-            const parent = [...parentSelector.selector]
-
-            if (
-                parent.length > 0 &&
-                isSelectorCombinator(parent[parent.length - 1]) &&
-                nodes.length > 0 &&
-                isSelectorCombinator(nodes[0])
-            ) {
-                if (isDescendantCombinator(nodes[0])) {
-                    nodes.shift()
-                } else if (isDescendantCombinator(parent[parent.length - 1])) {
-                    parent.pop()
-                }
-            }
-
-            return new ResolvedSelector(owner, [...parent, ...nodes])
-        })
+    const nestingIndex = selectorNodes.findIndex(isNestingSelector);
+
+    if (nestingIndex === 0) {
+      return this.resolveSelectorForNestPrefixed(
+        owner,
+        selectorNodes,
+        parentSelectors,
+        container
+      );
+    }
+    return [new ResolvedSelector(owner, selectorNodes)];
+  }
+
+  /**
+   * Resolve selectors that a nesting selector on the first.
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  private resolveSelectorForNestPrefixed(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorNode[],
+    parentSelectors: ResolvedSelectors | null,
+    container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    if (!selectorNodes.length || !isNestingSelector(selectorNodes[0])) {
+      // To be nest-prefixed, a nesting selector must be the first simple selector in the first compound selector of the selector.
+      return [new ResolvedSelector(owner, selectorNodes)];
+    }
+    const after = selectorNodes.slice(1);
+
+    return this.resolveSelectorForNestConcat(
+      owner,
+      after,
+      parentSelectors,
+      container
+    );
+  }
+
+  /**
+   * Resolves selectors that concatenate nested selectors.
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  protected resolveSelectorForNestConcat(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorNode[],
+    parentSelectors: ResolvedSelectors | null,
+    _container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    if (!parentSelectors) {
+      const nodes = [...selectorNodes];
+      if (isDescendantCombinator(nodes[0])) {
+        nodes.shift();
+      }
+      if (isDescendantCombinator(nodes[nodes.length - 1])) {
+        nodes.pop();
+      }
+      return [new ResolvedSelector(owner, [...nodes])];
     }
 
-    /**
-     * Resolve selectors that contain a nesting selector.
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    protected resolveSelectorForNestContaining(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorNode[],
-        nestingInfo: NestingInfo | null,
-        parentSelectors: ResolvedSelectors | null,
-        _container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        if (!nestingInfo) {
-            // Must be nest-containing, which means it contains a nesting selector in it somewhere.
-            return [new ResolvedSelector(owner, selectorNodes)]
+    return parentSelectors.selectors.map((parentSelector) => {
+      const nodes = [...selectorNodes];
+      const parent = [...parentSelector.selector];
+
+      if (
+        parent.length > 0 &&
+        isSelectorCombinator(parent[parent.length - 1]) &&
+        nodes.length > 0 &&
+        isSelectorCombinator(nodes[0])
+      ) {
+        if (isDescendantCombinator(nodes[0])) {
+          nodes.shift();
+        } else if (isDescendantCombinator(parent[parent.length - 1])) {
+          parent.pop();
         }
-        const {
-            nestingIndex,
-            nodes: hasNestingNodes,
-            node: nestingNode,
-        } = nestingInfo
-
-        const beforeSelector = hasNestingNodes.slice(0, nestingIndex)
-        const afterSelector = hasNestingNodes.slice(nestingIndex + 1)
-        const nestingLeftNode =
-            beforeSelector.length > 0
-                ? beforeSelector[beforeSelector.length - 1]
-                : null
-        const nestingRightNode =
-            afterSelector.length > 0 ? afterSelector[0] : null
-        const maybeJoinLeft =
-            nestingLeftNode &&
-            nestingLeftNode.range[1] === nestingNode.range[0] &&
-            !isSelectorCombinator(nestingLeftNode)
-        const maybeJoinRight =
-            nestingRightNode &&
-            nestingNode.range[1] === nestingRightNode.range[0] &&
-            isTypeSelector(nestingRightNode)
-
-        let resolved: ResolvedSelector[]
-
-        if (parentSelectors) {
-            resolved = parentSelectors.selectors.map((p) => {
-                const before = [...beforeSelector]
-                const after = [...afterSelector]
-                const parentSelector = [...p.selector]
-                const needJoinLeft =
-                    maybeJoinLeft && isTypeSelector(parentSelector[0])
-                const needJoinRight =
-                    maybeJoinRight &&
-                    !isSelectorCombinator(
-                        parentSelector[parentSelector.length - 1],
-                    )
-                if (
-                    needJoinLeft &&
-                    needJoinRight &&
-                    parentSelector.length === 1
-                ) {
-                    // concat both (e.g. `bar { @nest .foo-&-baz {} }` -> .foo-bar-baz)
-                    before.push(
-                        newNestingConcatBothSelectorNodes(
-                            before.pop() as VCSSSelectorValueNode,
-                            parentSelector.shift() as VCSSTypeSelector,
-                            after.shift() as VCSSTypeSelector,
-                            nestingNode,
-                        ),
-                    )
-                } else {
-                    if (needJoinLeft) {
-                        // concat left (e.g. `bar { @nest .foo-& {} }` -> .foo-bar)
-                        before.push(
-                            newNestingConcatLeftSelectorNodes(
-                                before.pop() as VCSSSelectorValueNode,
-                                parentSelector.shift() as VCSSTypeSelector,
-                                nestingNode,
-                            ),
-                        )
-                    }
-                    if (needJoinRight) {
-                        // concat right (e.g. `.foo { @nest &-bar {} }` -> .foo-bar)
-                        after.unshift(
-                            newNestingConcatRightSelectorNodes(
-                                parentSelector.pop() as VCSSSelectorValueNode,
-                                after.shift() as VCSSTypeSelector,
-                                nestingNode,
-                            ),
-                        )
-                    }
-                }
-                return new ResolvedSelector(owner, [
-                    ...before,
-                    ...parentSelector,
-                    ...after,
-                ])
-            })
+      }
+
+      return new ResolvedSelector(owner, [...parent, ...nodes]);
+    });
+  }
+
+  /**
+   * Resolve selectors that contain a nesting selector.
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  protected resolveSelectorForNestContaining(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorNode[],
+    nestingInfo: NestingInfo | null,
+    parentSelectors: ResolvedSelectors | null,
+    _container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    if (!nestingInfo) {
+      // Must be nest-containing, which means it contains a nesting selector in it somewhere.
+      return [new ResolvedSelector(owner, selectorNodes)];
+    }
+    const {
+      nestingIndex,
+      nodes: hasNestingNodes,
+      node: nestingNode,
+    } = nestingInfo;
+
+    const beforeSelector = hasNestingNodes.slice(0, nestingIndex);
+    const afterSelector = hasNestingNodes.slice(nestingIndex + 1);
+    const nestingLeftNode =
+      beforeSelector.length > 0
+        ? beforeSelector[beforeSelector.length - 1]
+        : null;
+    const nestingRightNode = afterSelector.length > 0 ? afterSelector[0] : null;
+    const maybeJoinLeft =
+      nestingLeftNode &&
+      nestingLeftNode.range[1] === nestingNode.range[0] &&
+      !isSelectorCombinator(nestingLeftNode);
+    const maybeJoinRight =
+      nestingRightNode &&
+      nestingNode.range[1] === nestingRightNode.range[0] &&
+      isTypeSelector(nestingRightNode);
+
+    let resolved: ResolvedSelector[];
+
+    if (parentSelectors) {
+      resolved = parentSelectors.selectors.map((p) => {
+        const before = [...beforeSelector];
+        const after = [...afterSelector];
+        const parentSelector = [...p.selector];
+        const needJoinLeft = maybeJoinLeft && isTypeSelector(parentSelector[0]);
+        const needJoinRight =
+          maybeJoinRight &&
+          !isSelectorCombinator(parentSelector[parentSelector.length - 1]);
+        if (needJoinLeft && needJoinRight && parentSelector.length === 1) {
+          // concat both (e.g. `bar { @nest .foo-&-baz {} }` -> .foo-bar-baz)
+          before.push(
+            newNestingConcatBothSelectorNodes(
+              before.pop() as VCSSSelectorValueNode,
+              parentSelector.shift() as VCSSTypeSelector,
+              after.shift() as VCSSTypeSelector,
+              nestingNode
+            )
+          );
         } else {
-            const before = [...beforeSelector]
-            const after = [...afterSelector]
-            while (isDescendantCombinator(before[0])) {
-                before.shift()
-            }
-            if (isDescendantCombinator(after[0])) {
-                while (isDescendantCombinator(before[before.length - 1])) {
-                    before.pop()
-                }
-            }
-            while (before.length === 0 && isDescendantCombinator(after[0])) {
-                after.shift()
-            }
-            while (isDescendantCombinator(after[after.length - 1])) {
-                after.pop()
-            }
-            resolved = [new ResolvedSelector(owner, [...before, ...after])]
+          if (needJoinLeft) {
+            // concat left (e.g. `bar { @nest .foo-& {} }` -> .foo-bar)
+            before.push(
+              newNestingConcatLeftSelectorNodes(
+                before.pop() as VCSSSelectorValueNode,
+                parentSelector.shift() as VCSSTypeSelector,
+                nestingNode
+              )
+            );
+          }
+          if (needJoinRight) {
+            // concat right (e.g. `.foo { @nest &-bar {} }` -> .foo-bar)
+            after.unshift(
+              newNestingConcatRightSelectorNodes(
+                parentSelector.pop() as VCSSSelectorValueNode,
+                after.shift() as VCSSTypeSelector,
+                nestingNode
+              )
+            );
+          }
         }
-
-        let nestingTargetNode: VCSSSelectorNode = nestingNode
-        while (!selectorNodes.includes(nestingTargetNode)) {
-            const parent = nestingTargetNode.parent as
-                | VCSSSelector
-                | VCSSSelectorPseudo
-            const index: number = parent.parent.nodes.indexOf(parent as never)
-            const before = parent.parent.nodes.slice(
-                0,
-                index,
-            ) as VCSSSelectorNode[]
-            const after = parent.parent.nodes.slice(
-                index + 1,
-            ) as VCSSSelectorNode[]
-            resolved = resolved.map((selector) => {
-                const newNode = parent.copy()
-                newNode.nodes = selector.selector as never
-                return new ResolvedSelector(owner, [
-                    ...before,
-                    newNode,
-                    ...after,
-                ])
-            })
-            nestingTargetNode = parent
+        return new ResolvedSelector(owner, [
+          ...before,
+          ...parentSelector,
+          ...after,
+        ]);
+      });
+    } else {
+      const before = [...beforeSelector];
+      const after = [...afterSelector];
+      while (isDescendantCombinator(before[0])) {
+        before.shift();
+      }
+      if (isDescendantCombinator(after[0])) {
+        while (isDescendantCombinator(before[before.length - 1])) {
+          before.pop();
         }
-        return resolved
+      }
+      while (before.length === 0 && isDescendantCombinator(after[0])) {
+        after.shift();
+      }
+      while (isDescendantCombinator(after[after.length - 1])) {
+        after.pop();
+      }
+      resolved = [new ResolvedSelector(owner, [...before, ...after])];
+    }
+
+    let nestingTargetNode: VCSSSelectorNode = nestingNode;
+    while (!selectorNodes.includes(nestingTargetNode)) {
+      const parent = nestingTargetNode.parent as
+        | VCSSSelector
+        | VCSSSelectorPseudo;
+      const index: number = parent.parent.nodes.indexOf(parent as never);
+      const before = parent.parent.nodes.slice(0, index) as VCSSSelectorNode[];
+      const after = parent.parent.nodes.slice(index + 1) as VCSSSelectorNode[];
+      resolved = resolved.map((selector) => {
+        const newNode = parent.copy();
+        newNode.nodes = selector.selector as never;
+        return new ResolvedSelector(owner, [...before, newNode, ...after]);
+      });
+      nestingTargetNode = parent;
     }
+    return resolved;
+  }
 }
 
 /**
  * Creates a selector node that concat the left and right selectors of the parent selector and the nested selector.
  */
 function newNestingConcatBothSelectorNodes(
-    left: VCSSSelectorValueNode,
-    parent: VCSSTypeSelector,
-    right: VCSSTypeSelector,
-    _nesting: VCSSNestingSelector,
+  left: VCSSSelectorValueNode,
+  parent: VCSSTypeSelector,
+  right: VCSSTypeSelector,
+  _nesting: VCSSNestingSelector
 ) {
-    const loc = {
-        start: left.loc.start,
-        end: right.loc.end,
-    }
-    const newNode = left.copy({
-        loc,
-        start: left.range[0],
-        end: right.range[1],
-        parent: left.parent,
-        value: `${left.value}${parent.selector}${right.selector}`,
-    })
-
-    return newNode
+  const loc = {
+    start: left.loc.start,
+    end: right.loc.end,
+  };
+  const newNode = left.copy({
+    loc,
+    start: left.range[0],
+    end: right.range[1],
+    parent: left.parent,
+    value: `${left.value}${parent.selector}${right.selector}`,
+  });
+
+  return newNode;
 }
 
 /**
  * Creates a selector node that concat the left selectors of the parent selector and the nested selector.
  */
 function newNestingConcatLeftSelectorNodes(
-    left: VCSSSelectorValueNode,
-    parent: VCSSTypeSelector,
-    nesting: VCSSNestingSelector,
+  left: VCSSSelectorValueNode,
+  parent: VCSSTypeSelector,
+  nesting: VCSSNestingSelector
 ) {
-    const loc = {
-        start: left.loc.start,
-        end: nesting.loc.end,
-    }
-    const newNode = left.copy({
-        loc,
-        start: left.range[0],
-        end: nesting.range[1],
-        parent: left.parent,
-        value: `${left.value}${parent.selector}`,
-    })
-    return newNode
+  const loc = {
+    start: left.loc.start,
+    end: nesting.loc.end,
+  };
+  const newNode = left.copy({
+    loc,
+    start: left.range[0],
+    end: nesting.range[1],
+    parent: left.parent,
+    value: `${left.value}${parent.selector}`,
+  });
+  return newNode;
 }
 
 /**
  * Creates a selector node that concat the right selectors of the parent selector and the nested selector.
  */
 function newNestingConcatRightSelectorNodes(
-    parent: VCSSSelectorValueNode,
-    right: VCSSTypeSelector,
-    nesting: VCSSNestingSelector,
+  parent: VCSSSelectorValueNode,
+  right: VCSSTypeSelector,
+  nesting: VCSSNestingSelector
 ) {
-    const loc = {
-        start: nesting.loc.start,
-        end: right.loc.end,
-    }
-    const newNode = parent.copy({
-        node: right.node,
-        loc,
-        start: nesting.range[0],
-        end: right.range[1],
-        parent: right.parent,
-        value: `${parent.value}${right.selector}`,
-    })
-    return newNode
+  const loc = {
+    start: nesting.loc.start,
+    end: right.loc.end,
+  };
+  const newNode = parent.copy({
+    node: right.node,
+    loc,
+    start: nesting.range[0],
+    end: right.range[1],
+    parent: right.parent,
+    value: `${parent.value}${right.selector}`,
+  });
+  return newNode;
 }
diff --git a/lib/styles/selectors/resolver/scss-selector-resolver.ts b/lib/styles/selectors/resolver/scss-selector-resolver.ts
index c5011a5f..556c2cae 100644
--- a/lib/styles/selectors/resolver/scss-selector-resolver.ts
+++ b/lib/styles/selectors/resolver/scss-selector-resolver.ts
@@ -1,160 +1,160 @@
-import type { NestingInfo } from "../../utils/selectors"
+import type { NestingInfo } from "../../utils/selectors";
 import {
-    isNestingAtRule,
-    findNestingSelectors,
-    isSelectorCombinator,
-    findNestingSelector,
-} from "../../utils/selectors"
+  isNestingAtRule,
+  findNestingSelectors,
+  isSelectorCombinator,
+  findNestingSelector,
+} from "../../utils/selectors";
 import type {
-    VCSSSelectorValueNode,
-    VCSSStyleRule,
-    VCSSAtRule,
-    VCSS,
-} from "../../ast"
-import { VCSSSelectorCombinator } from "../../ast"
-import type { ResolvedSelectors } from "./css-selector-resolver"
-import { CSSSelectorResolver, ResolvedSelector } from "./css-selector-resolver"
-import type { PostCSSSPCombinatorNode } from "../../../types"
+  VCSSSelectorValueNode,
+  VCSSStyleRule,
+  VCSSAtRule,
+  VCSS,
+} from "../../ast";
+import { VCSSSelectorCombinator } from "../../ast";
+import type { ResolvedSelectors } from "./css-selector-resolver";
+import { CSSSelectorResolver, ResolvedSelector } from "./css-selector-resolver";
+import type { PostCSSSPCombinatorNode } from "../../../types";
 
 export class SCSSSelectorResolver extends CSSSelectorResolver {
-    /**
-     * Resolve nesting selector
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    protected resolveNestingSelectors(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorValueNode[],
-        parentSelectors: ResolvedSelectors,
-        container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        if (isNestingAtRule(container)) {
-            return this.resolveSelectorForNestContaining(
-                owner,
-                selectorNodes,
-                findNestingSelector(selectorNodes),
-                parentSelectors,
-                container,
-            )
-        }
-        return this.resolveSelectorForSCSSNesting(
-            owner,
-            selectorNodes,
-            parentSelectors,
-            container,
-        )
+  /**
+   * Resolve nesting selector
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  protected resolveNestingSelectors(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorValueNode[],
+    parentSelectors: ResolvedSelectors,
+    container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    if (isNestingAtRule(container)) {
+      return this.resolveSelectorForNestContaining(
+        owner,
+        selectorNodes,
+        findNestingSelector(selectorNodes),
+        parentSelectors,
+        container
+      );
     }
+    return this.resolveSelectorForSCSSNesting(
+      owner,
+      selectorNodes,
+      parentSelectors,
+      container
+    );
+  }
 
-    /**
-     * Resolve nesting selector for lang SCSS
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    private resolveSelectorForSCSSNesting(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorValueNode[],
-        parentSelectors: ResolvedSelectors,
-        container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        const nesting = findNestingSelector(selectorNodes)
-        if (nesting != null) {
-            let resolvedSelectors = this.resolveSelectorForNestContaining(
-                owner,
-                selectorNodes,
-                nesting,
-                parentSelectors,
-                container,
-            )
-
-            let hasNesting = true
-            while (hasNesting) {
-                hasNesting = false
-                const nextResolvedSelectors = []
-                for (const resolvedSelector of resolvedSelectors) {
-                    const nextNesting = findNextNestingSelector(
-                        resolvedSelector,
-                        container,
-                    )
-                    if (nextNesting) {
-                        hasNesting = true
-                        nextResolvedSelectors.push(
-                            ...this.resolveSelectorForNestContaining(
-                                owner,
-                                resolvedSelector.selector,
-                                nextNesting,
-                                parentSelectors,
-                                container,
-                            ),
-                        )
-                    }
-                }
-                if (!hasNesting) {
-                    break
-                }
-                resolvedSelectors = nextResolvedSelectors
-            }
-            return resolvedSelectors
-        }
+  /**
+   * Resolve nesting selector for lang SCSS
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  private resolveSelectorForSCSSNesting(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorValueNode[],
+    parentSelectors: ResolvedSelectors,
+    container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    const nesting = findNestingSelector(selectorNodes);
+    if (nesting != null) {
+      let resolvedSelectors = this.resolveSelectorForNestContaining(
+        owner,
+        selectorNodes,
+        nesting,
+        parentSelectors,
+        container
+      );
 
-        // SCSS css nesting
-        const first = selectorNodes[0]
-        if (isSelectorCombinator(first)) {
-            return this.resolveSelectorForNestConcat(
+      let hasNesting = true;
+      while (hasNesting) {
+        hasNesting = false;
+        const nextResolvedSelectors = [];
+        for (const resolvedSelector of resolvedSelectors) {
+          const nextNesting = findNextNestingSelector(
+            resolvedSelector,
+            container
+          );
+          if (nextNesting) {
+            hasNesting = true;
+            nextResolvedSelectors.push(
+              ...this.resolveSelectorForNestContaining(
                 owner,
-                selectorNodes,
+                resolvedSelector.selector,
+                nextNesting,
                 parentSelectors,
-                container,
-            )
+                container
+              )
+            );
+          }
         }
+        if (!hasNesting) {
+          break;
+        }
+        resolvedSelectors = nextResolvedSelectors;
+      }
+      return resolvedSelectors;
+    }
 
-        // create descendant combinator
-        const comb = new VCSSSelectorCombinator(
-            first.node as PostCSSSPCombinatorNode,
-            {
-                start: first.loc.start,
-                end: first.loc.start,
-            },
-            first.range[0],
-            first.range[0],
-            first.parent as never,
-        )
-        comb.value = " "
-        comb.selector = " "
-
-        return this.resolveSelectorForNestConcat(
-            owner,
-            [comb, ...selectorNodes],
-            parentSelectors,
-            container,
-        )
+    // SCSS css nesting
+    const first = selectorNodes[0];
+    if (isSelectorCombinator(first)) {
+      return this.resolveSelectorForNestConcat(
+        owner,
+        selectorNodes,
+        parentSelectors,
+        container
+      );
     }
+
+    // create descendant combinator
+    const comb = new VCSSSelectorCombinator(
+      first.node as PostCSSSPCombinatorNode,
+      {
+        start: first.loc.start,
+        end: first.loc.start,
+      },
+      first.range[0],
+      first.range[0],
+      first.parent as never
+    );
+    comb.value = " ";
+    comb.selector = " ";
+
+    return this.resolveSelectorForNestConcat(
+      owner,
+      [comb, ...selectorNodes],
+      parentSelectors,
+      container
+    );
+  }
 }
 
-export { ResolvedSelector }
+export { ResolvedSelector };
 
 /**
  * Find next nesting selector
  */
 export function findNextNestingSelector(
-    resolved: ResolvedSelector,
-    container: VCSSAtRule | VCSSStyleRule,
+  resolved: ResolvedSelector,
+  container: VCSSAtRule | VCSSStyleRule
 ): NestingInfo | null {
-    for (const nest of findNestingSelectors(resolved.selector)) {
-        let parent: VCSS = nest.node.parent
-        while (
-            parent &&
-            parent.type !== "VCSSAtRule" &&
-            parent.type !== "VCSSStyleRule"
-        ) {
-            parent = parent.parent
-        }
-        if (parent === container) {
-            return nest
-        }
+  for (const nest of findNestingSelectors(resolved.selector)) {
+    let parent: VCSS = nest.node.parent;
+    while (
+      parent &&
+      parent.type !== "VCSSAtRule" &&
+      parent.type !== "VCSSStyleRule"
+    ) {
+      parent = parent.parent;
+    }
+    if (parent === container) {
+      return nest;
     }
-    return null
+  }
+  return null;
 }
diff --git a/lib/styles/selectors/resolver/stylus-selector-resolver.ts b/lib/styles/selectors/resolver/stylus-selector-resolver.ts
index a8e03380..880ba158 100644
--- a/lib/styles/selectors/resolver/stylus-selector-resolver.ts
+++ b/lib/styles/selectors/resolver/stylus-selector-resolver.ts
@@ -1,330 +1,329 @@
-import type { NestingInfo } from "../../utils/selectors"
+import type { NestingInfo } from "../../utils/selectors";
 import {
-    isNestingAtRule,
-    findNestingSelectors,
-    findNestingSelector,
-    hasNodesSelector,
-    isSelectorCombinator,
-} from "../../utils/selectors"
+  isNestingAtRule,
+  findNestingSelectors,
+  findNestingSelector,
+  hasNodesSelector,
+  isSelectorCombinator,
+} from "../../utils/selectors";
 import type {
-    VCSSStyleRule,
-    VCSSAtRule,
-    VCSS,
-    VCSSSelectorNode,
-} from "../../ast"
-import { VCSSSelectorCombinator } from "../../ast"
+  VCSSStyleRule,
+  VCSSAtRule,
+  VCSS,
+  VCSSSelectorNode,
+} from "../../ast";
+import { VCSSSelectorCombinator } from "../../ast";
 import {
-    CSSSelectorResolver,
-    ResolvedSelector,
-    ResolvedSelectors,
-} from "./css-selector-resolver"
-import type { PostCSSSPCombinatorNode } from "../../../types"
+  CSSSelectorResolver,
+  ResolvedSelector,
+  ResolvedSelectors,
+} from "./css-selector-resolver";
+import type { PostCSSSPCombinatorNode } from "../../../types";
 
 export class StylusSelectorResolver extends CSSSelectorResolver {
-    /**
-     * Resolve nesting selector
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    protected resolveNestingSelectors(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorNode[],
-        parentSelectors: ResolvedSelectors | null,
-        container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        if (isNestingAtRule(container)) {
-            return this.resolveSelectorForNestContaining(
-                owner,
-                selectorNodes,
-                findNestingSelector(selectorNodes),
-                parentSelectors,
-                container,
-            )
-        }
-        return this.resolveSelectorForStylusNesting(
-            owner,
-            selectorNodes,
-            parentSelectors,
-            container,
-        )
+  /**
+   * Resolve nesting selector
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  protected resolveNestingSelectors(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorNode[],
+    parentSelectors: ResolvedSelectors | null,
+    container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    if (isNestingAtRule(container)) {
+      return this.resolveSelectorForNestContaining(
+        owner,
+        selectorNodes,
+        findNestingSelector(selectorNodes),
+        parentSelectors,
+        container
+      );
     }
+    return this.resolveSelectorForStylusNesting(
+      owner,
+      selectorNodes,
+      parentSelectors,
+      container
+    );
+  }
 
-    /**
-     * Resolve nesting selector for lang Stylus
-     * @param {Node[]} selectorNodes the selector
-     * @param {ResolvedSelector[]} parentSelectors parent selectors
-     * @param {Node} container the container node
-     * @returns {ResolvedSelector[]} resolved selectors
-     */
-    private resolveSelectorForStylusNesting(
-        owner: ResolvedSelectors,
-        selectorNodes: VCSSSelectorNode[],
-        parentSelectors: ResolvedSelectors | null,
-        container: VCSSAtRule | VCSSStyleRule,
-    ): ResolvedSelector[] {
-        const nesting = findNestingSelector(selectorNodes)
-        if (nesting != null) {
-            const nestingParent = parentSelectors
-                ? this.getNestingParentSelectors(parentSelectors, nesting)
-                : null
-            let resolvedSelectors = this.resolveSelectorForNestContaining(
-                owner,
-                selectorNodes,
-                nesting,
-                nestingParent,
-                container,
-            )
-
-            let hasNesting = true
-            while (hasNesting) {
-                hasNesting = false
-                const nextResolvedSelectors = []
-                for (const resolvedSelector of resolvedSelectors) {
-                    const nextNesting = findNextNestingSelector(
-                        resolvedSelector,
-                        container,
-                    )
-                    if (nextNesting) {
-                        hasNesting = true
-                        const nextNestingParent = parentSelectors
-                            ? this.getNestingParentSelectors(
-                                  parentSelectors,
-                                  nextNesting,
-                              )
-                            : null
-                        nextResolvedSelectors.push(
-                            ...this.resolveSelectorForNestContaining(
-                                owner,
-                                resolvedSelector.selector,
-                                nextNesting,
-                                nextNestingParent,
-                                container,
-                            ),
-                        )
-                    }
-                }
-                if (!hasNesting) {
-                    break
-                }
-                resolvedSelectors = nextResolvedSelectors
-            }
-            return resolvedSelectors
-        }
+  /**
+   * Resolve nesting selector for lang Stylus
+   * @param {Node[]} selectorNodes the selector
+   * @param {ResolvedSelector[]} parentSelectors parent selectors
+   * @param {Node} container the container node
+   * @returns {ResolvedSelector[]} resolved selectors
+   */
+  private resolveSelectorForStylusNesting(
+    owner: ResolvedSelectors,
+    selectorNodes: VCSSSelectorNode[],
+    parentSelectors: ResolvedSelectors | null,
+    container: VCSSAtRule | VCSSStyleRule
+  ): ResolvedSelector[] {
+    const nesting = findNestingSelector(selectorNodes);
+    if (nesting != null) {
+      const nestingParent = parentSelectors
+        ? this.getNestingParentSelectors(parentSelectors, nesting)
+        : null;
+      let resolvedSelectors = this.resolveSelectorForNestContaining(
+        owner,
+        selectorNodes,
+        nesting,
+        nestingParent,
+        container
+      );
 
-        const first = selectorNodes[0]
-        if (isSelectorCombinator(first)) {
-            return this.resolveSelectorForNestConcat(
+      let hasNesting = true;
+      while (hasNesting) {
+        hasNesting = false;
+        const nextResolvedSelectors = [];
+        for (const resolvedSelector of resolvedSelectors) {
+          const nextNesting = findNextNestingSelector(
+            resolvedSelector,
+            container
+          );
+          if (nextNesting) {
+            hasNesting = true;
+            const nextNestingParent = parentSelectors
+              ? this.getNestingParentSelectors(parentSelectors, nextNesting)
+              : null;
+            nextResolvedSelectors.push(
+              ...this.resolveSelectorForNestContaining(
                 owner,
-                selectorNodes,
-                parentSelectors,
-                container,
-            )
+                resolvedSelector.selector,
+                nextNesting,
+                nextNestingParent,
+                container
+              )
+            );
+          }
         }
+        if (!hasNesting) {
+          break;
+        }
+        resolvedSelectors = nextResolvedSelectors;
+      }
+      return resolvedSelectors;
+    }
 
-        // create descendant combinator
-        const comb = new VCSSSelectorCombinator(
-            first.node as PostCSSSPCombinatorNode,
-            {
-                start: first.loc.start,
-                end: first.loc.start,
-            },
-            first.range[0],
-            first.range[0],
-            first.parent as never,
-        )
-        comb.value = " "
-        comb.selector = " "
-
-        return this.resolveSelectorForNestConcat(
-            owner,
-            [comb, ...selectorNodes],
-            parentSelectors,
-            container,
-        )
+    const first = selectorNodes[0];
+    if (isSelectorCombinator(first)) {
+      return this.resolveSelectorForNestConcat(
+        owner,
+        selectorNodes,
+        parentSelectors,
+        container
+      );
     }
 
-    /**
-     * Gets the ResolvedSelectors that correspond to the given nesting selector.
-     */
-    private getNestingParentSelectors(
-        parentSelectors: ResolvedSelectors,
-        nesting: NestingInfo,
-    ): ResolvedSelectors | null {
-        if (nesting.node.value === "&") {
-            // The nestingNode is parent reference. e.g `&`
-            return parentSelectors
-        }
+    // create descendant combinator
+    const comb = new VCSSSelectorCombinator(
+      first.node as PostCSSSPCombinatorNode,
+      {
+        start: first.loc.start,
+        end: first.loc.start,
+      },
+      first.range[0],
+      first.range[0],
+      first.parent as never
+    );
+    comb.value = " ";
+    comb.selector = " ";
 
-        const partialRef = /^\^\[([\s\S]+?)\]$/u.exec(nesting.node.value)
-        if (partialRef) {
-            // The nestingNode is a partial reference. e.g. `^[0]`, `^[1]`, `^[-1]`, `^[1..-1]`
-            const partialRefValue = partialRef[1]
-            const arrayParentSelectors = toArray(parentSelectors)
-            const parsed = parsePartialRefValue(
-                partialRefValue,
-                arrayParentSelectors.length,
-            )
+    return this.resolveSelectorForNestConcat(
+      owner,
+      [comb, ...selectorNodes],
+      parentSelectors,
+      container
+    );
+  }
 
-            if (!parsed) {
-                return null
-            }
-            if (parsed.start === 0) {
-                // e.g. `^[0]`, `^[1]`, `^[-1]`
-                return arrayParentSelectors[parsed.end]
-            }
-            // e.g. `^[1..-1]`
-            return this.buildRangeResolveNestingSelectors(
-                arrayParentSelectors.slice(parsed.start, parsed.end + 1),
-            )
-        }
+  /**
+   * Gets the ResolvedSelectors that correspond to the given nesting selector.
+   */
+  private getNestingParentSelectors(
+    parentSelectors: ResolvedSelectors,
+    nesting: NestingInfo
+  ): ResolvedSelectors | null {
+    if (nesting.node.value === "&") {
+      // The nestingNode is parent reference. e.g `&`
+      return parentSelectors;
+    }
 
-        if (nesting.node.value === "~/" && nesting.nestingIndex === 0) {
-            // The nestingNode is initial reference. `~/`
-            const arrayParentSelectors = toArray(parentSelectors)
-            return arrayParentSelectors[0]
-        }
+    const partialRef = /^\^\[([\s\S]+?)\]$/u.exec(nesting.node.value);
+    if (partialRef) {
+      // The nestingNode is a partial reference. e.g. `^[0]`, `^[1]`, `^[-1]`, `^[1..-1]`
+      const partialRefValue = partialRef[1];
+      const arrayParentSelectors = toArray(parentSelectors);
+      const parsed = parsePartialRefValue(
+        partialRefValue,
+        arrayParentSelectors.length
+      );
 
-        if (
-            /^(?:\.\.\/)+$/u.test(nesting.node.value) &&
-            nesting.nestingIndex === 0
-        ) {
-            // The nestingNode is relative reference. e.g. `../`
-            const arrayParentSelectors = toArray(parentSelectors)
-            const index =
-                arrayParentSelectors.length - nesting.node.value.length / 3 - 1
-            return arrayParentSelectors.length > index && index >= 0
-                ? arrayParentSelectors[index]
-                : null
-        }
+      if (!parsed) {
+        return null;
+      }
+      if (parsed.start === 0) {
+        // e.g. `^[0]`, `^[1]`, `^[-1]`
+        return arrayParentSelectors[parsed.end];
+      }
+      // e.g. `^[1..-1]`
+      return this.buildRangeResolveNestingSelectors(
+        arrayParentSelectors.slice(parsed.start, parsed.end + 1)
+      );
+    }
 
-        if (nesting.node.value === "/" && nesting.nestingIndex === 0) {
-            // The nestingNode is root reference. `/`
-            return null
-        }
+    if (nesting.node.value === "~/" && nesting.nestingIndex === 0) {
+      // The nestingNode is initial reference. `~/`
+      const arrayParentSelectors = toArray(parentSelectors);
+      return arrayParentSelectors[0];
+    }
 
-        // unknown
-        return parentSelectors
+    if (
+      /^(?:\.\.\/)+$/u.test(nesting.node.value) &&
+      nesting.nestingIndex === 0
+    ) {
+      // The nestingNode is relative reference. e.g. `../`
+      const arrayParentSelectors = toArray(parentSelectors);
+      const index =
+        arrayParentSelectors.length - nesting.node.value.length / 3 - 1;
+      return arrayParentSelectors.length > index && index >= 0
+        ? arrayParentSelectors[index]
+        : null;
     }
 
-    private buildRangeResolveNestingSelectors(
-        range: ResolvedSelectors[],
-    ): ResolvedSelectors {
-        const stack = [...range]
+    if (nesting.node.value === "/" && nesting.nestingIndex === 0) {
+      // The nestingNode is root reference. `/`
+      return null;
+    }
 
-        let resolvedSelectors: ResolvedSelectors | null = null
-        let next = stack.shift()
-        while (next != null) {
-            const targetResolvedSelectors: ResolvedSelectors =
-                new ResolvedSelectors(next.container, resolvedSelectors)
-            for (const selector of next.container.selectors.filter(
-                hasNodesSelector,
-            )) {
-                const selectors = this.resolveNestingSelectors(
-                    targetResolvedSelectors,
-                    selector.nodes,
-                    resolvedSelectors,
-                    next.container,
-                )
-                targetResolvedSelectors.selectors.push(...selectors)
-            }
-            resolvedSelectors = targetResolvedSelectors
-            next = stack.shift()
-        }
+    // unknown
+    return parentSelectors;
+  }
+
+  private buildRangeResolveNestingSelectors(
+    range: ResolvedSelectors[]
+  ): ResolvedSelectors {
+    const stack = [...range];
 
-        return resolvedSelectors as ResolvedSelectors
+    let resolvedSelectors: ResolvedSelectors | null = null;
+    let next = stack.shift();
+    while (next != null) {
+      const targetResolvedSelectors: ResolvedSelectors = new ResolvedSelectors(
+        next.container,
+        resolvedSelectors
+      );
+      for (const selector of next.container.selectors.filter(
+        hasNodesSelector
+      )) {
+        const selectors = this.resolveNestingSelectors(
+          targetResolvedSelectors,
+          selector.nodes,
+          resolvedSelectors,
+          next.container
+        );
+        targetResolvedSelectors.selectors.push(...selectors);
+      }
+      resolvedSelectors = targetResolvedSelectors;
+      next = stack.shift();
     }
+
+    return resolvedSelectors as ResolvedSelectors;
+  }
 }
 
-export { ResolvedSelector }
+export { ResolvedSelector };
 
 /**
  * Find next nesting selector
  */
 export function findNextNestingSelector(
-    resolved: ResolvedSelector,
-    container: VCSSAtRule | VCSSStyleRule,
+  resolved: ResolvedSelector,
+  container: VCSSAtRule | VCSSStyleRule
 ): NestingInfo | null {
-    for (const nest of findNestingSelectors(resolved.selector)) {
-        let parent: VCSS = nest.node.parent
-        while (
-            parent &&
-            parent.type !== "VCSSAtRule" &&
-            parent.type !== "VCSSStyleRule"
-        ) {
-            parent = parent.parent
-        }
-        if (parent === container) {
-            return nest
-        }
+  for (const nest of findNestingSelectors(resolved.selector)) {
+    let parent: VCSS = nest.node.parent;
+    while (
+      parent &&
+      parent.type !== "VCSSAtRule" &&
+      parent.type !== "VCSSStyleRule"
+    ) {
+      parent = parent.parent;
+    }
+    if (parent === container) {
+      return nest;
     }
-    return null
+  }
+  return null;
 }
 
 /**
  * Parse partial reference values
  */
 function parsePartialRefValue(partialRefValue: string, length: number) {
-    /**
-     * num to index
-     */
-    function numberToIndex(n: number, minusOffset = 0) {
-        if (n >= 0) {
-            return n
-        }
-        return length + n + minusOffset
+  /**
+   * num to index
+   */
+  function numberToIndex(n: number, minusOffset = 0) {
+    if (n >= 0) {
+      return n;
     }
+    return length + n + minusOffset;
+  }
 
-    const num = Number(partialRefValue)
-    if (Number.isInteger(num)) {
-        // e.g. `^[0]`, `^[1]`, `^[-1]`
-        const index = numberToIndex(num, -1)
-        if (index < 0 || length <= index) {
-            // out of range
-            return null
-        }
-        return {
-            start: 0,
-            end: index,
-        }
+  const num = Number(partialRefValue);
+  if (Number.isInteger(num)) {
+    // e.g. `^[0]`, `^[1]`, `^[-1]`
+    const index = numberToIndex(num, -1);
+    if (index < 0 || length <= index) {
+      // out of range
+      return null;
     }
+    return {
+      start: 0,
+      end: index,
+    };
+  }
 
-    const rangeValues = /^([+-]?\d+)\.\.([+-]?\d+)$/u.exec(partialRefValue)
+  const rangeValues = /^([+-]?\d+)\.\.([+-]?\d+)$/u.exec(partialRefValue);
 
-    if (rangeValues) {
-        // The nestingNode is ranges in partial references.
-        const start = numberToIndex(Number(rangeValues[1]))
-        const end = numberToIndex(Number(rangeValues[2]))
+  if (rangeValues) {
+    // The nestingNode is ranges in partial references.
+    const start = numberToIndex(Number(rangeValues[1]));
+    const end = numberToIndex(Number(rangeValues[2]));
 
-        if (
-            start < 0 ||
-            length <= start ||
-            end < 0 ||
-            length <= end ||
-            end < start
-        ) {
-            // out of range
-            return null
-        }
-        return {
-            start,
-            end,
-        }
+    if (
+      start < 0 ||
+      length <= start ||
+      end < 0 ||
+      length <= end ||
+      end < start
+    ) {
+      // out of range
+      return null;
     }
-    // unknown
-    return null
+    return {
+      start,
+      end,
+    };
+  }
+  // unknown
+  return null;
 }
 
 /**
  * ResolvedSelectors to array ResolvedSelectors
  */
 function toArray(selectors: ResolvedSelectors): ResolvedSelectors[] {
-    const array = [selectors]
-    let parent = selectors.parent
-    while (parent != null) {
-        array.unshift(parent)
-        parent = parent.parent
-    }
-    return array
+  const array = [selectors];
+  let parent = selectors.parent;
+  while (parent != null) {
+    array.unshift(parent);
+    parent = parent.parent;
+  }
+  return array;
 }
diff --git a/lib/styles/template/at-rule-params/css.ts b/lib/styles/template/at-rule-params/css.ts
index 9ba21a24..acd167f1 100644
--- a/lib/styles/template/at-rule-params/css.ts
+++ b/lib/styles/template/at-rule-params/css.ts
@@ -2,5 +2,5 @@
  * Returns the template elements that the given atrule params.
  */
 export default function (text: string): string[] {
-    return [text]
+  return [text];
 }
diff --git a/lib/styles/template/at-rule-params/index.ts b/lib/styles/template/at-rule-params/index.ts
index 7adcb9fe..dcae7682 100644
--- a/lib/styles/template/at-rule-params/index.ts
+++ b/lib/styles/template/at-rule-params/index.ts
@@ -1,24 +1,24 @@
-import getCSSTemplateElements from "./css"
-import getSCSSTemplateElements from "./scss"
-import getStylusTemplateElements from "./stylus"
-import type { Interpolation } from "../interpolation"
-import { isSupportedStyleLang } from "../../utils"
+import getCSSTemplateElements from "./css";
+import getSCSSTemplateElements from "./scss";
+import getStylusTemplateElements from "./stylus";
+import type { Interpolation } from "../interpolation";
+import { isSupportedStyleLang } from "../../utils";
 
 const BUILDERS = {
-    css: getCSSTemplateElements,
-    scss: getSCSSTemplateElements,
-    stylus: getStylusTemplateElements,
-}
+  css: getCSSTemplateElements,
+  scss: getSCSSTemplateElements,
+  stylus: getStylusTemplateElements,
+};
 
 /**
  * Returns the template elements that the given atrule params.
  */
 export default function getAtRuleParamsTemplateElements(
-    text: string,
-    lang: string,
+  text: string,
+  lang: string
 ): (Interpolation | string)[] {
-    const templateBuilder = isSupportedStyleLang(lang)
-        ? BUILDERS[lang]
-        : getCSSTemplateElements
-    return templateBuilder(text.trim())
+  const templateBuilder = isSupportedStyleLang(lang)
+    ? BUILDERS[lang]
+    : getCSSTemplateElements;
+  return templateBuilder(text.trim());
 }
diff --git a/lib/styles/template/at-rule-params/scss.ts b/lib/styles/template/at-rule-params/scss.ts
index 62a0fc41..45f69cf4 100644
--- a/lib/styles/template/at-rule-params/scss.ts
+++ b/lib/styles/template/at-rule-params/scss.ts
@@ -1,9 +1,9 @@
-import type { Interpolation } from "../interpolation"
-import { processText } from "../scss/util"
+import type { Interpolation } from "../interpolation";
+import { processText } from "../scss/util";
 
 /**
  * Returns the template elements that the given atrule params.
  */
 export default function (text: string): (Interpolation | string)[] {
-    return processText(text)
+  return processText(text);
 }
diff --git a/lib/styles/template/at-rule-params/stylus.ts b/lib/styles/template/at-rule-params/stylus.ts
index 44f23971..1cc74194 100644
--- a/lib/styles/template/at-rule-params/stylus.ts
+++ b/lib/styles/template/at-rule-params/stylus.ts
@@ -1,9 +1,9 @@
-import type { Interpolation } from "../interpolation"
-import { processText } from "../stylus/util"
+import type { Interpolation } from "../interpolation";
+import { processText } from "../stylus/util";
 
 /**
  * Returns the template elements that the given atrule params.
  */
 export default function (text: string): (Interpolation | string)[] {
-    return processText(text)
+  return processText(text);
 }
diff --git a/lib/styles/template/decl-value/css.ts b/lib/styles/template/decl-value/css.ts
index b709100c..9458ec21 100644
--- a/lib/styles/template/decl-value/css.ts
+++ b/lib/styles/template/decl-value/css.ts
@@ -2,5 +2,5 @@
  * Returns the template elements that the given decl value.
  */
 export default function (text: string): string[] {
-    return [text]
+  return [text];
 }
diff --git a/lib/styles/template/decl-value/index.ts b/lib/styles/template/decl-value/index.ts
index e17024f0..f8e8bd2f 100644
--- a/lib/styles/template/decl-value/index.ts
+++ b/lib/styles/template/decl-value/index.ts
@@ -1,24 +1,24 @@
-import getCSSTemplateElements from "./css"
-import getSCSSTemplateElements from "./scss"
-import getStylusTemplateElements from "./stylus"
-import type { Interpolation } from "../interpolation"
-import { isSupportedStyleLang } from "../../utils"
+import getCSSTemplateElements from "./css";
+import getSCSSTemplateElements from "./scss";
+import getStylusTemplateElements from "./stylus";
+import type { Interpolation } from "../interpolation";
+import { isSupportedStyleLang } from "../../utils";
 
 const BUILDERS = {
-    css: getCSSTemplateElements,
-    scss: getSCSSTemplateElements,
-    stylus: getStylusTemplateElements,
-}
+  css: getCSSTemplateElements,
+  scss: getSCSSTemplateElements,
+  stylus: getStylusTemplateElements,
+};
 
 /**
  * Returns the template elements that the given decl value.
  */
 export default function getDeclValueTemplateElements(
-    text: string,
-    lang: string,
+  text: string,
+  lang: string
 ): (Interpolation | string)[] {
-    const templateBuilder = isSupportedStyleLang(lang)
-        ? BUILDERS[lang]
-        : getCSSTemplateElements
-    return templateBuilder(text.trim())
+  const templateBuilder = isSupportedStyleLang(lang)
+    ? BUILDERS[lang]
+    : getCSSTemplateElements;
+  return templateBuilder(text.trim());
 }
diff --git a/lib/styles/template/decl-value/scss.ts b/lib/styles/template/decl-value/scss.ts
index 3a1d1481..9c9cc765 100644
--- a/lib/styles/template/decl-value/scss.ts
+++ b/lib/styles/template/decl-value/scss.ts
@@ -1,9 +1,9 @@
-import type { Interpolation } from "../interpolation"
-import { processValue } from "../scss/util"
+import type { Interpolation } from "../interpolation";
+import { processValue } from "../scss/util";
 
 /**
  * Returns the template elements that the given decl value.
  */
 export default function (text: string): (Interpolation | string)[] {
-    return processValue(text)
+  return processValue(text);
 }
diff --git a/lib/styles/template/decl-value/stylus.ts b/lib/styles/template/decl-value/stylus.ts
index 9f663470..827654de 100644
--- a/lib/styles/template/decl-value/stylus.ts
+++ b/lib/styles/template/decl-value/stylus.ts
@@ -1,9 +1,9 @@
-import type { Interpolation } from "../interpolation"
-import { processValue } from "../stylus/util"
+import type { Interpolation } from "../interpolation";
+import { processValue } from "../stylus/util";
 
 /**
  * Returns the template elements that the given decl value.
  */
 export default function (text: string): (Interpolation | string)[] {
-    return processValue(text)
+  return processValue(text);
 }
diff --git a/lib/styles/template/index.ts b/lib/styles/template/index.ts
index 72ef2846..ddf75949 100644
--- a/lib/styles/template/index.ts
+++ b/lib/styles/template/index.ts
@@ -1,263 +1,259 @@
-import { escapeRegExp } from "../utils"
-import type { AST } from "../../types"
-import { Interpolation } from "./interpolation"
+import { escapeRegExp } from "../utils";
+import type { AST } from "../../types";
+import { Interpolation } from "./interpolation";
 import type {
-    VCSSIDSelector,
-    VCSSClassSelector,
-    VCSSTypeSelector,
-    VCSSAtRule,
-    VCSSDeclarationProperty,
-} from "../ast"
-import getSelectorTemplateElements from "./selector"
-import getAtRuleParamsTemplateElements from "./at-rule-params"
-import getDeclValueTemplateElements from "./decl-value"
-import { isDefined } from "../../utils/utils"
+  VCSSIDSelector,
+  VCSSClassSelector,
+  VCSSTypeSelector,
+  VCSSAtRule,
+  VCSSDeclarationProperty,
+} from "../ast";
+import getSelectorTemplateElements from "./selector";
+import getAtRuleParamsTemplateElements from "./at-rule-params";
+import getDeclValueTemplateElements from "./decl-value";
+import { isDefined } from "../../utils/utils";
 
-export { Interpolation }
+export { Interpolation };
 
 /**
  * This class checks whether the identifiers match including interpolation.
  */
 export class Template {
-    public static interpolationTemplate = new Template([new Interpolation("?")])
+  public static interpolationTemplate = new Template([new Interpolation("?")]);
 
-    public elements: (Interpolation | string)[]
+  public elements: (Interpolation | string)[];
 
-    public readonly string: string | null = null
+  public readonly string: string | null = null;
 
-    private _text: string | null = null
+  private _text: string | null = null;
 
-    private _regexp: RegExp | null = null
+  private _regexp: RegExp | null = null;
 
-    public constructor(
-        elements: (Interpolation | string | null | undefined)[],
-    ) {
-        this.elements = elements
-            .filter(isDefined)
-            .filter((e) => e !== "")
-            .reduce((l, e) => {
-                if (l.length) {
-                    const lastIndex = l.length - 1
-                    const last = l[lastIndex]
-                    if (typeof e === "string" && typeof last === "string") {
-                        l[lastIndex] = last + e
-                        return l
-                    }
-                    if (typeof e !== "string" && typeof last !== "string") {
-                        l[lastIndex] = new Interpolation(last.text + e.text)
-                        return l
-                    }
-                }
-                l.push(e)
-                return l
-            }, [] as (Interpolation | string)[])
-
-        if (this.elements.length === 1) {
-            const element = this.elements[0]
-            if (typeof element === "string") {
-                this.string = element
-            }
-        } else if (this.elements.length === 0) {
-            this.string = ""
+  public constructor(elements: (Interpolation | string | null | undefined)[]) {
+    this.elements = elements
+      .filter(isDefined)
+      .filter((e) => e !== "")
+      .reduce((l, e) => {
+        if (l.length) {
+          const lastIndex = l.length - 1;
+          const last = l[lastIndex];
+          if (typeof e === "string" && typeof last === "string") {
+            l[lastIndex] = last + e;
+            return l;
+          }
+          if (typeof e !== "string" && typeof last !== "string") {
+            l[lastIndex] = new Interpolation(last.text + e.text);
+            return l;
+          }
         }
-    }
+        l.push(e);
+        return l;
+      }, [] as (Interpolation | string)[]);
 
-    public static of(value: string): Template {
-        return new Template([value])
+    if (this.elements.length === 1) {
+      const element = this.elements[0];
+      if (typeof element === "string") {
+        this.string = element;
+      }
+    } else if (this.elements.length === 0) {
+      this.string = "";
     }
+  }
 
-    public static ofSelector(
-        node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector,
-    ): Template {
-        return new Template(getSelectorTemplateElements(node))
-    }
+  public static of(value: string): Template {
+    return new Template([value]);
+  }
 
-    public static ofParams(node: VCSSAtRule): Template {
-        return new Template(
-            getAtRuleParamsTemplateElements(node.paramsText.trim(), node.lang),
-        )
-    }
+  public static ofSelector(
+    node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector
+  ): Template {
+    return new Template(getSelectorTemplateElements(node));
+  }
 
-    public static ofDeclValue(text: string, lang: string): Template
+  public static ofParams(node: VCSSAtRule): Template {
+    return new Template(
+      getAtRuleParamsTemplateElements(node.paramsText.trim(), node.lang)
+    );
+  }
 
-    public static ofDeclValue(node: VCSSDeclarationProperty): Template
+  public static ofDeclValue(text: string, lang: string): Template;
 
-    public static ofDeclValue(
-        nodeOrText: VCSSDeclarationProperty | string,
-        lang?: string,
-    ): Template {
-        if (typeof nodeOrText === "string") {
-            return new Template(
-                getDeclValueTemplateElements(nodeOrText, lang || ""),
-            )
-        }
-        return new Template(
-            getDeclValueTemplateElements(nodeOrText.value, nodeOrText.lang),
-        )
-    }
+  public static ofDeclValue(node: VCSSDeclarationProperty): Template;
 
-    public static ofNode(
-        node:
-            | AST.ESLintBlockStatement
-            | AST.ESLintExpression
-            | AST.ESLintPattern
-            | AST.ESLintPrivateIdentifier
-            | AST.VLiteral
-            | AST.VFilterSequenceExpression
-            | AST.VForExpression
-            | AST.VOnExpression
-            | AST.VSlotScopeExpression,
-    ): Template | null {
-        if (node.type === "VLiteral") {
-            return Template.of(node.value)
-        }
-        if (node.type === "Literal") {
-            return Template.of(`${node.value}`)
-        }
-        if (node.type === "TemplateLiteral") {
-            const elements: (string | Interpolation | undefined)[] = []
-            for (const element of node.quasis) {
-                elements.push(element.value.cooked || element.value.raw)
-                elements.push(new Interpolation("${}"))
-            }
-            elements.pop()
-            return new Template(elements)
-        }
-        if (node.type === "BinaryExpression" && node.operator === "+") {
-            const left = Template.ofNode(node.left)
-            const right = Template.ofNode(node.right)
-            if (left && right) {
-                return left.concat(right)
-            } else if (left) {
-                return left.concat(Template.interpolationTemplate)
-            } else if (right) {
-                return Template.interpolationTemplate.concat(right)
-            }
-        }
-        return null
+  public static ofDeclValue(
+    nodeOrText: VCSSDeclarationProperty | string,
+    lang?: string
+  ): Template {
+    if (typeof nodeOrText === "string") {
+      return new Template(getDeclValueTemplateElements(nodeOrText, lang || ""));
     }
+    return new Template(
+      getDeclValueTemplateElements(nodeOrText.value, nodeOrText.lang)
+    );
+  }
 
-    public match(o: Template): boolean {
-        if (this.string != null && o.string != null) {
-            return this.string === o.string
-        }
-        if (this.regexp.test(o.text)) {
-            return true
-        }
-        if (o.regexp.test(this.text)) {
-            return true
-        }
-        return false
+  public static ofNode(
+    node:
+      | AST.ESLintBlockStatement
+      | AST.ESLintExpression
+      | AST.ESLintPattern
+      | AST.ESLintPrivateIdentifier
+      | AST.VLiteral
+      | AST.VFilterSequenceExpression
+      | AST.VForExpression
+      | AST.VOnExpression
+      | AST.VSlotScopeExpression
+  ): Template | null {
+    if (node.type === "VLiteral") {
+      return Template.of(node.value);
     }
-
-    public matchString(s: string): boolean {
-        if (this.string != null) {
-            return this.string === s
-        }
-        if (this.regexp.test(s)) {
-            return true
-        }
-        return false
+    if (node.type === "Literal") {
+      return Template.of(`${node.value}`);
     }
-
-    public endsWith(s: string): boolean {
-        if (this.string != null) {
-            return this.string.endsWith(s)
-        }
-        const last = this.elements[this.elements.length - 1]
-        if (typeof last === "string") {
-            if (last.endsWith(s)) {
-                return true
-            }
-        }
-        // any
-        return true
+    if (node.type === "TemplateLiteral") {
+      const elements: (string | Interpolation | undefined)[] = [];
+      for (const element of node.quasis) {
+        elements.push(element.value.cooked || element.value.raw);
+        elements.push(new Interpolation("${}"));
+      }
+      elements.pop();
+      return new Template(elements);
     }
-
-    public concat(o: string | Template): Template {
-        if (typeof o === "string") {
-            return new Template([...this.elements, o])
-        }
-
-        return new Template([...this.elements, ...o.elements])
+    if (node.type === "BinaryExpression" && node.operator === "+") {
+      const left = Template.ofNode(node.left);
+      const right = Template.ofNode(node.right);
+      if (left && right) {
+        return left.concat(right);
+      } else if (left) {
+        return left.concat(Template.interpolationTemplate);
+      } else if (right) {
+        return Template.interpolationTemplate.concat(right);
+      }
     }
+    return null;
+  }
 
-    public hasString(s: string): boolean {
-        return this.elements.some((e) => {
-            if (typeof e === "string") {
-                return e.includes(s)
-            }
-            return false
-        })
+  public match(o: Template): boolean {
+    if (this.string != null && o.string != null) {
+      return this.string === o.string;
     }
-
-    public divide(s: string | RegExp): Template[] {
-        const results: Template[] = []
-        let elements: (string | Interpolation | undefined)[] = []
-        for (const e of this.elements) {
-            if (typeof e === "string") {
-                if (e.search(s) >= 0) {
-                    const list = e.split(s)
-                    elements.push(list.shift())
-                    results.push(new Template(elements))
-                    while (list.length > 1) {
-                        results.push(new Template([list.shift()]))
-                    }
-                    elements = [list.shift()]
-                } else {
-                    elements.push(e)
-                }
-            } else {
-                elements.push(e)
-            }
-        }
-        if (elements.length) {
-            results.push(new Template(elements))
-        }
-        return results
+    if (this.regexp.test(o.text)) {
+      return true;
     }
+    if (o.regexp.test(this.text)) {
+      return true;
+    }
+    return false;
+  }
 
-    public toLowerCase(): Template {
-        return new Template(
-            this.elements.map((e) => {
-                if (typeof e === "string") {
-                    return e.toLowerCase()
-                }
-                return e
-            }),
-        )
+  public matchString(s: string): boolean {
+    if (this.string != null) {
+      return this.string === s;
+    }
+    if (this.regexp.test(s)) {
+      return true;
     }
+    return false;
+  }
 
-    private get text(): string {
-        return this._text || (this._text = this.buildText())
+  public endsWith(s: string): boolean {
+    if (this.string != null) {
+      return this.string.endsWith(s);
     }
+    const last = this.elements[this.elements.length - 1];
+    if (typeof last === "string") {
+      if (last.endsWith(s)) {
+        return true;
+      }
+    }
+    // any
+    return true;
+  }
 
-    private get regexp(): RegExp {
-        return this._regexp || (this._regexp = this.buildRegexp())
+  public concat(o: string | Template): Template {
+    if (typeof o === "string") {
+      return new Template([...this.elements, o]);
     }
 
-    private buildRegexp(): RegExp {
-        let expr = "^"
-        for (const e of this.elements) {
-            if (typeof e === "string") {
-                expr += escapeRegExp(e)
-            } else {
-                expr += "[\\s\\S]*"
-            }
+    return new Template([...this.elements, ...o.elements]);
+  }
+
+  public hasString(s: string): boolean {
+    return this.elements.some((e) => {
+      if (typeof e === "string") {
+        return e.includes(s);
+      }
+      return false;
+    });
+  }
+
+  public divide(s: string | RegExp): Template[] {
+    const results: Template[] = [];
+    let elements: (string | Interpolation | undefined)[] = [];
+    for (const e of this.elements) {
+      if (typeof e === "string") {
+        if (e.search(s) >= 0) {
+          const list = e.split(s);
+          elements.push(list.shift());
+          results.push(new Template(elements));
+          while (list.length > 1) {
+            results.push(new Template([list.shift()]));
+          }
+          elements = [list.shift()];
+        } else {
+          elements.push(e);
         }
-        expr += "$"
-        return new RegExp(expr, "u")
+      } else {
+        elements.push(e);
+      }
     }
+    if (elements.length) {
+      results.push(new Template(elements));
+    }
+    return results;
+  }
 
-    private buildText(): string {
-        let text = ""
-        for (const e of this.elements) {
-            if (typeof e === "string") {
-                text += e
-            } else {
-                text += "\ue000"
-            }
+  public toLowerCase(): Template {
+    return new Template(
+      this.elements.map((e) => {
+        if (typeof e === "string") {
+          return e.toLowerCase();
         }
-        return text
+        return e;
+      })
+    );
+  }
+
+  private get text(): string {
+    return this._text || (this._text = this.buildText());
+  }
+
+  private get regexp(): RegExp {
+    return this._regexp || (this._regexp = this.buildRegexp());
+  }
+
+  private buildRegexp(): RegExp {
+    let expr = "^";
+    for (const e of this.elements) {
+      if (typeof e === "string") {
+        expr += escapeRegExp(e);
+      } else {
+        expr += "[\\s\\S]*";
+      }
+    }
+    expr += "$";
+    return new RegExp(expr, "u");
+  }
+
+  private buildText(): string {
+    let text = "";
+    for (const e of this.elements) {
+      if (typeof e === "string") {
+        text += e;
+      } else {
+        text += "\ue000";
+      }
     }
+    return text;
+  }
 }
diff --git a/lib/styles/template/interpolation.ts b/lib/styles/template/interpolation.ts
index effab002..580a9c92 100644
--- a/lib/styles/template/interpolation.ts
+++ b/lib/styles/template/interpolation.ts
@@ -1,7 +1,7 @@
 export class Interpolation {
-    public text: string
+  public text: string;
 
-    public constructor(text: string) {
-        this.text = text
-    }
+  public constructor(text: string) {
+    this.text = text;
+  }
 }
diff --git a/lib/styles/template/scss/util.ts b/lib/styles/template/scss/util.ts
index 76f068d2..537d12f1 100644
--- a/lib/styles/template/scss/util.ts
+++ b/lib/styles/template/scss/util.ts
@@ -1,39 +1,39 @@
-import { Interpolation } from "../interpolation"
+import { Interpolation } from "../interpolation";
 
 /**
  * Returns the template elements that the given text.
  */
 export function processText(text: string): (Interpolation | string)[] {
-    const elements = []
-    const value = text
-    let start = 0
-    const reg = /#\{[\s\S]*?\}/gu
-    let re = null
-    while ((re = reg.exec(value))) {
-        elements.push(value.slice(start, re.index))
-        elements.push(new Interpolation(value.slice(re.index, reg.lastIndex)))
-        start = reg.lastIndex
-    }
-    elements.push(value.slice(start))
+  const elements = [];
+  const value = text;
+  let start = 0;
+  const reg = /#\{[\s\S]*?\}/gu;
+  let re = null;
+  while ((re = reg.exec(value))) {
+    elements.push(value.slice(start, re.index));
+    elements.push(new Interpolation(value.slice(re.index, reg.lastIndex)));
+    start = reg.lastIndex;
+  }
+  elements.push(value.slice(start));
 
-    return elements
+  return elements;
 }
 
 /**
  * Returns the template elements that the given value.
  */
 export function processValue(text: string): (Interpolation | string)[] {
-    const elements = []
-    const value = text
-    let start = 0
-    const reg = /#\{[\s\S]*?\}|\$[\w-]+/gu
-    let re = null
-    while ((re = reg.exec(value))) {
-        elements.push(value.slice(start, re.index))
-        elements.push(new Interpolation(value.slice(re.index, reg.lastIndex)))
-        start = reg.lastIndex
-    }
-    elements.push(value.slice(start))
+  const elements = [];
+  const value = text;
+  let start = 0;
+  const reg = /#\{[\s\S]*?\}|\$[\w-]+/gu;
+  let re = null;
+  while ((re = reg.exec(value))) {
+    elements.push(value.slice(start, re.index));
+    elements.push(new Interpolation(value.slice(re.index, reg.lastIndex)));
+    start = reg.lastIndex;
+  }
+  elements.push(value.slice(start));
 
-    return elements
+  return elements;
 }
diff --git a/lib/styles/template/selector/css.ts b/lib/styles/template/selector/css.ts
index 8c4d0a01..e7c2f67d 100644
--- a/lib/styles/template/selector/css.ts
+++ b/lib/styles/template/selector/css.ts
@@ -1,14 +1,14 @@
 import type {
-    VCSSIDSelector,
-    VCSSTypeSelector,
-    VCSSClassSelector,
-} from "../../ast"
+  VCSSIDSelector,
+  VCSSTypeSelector,
+  VCSSClassSelector,
+} from "../../ast";
 
 /**
  * Returns the template elements that the given selector node define.
  */
 export default function (
-    node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector,
+  node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector
 ): string[] {
-    return [node.value]
+  return [node.value];
 }
diff --git a/lib/styles/template/selector/index.ts b/lib/styles/template/selector/index.ts
index 4a270470..8322a435 100644
--- a/lib/styles/template/selector/index.ts
+++ b/lib/styles/template/selector/index.ts
@@ -1,28 +1,28 @@
-import getCSSTemplateElements from "./css"
-import getSCSSTemplateElements from "./scss"
-import getStylusTemplateElements from "./stylus"
+import getCSSTemplateElements from "./css";
+import getSCSSTemplateElements from "./scss";
+import getStylusTemplateElements from "./stylus";
 import type {
-    VCSSIDSelector,
-    VCSSTypeSelector,
-    VCSSClassSelector,
-} from "../../ast"
-import type { Interpolation } from "../interpolation"
-import { isSupportedStyleLang } from "../../utils"
+  VCSSIDSelector,
+  VCSSTypeSelector,
+  VCSSClassSelector,
+} from "../../ast";
+import type { Interpolation } from "../interpolation";
+import { isSupportedStyleLang } from "../../utils";
 
 const BUILDERS = {
-    css: getCSSTemplateElements,
-    scss: getSCSSTemplateElements,
-    stylus: getStylusTemplateElements,
-}
+  css: getCSSTemplateElements,
+  scss: getSCSSTemplateElements,
+  stylus: getStylusTemplateElements,
+};
 
 /**
  * Returns the template elements that the given selector node define.
  */
 export default function getSelectorTemplateElements(
-    node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector,
+  node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector
 ): (Interpolation | string)[] {
-    const templateBuilder = isSupportedStyleLang(node.lang)
-        ? BUILDERS[node.lang]
-        : getCSSTemplateElements
-    return templateBuilder(node)
+  const templateBuilder = isSupportedStyleLang(node.lang)
+    ? BUILDERS[node.lang]
+    : getCSSTemplateElements;
+  return templateBuilder(node);
 }
diff --git a/lib/styles/template/selector/scss.ts b/lib/styles/template/selector/scss.ts
index 0145d574..36c24849 100644
--- a/lib/styles/template/selector/scss.ts
+++ b/lib/styles/template/selector/scss.ts
@@ -1,16 +1,16 @@
 import type {
-    VCSSIDSelector,
-    VCSSClassSelector,
-    VCSSTypeSelector,
-} from "../../ast"
-import type { Interpolation } from "../interpolation"
-import { processText } from "../scss/util"
+  VCSSIDSelector,
+  VCSSClassSelector,
+  VCSSTypeSelector,
+} from "../../ast";
+import type { Interpolation } from "../interpolation";
+import { processText } from "../scss/util";
 
 /**
  * Returns the template elements that the given selector node define.
  */
 export default function (
-    node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector,
+  node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector
 ): (Interpolation | string)[] {
-    return processText(node.value)
+  return processText(node.value);
 }
diff --git a/lib/styles/template/selector/stylus.ts b/lib/styles/template/selector/stylus.ts
index 0cd84ea6..efd4b7df 100644
--- a/lib/styles/template/selector/stylus.ts
+++ b/lib/styles/template/selector/stylus.ts
@@ -1,16 +1,16 @@
 import type {
-    VCSSIDSelector,
-    VCSSClassSelector,
-    VCSSTypeSelector,
-} from "../../ast"
-import type { Interpolation } from "../interpolation"
-import { processText } from "../stylus/util"
+  VCSSIDSelector,
+  VCSSClassSelector,
+  VCSSTypeSelector,
+} from "../../ast";
+import type { Interpolation } from "../interpolation";
+import { processText } from "../stylus/util";
 
 /**
  * Returns the template elements that the given selector node define.
  */
 export default function (
-    node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector,
+  node: VCSSIDSelector | VCSSClassSelector | VCSSTypeSelector
 ): (Interpolation | string)[] {
-    return processText(node.value)
+  return processText(node.value);
 }
diff --git a/lib/styles/template/stylus/util.ts b/lib/styles/template/stylus/util.ts
index 9b94383c..035c0416 100644
--- a/lib/styles/template/stylus/util.ts
+++ b/lib/styles/template/stylus/util.ts
@@ -1,30 +1,30 @@
-import { Interpolation } from "../interpolation"
+import { Interpolation } from "../interpolation";
 
 /**
  * Returns the template elements that the given text.
  */
 export function processText(text: string): (Interpolation | string)[] {
-    const elements = []
-    const value = text
-    let start = 0
-    const reg = /\{[\s\S]*?\}/gu
-    let re = null
-    while ((re = reg.exec(value))) {
-        elements.push(value.slice(start, re.index))
-        elements.push(new Interpolation(value.slice(re.index, reg.lastIndex)))
-        start = reg.lastIndex
-    }
-    elements.push(value.slice(start))
+  const elements = [];
+  const value = text;
+  let start = 0;
+  const reg = /\{[\s\S]*?\}/gu;
+  let re = null;
+  while ((re = reg.exec(value))) {
+    elements.push(value.slice(start, re.index));
+    elements.push(new Interpolation(value.slice(re.index, reg.lastIndex)));
+    start = reg.lastIndex;
+  }
+  elements.push(value.slice(start));
 
-    return elements
+  return elements;
 }
 
 /**
  * Returns the template elements that the given value.
  */
 export function processValue(text: string): (Interpolation | string)[] {
-    if (text.includes("+") || text.includes("$")) {
-        return [new Interpolation(text)]
-    }
-    return [text]
+  if (text.includes("+") || text.includes("$")) {
+    return [new Interpolation(text)];
+  }
+  return [text];
 }
diff --git a/lib/styles/utils/css-nodes.ts b/lib/styles/utils/css-nodes.ts
index c39f5d7f..53260285 100644
--- a/lib/styles/utils/css-nodes.ts
+++ b/lib/styles/utils/css-nodes.ts
@@ -1,85 +1,85 @@
 import type {
-    VCSSAtRule,
-    VCSSNode,
-    VCSSStyleRule,
-    VCSSContainerNode,
-    VCSSStyleSheet,
-    VCSSSelectorNode,
-    VCSSSelector,
-    VCSSSelectorPseudo,
-    VCSSDeclarationProperty,
-    VCSSComment,
-} from "../ast"
-import { isNestingAtRule } from "./selectors"
+  VCSSAtRule,
+  VCSSNode,
+  VCSSStyleRule,
+  VCSSContainerNode,
+  VCSSStyleSheet,
+  VCSSSelectorNode,
+  VCSSSelector,
+  VCSSSelectorPseudo,
+  VCSSDeclarationProperty,
+  VCSSComment,
+} from "../ast";
+import { isNestingAtRule } from "./selectors";
 
 /**
  * Checks whether the given node is VCSSAtRule
  * @param node node to check
  */
 export function isVCSSAtRule(
-    node: VCSSNode | VCSSSelector | VCSSSelectorPseudo | null,
+  node: VCSSNode | VCSSSelector | VCSSSelectorPseudo | null
 ): node is VCSSAtRule {
-    return node?.type === "VCSSAtRule"
+  return node?.type === "VCSSAtRule";
 }
 /**
  * Checks whether the given node is VCSSStyleRule
  * @param node node to check
  */
 export function isVCSSStyleRule(
-    node: VCSSNode | VCSSSelector | VCSSSelectorPseudo | null,
+  node: VCSSNode | VCSSSelector | VCSSSelectorPseudo | null
 ): node is VCSSStyleRule {
-    return node?.type === "VCSSStyleRule"
+  return node?.type === "VCSSStyleRule";
 }
 /**
  * Checks whether the given node is VCSSStyleSheet
  * @param node node to check
  */
 export function isVCSSStyleSheet(
-    node: VCSSNode | null,
+  node: VCSSNode | null
 ): node is VCSSStyleSheet {
-    return node?.type === "VCSSStyleSheet"
+  return node?.type === "VCSSStyleSheet";
 }
 /**
  * Checks whether the given node is VCSSDeclarationProperty
  * @param node node to check
  */
 export function isVCSSDeclarationProperty(
-    node: VCSSNode | null,
+  node: VCSSNode | null
 ): node is VCSSDeclarationProperty {
-    return node?.type === "VCSSDeclarationProperty"
+  return node?.type === "VCSSDeclarationProperty";
 }
 /**
  * Checks whether the given node is VCSSComment
  * @param node node to check
  */
 export function isVCSSComment(node: VCSSNode | null): node is VCSSComment {
-    return node?.type === "VCSSComment" || node?.type === "VCSSInlineComment"
+  return node?.type === "VCSSComment" || node?.type === "VCSSInlineComment";
 }
 /**
  * Checks whether the given node has nodes node
  * @param node node to check
  */
 export function isVCSSContainerNode(
-    node: VCSSNode | null,
+  node: VCSSNode | null
 ): node is VCSSContainerNode {
-    return (
-        isVCSSAtRule(node) ||
-        isVCSSStyleRule(node) ||
-        isVCSSStyleSheet(node) ||
-        node?.type === "VCSSUnknown"
-    )
+  return (
+    isVCSSAtRule(node) ||
+    isVCSSStyleRule(node) ||
+    isVCSSStyleSheet(node) ||
+    node?.type === "VCSSUnknown"
+  );
 }
 
 /**
  * Checks whether the given node has selectors.
  */
 export function hasSelectorNodes(
-    node: VCSSNode | VCSSSelector | VCSSSelectorPseudo,
+  node: VCSSNode | VCSSSelector | VCSSSelectorPseudo
 ): node is
-    | (VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] })
-    | VCSSStyleRule {
-    if (isVCSSStyleRule(node) || isNestingAtRule(node)) {
-        return true
-    }
-    return false
+  | (VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] })
+  | VCSSStyleRule {
+  if (isVCSSStyleRule(node) || isNestingAtRule(node)) {
+    return true;
+  }
+  return false;
 }
diff --git a/lib/styles/utils/index.ts b/lib/styles/utils/index.ts
index 3110d560..64465ef1 100644
--- a/lib/styles/utils/index.ts
+++ b/lib/styles/utils/index.ts
@@ -3,9 +3,9 @@
  * @param lang
  */
 export function isSupportedStyleLang(
-    lang: string,
+  lang: string
 ): lang is "css" | "scss" | "stylus" {
-    return lang === "css" || lang === "scss" || lang === "stylus"
+  return lang === "css" || lang === "scss" || lang === "stylus";
 }
 
 /**
@@ -14,6 +14,6 @@ export function isSupportedStyleLang(
  * @returns {string} The escape string
  */
 export function escapeRegExp(value: string): string {
-    // eslint-disable-next-line regexp/no-obscure-range -- ignore
-    return value.replace(/[$(-+.?[-^{-}]/gu, "\\$&") // $& means the whole matched string
+  // eslint-disable-next-line regexp/no-obscure-range -- ignore
+  return value.replace(/[$(-+.?[-^{-}]/gu, "\\$&"); // $& means the whole matched string
 }
diff --git a/lib/styles/utils/nodes.ts b/lib/styles/utils/nodes.ts
index bccb6844..75c43fcd 100644
--- a/lib/styles/utils/nodes.ts
+++ b/lib/styles/utils/nodes.ts
@@ -1,6 +1,6 @@
-import type { AST, TSAsExpression, RuleContext } from "../../types"
-import eslintUtils from "eslint-utils"
-import type { ScopeManager, Scope } from "eslint-scope"
+import type { AST, TSAsExpression, RuleContext } from "../../types";
+import eslintUtils from "eslint-utils";
+import type { ScopeManager, Scope } from "eslint-scope";
 
 /**
  * Unwrap typescript types like "X as F"
@@ -8,31 +8,31 @@ import type { ScopeManager, Scope } from "eslint-scope"
  * @return {ASTNode}
  */
 export function unwrapTypesExpression<
-    T extends
-        | AST.ESLintExpression
-        | AST.ESLintSuper
-        | AST.ESLintDeclaration
-        | AST.ESLintSpreadElement
-        | TSAsExpression,
+  T extends
+    | AST.ESLintExpression
+    | AST.ESLintSuper
+    | AST.ESLintDeclaration
+    | AST.ESLintSpreadElement
+    | TSAsExpression
 >(node: T): T {
-    return node?.type === "TSAsExpression" ? (node.expression as T) : node
+  return node?.type === "TSAsExpression" ? (node.expression as T) : node;
 }
 
 /**
  * Gets the string from given node
  */
 export function getStringFromNode(
-    node: AST.ESLintExpression,
-    context: RuleContext,
+  node: AST.ESLintExpression,
+  context: RuleContext
 ): string | null {
-    const evaluated = eslintUtils.getStaticValue(
-        node,
-        getScope(context.getSourceCode().scopeManager, node),
-    )
-    if (evaluated && typeof evaluated.value === "string") {
-        return evaluated.value
-    }
-    return null
+  const evaluated = eslintUtils.getStaticValue(
+    node,
+    getScope(context.getSourceCode().scopeManager, node)
+  );
+  if (evaluated && typeof evaluated.value === "string") {
+    return evaluated.value;
+  }
+  return null;
 }
 
 /**
@@ -42,26 +42,26 @@ export function getStringFromNode(
  * @returns {eslint-scope.Scope} The scope information for this node
  */
 function getScope(
-    scopeManager: ScopeManager,
-    currentNode: AST.ESLintNode,
+  scopeManager: ScopeManager,
+  currentNode: AST.ESLintNode
 ): Scope {
-    // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
-    const inner = currentNode.type !== "Program"
+  // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
+  const inner = currentNode.type !== "Program";
 
-    for (
-        let node: AST.ESLintNode | null | undefined = currentNode;
-        node;
-        node = node.parent as AST.ESLintNode
-    ) {
-        const scope = scopeManager.acquire(node as never, inner)
+  for (
+    let node: AST.ESLintNode | null | undefined = currentNode;
+    node;
+    node = node.parent as AST.ESLintNode
+  ) {
+    const scope = scopeManager.acquire(node as never, inner);
 
-        if (scope) {
-            if (scope.type === "function-expression-name") {
-                return scope.childScopes[0]
-            }
-            return scope
-        }
+    if (scope) {
+      if (scope.type === "function-expression-name") {
+        return scope.childScopes[0];
+      }
+      return scope;
     }
+  }
 
-    return scopeManager.scopes[0]
+  return scopeManager.scopes[0];
 }
diff --git a/lib/styles/utils/selectors.ts b/lib/styles/utils/selectors.ts
index bc7c421b..40f83175 100644
--- a/lib/styles/utils/selectors.ts
+++ b/lib/styles/utils/selectors.ts
@@ -1,108 +1,100 @@
 import type {
-    VCSSSelectorNode,
-    VCSSIDSelector,
-    VCSSClassSelector,
-    VCSSUniversalSelector,
-    VCSSNestingSelector,
-    VCSSSelectorCombinator,
-    VCSSAtRule,
-    VCSSNode,
-    VCSSTypeSelector,
-    VCSSSelectorPseudo,
-    VCSSSelectorValueNode,
-} from "../ast"
-import { VCSSSelector } from "../ast"
-import { isVCSSAtRule } from "./css-nodes"
-import type { SourceLocation } from "../../types"
+  VCSSSelectorNode,
+  VCSSIDSelector,
+  VCSSClassSelector,
+  VCSSUniversalSelector,
+  VCSSNestingSelector,
+  VCSSSelectorCombinator,
+  VCSSAtRule,
+  VCSSNode,
+  VCSSTypeSelector,
+  VCSSSelectorPseudo,
+  VCSSSelectorValueNode,
+} from "../ast";
+import { VCSSSelector } from "../ast";
+import { isVCSSAtRule } from "./css-nodes";
+import type { SourceLocation } from "../../types";
 
 /**
  * Checks whether the given node is VCSSTypeSelector
  * @param node node to check
  */
 export function hasNodesSelector(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelector | VCSSSelectorPseudo {
-    return (
-        node != null &&
-        (node.type === "VCSSSelector" || node.type === "VCSSSelectorPseudo")
-    )
+  return (
+    node != null &&
+    (node.type === "VCSSSelector" || node.type === "VCSSSelectorPseudo")
+  );
 }
 
 /**
  * Returns the normalized result of Pseudo params.
  */
 export function normalizePseudoParams(
-    pseudo: VCSSSelectorPseudo,
-    nodes: VCSSSelectorNode[],
+  pseudo: VCSSSelectorPseudo,
+  nodes: VCSSSelectorNode[]
 ): VCSSSelector[] {
-    const results: VCSSSelector[] = []
-    let buffer: VCSSSelectorValueNode[] = []
-    for (const node of nodes) {
-        if (node.type === "VCSSSelector") {
-            if (buffer.length) {
-                const startNode = buffer[0]
-                const endNode = buffer[buffer.length - 1]
-                const loc: SourceLocation = {
-                    start: startNode.loc.start,
-                    end: endNode.loc.end,
-                }
-                results.push(
-                    new VCSSSelector(
-                        buffer[0] as never,
-                        loc,
-                        startNode.start,
-                        endNode.end,
-                        {
-                            parent: pseudo,
-                            nodes: buffer,
-                        },
-                    ),
-                )
-                buffer = []
-            }
-            results.push(node)
-        } else {
-            buffer.push(node)
-        }
-    }
-    if (buffer.length) {
-        const startNode = buffer[0]
-        const endNode = buffer[buffer.length - 1]
+  const results: VCSSSelector[] = [];
+  let buffer: VCSSSelectorValueNode[] = [];
+  for (const node of nodes) {
+    if (node.type === "VCSSSelector") {
+      if (buffer.length) {
+        const startNode = buffer[0];
+        const endNode = buffer[buffer.length - 1];
         const loc: SourceLocation = {
-            start: startNode.loc.start,
-            end: endNode.loc.end,
-        }
+          start: startNode.loc.start,
+          end: endNode.loc.end,
+        };
         results.push(
-            new VCSSSelector(
-                buffer[0] as never,
-                loc,
-                startNode.start,
-                endNode.end,
-                {
-                    parent: pseudo,
-                    nodes: buffer,
-                },
-            ),
-        )
-        buffer = []
+          new VCSSSelector(
+            buffer[0] as never,
+            loc,
+            startNode.start,
+            endNode.end,
+            {
+              parent: pseudo,
+              nodes: buffer,
+            }
+          )
+        );
+        buffer = [];
+      }
+      results.push(node);
+    } else {
+      buffer.push(node);
     }
-    return results
+  }
+  if (buffer.length) {
+    const startNode = buffer[0];
+    const endNode = buffer[buffer.length - 1];
+    const loc: SourceLocation = {
+      start: startNode.loc.start,
+      end: endNode.loc.end,
+    };
+    results.push(
+      new VCSSSelector(buffer[0] as never, loc, startNode.start, endNode.end, {
+        parent: pseudo,
+        nodes: buffer,
+      })
+    );
+    buffer = [];
+  }
+  return results;
 }
 
-export type VDeepPseudo = VCSSSelectorPseudo & { value: "::v-deep" }
-export type VSlottedPseudo = VCSSSelectorPseudo & { value: "::v-slotted" }
-export type VGlobalPseudo = VCSSSelectorPseudo & { value: "::v-global" }
+export type VDeepPseudo = VCSSSelectorPseudo & { value: "::v-deep" };
+export type VSlottedPseudo = VCSSSelectorPseudo & { value: "::v-slotted" };
+export type VGlobalPseudo = VCSSSelectorPseudo & { value: "::v-global" };
 
 /**
  * Checks whether the given node is ::v-deep or ::v-slotted or ::v-global pseudo
  * @param node node to check
  */
 export function isVueSpecialPseudo(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VDeepPseudo | VSlottedPseudo | VGlobalPseudo {
-    return (
-        isVDeepPseudo(node) || isVSlottedPseudo(node) || isVGlobalPseudo(node)
-    )
+  return isVDeepPseudo(node) || isVSlottedPseudo(node) || isVGlobalPseudo(node);
 }
 
 /**
@@ -110,12 +102,12 @@ export function isVueSpecialPseudo(
  * @param node node to check
  */
 export function isVDeepPseudoV2(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VDeepPseudo {
-    if (isVDeepPseudo(node)) {
-        return node.nodes.length === 0
-    }
-    return false
+  if (isVDeepPseudo(node)) {
+    return node.nodes.length === 0;
+  }
+  return false;
 }
 
 /**
@@ -123,39 +115,39 @@ export function isVDeepPseudoV2(
  * @param node node to check
  */
 export function isVDeepPseudo(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VDeepPseudo {
-    if (isPseudo(node)) {
-        const val = node.value.trim()
-        return val === "::v-deep" || val === ":deep"
-    }
-    return false
+  if (isPseudo(node)) {
+    const val = node.value.trim();
+    return val === "::v-deep" || val === ":deep";
+  }
+  return false;
 }
 /**
  * Checks whether the given node is ::v-slotted pseudo
  * @param node node to check
  */
 export function isVSlottedPseudo(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VSlottedPseudo {
-    if (isPseudo(node)) {
-        const val = node.value.trim()
-        return val === "::v-slotted" || val === ":slotted"
-    }
-    return false
+  if (isPseudo(node)) {
+    const val = node.value.trim();
+    return val === "::v-slotted" || val === ":slotted";
+  }
+  return false;
 }
 /**
  * Checks whether the given node is ::v-global pseudo
  * @param node node to check
  */
 export function isVGlobalPseudo(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VGlobalPseudo {
-    if (isPseudo(node)) {
-        const val = node.value.trim()
-        return val === "::v-global" || val === ":global"
-    }
-    return false
+  if (isPseudo(node)) {
+    const val = node.value.trim();
+    return val === "::v-global" || val === ":global";
+  }
+  return false;
 }
 
 /**
@@ -163,10 +155,10 @@ export function isVGlobalPseudo(
  * @param node node to check
  */
 export function isPseudoEmptyArguments(node: VCSSSelectorPseudo): boolean {
-    return (
-        node.nodes.length === 0 ||
-        (node.nodes.length === 1 && node.nodes[0].nodes.length === 0)
-    )
+  return (
+    node.nodes.length === 0 ||
+    (node.nodes.length === 1 && node.nodes[0].nodes.length === 0)
+  );
 }
 
 /**
@@ -174,9 +166,9 @@ export function isPseudoEmptyArguments(node: VCSSSelectorPseudo): boolean {
  * @param node node to check
  */
 export function isTypeSelector(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSTypeSelector {
-    return node?.type === "VCSSTypeSelector"
+  return node?.type === "VCSSTypeSelector";
 }
 
 /**
@@ -184,9 +176,9 @@ export function isTypeSelector(
  * @param node node to check
  */
 export function isIDSelector(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSIDSelector {
-    return node?.type === "VCSSIDSelector"
+  return node?.type === "VCSSIDSelector";
 }
 
 /**
@@ -194,9 +186,9 @@ export function isIDSelector(
  * @param node node to check
  */
 export function isClassSelector(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSClassSelector {
-    return node?.type === "VCSSClassSelector"
+  return node?.type === "VCSSClassSelector";
 }
 
 /**
@@ -204,9 +196,9 @@ export function isClassSelector(
  * @param node node to check
  */
 export function isUniversalSelector(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSUniversalSelector {
-    return node?.type === "VCSSUniversalSelector"
+  return node?.type === "VCSSUniversalSelector";
 }
 
 /**
@@ -214,9 +206,9 @@ export function isUniversalSelector(
  * @param node node to check
  */
 export function isNestingSelector(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSNestingSelector {
-    return node?.type === "VCSSNestingSelector"
+  return node?.type === "VCSSNestingSelector";
 }
 
 /**
@@ -224,9 +216,9 @@ export function isNestingSelector(
  * @param node node to check
  */
 export function isPseudo(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorPseudo {
-    return node?.type === "VCSSSelectorPseudo"
+  return node?.type === "VCSSSelectorPseudo";
 }
 
 /**
@@ -234,9 +226,9 @@ export function isPseudo(
  * @param node node to check
  */
 export function isSelectorCombinator(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorCombinator | VDeepPseudo {
-    return node?.type === "VCSSSelectorCombinator"
+  return node?.type === "VCSSSelectorCombinator";
 }
 
 /**
@@ -244,9 +236,9 @@ export function isSelectorCombinator(
  * @param node node to check
  */
 export function isDescendantCombinator(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorCombinator & { value: " " } {
-    return isSelectorCombinator(node) && node.value.trim() === ""
+  return isSelectorCombinator(node) && node.value.trim() === "";
 }
 
 /**
@@ -254,9 +246,9 @@ export function isDescendantCombinator(
  * @param node node to check
  */
 export function isChildCombinator(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorCombinator & { value: ">" } {
-    return isSelectorCombinator(node) && node.value.trim() === ">"
+  return isSelectorCombinator(node) && node.value.trim() === ">";
 }
 
 /**
@@ -264,9 +256,9 @@ export function isChildCombinator(
  * @param node node to check
  */
 export function isAdjacentSiblingCombinator(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorCombinator & { value: "+" } {
-    return isSelectorCombinator(node) && node.value.trim() === "+"
+  return isSelectorCombinator(node) && node.value.trim() === "+";
 }
 
 /**
@@ -274,9 +266,9 @@ export function isAdjacentSiblingCombinator(
  * @param node node to check
  */
 export function isGeneralSiblingCombinator(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorCombinator & { value: "~" } {
-    return isSelectorCombinator(node) && node.value.trim() === "~"
+  return isSelectorCombinator(node) && node.value.trim() === "~";
 }
 
 /**
@@ -284,13 +276,13 @@ export function isGeneralSiblingCombinator(
  * @param node node to check
  */
 export function isDeepCombinator(
-    node: VCSSSelectorNode | null,
+  node: VCSSSelectorNode | null
 ): node is VCSSSelectorCombinator & { value: ">>>" | "/deep/" } {
-    if (isSelectorCombinator(node)) {
-        const val = node.value.trim()
-        return val === ">>>" || val === "/deep/"
-    }
-    return false
+  if (isSelectorCombinator(node)) {
+    const val = node.value.trim();
+    return val === ">>>" || val === "/deep/";
+  }
+  return false;
 }
 
 /**
@@ -298,49 +290,49 @@ export function isDeepCombinator(
  * @param node node to check
  */
 export function isNestingAtRule(
-    node: VCSSNode | VCSSSelector | VCSSSelectorPseudo | null,
+  node: VCSSNode | VCSSSelector | VCSSSelectorPseudo | null
 ): node is VCSSAtRule & { name: "nest"; selectors: VCSSSelectorNode[] } {
-    if (node == null) {
-        return false
-    }
-    return isVCSSAtRule(node) && node.name === "nest" && node.identifier === "@"
+  if (node == null) {
+    return false;
+  }
+  return isVCSSAtRule(node) && node.name === "nest" && node.identifier === "@";
 }
 
 export type NestingInfo = {
-    node: VCSSNestingSelector
-    nodes: VCSSSelectorNode[]
-    nestingIndex: number
-}
+  node: VCSSNestingSelector;
+  nodes: VCSSSelectorNode[];
+  nestingIndex: number;
+};
 /**
  * Find nesting selectors
  * @param {Node[]} nodes selector nodes
  * @returns {IterableIterator<NestingInfo>} nesting selectors info
  */
 export function* findNestingSelectors(
-    nodes: VCSSSelectorNode[],
+  nodes: VCSSSelectorNode[]
 ): IterableIterator<NestingInfo> {
-    for (const node of nodes) {
-        if (isNestingSelector(node)) {
-            yield {
-                nestingIndex: nodes.indexOf(node as never),
-                node,
-                nodes,
-            }
-        }
-        if (hasNodesSelector(node)) {
-            yield* findNestingSelectors(node.nodes)
-        }
+  for (const node of nodes) {
+    if (isNestingSelector(node)) {
+      yield {
+        nestingIndex: nodes.indexOf(node as never),
+        node,
+        nodes,
+      };
+    }
+    if (hasNodesSelector(node)) {
+      yield* findNestingSelectors(node.nodes);
     }
+  }
 }
 
 /**
  * Find nesting selector
  */
 export function findNestingSelector(
-    nodes: VCSSSelectorNode[],
+  nodes: VCSSSelectorNode[]
 ): NestingInfo | null {
-    for (const nest of findNestingSelectors(nodes)) {
-        return nest
-    }
-    return null
+  for (const nest of findNestingSelectors(nodes)) {
+    return nest;
+  }
+  return null;
 }
diff --git a/lib/types.ts b/lib/types.ts
index 8b680435..03cc5658 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -1,147 +1,150 @@
-import type AST from "vue-eslint-parser/ast"
-import type * as postcss from "postcss"
-import type selectorParser from "postcss-selector-parser"
-import type { ScopeManager } from "eslint-scope"
-import type { Rule } from "eslint"
+import type AST from "vue-eslint-parser/ast";
+import type * as postcss from "postcss";
+import type selectorParser from "postcss-selector-parser";
+import type { ScopeManager } from "eslint-scope";
+import type { Rule } from "eslint";
 
-export { AST }
+export { AST };
 
 // type RuleListener = { [key: string]: (node: never) => void }
 interface RuleListener {
-    [key: string]: ((node: never) => void) | undefined
+  [key: string]: ((node: never) => void) | undefined;
 }
 
 export type Rule = {
-    create(context: RuleContext): RuleListener
-    meta: {
-        docs: {
-            description: string
-            categories: ("recommended" | "vue3-recommended")[]
-            ruleId?: string
-            ruleName?: string
-            default?: string
-            replacedBy?: string[]
-            url: string
-            suggestion?: true
-        }
-        deprecated?: boolean
-        fixable?: "code" | "whitespace" | null
-        hasSuggestions?: boolean
-        schema: unknown[]
-        messages: { [key: string]: string }
-        type: "suggestion" | "problem"
-    }
-}
+  create(context: RuleContext): RuleListener;
+  meta: {
+    docs: {
+      description: string;
+      categories: ("recommended" | "vue3-recommended")[];
+      ruleId?: string;
+      ruleName?: string;
+      default?: string;
+      replacedBy?: string[];
+      url: string;
+      suggestion?: true;
+    };
+    deprecated?: boolean;
+    fixable?: "code" | "whitespace" | null;
+    hasSuggestions?: boolean;
+    schema: unknown[];
+    messages: { [key: string]: string };
+    type: "suggestion" | "problem";
+  };
+};
 
 export interface VDirectiveKeyV5 extends AST.HasLocation, AST.HasParent {
-    type: "VDirectiveKey"
-    name: string
-    argument: string | null
-    modifiers: string[]
-    parent: AST.VDirective
-    shorthand: boolean
-    raw: {
-        name: string
-        argument: string | null
-        modifiers: string[]
-    }
+  type: "VDirectiveKey";
+  name: string;
+  argument: string | null;
+  modifiers: string[];
+  parent: AST.VDirective;
+  shorthand: boolean;
+  raw: {
+    name: string;
+    argument: string | null;
+    modifiers: string[];
+  };
 }
 export interface VDirectiveKeyV6 extends AST.HasLocation, AST.HasParent {
-    type: "VDirectiveKey"
-    parent: AST.VDirective
-    name: AST.VIdentifier
-    argument: AST.VExpressionContainer | AST.VIdentifier | null
-    modifiers: AST.VIdentifier[]
+  type: "VDirectiveKey";
+  parent: AST.VDirective;
+  name: AST.VIdentifier;
+  argument: AST.VExpressionContainer | AST.VIdentifier | null;
+  modifiers: AST.VIdentifier[];
 }
 
-export type VDirectiveKey = VDirectiveKeyV5 | VDirectiveKeyV6
+export type VDirectiveKey = VDirectiveKeyV5 | VDirectiveKeyV6;
 
 export interface TSAsExpression extends AST.HasLocation, AST.HasParent {
-    type: "TSAsExpression"
-    expression: AST.ESLintExpression
+  type: "TSAsExpression";
+  expression: AST.ESLintExpression;
 }
 
-export type ASTNode = AST.Node | AST.ESLintLegacySpreadProperty | TSAsExpression
+export type ASTNode =
+  | AST.Node
+  | AST.ESLintLegacySpreadProperty
+  | TSAsExpression;
 
-export type LineAndColumnData = AST.Location
-export type SourceLocation = AST.LocationRange
-export type Range = [number, number]
+export type LineAndColumnData = AST.Location;
+export type SourceLocation = AST.LocationRange;
+export type Range = [number, number];
 interface ParserServices {
-    /**
-     * Get the token store of the template body.
-     * @returns The token store of template body.
-     */
-    getTemplateBodyTokenStore?: () => TokenStore
-
-    /**
-     * Get the root document fragment.
-     * @returns The root document fragment.
-     */
-    getDocumentFragment?: () => AST.VDocumentFragment | null
+  /**
+   * Get the token store of the template body.
+   * @returns The token store of template body.
+   */
+  getTemplateBodyTokenStore?: () => TokenStore;
+
+  /**
+   * Get the root document fragment.
+   * @returns The root document fragment.
+   */
+  getDocumentFragment?: () => AST.VDocumentFragment | null;
 }
 export interface RuleContext {
-    id: string
-    getSourceCode: () => SourceCode
-    report: (descriptor: ReportDescriptor) => void
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-    options: any[]
-    getFilename: () => string
-    parserServices: ParserServices
+  id: string;
+  getSourceCode: () => SourceCode;
+  report: (descriptor: ReportDescriptor) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+  options: any[];
+  getFilename: () => string;
+  parserServices: ParserServices;
 }
 
 interface Fix {
-    range: Range
-    text: string
+  range: Range;
+  text: string;
 }
 export interface RuleFixer {
-    /* eslint-disable @typescript-eslint/no-explicit-any -- ignore */
-    insertTextAfter(nodeOrToken: any, text: string): Fix
+  /* eslint-disable @typescript-eslint/no-explicit-any -- ignore */
+  insertTextAfter(nodeOrToken: any, text: string): Fix;
 
-    insertTextAfterRange(range: Range, text: string): Fix
+  insertTextAfterRange(range: Range, text: string): Fix;
 
-    insertTextBefore(nodeOrToken: any, text: string): Fix
+  insertTextBefore(nodeOrToken: any, text: string): Fix;
 
-    insertTextBeforeRange(range: Range, text: string): Fix
+  insertTextBeforeRange(range: Range, text: string): Fix;
 
-    remove(nodeOrToken: any): Fix
+  remove(nodeOrToken: any): Fix;
 
-    removeRange(range: Range): Fix
+  removeRange(range: Range): Fix;
 
-    replaceText(nodeOrToken: any, text: string): Fix
+  replaceText(nodeOrToken: any, text: string): Fix;
 
-    replaceTextRange(range: Range, text: string): Fix
+  replaceTextRange(range: Range, text: string): Fix;
 
-    /* eslint-enable @typescript-eslint/no-explicit-any -- ignore */
+  /* eslint-enable @typescript-eslint/no-explicit-any -- ignore */
 }
 
 export type ReportSuggestion = ({ messageId: string } | { desc: string }) & {
-    fix?(fixer: RuleFixer): null | Fix | Fix[] | IterableIterator<Fix>
-}
-export type ReportDescriptorNodeLocation = { node: AST.HasLocation }
+  fix?(fixer: RuleFixer): null | Fix | Fix[] | IterableIterator<Fix>;
+};
+export type ReportDescriptorNodeLocation = { node: AST.HasLocation };
 export type ReportDescriptorSourceLocation = {
-    loc: SourceLocation | { line: number; column: number }
-}
+  loc: SourceLocation | { line: number; column: number };
+};
 
 export type ReportDescriptorLocation =
-    | ReportDescriptorNodeLocation
-    | ReportDescriptorSourceLocation
+  | ReportDescriptorNodeLocation
+  | ReportDescriptorSourceLocation;
 
 export type ReportDescriptor = ReportDescriptorLocation &
-    Rule.ReportDescriptorOptions &
-    Rule.ReportDescriptorMessage & {
-        suggest?: ReportSuggestion[]
-    }
+  Rule.ReportDescriptorOptions &
+  Rule.ReportDescriptorMessage & {
+    suggest?: ReportSuggestion[];
+  };
 
-type FilterPredicate = (tokenOrComment: AST.Token) => boolean
+type FilterPredicate = (tokenOrComment: AST.Token) => boolean;
 
 type CursorWithSkipOptions =
-    | number
-    | FilterPredicate
-    | {
-          includeComments?: boolean
-          filter?: FilterPredicate
-          skip?: number
-      }
+  | number
+  | FilterPredicate
+  | {
+      includeComments?: boolean;
+      filter?: FilterPredicate;
+      skip?: number;
+    };
 
 // type CursorWithCountOptions =
 //     | number
@@ -153,134 +156,134 @@ type CursorWithSkipOptions =
 //       }
 
 export interface SourceCode {
-    text: string
-    ast: AST.ESLintProgram
-    lines: string[]
-    hasBOM: boolean
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-    visitorKeys: any
-    scopeManager: ScopeManager
-    getAllComments: () => AST.Token[]
+  text: string;
+  ast: AST.ESLintProgram;
+  lines: string[];
+  hasBOM: boolean;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+  visitorKeys: any;
+  scopeManager: ScopeManager;
+  getAllComments: () => AST.Token[];
 
-    getText(node?: AST.Node, beforeCount?: number, afterCount?: number): string
+  getText(node?: AST.Node, beforeCount?: number, afterCount?: number): string;
 
-    getLines(): string[]
+  getLines(): string[];
 
-    getNodeByRangeIndex(index: number): AST.ESLintNode | null
+  getNodeByRangeIndex(index: number): AST.ESLintNode | null;
 
-    getLocFromIndex(index: number): LineAndColumnData
+  getLocFromIndex(index: number): LineAndColumnData;
 
-    getIndexFromLoc(location: LineAndColumnData): number
+  getIndexFromLoc(location: LineAndColumnData): number;
 
-    getFirstToken(
-        node: AST.Node,
-        options?: CursorWithSkipOptions,
-    ): AST.Token | null
+  getFirstToken(
+    node: AST.Node,
+    options?: CursorWithSkipOptions
+  ): AST.Token | null;
 }
 export interface TokenStore {
-    getFirstToken(
-        node: AST.Node,
-        options?: CursorWithSkipOptions,
-    ): AST.Token | null
-    getLastToken(
-        node: AST.Node,
-        options?: CursorWithSkipOptions,
-    ): AST.Token | null
-    getTokens(
-        node: AST.Node,
-        beforeCount?: number,
-        afterCount?: number,
-    ): AST.Token[]
-    getTokenBefore(node: AST.Node): AST.Token
-    getTokenAfter(node: AST.Node): AST.Token
+  getFirstToken(
+    node: AST.Node,
+    options?: CursorWithSkipOptions
+  ): AST.Token | null;
+  getLastToken(
+    node: AST.Node,
+    options?: CursorWithSkipOptions
+  ): AST.Token | null;
+  getTokens(
+    node: AST.Node,
+    beforeCount?: number,
+    afterCount?: number
+  ): AST.Token[];
+  getTokenBefore(node: AST.Node): AST.Token;
+  getTokenAfter(node: AST.Node): AST.Token;
 }
 type HasPostCSSSource = {
-    source: postcss.Source
-}
+  source: postcss.Source;
+};
 export type PostCSSNode =
-    | PostCSSRoot
-    | PostCSSAtRule
-    | PostCSSRule
-    | PostCSSDeclaration
-    | PostCSSComment
+  | PostCSSRoot
+  | PostCSSAtRule
+  | PostCSSRule
+  | PostCSSDeclaration
+  | PostCSSComment;
 type PostCSSChildNode = (
-    | PostCSSAtRule
-    | PostCSSRule
-    | PostCSSDeclaration
-    | PostCSSComment
+  | PostCSSAtRule
+  | PostCSSRule
+  | PostCSSDeclaration
+  | PostCSSComment
 ) &
-    postcss.ChildNode
+  postcss.ChildNode;
 export interface PostCSSRoot extends postcss.Root, HasPostCSSSource {
-    nodes: PostCSSChildNode[]
-    source: postcss.Source & {
-        input: postcss.Input & {
-            css: string
-        }
-    }
+  nodes: PostCSSChildNode[];
+  source: postcss.Source & {
+    input: postcss.Input & {
+      css: string;
+    };
+  };
 }
 export interface PostCSSAtRule extends postcss.AtRule, HasPostCSSSource {
-    nodes: PostCSSChildNode[]
-    raws: postcss.AtRule["raws"] & {
-        params?: {
-            raw: string
-        }
-    }
-    source: postcss.Source
+  nodes: PostCSSChildNode[];
+  raws: postcss.AtRule["raws"] & {
+    params?: {
+      raw: string;
+    };
+  };
+  source: postcss.Source;
 }
 export interface PostCSSRule extends postcss.Rule, HasPostCSSSource {
-    nodes: PostCSSChildNode[]
-    raws: postcss.Rule["raws"] & {
-        selector?: {
-            raw: string
-        }
-    }
-    source: postcss.Source
+  nodes: PostCSSChildNode[];
+  raws: postcss.Rule["raws"] & {
+    selector?: {
+      raw: string;
+    };
+  };
+  source: postcss.Source;
 }
-export type PostCSSDeclaration = postcss.Declaration & HasPostCSSSource
+export type PostCSSDeclaration = postcss.Declaration & HasPostCSSSource;
 export interface PostCSSComment extends postcss.Comment, HasPostCSSSource {
-    raws: postcss.Comment["raws"] & {
-        inline?: boolean
-    }
-    source: postcss.Source
+  raws: postcss.Comment["raws"] & {
+    inline?: boolean;
+  };
+  source: postcss.Source;
 }
-export type PostCSSContainer = PostCSSRoot | PostCSSAtRule | PostCSSRule
+export type PostCSSContainer = PostCSSRoot | PostCSSAtRule | PostCSSRule;
 
 export type PostCSSSPNode =
-    | PostCSSSPTypeNode
-    | PostCSSSPIDNode
-    | PostCSSSPClassNameNode
-    | PostCSSSPNestingNode
-    | PostCSSSPUniversalNode
-    | PostCSSSPAttributeNode
-    | PostCSSSPPseudoNode
-    | PostCSSSPCombinatorNode
-    | PostCSSSPCommentNode
-    | PostCSSSPStringNode
-    | PostCSSSPRootNode
-    | PostCSSSPSelector
-export type PostCSSSPTypeNode = selectorParser.Tag
-export type PostCSSSPIDNode = selectorParser.Identifier
-export type PostCSSSPClassNameNode = selectorParser.ClassName
-export type PostCSSSPNestingNode = selectorParser.Nesting
-export type PostCSSSPUniversalNode = selectorParser.Universal
+  | PostCSSSPTypeNode
+  | PostCSSSPIDNode
+  | PostCSSSPClassNameNode
+  | PostCSSSPNestingNode
+  | PostCSSSPUniversalNode
+  | PostCSSSPAttributeNode
+  | PostCSSSPPseudoNode
+  | PostCSSSPCombinatorNode
+  | PostCSSSPCommentNode
+  | PostCSSSPStringNode
+  | PostCSSSPRootNode
+  | PostCSSSPSelector;
+export type PostCSSSPTypeNode = selectorParser.Tag;
+export type PostCSSSPIDNode = selectorParser.Identifier;
+export type PostCSSSPClassNameNode = selectorParser.ClassName;
+export type PostCSSSPNestingNode = selectorParser.Nesting;
+export type PostCSSSPUniversalNode = selectorParser.Universal;
 export interface PostCSSSPAttributeNode extends selectorParser.Attribute {
-    raws: selectorParser.Attribute["raws"] & {
-        insensitiveFlag?: string
-    }
+  raws: selectorParser.Attribute["raws"] & {
+    insensitiveFlag?: string;
+  };
 }
-export type PostCSSSPPseudoNode = selectorParser.Pseudo
-export type PostCSSSPCombinatorNode = selectorParser.Combinator
-export type PostCSSSPCommentNode = selectorParser.Comment
-export type PostCSSSPStringNode = selectorParser.String
-export type PostCSSSPRootNode = selectorParser.Root
-export type PostCSSSPSelector = selectorParser.Selector
+export type PostCSSSPPseudoNode = selectorParser.Pseudo;
+export type PostCSSSPCombinatorNode = selectorParser.Combinator;
+export type PostCSSSPCommentNode = selectorParser.Comment;
+export type PostCSSSPStringNode = selectorParser.String;
+export type PostCSSSPRootNode = selectorParser.Root;
+export type PostCSSSPSelector = selectorParser.Selector;
 
 export type PostCSSSPContainer =
-    | PostCSSSPRootNode
-    | PostCSSSPSelector
-    | PostCSSSPPseudoNode
+  | PostCSSSPRootNode
+  | PostCSSSPSelector
+  | PostCSSSPPseudoNode;
 
 export interface PostCSSLoc {
-    line: number
-    column: number
+  line: number;
+  column: number;
 }
diff --git a/lib/utils/regexp.ts b/lib/utils/regexp.ts
index fad4c44c..a87c6a2e 100644
--- a/lib/utils/regexp.ts
+++ b/lib/utils/regexp.ts
@@ -1,4 +1,4 @@
-const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u
+const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u;
 
 /**
  * Convert a string to the `RegExp`.
@@ -9,16 +9,16 @@ const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u
  * @returns {RegExp} Returns the `RegExp`.
  */
 export function toRegExp(string: string, flags?: string): RegExp {
-    const parts = RE_REGEXP_STR.exec(string)
-    if (parts) {
-        let flagArgs: string
-        if (flags) {
-            flagArgs = [...new Set(parts[2] + flags)].join("")
-        } else {
-            flagArgs = parts[2]
-        }
-
-        return new RegExp(parts[1], flagArgs)
+  const parts = RE_REGEXP_STR.exec(string);
+  if (parts) {
+    let flagArgs: string;
+    if (flags) {
+      flagArgs = [...new Set(parts[2] + flags)].join("");
+    } else {
+      flagArgs = parts[2];
     }
-    return new RegExp(string, flags)
+
+    return new RegExp(parts[1], flagArgs);
+  }
+  return new RegExp(string, flags);
 }
diff --git a/lib/utils/rules.ts b/lib/utils/rules.ts
index ecb8d75a..ed66fbb3 100644
--- a/lib/utils/rules.ts
+++ b/lib/utils/rules.ts
@@ -1,74 +1,74 @@
-import type { Rule } from "../types"
+import type { Rule } from "../types";
 
 const baseRules = [
-    {
-        rule: require("../rules/enforce-style-type"),
-        ruleName: "enforce-style-type",
-        ruleId: "vue-scoped-css/enforce-style-type",
-    },
-    {
-        rule: require("../rules/no-deprecated-deep-combinator"),
-        ruleName: "no-deprecated-deep-combinator",
-        ruleId: "vue-scoped-css/no-deprecated-deep-combinator",
-    },
-    {
-        rule: require("../rules/no-deprecated-v-enter-v-leave-class"),
-        ruleName: "no-deprecated-v-enter-v-leave-class",
-        ruleId: "vue-scoped-css/no-deprecated-v-enter-v-leave-class",
-    },
-    {
-        rule: require("../rules/no-parent-of-v-global"),
-        ruleName: "no-parent-of-v-global",
-        ruleId: "vue-scoped-css/no-parent-of-v-global",
-    },
-    {
-        rule: require("../rules/no-parsing-error"),
-        ruleName: "no-parsing-error",
-        ruleId: "vue-scoped-css/no-parsing-error",
-    },
-    {
-        rule: require("../rules/no-unused-keyframes"),
-        ruleName: "no-unused-keyframes",
-        ruleId: "vue-scoped-css/no-unused-keyframes",
-    },
-    {
-        rule: require("../rules/no-unused-selector"),
-        ruleName: "no-unused-selector",
-        ruleId: "vue-scoped-css/no-unused-selector",
-    },
-    {
-        rule: require("../rules/require-scoped"),
-        ruleName: "require-scoped",
-        ruleId: "vue-scoped-css/require-scoped",
-    },
-    {
-        rule: require("../rules/require-selector-used-inside"),
-        ruleName: "require-selector-used-inside",
-        ruleId: "vue-scoped-css/require-selector-used-inside",
-    },
-    {
-        rule: require("../rules/require-v-deep-argument"),
-        ruleName: "require-v-deep-argument",
-        ruleId: "vue-scoped-css/require-v-deep-argument",
-    },
-    {
-        rule: require("../rules/require-v-global-argument"),
-        ruleName: "require-v-global-argument",
-        ruleId: "vue-scoped-css/require-v-global-argument",
-    },
-    {
-        rule: require("../rules/require-v-slotted-argument"),
-        ruleName: "require-v-slotted-argument",
-        ruleId: "vue-scoped-css/require-v-slotted-argument",
-    },
-]
+  {
+    rule: require("../rules/enforce-style-type"),
+    ruleName: "enforce-style-type",
+    ruleId: "vue-scoped-css/enforce-style-type",
+  },
+  {
+    rule: require("../rules/no-deprecated-deep-combinator"),
+    ruleName: "no-deprecated-deep-combinator",
+    ruleId: "vue-scoped-css/no-deprecated-deep-combinator",
+  },
+  {
+    rule: require("../rules/no-deprecated-v-enter-v-leave-class"),
+    ruleName: "no-deprecated-v-enter-v-leave-class",
+    ruleId: "vue-scoped-css/no-deprecated-v-enter-v-leave-class",
+  },
+  {
+    rule: require("../rules/no-parent-of-v-global"),
+    ruleName: "no-parent-of-v-global",
+    ruleId: "vue-scoped-css/no-parent-of-v-global",
+  },
+  {
+    rule: require("../rules/no-parsing-error"),
+    ruleName: "no-parsing-error",
+    ruleId: "vue-scoped-css/no-parsing-error",
+  },
+  {
+    rule: require("../rules/no-unused-keyframes"),
+    ruleName: "no-unused-keyframes",
+    ruleId: "vue-scoped-css/no-unused-keyframes",
+  },
+  {
+    rule: require("../rules/no-unused-selector"),
+    ruleName: "no-unused-selector",
+    ruleId: "vue-scoped-css/no-unused-selector",
+  },
+  {
+    rule: require("../rules/require-scoped"),
+    ruleName: "require-scoped",
+    ruleId: "vue-scoped-css/require-scoped",
+  },
+  {
+    rule: require("../rules/require-selector-used-inside"),
+    ruleName: "require-selector-used-inside",
+    ruleId: "vue-scoped-css/require-selector-used-inside",
+  },
+  {
+    rule: require("../rules/require-v-deep-argument"),
+    ruleName: "require-v-deep-argument",
+    ruleId: "vue-scoped-css/require-v-deep-argument",
+  },
+  {
+    rule: require("../rules/require-v-global-argument"),
+    ruleName: "require-v-global-argument",
+    ruleId: "vue-scoped-css/require-v-global-argument",
+  },
+  {
+    rule: require("../rules/require-v-slotted-argument"),
+    ruleName: "require-v-slotted-argument",
+    ruleId: "vue-scoped-css/require-v-slotted-argument",
+  },
+];
 
 export const rules = baseRules.map((obj) => {
-    const rule = obj.rule
-    rule.meta.docs.ruleName = obj.ruleName
-    rule.meta.docs.ruleId = obj.ruleId
-    return rule as Rule
-})
+  const rule = obj.rule;
+  rule.meta.docs.ruleName = obj.ruleName;
+  rule.meta.docs.ruleId = obj.ruleId;
+  return rule as Rule;
+});
 
 /**
  * Collect the rules
@@ -76,15 +76,15 @@ export const rules = baseRules.map((obj) => {
  * @returns {Array} rules
  */
 export function collectRules(category?: "recommended" | "vue3-recommended"): {
-    [key: string]: string
+  [key: string]: string;
 } {
-    return rules.reduce((obj, rule) => {
-        if (
-            (!category || rule.meta.docs.categories.includes(category)) &&
-            !rule.meta.deprecated
-        ) {
-            obj[rule.meta.docs.ruleId || ""] = rule.meta.docs.default || "error"
-        }
-        return obj
-    }, {} as { [key: string]: string })
+  return rules.reduce((obj, rule) => {
+    if (
+      (!category || rule.meta.docs.categories.includes(category)) &&
+      !rule.meta.deprecated
+    ) {
+      obj[rule.meta.docs.ruleId || ""] = rule.meta.docs.default || "error";
+    }
+    return obj;
+  }, {} as { [key: string]: string });
 }
diff --git a/lib/utils/templates.ts b/lib/utils/templates.ts
index baf8130c..ef189e5c 100644
--- a/lib/utils/templates.ts
+++ b/lib/utils/templates.ts
@@ -1,33 +1,38 @@
-import type { AST, RuleContext, VDirectiveKey, VDirectiveKeyV6 } from "../types"
+import type {
+  AST,
+  RuleContext,
+  VDirectiveKey,
+  VDirectiveKeyV6,
+} from "../types";
 
 /**
  * Get VElements
  */
 export function getElements(
-    context: RuleContext,
-    predicate: (element: AST.VElement) => boolean,
+  context: RuleContext,
+  predicate: (element: AST.VElement) => boolean
 ): AST.VElement[] {
-    const node = context.getSourceCode().ast
-    const body = node.templateBody
-    if (!body) {
-        return []
-    }
-    return [...iterate(body)]
+  const node = context.getSourceCode().ast;
+  const body = node.templateBody;
+  if (!body) {
+    return [];
+  }
+  return [...iterate(body)];
 
-    /**
-     * Iterate
-     */
-    function* iterate(element: AST.VElement): IterableIterator<AST.VElement> {
-        if (predicate(element)) {
-            yield element
-        }
+  /**
+   * Iterate
+   */
+  function* iterate(element: AST.VElement): IterableIterator<AST.VElement> {
+    if (predicate(element)) {
+      yield element;
+    }
 
-        for (const child of element.children) {
-            if (isVElement(child)) {
-                yield* iterate(child)
-            }
-        }
+    for (const child of element.children) {
+      if (isVElement(child)) {
+        yield* iterate(child);
+      }
     }
+  }
 }
 
 /**
@@ -35,9 +40,9 @@ export function getElements(
  * @param node node to check
  */
 export function isVElement(
-    node: AST.VElement | AST.VText | AST.VExpressionContainer,
+  node: AST.VElement | AST.VText | AST.VExpressionContainer
 ): node is AST.VElement {
-    return node?.type === "VElement"
+  return node?.type === "VElement";
 }
 
 /**
@@ -46,12 +51,12 @@ export function isVElement(
  * @returns {boolean} `true` if the given element is the `<transition>` element.
  */
 export function isTransitionElement(
-    element: AST.VElement | AST.VDocumentFragment,
+  element: AST.VElement | AST.VDocumentFragment
 ): boolean {
-    return (
-        element.type === "VElement" &&
-        (element.name === "transition" || element.rawName === "Transition")
-    )
+  return (
+    element.type === "VElement" &&
+    (element.name === "transition" || element.rawName === "Transition")
+  );
 }
 
 /**
@@ -60,39 +65,37 @@ export function isTransitionElement(
  * @returns {boolean} `true` if the given element is the `<transition-group>` element.
  */
 export function isTransitionGroupElement(
-    element: AST.VElement | AST.VDocumentFragment,
+  element: AST.VElement | AST.VDocumentFragment
 ): boolean {
-    return (
-        element.type === "VElement" &&
-        (element.name === "transition-group" ||
-            element.rawName === "TransitionGroup")
-    )
+  return (
+    element.type === "VElement" &&
+    (element.name === "transition-group" ||
+      element.rawName === "TransitionGroup")
+  );
 }
 
 /**
  * Find attribute from given node
  */
 export function findAttribute(
-    node: AST.VElement | AST.VStartTag,
-    name: string,
+  node: AST.VElement | AST.VStartTag,
+  name: string
 ): AST.VAttribute | AST.VDirective | null {
-    if (node.type === "VElement") {
-        return findAttribute(node.startTag, name)
-    }
-    return (
-        node.attributes.find(
-            (attr): attr is AST.VAttribute | AST.VDirective => {
-                if (isVDirective(attr)) {
-                    if (isVBind(attr.key)) {
-                        return getArgument(attr.key) === name
-                    }
-                } else {
-                    return attr.key.name === name
-                }
-                return false
-            },
-        ) || null
-    )
+  if (node.type === "VElement") {
+    return findAttribute(node.startTag, name);
+  }
+  return (
+    node.attributes.find((attr): attr is AST.VAttribute | AST.VDirective => {
+      if (isVDirective(attr)) {
+        if (isVBind(attr.key)) {
+          return getArgument(attr.key) === name;
+        }
+      } else {
+        return attr.key.name === name;
+      }
+      return false;
+    }) || null
+  );
 }
 
 /**
@@ -100,9 +103,9 @@ export function findAttribute(
  * @param node node to check
  */
 export function isVDirective(
-    node: AST.VAttribute | AST.VDirective,
+  node: AST.VAttribute | AST.VDirective
 ): node is AST.VDirective {
-    return node.type === "VAttribute" && node.directive
+  return node.type === "VAttribute" && node.directive;
 }
 
 /**
@@ -111,19 +114,19 @@ export function isVDirective(
  * @returns {boolean} `true` if the given key is a `v-bind` directive.
  */
 export function isVBind(key: VDirectiveKey): boolean {
-    if (isVDirectiveKeyV6(key)) {
-        if (key.name.name !== "bind") {
-            return false
-        }
-        return true
-    }
-    if (
-        // vue-eslint-parser@<6.0.0
-        key.name !== "bind"
-    ) {
-        return false
+  if (isVDirectiveKeyV6(key)) {
+    if (key.name.name !== "bind") {
+      return false;
     }
-    return true
+    return true;
+  }
+  if (
+    // vue-eslint-parser@<6.0.0
+    key.name !== "bind"
+  ) {
+    return false;
+  }
+  return true;
 }
 
 /**
@@ -132,32 +135,32 @@ export function isVBind(key: VDirectiveKey): boolean {
  * @returns {string|null} the directive argument of the given key. `null` if the directive argument is unknown.
  */
 export function getArgument(key: VDirectiveKey): string | null {
-    if (isVDirectiveKeyV6(key)) {
-        const argument = key.argument
-        if (argument == null) {
-            // `v-bind="..."` can not identify names.
-            return null
-        }
-        if (argument.type === "VExpressionContainer") {
-            // Dynamic arguments can not identify names.
-            return null
-        }
-        if (argument.type === "VIdentifier") {
-            return argument.name
-        }
-        return null
-    }
-    const argument = key.argument
+  if (isVDirectiveKeyV6(key)) {
+    const argument = key.argument;
     if (argument == null) {
-        // `v-bind="..."` can not identify names.
-        return null
+      // `v-bind="..."` can not identify names.
+      return null;
     }
-    // vue-eslint-parser@<6.0.0
-    if (/^\[.*\]$/u.test(argument)) {
-        // Dynamic arguments?
-        return null
+    if (argument.type === "VExpressionContainer") {
+      // Dynamic arguments can not identify names.
+      return null;
+    }
+    if (argument.type === "VIdentifier") {
+      return argument.name;
     }
-    return argument || ""
+    return null;
+  }
+  const argument = key.argument;
+  if (argument == null) {
+    // `v-bind="..."` can not identify names.
+    return null;
+  }
+  // vue-eslint-parser@<6.0.0
+  if (/^\[.*\]$/u.test(argument)) {
+    // Dynamic arguments?
+    return null;
+  }
+  return argument || "";
 }
 
 /**
@@ -165,7 +168,7 @@ export function getArgument(key: VDirectiveKey): string | null {
  * @param node node to check
  */
 export function isVDirectiveKeyV6(
-    node: VDirectiveKey,
+  node: VDirectiveKey
 ): node is VDirectiveKeyV6 {
-    return typeof node.name !== "string"
+  return typeof node.name !== "string";
 }
diff --git a/lib/utils/utils.ts b/lib/utils/utils.ts
index f51d435c..a5dd7333 100644
--- a/lib/utils/utils.ts
+++ b/lib/utils/utils.ts
@@ -1,17 +1,17 @@
-import type { RuleContext } from "../types"
+import type { RuleContext } from "../types";
 
 /**
  * Checks whether the given context has template block
  */
 export function hasTemplateBlock(context: RuleContext): boolean {
-    const sourceCode = context.getSourceCode()
-    const { ast } = sourceCode
-    return Boolean(ast.templateBody)
+  const sourceCode = context.getSourceCode();
+  const { ast } = sourceCode;
+  return Boolean(ast.templateBody);
 }
 
 /**
  * Checks whether the given node has defined
  */
 export function isDefined<T>(item: T | null | undefined): item is T {
-    return item !== null && item !== undefined
+  return item !== null && item !== undefined;
 }
diff --git a/package-lock.json b/package-lock.json
index 67766cce..0592b165 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1468,9 +1468,9 @@
             }
         },
         "@ota-meshi/eslint-plugin": {
-            "version": "0.11.1",
-            "resolved": "https://registry.npmjs.org/@ota-meshi/eslint-plugin/-/eslint-plugin-0.11.1.tgz",
-            "integrity": "sha512-VKfIaz089KeXLhVRjfNJotXra9yc/gwwr/l1gOu6dcXGHYsv5eEv0uNzmxvCvtfP5Kf2qYFYMBHCgmSjKdPSVg==",
+            "version": "0.12.0",
+            "resolved": "https://registry.npmjs.org/@ota-meshi/eslint-plugin/-/eslint-plugin-0.12.0.tgz",
+            "integrity": "sha512-OAoyqxJWhyjdpRwrqUCvnYCrXN4A1VmjKvadh8edIBJnK8ad6QIHgFK2CDCmv7u84lSKXMDFRKVtjk+UYNFjIg==",
             "dev": true,
             "requires": {
                 "semver": "^7.3.4"
diff --git a/package.json b/package.json
index 4c176079..fed31a04 100644
--- a/package.json
+++ b/package.json
@@ -47,7 +47,7 @@
     "dist"
   ],
   "devDependencies": {
-    "@ota-meshi/eslint-plugin": "^0.11.0",
+    "@ota-meshi/eslint-plugin": "^0.12.0",
     "@types/eslint": "^8.0.0",
     "@types/eslint-visitor-keys": "^1.0.0",
     "@types/estree": "^1.0.0",
diff --git a/tests/lib/comment-directives.ts b/tests/lib/comment-directives.ts
index b92eca97..71624f17 100644
--- a/tests/lib/comment-directives.ts
+++ b/tests/lib/comment-directives.ts
@@ -1,20 +1,20 @@
-import { RuleTester } from "eslint"
-import rule = require("../../lib/rules/no-unused-selector")
+import { RuleTester } from "eslint";
+import rule = require("../../lib/rules/no-unused-selector");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-unused-selector-comment-directives", rule as any, {
-    valid: [],
-    invalid: [
-        // comment directives
-        {
-            code: `
+  valid: [],
+  invalid: [
+    // comment directives
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -30,10 +30,10 @@ tester.run("no-unused-selector-comment-directives", rule as any, {
             }
             </style>
             `,
-            errors: [{ messageId: "unused", data: { selector: ".foo" } }],
-        },
-        {
-            code: `
+      errors: [{ messageId: "unused", data: { selector: ".foo" } }],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -49,10 +49,10 @@ tester.run("no-unused-selector-comment-directives", rule as any, {
             }
             </style>
             `,
-            errors: [{ messageId: "unused", data: { selector: ".foo" } }],
-        },
-        {
-            code: `
+      errors: [{ messageId: "unused", data: { selector: ".foo" } }],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -68,14 +68,14 @@ tester.run("no-unused-selector-comment-directives", rule as any, {
             }
             </style>
             `,
-            errors: [
-                { messageId: "unused", data: { selector: "div>li.bar" } },
-                { messageId: "unused", data: { selector: ".foo" } },
-                { messageId: "unused", data: { selector: "li.foo" } },
-            ],
-        },
-        {
-            code: `
+      errors: [
+        { messageId: "unused", data: { selector: "div>li.bar" } },
+        { messageId: "unused", data: { selector: ".foo" } },
+        { messageId: "unused", data: { selector: "li.foo" } },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -91,10 +91,10 @@ tester.run("no-unused-selector-comment-directives", rule as any, {
             }
             </style>
             `,
-            errors: [{ messageId: "unused", data: { selector: "li.foo" } }],
-        },
-        {
-            code: `
+      errors: [{ messageId: "unused", data: { selector: "li.foo" } }],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -110,10 +110,10 @@ tester.run("no-unused-selector-comment-directives", rule as any, {
             }
             </style>
             `,
-            errors: [{ messageId: "unused", data: { selector: "li.foo" } }],
-        },
-        {
-            code: `
+      errors: [{ messageId: "unused", data: { selector: "li.foo" } }],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -129,11 +129,11 @@ tester.run("no-unused-selector-comment-directives", rule as any, {
             }
             </style>
             `,
-            errors: [
-                { messageId: "unused", data: { selector: "div>li.bar" } },
-                { messageId: "unused", data: { selector: ".foo" } },
-                { messageId: "unused", data: { selector: "li.foo" } },
-            ],
-        },
-    ],
-})
+      errors: [
+        { messageId: "unused", data: { selector: "div>li.bar" } },
+        { messageId: "unused", data: { selector: ".foo" } },
+        { messageId: "unused", data: { selector: "li.foo" } },
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules-without-vue-eslint-parser.ts b/tests/lib/rules-without-vue-eslint-parser.ts
index 9aa3ea74..b74392a8 100644
--- a/tests/lib/rules-without-vue-eslint-parser.ts
+++ b/tests/lib/rules-without-vue-eslint-parser.ts
@@ -1,27 +1,27 @@
-import { Linter } from "eslint"
-import plugin = require("../../lib/index")
+import { Linter } from "eslint";
+import plugin = require("../../lib/index");
 
 describe("Don't crash even if without vue-eslint-parser.", () => {
-    const code = "<style scoped>.a {}</style>"
+  const code = "<style scoped>.a {}</style>";
 
-    for (const key of Object.keys(plugin.rules)) {
-        const ruleId = `vue-scoped-css/${key}`
+  for (const key of Object.keys(plugin.rules)) {
+    const ruleId = `vue-scoped-css/${key}`;
 
-        it(ruleId, () => {
-            const linter = new Linter()
-            const config = {
-                parserOptions: {
-                    ecmaVersion: 2015,
-                    ecmaFeatures: {
-                        jsx: true,
-                    },
-                },
-                rules: {
-                    [ruleId]: "error",
-                },
-            }
-            linter.defineRule(ruleId, plugin.rules[key] as any)
-            linter.verifyAndFix(code, config as any, "test.vue")
-        })
-    }
-})
+    it(ruleId, () => {
+      const linter = new Linter();
+      const config = {
+        parserOptions: {
+          ecmaVersion: 2015,
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+        rules: {
+          [ruleId]: "error",
+        },
+      };
+      linter.defineRule(ruleId, plugin.rules[key] as any);
+      linter.verifyAndFix(code, config as any, "test.vue");
+    });
+  }
+});
diff --git a/tests/lib/rules/enforce-style-type.ts b/tests/lib/rules/enforce-style-type.ts
index 7514a99b..1152d648 100644
--- a/tests/lib/rules/enforce-style-type.ts
+++ b/tests/lib/rules/enforce-style-type.ts
@@ -1,537 +1,537 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/enforce-style-type")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/enforce-style-type");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("enforce-style-type", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template>
         </template>
         `,
-        `
+    `
         <template>
         </template>
         <style scoped>
         </style>
         `,
-        {
-            code: `
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: [{}],
-        },
-        {
-            code: `
+      options: [{}],
+    },
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain"],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          allows: ["plain"],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: [
-                {
-                    allows: ["scoped"],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          allows: ["scoped"],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style module>
             </style>
             `,
-            options: [
-                {
-                    allows: ["module"],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          allows: ["module"],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style module="$s">
             </style>
             `,
-            options: [
-                {
-                    allows: ["module"],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          allows: ["module"],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain", "scoped", "module"],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          allows: ["plain", "scoped", "module"],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain", "scoped", "module"],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          allows: ["plain", "scoped", "module"],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style module>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain", "scoped", "module"],
-                },
-            ],
-        },
-    ],
-    invalid: [
+      options: [
         {
-            code: `
+          allows: ["plain", "scoped", "module"],
+        },
+      ],
+    },
+  ],
+  invalid: [
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: [{}],
-            errors: [
-                {
-                    messageId: "forbiddenPlain",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 20,
-                    suggestions: [
-                        {
-                            desc: "Add attribute `scoped`.",
-                            output: `
+      options: [{}],
+      errors: [
+        {
+          messageId: "forbiddenPlain",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 20,
+          suggestions: [
+            {
+              desc: "Add attribute `scoped`.",
+              output: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: [
-                {
-                    allows: ["scoped"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenPlain",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 20,
-                    suggestions: [
-                        {
-                            desc: "Add attribute `scoped`.",
-                            output: `
+      options: [
+        {
+          allows: ["scoped"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenPlain",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 20,
+          suggestions: [
+            {
+              desc: "Add attribute `scoped`.",
+              output: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style module>
             </style>
             `,
-            options: [
-                {
-                    allows: ["scoped"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenStyle",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            messageId: "change",
-                            output: `
+      options: [
+        {
+          allows: ["scoped"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenStyle",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              messageId: "change",
+              output: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: [
-                {
-                    allows: ["module"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenPlain",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 20,
-                    suggestions: [
-                        {
-                            desc: "Add attribute `module`.",
-                            output: `
+      options: [
+        {
+          allows: ["module"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenPlain",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 20,
+          suggestions: [
+            {
+              desc: "Add attribute `module`.",
+              output: `
             <template>
             </template>
             <style module>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: [
-                {
-                    allows: ["module"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenStyle",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            desc: "Change `scoped` to `module` attribute.",
-                            output: `
+      options: [
+        {
+          allows: ["module"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenStyle",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              desc: "Change `scoped` to `module` attribute.",
+              output: `
             <template>
             </template>
             <style module>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenStyle",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            desc: "Remove attribute `scoped`.",
-                            output: `
+      options: [
+        {
+          allows: ["plain"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenStyle",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              desc: "Remove attribute `scoped`.",
+              output: `
             <template>
             </template>
             <style>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style module>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenStyle",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            desc: "Remove attribute `module`.",
-                            output: `
+      options: [
+        {
+          allows: ["plain"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenStyle",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              desc: "Remove attribute `module`.",
+              output: `
             <template>
             </template>
             <style>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: [
-                {
-                    allows: ["scoped", "module"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenPlain",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 20,
-                    suggestions: [],
-                },
-            ],
+      options: [
+        {
+          allows: ["scoped", "module"],
         },
+      ],
+      errors: [
         {
-            code: `
+          messageId: "forbiddenPlain",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 20,
+          suggestions: [],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style module>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain", "scoped"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenStyle",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            desc: "Remove attribute `module`.",
-                            output: `
+      options: [
+        {
+          allows: ["plain", "scoped"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenStyle",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              desc: "Remove attribute `module`.",
+              output: `
             <template>
             </template>
             <style>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain", "module"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenStyle",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            desc: "Remove attribute `scoped`.",
-                            output: `
+      options: [
+        {
+          allows: ["plain", "module"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenStyle",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              desc: "Remove attribute `scoped`.",
+              output: `
             <template>
             </template>
             <style>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped module>
             </style>
             `,
-            errors: [
-                {
-                    messageId: "forbiddenScopedModule",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 34,
-                    suggestions: [
-                        {
-                            desc: "Remove attribute `module`.",
-                            output: `
+      errors: [
+        {
+          messageId: "forbiddenScopedModule",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 34,
+          suggestions: [
+            {
+              desc: "Remove attribute `module`.",
+              output: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped module>
             </style>
             `,
-            options: [
-                {
-                    allows: ["module"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenScopedModule",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 34,
-                    suggestions: [
-                        {
-                            desc: "Remove attribute `scoped`.",
-                            output: `
+      options: [
+        {
+          allows: ["module"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenScopedModule",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 34,
+          suggestions: [
+            {
+              desc: "Remove attribute `scoped`.",
+              output: `
             <template>
             </template>
             <style module>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style scoped module random-attr>
             </style>
             `,
-            options: [
-                {
-                    allows: ["plain"],
-                },
-            ],
-            errors: [
-                {
-                    messageId: "forbiddenScopedModule",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 46,
-                    suggestions: [
-                        {
-                            desc: "Remove attributes `scoped`, `module`.",
-                            output: `
+      options: [
+        {
+          allows: ["plain"],
+        },
+      ],
+      errors: [
+        {
+          messageId: "forbiddenScopedModule",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 46,
+          suggestions: [
+            {
+              desc: "Remove attributes `scoped`, `module`.",
+              output: `
             <template>
             </template>
             <style random-attr>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-    ],
-})
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/no-deprecated-deep-combinator.ts b/tests/lib/rules/no-deprecated-deep-combinator.ts
index e9319aa3..fd681d15 100644
--- a/tests/lib/rules/no-deprecated-deep-combinator.ts
+++ b/tests/lib/rules/no-deprecated-deep-combinator.ts
@@ -1,17 +1,17 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/no-deprecated-deep-combinator")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/no-deprecated-deep-combinator");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-deprecated-deep-combinator", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><div class="item">sample</div></template>
         <style scoped>
         a > .b {}
@@ -20,60 +20,60 @@ tester.run("no-deprecated-deep-combinator", rule as any, {
         a :deep(.b) {}
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><div class="item">sample</div></template>
             <style scoped>
             a >>> .b {}
             a /deep/ .b {}
             </style>
             `,
-            output: `
+      output: `
             <template><div class="item">sample</div></template>
             <style scoped>
             a ::v-deep .b {}
             a ::v-deep .b {}
             </style>
             `,
-            errors: [
-                {
-                    message: "The deep combinator `>>>` is deprecated.",
-                    line: 4,
-                    column: 15,
-                    endLine: 4,
-                    endColumn: 18,
-                },
-                {
-                    message: "The deep combinator `/deep/` is deprecated.",
-                    line: 5,
-                    column: 15,
-                    endLine: 5,
-                    endColumn: 21,
-                },
-            ],
+      errors: [
+        {
+          message: "The deep combinator `>>>` is deprecated.",
+          line: 4,
+          column: 15,
+          endLine: 4,
+          endColumn: 18,
         },
-
         {
-            code: `
+          message: "The deep combinator `/deep/` is deprecated.",
+          line: 5,
+          column: 15,
+          endLine: 5,
+          endColumn: 21,
+        },
+      ],
+    },
+
+    {
+      code: `
             <template><div class="item">sample</div></template>
             <style scoped>
             a>>>.b {}
             a/deep/.b {}
             </style>
             `,
-            output: `
+      output: `
             <template><div class="item">sample</div></template>
             <style scoped>
             a ::v-deep .b {}
             a ::v-deep .b {}
             </style>
             `,
-            errors: [
-                "The deep combinator `>>>` is deprecated.",
-                "The deep combinator `/deep/` is deprecated.",
-            ],
-        },
-    ],
-})
+      errors: [
+        "The deep combinator `>>>` is deprecated.",
+        "The deep combinator `/deep/` is deprecated.",
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/no-deprecated-v-enter-v-leave-class.ts b/tests/lib/rules/no-deprecated-v-enter-v-leave-class.ts
index 62f3c152..0aec5ccd 100644
--- a/tests/lib/rules/no-deprecated-v-enter-v-leave-class.ts
+++ b/tests/lib/rules/no-deprecated-v-enter-v-leave-class.ts
@@ -1,17 +1,17 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/no-deprecated-v-enter-v-leave-class")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/no-deprecated-v-enter-v-leave-class");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template>
             <Transition><div v-if="foo"/></Transition>
         </template>
@@ -20,7 +20,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .v-leave-from {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition><div v-if="foo"/></Transition>
         </template>
@@ -29,7 +29,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .v-leave, .v-leave-from {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition
               enter-from-class="foo"
@@ -42,7 +42,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition
               enter-from-class="foo"
@@ -57,7 +57,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition name="xx"><div v-if="foo"/></Transition>
         </template>
@@ -66,7 +66,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .xx-leave, .xx-leave-from {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition><div v-if="foo"/></Transition>
             <Transition name="xx"><div v-if="foo"/></Transition>
@@ -78,7 +78,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .foo ::v-deep(.xx-leave) { .v-enter {} }
         </style>
         `,
-        `
+    `
         <template>
             <Transition><div v-if="foo"/></Transition>
         </template>
@@ -89,7 +89,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template>
             <Transition :name="name"><div v-if="foo"/></Transition>
         </template>
@@ -103,7 +103,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .xx-leave {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition :name="name"><div v-if="foo"/></Transition>
         </template>
@@ -119,7 +119,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .xx-leave {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition><div v-if="foo"/></Transition>
         </template>
@@ -130,7 +130,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template>
             <Transition><div v-if="foo"/></Transition>
         </template>
@@ -139,7 +139,7 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .v-leave {}
         </style>
         `,
-        `
+    `
         <template>
             <Transition :name="name"><div v-if="foo"/></Transition>
         </template>
@@ -155,10 +155,10 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
         .xx-leave {}
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template>
                 <Transition><div v-if="foo"/></Transition>
             </template>
@@ -167,21 +167,21 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             .v-leave {}
             </style>
             `,
-            errors: [
-                {
-                    message: "The `v-enter` class is renamed in Vue 3.",
-                    line: 6,
-                    column: 13,
-                },
-                {
-                    message: "The `v-leave` class is renamed in Vue 3.",
-                    line: 7,
-                    column: 13,
-                },
-            ],
+      errors: [
+        {
+          message: "The `v-enter` class is renamed in Vue 3.",
+          line: 6,
+          column: 13,
         },
         {
-            code: `
+          message: "The `v-leave` class is renamed in Vue 3.",
+          line: 7,
+          column: 13,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <Transition
                   enter-class="foo"
@@ -194,23 +194,23 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             .bar {}
             </style>
             `,
-            errors: [
-                {
-                    message:
-                        "The `enter-class` prop is renamed in Vue 3. Rename to `enter-from-class`.",
-                    line: 4,
-                    column: 19,
-                },
-                {
-                    message:
-                        "The `leave-class` prop is renamed in Vue 3. Rename to `leave-from-class`.",
-                    line: 5,
-                    column: 19,
-                },
-            ],
+      errors: [
+        {
+          message:
+            "The `enter-class` prop is renamed in Vue 3. Rename to `enter-from-class`.",
+          line: 4,
+          column: 19,
         },
         {
-            code: `
+          message:
+            "The `leave-class` prop is renamed in Vue 3. Rename to `leave-from-class`.",
+          line: 5,
+          column: 19,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <Transition name="xx"><div v-if="foo"/></Transition>
             </template>
@@ -219,13 +219,13 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             .xx-leave {}
             </style>
             `,
-            errors: [
-                "The `v-enter` class is renamed in Vue 3.",
-                "The `v-leave` class is renamed in Vue 3.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The `v-enter` class is renamed in Vue 3.",
+        "The `v-leave` class is renamed in Vue 3.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <Transition><div v-if="foo"/></Transition>
             </template>
@@ -236,13 +236,13 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             }
             </style>
             `,
-            errors: [
-                "The `v-enter` class is renamed in Vue 3.",
-                "The `v-leave` class is renamed in Vue 3.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The `v-enter` class is renamed in Vue 3.",
+        "The `v-leave` class is renamed in Vue 3.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <Transition><div v-if="foo"/></Transition>
             </template>
@@ -253,13 +253,13 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             }
             </style>
             `,
-            errors: [
-                "The `v-enter` class is renamed in Vue 3.",
-                "The `v-leave` class is renamed in Vue 3.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The `v-enter` class is renamed in Vue 3.",
+        "The `v-leave` class is renamed in Vue 3.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <Transition :name="name"><div v-if="foo"/></Transition>
             </template>
@@ -275,13 +275,13 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             .xx-leave {}
             </style>
             `,
-            errors: [
-                "The `v-enter` class is renamed in Vue 3.",
-                "The `v-leave` class is renamed in Vue 3.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The `v-enter` class is renamed in Vue 3.",
+        "The `v-leave` class is renamed in Vue 3.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <Transition :name="name"><div v-if="foo"/></Transition>
             </template>
@@ -297,10 +297,10 @@ tester.run("no-deprecated-v-enter-v-leave-class", rule as any, {
             .xx-leave {}
             </style>
             `,
-            errors: [
-                "The `v-enter` class is renamed in Vue 3.",
-                "The `v-leave` class is renamed in Vue 3.",
-            ],
-        },
-    ],
-})
+      errors: [
+        "The `v-enter` class is renamed in Vue 3.",
+        "The `v-leave` class is renamed in Vue 3.",
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/no-parent-of-v-global.ts b/tests/lib/rules/no-parent-of-v-global.ts
index cf51b25f..a5cfcb45 100644
--- a/tests/lib/rules/no-parent-of-v-global.ts
+++ b/tests/lib/rules/no-parent-of-v-global.ts
@@ -1,40 +1,40 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/no-parent-of-v-global")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/no-parent-of-v-global");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-parent-of-v-global", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><div class="item">sample</div></template>
         <style scoped>
         ::v-global(.foo) {}
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><div class="item">sample</div></template>
             <style scoped>
             .bar ::v-global(.foo) {}
             </style>
             `,
-            errors: [
-                {
-                    message:
-                        "The parent selector of the `::v-global()` pseudo-element is useless.",
-                    line: 4,
-                    column: 18,
-                    endColumn: 34,
-                },
-            ],
+      errors: [
+        {
+          message:
+            "The parent selector of the `::v-global()` pseudo-element is useless.",
+          line: 4,
+          column: 18,
+          endColumn: 34,
         },
-    ],
-})
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/no-parsing-error.ts b/tests/lib/rules/no-parsing-error.ts
index 32ca30b3..01764f3d 100644
--- a/tests/lib/rules/no-parsing-error.ts
+++ b/tests/lib/rules/no-parsing-error.ts
@@ -1,78 +1,78 @@
-import { RuleTester } from "eslint"
-import semver from "semver"
-import rule = require("../../../lib/rules/no-parsing-error")
-const parserVersion = require("vue-eslint-parser/package.json").version
+import { RuleTester } from "eslint";
+import semver from "semver";
+import rule = require("../../../lib/rules/no-parsing-error");
+const parserVersion = require("vue-eslint-parser/package.json").version;
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-parsing-error", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped>
         .item {}
         </style>
         `,
-        `
+    `
         <template></template>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped/>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
             <style scoped>
             .item {
             </style>
             `,
-            errors: [
-                {
-                    message: "Parsing error: Unclosed block.",
-                    line: 4,
-                    column: 13,
-                },
-            ],
+      errors: [
+        {
+          message: "Parsing error: Unclosed block.",
+          line: 4,
+          column: 13,
         },
-        ...(semver.satisfies(parserVersion, ">=7.0.0")
-            ? [
-                  {
-                      code: `
+      ],
+    },
+    ...(semver.satisfies(parserVersion, ">=7.0.0")
+      ? [
+          {
+            code: `
             <style scoped>
             .item {
             `,
-                      errors: [
-                          {
-                              message: "Parsing error: Missing end tag.",
-                              line: 2,
-                              column: 27,
-                          },
-                      ],
-                  },
-                  {
-                      code: `
+            errors: [
+              {
+                message: "Parsing error: Missing end tag.",
+                line: 2,
+                column: 27,
+              },
+            ],
+          },
+          {
+            code: `
             <style scoped>
             .item {
             </style>
             <doc></doc  `,
-                      errors: [
-                          {
-                              message: "Parsing error: eof-in-tag.",
-                              line: 5,
-                              column: 25,
-                          },
-                      ],
-                  },
-              ]
-            : []),
-    ],
-})
+            errors: [
+              {
+                message: "Parsing error: eof-in-tag.",
+                line: 5,
+                column: 25,
+              },
+            ],
+          },
+        ]
+      : []),
+  ],
+});
diff --git a/tests/lib/rules/no-unused-keyframes.ts b/tests/lib/rules/no-unused-keyframes.ts
index 8129085b..d1b74e55 100644
--- a/tests/lib/rules/no-unused-keyframes.ts
+++ b/tests/lib/rules/no-unused-keyframes.ts
@@ -1,17 +1,17 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/no-unused-keyframes")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/no-unused-keyframes");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-unused-keyframes", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped>
         .item {
@@ -21,7 +21,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped>
         .item {
@@ -31,7 +31,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped lang="scss">
         .item {
@@ -50,7 +50,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped lang="stylus">
         .item
@@ -69,7 +69,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped lang="scss">
         .item {
@@ -79,7 +79,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped lang="stylus">
         .item
@@ -88,7 +88,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped lang="stylus">
         .item
@@ -97,7 +97,7 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
         <style scoped lang="scss">
         .item {
@@ -109,10 +109,10 @@ tester.run("no-unused-keyframes", rule as any, {
         }
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
             <style scoped>
             .item {
@@ -122,19 +122,19 @@ tester.run("no-unused-keyframes", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { params: "unused" },
-                    line: 7,
-                    column: 24,
-                    endLine: 7,
-                    endColumn: 30,
-                },
-            ],
-        },
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { params: "unused" },
+          line: 7,
+          column: 24,
+          endLine: 7,
+          endColumn: 30,
+        },
+      ],
+    },
+    {
+      code: `
             <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
             <style scoped lang="scss">
             .item {
@@ -144,19 +144,19 @@ tester.run("no-unused-keyframes", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { params: "fadein" },
-                    line: 7,
-                    column: 24,
-                    endLine: 7,
-                    endColumn: 30,
-                },
-            ],
-        },
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { params: "fadein" },
+          line: 7,
+          column: 24,
+          endLine: 7,
+          endColumn: 30,
+        },
+      ],
+    },
+    {
+      code: `
             <template><!-- When using vue-eslint-parser@5, a template tag is required.  --></template>
             <style scoped lang="stylus">
             .item
@@ -166,16 +166,16 @@ tester.run("no-unused-keyframes", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { params: "fadein" },
-                    line: 7,
-                    column: 24,
-                    endLine: 7,
-                    endColumn: 30,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { params: "fadein" },
+          line: 7,
+          column: 24,
+          endLine: 7,
+          endColumn: 30,
         },
-    ],
-})
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/no-unused-selector.ts b/tests/lib/rules/no-unused-selector.ts
index b423e32a..c6aaca32 100644
--- a/tests/lib/rules/no-unused-selector.ts
+++ b/tests/lib/rules/no-unused-selector.ts
@@ -1,17 +1,17 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/no-unused-selector")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/no-unused-selector");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("no-unused-selector", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -20,7 +20,7 @@ tester.run("no-unused-selector", rule as any, {
         div {color:red;}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -29,7 +29,7 @@ tester.run("no-unused-selector", rule as any, {
         div {color:red;}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -40,7 +40,7 @@ tester.run("no-unused-selector", rule as any, {
           color red
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -48,7 +48,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo, div {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"><div id="bar"></div></div></div>
         </template>
@@ -56,7 +56,7 @@ tester.run("no-unused-selector", rule as any, {
         div.foo /* comment */ #bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div>
                 <li class="foo"/>
@@ -66,8 +66,8 @@ tester.run("no-unused-selector", rule as any, {
         div > .foo {}
         </style>
         `,
-        // nesting
-        `
+    // nesting
+    `
         <template>
             <div>
                 <div>
@@ -79,7 +79,7 @@ tester.run("no-unused-selector", rule as any, {
         div { & > .foo {} }
         </style>
         `,
-        `
+    `
         <template>
             <div class="foo">
                 <ul>
@@ -91,8 +91,8 @@ tester.run("no-unused-selector", rule as any, {
         .foo { @nest .bar&-baz {} }
         </style>
         `,
-        // expressions
-        `
+    // expressions
+    `
         <template>
             <div><div :class="'foo bar'"/></div>
         </template>
@@ -100,7 +100,7 @@ tester.run("no-unused-selector", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="['foo bar']"/></div>
         </template>
@@ -108,7 +108,7 @@ tester.run("no-unused-selector", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="['foo', 'bar']"/></div>
         </template>
@@ -116,7 +116,7 @@ tester.run("no-unused-selector", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="{foo, bar: b}"/></div>
         </template>
@@ -124,7 +124,7 @@ tester.run("no-unused-selector", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="{'foo': f, 'bar': b}"/></div>
         </template>
@@ -132,9 +132,9 @@ tester.run("no-unused-selector", rule as any, {
         .bar {}
         </style>
         `,
-        // identifier
-        // data
-        `
+    // identifier
+    // data
+    `
         <template>
             <div><div :class="classes"/></div>
         </template>
@@ -151,7 +151,7 @@ tester.run("no-unused-selector", rule as any, {
         }
         </script>
         `,
-        `
+    `
         <template>
             <div><div :class="classes"/></div>
         </template>
@@ -168,7 +168,7 @@ tester.run("no-unused-selector", rule as any, {
         })
         </script>
         `,
-        `
+    `
         <template>
             <div><div :class="classes"/></div>
         </template>
@@ -185,8 +185,8 @@ tester.run("no-unused-selector", rule as any, {
         })
         </script>
         `,
-        // computed
-        `
+    // computed
+    `
         <template>
             <div><div :class="classes"/></div>
         </template>
@@ -203,9 +203,9 @@ tester.run("no-unused-selector", rule as any, {
         }
         </script>
         `,
-        // unknown
-        // complex script
-        `
+    // unknown
+    // complex script
+    `
         <template>
             <div><div :class="data.classes"/></div>
         </template>
@@ -213,8 +213,8 @@ tester.run("no-unused-selector", rule as any, {
         .foo {}
         </style>
         `,
-        // complex selector
-        `
+    // complex selector
+    `
         <template>
             <div><div class="b"/></div>
         </template>
@@ -222,8 +222,8 @@ tester.run("no-unused-selector", rule as any, {
         :not(.a) {}
         </style>
         `,
-        // The root element is considered to match if it matches at least one Class Selector.
-        `
+    // The root element is considered to match if it matches at least one Class Selector.
+    `
         <template>
             <div class="foo"/>
         </template>
@@ -231,8 +231,8 @@ tester.run("no-unused-selector", rule as any, {
         .foo.bar {}
         </style>
         `,
-        // apply parent classes
-        `
+    // apply parent classes
+    `
         <template>
             <div/>
         </template>
@@ -240,8 +240,8 @@ tester.run("no-unused-selector", rule as any, {
         .foo > div {}
         </style>
         `,
-        // transition
-        `
+    // transition
+    `
         <template>
             <transition>
                 <div/>
@@ -258,7 +258,7 @@ tester.run("no-unused-selector", rule as any, {
         .v-leave-to {}
         </style>
         `,
-        `
+    `
         <template>
             <transition name="foo">
                 <div/>
@@ -275,7 +275,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo-leave-to {}
         </style>
         `,
-        `
+    `
         <template>
             <!-- transition + slot -->
             <transition name="foo">
@@ -293,7 +293,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo-leave-to {}
         </style>
         `,
-        `
+    `
         <script></script>
         <style scoped lang="scss">
         .no-template {
@@ -301,10 +301,10 @@ tester.run("no-unused-selector", rule as any, {
         }
         </style>
         `,
-        // options
-        // ignoreBEMModifier
-        {
-            code: `
+    // options
+    // ignoreBEMModifier
+    {
+      code: `
             <template>
                 <div class="foo"/>
             </template>
@@ -312,11 +312,11 @@ tester.run("no-unused-selector", rule as any, {
             .foo--bar {}
             </style>
             `,
-            options: [{ ignoreBEMModifier: true }],
-        },
-        // captureClassesFromDoc
-        {
-            code: `
+      options: [{ ignoreBEMModifier: true }],
+    },
+    // captureClassesFromDoc
+    {
+      code: `
             <template>
                 <div>
                     <a class="button star"></a>
@@ -340,16 +340,16 @@ tester.run("no-unused-selector", rule as any, {
                 }
             }
             </style>`,
-            options: [
-                {
-                    captureClassesFromDoc: [
-                        "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
-                    ],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          captureClassesFromDoc: [
+            "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
+          ],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div></div>
             </template>
@@ -362,17 +362,17 @@ tester.run("no-unused-selector", rule as any, {
                 color: red;
             }
             </style>`,
-            options: [
-                {
-                    ignoreBEMModifier: true,
-                    captureClassesFromDoc: [
-                        "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
-                    ],
-                },
-            ],
+      options: [
+        {
+          ignoreBEMModifier: true,
+          captureClassesFromDoc: [
+            "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
+          ],
         },
-        // ignore nodes
-        `
+      ],
+    },
+    // ignore nodes
+    `
         <template>
             <div><div :class="data.classes"/></div>
         </template>
@@ -383,8 +383,8 @@ tester.run("no-unused-selector", rule as any, {
         }
         </style>
         `,
-        // not scoped
-        `
+    // not scoped
+    `
         <template>
             <div></div>
         </template>
@@ -393,8 +393,8 @@ tester.run("no-unused-selector", rule as any, {
         </style>
         `,
 
-        // deep
-        `
+    // deep
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -402,7 +402,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo ::v-deep #a {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -410,8 +410,8 @@ tester.run("no-unused-selector", rule as any, {
         .foo >>> #a {}
         </style>
         `,
-        // Vue.js 3.x
-        `
+    // Vue.js 3.x
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -419,7 +419,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo ::v-deep(#a) {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"><slot></slot></div></div>
         </template>
@@ -427,7 +427,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo ::v-slotted(.bar > .baz) {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"><slot></slot></div></div>
         </template>
@@ -435,7 +435,7 @@ tester.run("no-unused-selector", rule as any, {
         .foo ::v-slotted(.bar > .baz) .qux {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo" /></div>
         </template>
@@ -443,8 +443,8 @@ tester.run("no-unused-selector", rule as any, {
         .unknown ::v-global(.bar > .baz) .qux {}
         </style>
         `,
-        // with v-for
-        `
+    // with v-for
+    `
         <template>
             <div>
                 <div v-for="item in list" class="foo">{{ item }}</div>
@@ -456,7 +456,7 @@ tester.run("no-unused-selector", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template>
             <div>
                 <template v-for="item in list" >
@@ -471,10 +471,10 @@ tester.run("no-unused-selector", rule as any, {
         }
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template>
                 <li class="bar"/>
             </template>
@@ -483,27 +483,27 @@ tester.run("no-unused-selector", rule as any, {
             div {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 17,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div" },
-                    line: 7,
-                    column: 13,
-                    endLine: 7,
-                    endColumn: 16,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 17,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div" },
+          line: 7,
+          column: 13,
+          endLine: 7,
+          endColumn: 16,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <li class="bar"/>
             </template>
@@ -512,27 +512,27 @@ tester.run("no-unused-selector", rule as any, {
             div {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 17,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div" },
-                    line: 7,
-                    column: 13,
-                    endLine: 7,
-                    endColumn: 16,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 17,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div" },
+          line: 7,
+          column: 13,
+          endLine: 7,
+          endColumn: 16,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <li class="bar"/>
             </template>
@@ -543,27 +543,27 @@ tester.run("no-unused-selector", rule as any, {
               color red;
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 17,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div" },
-                    line: 8,
-                    column: 13,
-                    endLine: 8,
-                    endColumn: 16,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 17,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div" },
+          line: 8,
+          column: 13,
+          endLine: 8,
+          endColumn: 16,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <li class="bar"/>
             </template>
@@ -571,27 +571,27 @@ tester.run("no-unused-selector", rule as any, {
             .foo, /* comment */ div {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 17,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div" },
-                    line: 6,
-                    column: 33,
-                    endLine: 6,
-                    endColumn: 36,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 17,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div" },
+          line: 6,
+          column: 33,
+          endLine: 6,
+          endColumn: 36,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -603,35 +603,35 @@ tester.run("no-unused-selector", rule as any, {
             div > li.bar {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 8,
-                    column: 19,
-                    endLine: 8,
-                    endColumn: 23,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "li.foo" },
-                    line: 9,
-                    column: 19,
-                    endLine: 9,
-                    endColumn: 25,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li.bar" },
-                    line: 10,
-                    column: 13,
-                    endLine: 10,
-                    endColumn: 25,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 8,
+          column: 19,
+          endLine: 8,
+          endColumn: 23,
+        },
+        {
+          messageId: "unused",
+          data: { selector: "li.foo" },
+          line: 9,
+          column: 19,
+          endLine: 9,
+          endColumn: 25,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>li.bar" },
+          line: 10,
+          column: 13,
+          endLine: 10,
+          endColumn: 25,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -645,35 +645,35 @@ tester.run("no-unused-selector", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li.bar" },
-                    line: 8,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 27,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 9,
-                    column: 21,
-                    endLine: 9,
-                    endColumn: 25,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "li.foo" },
-                    line: 10,
-                    column: 21,
-                    endLine: 10,
-                    endColumn: 27,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li.bar" },
+          line: 8,
+          column: 13,
+          endLine: 11,
+          endColumn: 27,
+        },
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 9,
+          column: 21,
+          endLine: 9,
+          endColumn: 25,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "li.foo" },
+          line: 10,
+          column: 21,
+          endLine: 10,
+          endColumn: 27,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div class="foo">
                     <ul>
@@ -685,19 +685,19 @@ tester.run("no-unused-selector", rule as any, {
             .foo { @nest .bar&-baz {} }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".bar.foo-baz" },
-                    line: 10,
-                    column: 26,
-                    endLine: 10,
-                    endColumn: 35,
-                },
-            ],
-        },
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".bar.foo-baz" },
+          line: 10,
+          column: 26,
+          endLine: 10,
+          endColumn: 35,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <div class="a"></div>
@@ -708,21 +708,21 @@ tester.run("no-unused-selector", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div.b:not(.a)" },
-                    line: 8,
-                    column: 19,
-                    endLine: 8,
-                    endColumn: 32,
-                },
-            ],
-        },
-        // options
-        // ignoreBEMModifier
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div.b:not(.a)" },
+          line: 8,
+          column: 19,
+          endLine: 8,
+          endColumn: 32,
+        },
+      ],
+    },
+    // options
+    // ignoreBEMModifier
+    {
+      code: `
             <template>
                 <div>
                     <div class="foo"/>
@@ -732,21 +732,21 @@ tester.run("no-unused-selector", rule as any, {
             .foo--bar--baz {}
             </style>
             `,
-            options: [{ ignoreBEMModifier: true }],
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo--bar--baz" },
-                    line: 8,
-                    column: 13,
-                    endLine: 8,
-                    endColumn: 27,
-                },
-            ],
-        },
-        // captureClassesFromDoc
+      options: [{ ignoreBEMModifier: true }],
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".foo--bar--baz" },
+          line: 8,
+          column: 13,
+          endLine: 8,
+          endColumn: 27,
+        },
+      ],
+    },
+    // captureClassesFromDoc
+    {
+      code: `
             <template>
                 <div>
                     <a class="button star"></a>
@@ -772,27 +772,27 @@ tester.run("no-unused-selector", rule as any, {
                 }
             }
             </style>`,
-            options: [
-                {
-                    captureClassesFromDoc: [
-                        "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
-                    ],
-                },
-            ],
-            errors: [
-                {
-                    message: "The selector `a.button.star.unknown` is unused.",
-                    line: 18,
-                    column: 13,
-                    endLine: 23,
-                    endColumn: 26,
-                },
-            ],
+      options: [
+        {
+          captureClassesFromDoc: [
+            "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
+          ],
         },
-
-        // deep
+      ],
+      errors: [
         {
-            code: `
+          message: "The selector `a.button.star.unknown` is unused.",
+          line: 18,
+          column: 13,
+          endLine: 23,
+          endColumn: 26,
+        },
+      ],
+    },
+
+    // deep
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -807,27 +807,27 @@ tester.run("no-unused-selector", rule as any, {
             div > .item >>> .a {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: ".item" },
-                    line: 13,
-                    column: 19,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".item" },
+          line: 13,
+          column: 19,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -842,27 +842,27 @@ tester.run("no-unused-selector", rule as any, {
             div > .item /deep/ .a {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: ".item" },
-                    line: 13,
-                    column: 19,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".item" },
+          line: 13,
+          column: 19,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -877,29 +877,29 @@ tester.run("no-unused-selector", rule as any, {
             div > .item ::v-deep .a {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: ".item" },
-                    line: 13,
-                    column: 19,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
-
-        // multiple children parents
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".item" },
+          line: 13,
+          column: 19,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+
+    // multiple children parents
+    {
+      code: `
             <template>
                 <div class="foo">
                     <input class="bar baz">
@@ -916,21 +916,21 @@ tester.run("no-unused-selector", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".unknown" },
-                    line: 12,
-                    column: 13,
-                    endLine: 12,
-                    endColumn: 21,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".unknown" },
+          line: 12,
+          column: 13,
+          endLine: 12,
+          endColumn: 21,
         },
+      ],
+    },
 
-        // Vue.js 3.x
-        {
-            code: `
+    // Vue.js 3.x
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -945,25 +945,25 @@ tester.run("no-unused-selector", rule as any, {
             div > .item ::v-deep(.a) {}
             </style>
             `,
-            errors: [
-                {
-                    message: "The selector `div>li` is unused.",
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    message: "The selector `.item` is unused.",
-                    line: 13,
-                    column: 19,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          message: "The selector `div>li` is unused.",
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
         {
-            code: `
+          message: "The selector `.item` is unused.",
+          line: 13,
+          column: 19,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -975,18 +975,18 @@ tester.run("no-unused-selector", rule as any, {
             div > ul > ::v-slotted(.a) {}
             </style>
             `,
-            errors: [
-                {
-                    message: "The selector `::v-slotted(.a)` is unused.",
-                    line: 10,
-                    column: 24,
-                    endLine: 10,
-                    endColumn: 39,
-                },
-            ],
-        },
+      errors: [
         {
-            code: `
+          message: "The selector `::v-slotted(.a)` is unused.",
+          line: 10,
+          column: 24,
+          endLine: 10,
+          endColumn: 39,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -1003,32 +1003,32 @@ tester.run("no-unused-selector", rule as any, {
             div > h3 > ::v-slotted(.a) {}
             </style>
             `,
-            errors: [
-                {
-                    message: "The selector `li>::v-slotted(.a)` is unused.",
-                    line: 12,
-                    column: 19,
-                    endLine: 12,
-                    endColumn: 39,
-                },
-                {
-                    message: "The selector `.item>::v-slotted(.a)` is unused.",
-                    line: 14,
-                    column: 19,
-                    endLine: 14,
-                    endColumn: 42,
-                },
-                {
-                    message: "The selector `h3>::v-slotted(.a)` is unused.",
-                    line: 15,
-                    column: 19,
-                    endLine: 15,
-                    endColumn: 39,
-                },
-            ],
+      errors: [
+        {
+          message: "The selector `li>::v-slotted(.a)` is unused.",
+          line: 12,
+          column: 19,
+          endLine: 12,
+          endColumn: 39,
+        },
+        {
+          message: "The selector `.item>::v-slotted(.a)` is unused.",
+          line: 14,
+          column: 19,
+          endLine: 14,
+          endColumn: 42,
         },
         {
-            code: `
+          message: "The selector `h3>::v-slotted(.a)` is unused.",
+          line: 15,
+          column: 19,
+          endLine: 15,
+          endColumn: 39,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -1045,32 +1045,32 @@ tester.run("no-unused-selector", rule as any, {
             div > h3 > ::v-slotted(.a) .bar {}
             </style>
             `,
-            errors: [
-                {
-                    message: "The selector `li>::v-slotted(.a)` is unused.",
-                    line: 12,
-                    column: 19,
-                    endLine: 12,
-                    endColumn: 39,
-                },
-                {
-                    message: "The selector `.item>::v-slotted(.a)` is unused.",
-                    line: 14,
-                    column: 19,
-                    endLine: 14,
-                    endColumn: 42,
-                },
-                {
-                    message: "The selector `h3>::v-slotted(.a)` is unused.",
-                    line: 15,
-                    column: 19,
-                    endLine: 15,
-                    endColumn: 39,
-                },
-            ],
+      errors: [
+        {
+          message: "The selector `li>::v-slotted(.a)` is unused.",
+          line: 12,
+          column: 19,
+          endLine: 12,
+          endColumn: 39,
+        },
+        {
+          message: "The selector `.item>::v-slotted(.a)` is unused.",
+          line: 14,
+          column: 19,
+          endLine: 14,
+          endColumn: 42,
         },
         {
-            code: `
+          message: "The selector `h3>::v-slotted(.a)` is unused.",
+          line: 15,
+          column: 19,
+          endLine: 15,
+          endColumn: 39,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div><div :class="classes"/></div>
             </template>
@@ -1088,10 +1088,10 @@ tester.run("no-unused-selector", rule as any, {
             })
             </script>
             `,
-            errors: ["The selector `.bar` is unused."],
-        },
-        {
-            code: `
+      errors: ["The selector `.bar` is unused."],
+    },
+    {
+      code: `
             <template>
                 <div><div :class="classes"/></div>
             </template>
@@ -1109,7 +1109,7 @@ tester.run("no-unused-selector", rule as any, {
             })
             </script>
             `,
-            errors: ["The selector `.bar` is unused."],
-        },
-    ],
-})
+      errors: ["The selector `.bar` is unused."],
+    },
+  ],
+});
diff --git a/tests/lib/rules/require-scoped.ts b/tests/lib/rules/require-scoped.ts
index 4ec4ab25..d452ee1e 100644
--- a/tests/lib/rules/require-scoped.ts
+++ b/tests/lib/rules/require-scoped.ts
@@ -1,142 +1,142 @@
-import { RuleTester } from "eslint"
-import semver from "semver"
-import rule = require("../../../lib/rules/require-scoped")
+import { RuleTester } from "eslint";
+import semver from "semver";
+import rule = require("../../../lib/rules/require-scoped");
 
-const parserVersion = require("vue-eslint-parser/package.json").version
+const parserVersion = require("vue-eslint-parser/package.json").version;
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("require-scoped", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template>
         </template>
         <style scoped>
         </style>
         `,
-        `
+    `
         <template>
         </template>
         `,
-        {
-            code: `
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            options: ["never"],
-        },
-    ],
-    invalid: [
-        {
-            code: `
+      options: ["never"],
+    },
+  ],
+  invalid: [
+    {
+      code: `
             <template>
             </template>
             <style>
             </style>
             `,
-            errors: [
-                {
-                    messageId: "missing",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 20,
-                    suggestions: [
-                        {
-                            desc: "Add `scoped` attribute.",
-                            output: `
+      errors: [
+        {
+          messageId: "missing",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 20,
+          suggestions: [
+            {
+              desc: "Add `scoped` attribute.",
+              output: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        {
-            code: `
+      ],
+    },
+    {
+      code: `
             <template>
             </template>
             <style />
             `,
-            errors: [
-                {
-                    messageId: "missing",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 22,
-                    suggestions: [
-                        {
-                            desc: "Add `scoped` attribute.",
-                            output: `
+      errors: [
+        {
+          messageId: "missing",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 22,
+          suggestions: [
+            {
+              desc: "Add `scoped` attribute.",
+              output: `
             <template>
             </template>
             <style  scoped/>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-        ...(semver.satisfies(parserVersion, ">=7.0.0")
-            ? [
-                  {
-                      code: `
+      ],
+    },
+    ...(semver.satisfies(parserVersion, ">=7.0.0")
+      ? [
+          {
+            code: `
                         <script>
                         </script>
                         <style />
                         `,
-                      errors: [
-                          {
-                              messageId: "missing",
-                              line: 4,
-                              column: 25,
-                              endLine: 4,
-                              endColumn: 34,
-                          },
-                      ],
-                  },
-              ]
-            : []),
-        {
-            code: `
+            errors: [
+              {
+                messageId: "missing",
+                line: 4,
+                column: 25,
+                endLine: 4,
+                endColumn: 34,
+              },
+            ],
+          },
+        ]
+      : []),
+    {
+      code: `
             <template>
             </template>
             <style scoped>
             </style>
             `,
-            options: ["never"],
-            errors: [
-                {
-                    messageId: "forbidden",
-                    line: 4,
-                    column: 20,
-                    endLine: 4,
-                    endColumn: 26,
-                    suggestions: [
-                        {
-                            desc: "Remove `scoped` attribute.",
-                            output: `
+      options: ["never"],
+      errors: [
+        {
+          messageId: "forbidden",
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 26,
+          suggestions: [
+            {
+              desc: "Remove `scoped` attribute.",
+              output: `
             <template>
             </template>
             <style >
             </style>
             `,
-                        },
-                    ],
-                },
-            ],
+            },
+          ],
         },
-    ],
-})
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/require-selector-used-inside.ts b/tests/lib/rules/require-selector-used-inside.ts
index 9d78f77d..1bf9d378 100644
--- a/tests/lib/rules/require-selector-used-inside.ts
+++ b/tests/lib/rules/require-selector-used-inside.ts
@@ -1,17 +1,17 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/require-selector-used-inside")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/require-selector-used-inside");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("require-selector-used-inside", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -20,7 +20,7 @@ tester.run("require-selector-used-inside", rule as any, {
         div {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -28,7 +28,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo, div {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"><div id="bar"></div></div></div>
         </template>
@@ -36,7 +36,7 @@ tester.run("require-selector-used-inside", rule as any, {
         div.foo /* comment */ #bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div>
                 <li class="foo"/>
@@ -46,8 +46,8 @@ tester.run("require-selector-used-inside", rule as any, {
         div > .foo {}
         </style>
         `,
-        // nesting
-        `
+    // nesting
+    `
         <template>
             <div>
                 <div>
@@ -59,7 +59,7 @@ tester.run("require-selector-used-inside", rule as any, {
         div { & > .foo {} }
         </style>
         `,
-        `
+    `
         <template>
             <div class="foo">
                 <ul>
@@ -71,8 +71,8 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo { @nest .bar&-baz {} }
         </style>
         `,
-        // expressions
-        `
+    // expressions
+    `
         <template>
             <div><div :class="'foo bar'"/></div>
         </template>
@@ -80,7 +80,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="['foo bar']"/></div>
         </template>
@@ -88,7 +88,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="['foo', 'bar']"/></div>
         </template>
@@ -96,7 +96,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="{foo, bar: b}"/></div>
         </template>
@@ -104,7 +104,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .bar {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div :class="{'foo': f, 'bar': b}"/></div>
         </template>
@@ -112,9 +112,9 @@ tester.run("require-selector-used-inside", rule as any, {
         .bar {}
         </style>
         `,
-        // identifier
-        // data
-        `
+    // identifier
+    // data
+    `
         <template>
             <div><div :class="classes"/></div>
         </template>
@@ -131,8 +131,8 @@ tester.run("require-selector-used-inside", rule as any, {
         }
         </script>
         `,
-        // computed
-        `
+    // computed
+    `
         <template>
             <div><div :class="classes"/></div>
         </template>
@@ -149,9 +149,9 @@ tester.run("require-selector-used-inside", rule as any, {
         }
         </script>
         `,
-        // unknown
-        // complex script
-        `
+    // unknown
+    // complex script
+    `
         <template>
             <div><div :class="data.classes"/></div>
         </template>
@@ -159,8 +159,8 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo {}
         </style>
         `,
-        // complex selector
-        `
+    // complex selector
+    `
         <template>
             <div><div class="b"/></div>
         </template>
@@ -168,8 +168,8 @@ tester.run("require-selector-used-inside", rule as any, {
         :not(.a) {}
         </style>
         `,
-        // transition
-        `
+    // transition
+    `
         <template>
             <transition>
                 <div/>
@@ -186,7 +186,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .v-leave-to {}
         </style>
         `,
-        `
+    `
         <template>
             <transition name="foo">
                 <div/>
@@ -203,7 +203,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo-leave-to {}
         </style>
         `,
-        `
+    `
         <template>
             <!-- transition + slot -->
             <transition name="foo">
@@ -221,7 +221,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo-leave-to {}
         </style>
         `,
-        `
+    `
         <script></script>
         <style scoped lang="scss">
         .no-template {
@@ -229,10 +229,10 @@ tester.run("require-selector-used-inside", rule as any, {
         }
         </style>
         `,
-        // options
-        // ignoreBEMModifier
-        {
-            code: `
+    // options
+    // ignoreBEMModifier
+    {
+      code: `
             <template>
                 <div class="foo"/>
             </template>
@@ -240,11 +240,11 @@ tester.run("require-selector-used-inside", rule as any, {
             .foo--bar {}
             </style>
             `,
-            options: [{ ignoreBEMModifier: true }],
-        },
-        // captureClassesFromDoc
-        {
-            code: `
+      options: [{ ignoreBEMModifier: true }],
+    },
+    // captureClassesFromDoc
+    {
+      code: `
             <template>
                 <div>
                     <a class="button star"></a>
@@ -268,16 +268,16 @@ tester.run("require-selector-used-inside", rule as any, {
                 }
             }
             </style>`,
-            options: [
-                {
-                    captureClassesFromDoc: [
-                        "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
-                    ],
-                },
-            ],
-        },
+      options: [
         {
-            code: `
+          captureClassesFromDoc: [
+            "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
+          ],
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div></div>
             </template>
@@ -290,17 +290,17 @@ tester.run("require-selector-used-inside", rule as any, {
                 color: red;
             }
             </style>`,
-            options: [
-                {
-                    ignoreBEMModifier: true,
-                    captureClassesFromDoc: [
-                        "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
-                    ],
-                },
-            ],
+      options: [
+        {
+          ignoreBEMModifier: true,
+          captureClassesFromDoc: [
+            "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
+          ],
         },
-        // ignore nodes
-        `
+      ],
+    },
+    // ignore nodes
+    `
         <template>
             <div><div :class="data.classes"/></div>
         </template>
@@ -311,8 +311,8 @@ tester.run("require-selector-used-inside", rule as any, {
         }
         </style>
         `,
-        // not scoped
-        `
+    // not scoped
+    `
         <template>
             <div></div>
         </template>
@@ -321,8 +321,8 @@ tester.run("require-selector-used-inside", rule as any, {
         </style>
         `,
 
-        // deep
-        `
+    // deep
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -330,7 +330,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo ::v-deep #a {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -339,8 +339,8 @@ tester.run("require-selector-used-inside", rule as any, {
         </style>
         `,
 
-        // Vue.js 3.x
-        `
+    // Vue.js 3.x
+    `
         <template>
             <div><div class="foo"/></div>
         </template>
@@ -348,7 +348,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo ::v-deep(#a) {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"><slot></slot></div></div>
         </template>
@@ -356,7 +356,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo ::v-slotted(.bar > .baz) {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo"><slot></slot></div></div>
         </template>
@@ -364,7 +364,7 @@ tester.run("require-selector-used-inside", rule as any, {
         .foo ::v-slotted(.bar > .baz) .qux {}
         </style>
         `,
-        `
+    `
         <template>
             <div><div class="foo" /></div>
         </template>
@@ -372,8 +372,8 @@ tester.run("require-selector-used-inside", rule as any, {
         .unknown ::v-global(.bar > .baz) .qux {}
         </style>
         `,
-        // with v-for
-        `
+    // with v-for
+    `
         <template>
             <div>
                 <div v-for="item in list"class="foo">{{ item }}</div>
@@ -385,7 +385,7 @@ tester.run("require-selector-used-inside", rule as any, {
         }
         </style>
         `,
-        `
+    `
         <template>
             <div>
                 <template v-for="item in list" >
@@ -400,10 +400,10 @@ tester.run("require-selector-used-inside", rule as any, {
         }
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template>
                 <li class="bar"/>
             </template>
@@ -412,27 +412,27 @@ tester.run("require-selector-used-inside", rule as any, {
             div {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 17,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div" },
-                    line: 7,
-                    column: 13,
-                    endLine: 7,
-                    endColumn: 16,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 17,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div" },
+          line: 7,
+          column: 13,
+          endLine: 7,
+          endColumn: 16,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <li class="bar"/>
             </template>
@@ -440,27 +440,27 @@ tester.run("require-selector-used-inside", rule as any, {
             .foo, /* comment */ div {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 17,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div" },
-                    line: 6,
-                    column: 33,
-                    endLine: 6,
-                    endColumn: 36,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 17,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div" },
+          line: 6,
+          column: 33,
+          endLine: 6,
+          endColumn: 36,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -472,35 +472,35 @@ tester.run("require-selector-used-inside", rule as any, {
             div > li.bar {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>.foo" },
-                    line: 8,
-                    column: 13,
-                    endLine: 8,
-                    endColumn: 23,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 9,
-                    column: 13,
-                    endLine: 9,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 10,
-                    column: 13,
-                    endLine: 10,
-                    endColumn: 21,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>.foo" },
+          line: 8,
+          column: 13,
+          endLine: 8,
+          endColumn: 23,
+        },
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 9,
+          column: 13,
+          endLine: 9,
+          endColumn: 21,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 10,
+          column: 13,
+          endLine: 10,
+          endColumn: 21,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div class="foo"/>
             </template>
@@ -508,19 +508,19 @@ tester.run("require-selector-used-inside", rule as any, {
             .foo.bar {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo.bar" },
-                    line: 6,
-                    column: 13,
-                    endLine: 6,
-                    endColumn: 21,
-                },
-            ],
-        },
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".foo.bar" },
+          line: 6,
+          column: 13,
+          endLine: 6,
+          endColumn: 21,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div><ul>
                     <li class="bar"/>
@@ -534,35 +534,35 @@ tester.run("require-selector-used-inside", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>.foo" },
-                    line: 8,
-                    column: 13,
-                    endLine: 9,
-                    endColumn: 25,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 8,
-                    column: 13,
-                    endLine: 10,
-                    endColumn: 23,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 8,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 23,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>.foo" },
+          line: 8,
+          column: 13,
+          endLine: 9,
+          endColumn: 25,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 8,
+          column: 13,
+          endLine: 10,
+          endColumn: 23,
+        },
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 8,
+          column: 13,
+          endLine: 11,
+          endColumn: 23,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div class="foo">
                     <ul>
@@ -574,19 +574,19 @@ tester.run("require-selector-used-inside", rule as any, {
             .foo { @nest .bar&-baz {} }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".bar.foo-baz" },
-                    line: 10,
-                    column: 26,
-                    endLine: 10,
-                    endColumn: 35,
-                },
-            ],
-        },
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".bar.foo-baz" },
+          line: 10,
+          column: 26,
+          endLine: 10,
+          endColumn: 35,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <div class="a"></div>
@@ -597,21 +597,21 @@ tester.run("require-selector-used-inside", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>div.b" },
-                    line: 8,
-                    column: 13,
-                    endLine: 8,
-                    endColumn: 24,
-                },
-            ],
-        },
-        // options
-        // ignoreBEMModifier
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>div.b" },
+          line: 8,
+          column: 13,
+          endLine: 8,
+          endColumn: 24,
+        },
+      ],
+    },
+    // options
+    // ignoreBEMModifier
+    {
+      code: `
             <template>
                 <div>
                     <div class="foo"/>
@@ -621,21 +621,21 @@ tester.run("require-selector-used-inside", rule as any, {
             .foo--bar--baz {}
             </style>
             `,
-            options: [{ ignoreBEMModifier: true }],
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo--bar--baz" },
-                    line: 8,
-                    column: 13,
-                    endLine: 8,
-                    endColumn: 27,
-                },
-            ],
-        },
-        // captureClassesFromDoc
+      options: [{ ignoreBEMModifier: true }],
+      errors: [
         {
-            code: `
+          messageId: "unused",
+          data: { selector: ".foo--bar--baz" },
+          line: 8,
+          column: 13,
+          endLine: 8,
+          endColumn: 27,
+        },
+      ],
+    },
+    // captureClassesFromDoc
+    {
+      code: `
             <template>
                 <div>
                     <a class="button star"></a>
@@ -661,27 +661,27 @@ tester.run("require-selector-used-inside", rule as any, {
                 }
             }
             </style>`,
-            options: [
-                {
-                    captureClassesFromDoc: [
-                        "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
-                    ],
-                },
-            ],
-            errors: [
-                {
-                    message:
-                        "The selector `a.button.star.unknown` is unused in the template.",
-                    line: 18,
-                    column: 13,
-                    endLine: 23,
-                    endColumn: 26,
-                },
-            ],
+      options: [
+        {
+          captureClassesFromDoc: [
+            "/(\\.[a-z-]+)(?::[a-z-]+)?\\s+-\\s*[^\\r\\n]+/i",
+          ],
         },
-        // deep
+      ],
+      errors: [
         {
-            code: `
+          message:
+            "The selector `a.button.star.unknown` is unused in the template.",
+          line: 18,
+          column: 13,
+          endLine: 23,
+          endColumn: 26,
+        },
+      ],
+    },
+    // deep
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -696,27 +696,27 @@ tester.run("require-selector-used-inside", rule as any, {
             div > .item >>> .a {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>.item" },
-                    line: 13,
-                    column: 13,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>.item" },
+          line: 13,
+          column: 13,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -731,27 +731,27 @@ tester.run("require-selector-used-inside", rule as any, {
             div > .item /deep/ .a {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>.item" },
-                    line: 13,
-                    column: 13,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>.item" },
+          line: 13,
+          column: 13,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -766,29 +766,29 @@ tester.run("require-selector-used-inside", rule as any, {
             div > .item ::v-deep .a {}
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: "div>li" },
-                    line: 11,
-                    column: 13,
-                    endLine: 11,
-                    endColumn: 21,
-                },
-                {
-                    messageId: "unused",
-                    data: { selector: "div>.item" },
-                    line: 13,
-                    column: 13,
-                    endLine: 13,
-                    endColumn: 24,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: "div>li" },
+          line: 11,
+          column: 13,
+          endLine: 11,
+          endColumn: 21,
         },
-
-        // multiple parents children
         {
-            code: `
+          messageId: "unused",
+          data: { selector: "div>.item" },
+          line: 13,
+          column: 13,
+          endLine: 13,
+          endColumn: 24,
+        },
+      ],
+    },
+
+    // multiple parents children
+    {
+      code: `
             <template>
                 <div>
                     <div class="foo">
@@ -810,21 +810,21 @@ tester.run("require-selector-used-inside", rule as any, {
             }
             </style>
             `,
-            errors: [
-                {
-                    messageId: "unused",
-                    data: { selector: ".foo>.unknown" },
-                    line: 17,
-                    column: 13,
-                    endLine: 19,
-                    endColumn: 29,
-                },
-            ],
+      errors: [
+        {
+          messageId: "unused",
+          data: { selector: ".foo>.unknown" },
+          line: 17,
+          column: 13,
+          endLine: 19,
+          endColumn: 29,
         },
+      ],
+    },
 
-        // Vue.js 3.x
-        {
-            code: `
+    // Vue.js 3.x
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -839,13 +839,13 @@ tester.run("require-selector-used-inside", rule as any, {
             div > .item ::v-deep(.a) {}
             </style>
             `,
-            errors: [
-                "The selector `div>li` is unused in the template.",
-                "The selector `div>.item` is unused in the template.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The selector `div>li` is unused in the template.",
+        "The selector `div>.item` is unused in the template.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -857,12 +857,12 @@ tester.run("require-selector-used-inside", rule as any, {
             div > ul > ::v-slotted(.a) {}
             </style>
             `,
-            errors: [
-                "The selector `div>ul>::v-slotted(.a)` is unused in the template.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The selector `div>ul>::v-slotted(.a)` is unused in the template.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -879,14 +879,14 @@ tester.run("require-selector-used-inside", rule as any, {
             div > h3 > ::v-slotted(.a) {}
             </style>
             `,
-            errors: [
-                "The selector `div>li` is unused in the template.",
-                "The selector `div>.item` is unused in the template.",
-                "The selector `div>h3>::v-slotted(.a)` is unused in the template.",
-            ],
-        },
-        {
-            code: `
+      errors: [
+        "The selector `div>li` is unused in the template.",
+        "The selector `div>.item` is unused in the template.",
+        "The selector `div>h3>::v-slotted(.a)` is unused in the template.",
+      ],
+    },
+    {
+      code: `
             <template>
                 <div>
                     <ul class="list">
@@ -903,11 +903,11 @@ tester.run("require-selector-used-inside", rule as any, {
             div > h3 > ::v-slotted(.a) .bar {}
             </style>
             `,
-            errors: [
-                "The selector `div>li` is unused in the template.",
-                "The selector `div>.item` is unused in the template.",
-                "The selector `div>h3>` is unused in the template.",
-            ],
-        },
-    ],
-})
+      errors: [
+        "The selector `div>li` is unused in the template.",
+        "The selector `div>.item` is unused in the template.",
+        "The selector `div>h3>` is unused in the template.",
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/require-v-deep-argument.ts b/tests/lib/rules/require-v-deep-argument.ts
index 5e5791f8..a2f02c0e 100644
--- a/tests/lib/rules/require-v-deep-argument.ts
+++ b/tests/lib/rules/require-v-deep-argument.ts
@@ -1,57 +1,55 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/require-v-deep-argument")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/require-v-deep-argument");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("require-v-deep-argument", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><div class="item">sample</div></template>
         <style scoped>
         .baz .qux ::v-deep(.foo .bar) {}
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><div class="item">sample</div></template>
             <style scoped>
             .baz .qux ::v-deep .foo .bar {}
             .baz .qux ::v-deep() .foo .bar {}
             </style>
             `,
-            output: `
+      output: `
             <template><div class="item">sample</div></template>
             <style scoped>
             .baz .qux ::v-deep(.foo .bar) {}
             .baz .qux ::v-deep() .foo .bar {}
             </style>
             `,
-            errors: [
-                {
-                    message:
-                        "Need to pass argument to the `::v-deep` pseudo-element.",
-                    line: 4,
-                    column: 23,
-                    endLine: 4,
-                    endColumn: 31,
-                },
-                {
-                    message:
-                        "Need to pass argument to the `::v-deep` pseudo-element.",
-                    line: 5,
-                    column: 23,
-                    endLine: 5,
-                    endColumn: 33,
-                },
-            ],
+      errors: [
+        {
+          message: "Need to pass argument to the `::v-deep` pseudo-element.",
+          line: 4,
+          column: 23,
+          endLine: 4,
+          endColumn: 31,
         },
-    ],
-})
+        {
+          message: "Need to pass argument to the `::v-deep` pseudo-element.",
+          line: 5,
+          column: 23,
+          endLine: 5,
+          endColumn: 33,
+        },
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/require-v-global-argument.ts b/tests/lib/rules/require-v-global-argument.ts
index 7bd83553..2e0204e5 100644
--- a/tests/lib/rules/require-v-global-argument.ts
+++ b/tests/lib/rules/require-v-global-argument.ts
@@ -1,50 +1,48 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/require-v-global-argument")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/require-v-global-argument");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("require-v-global-argument", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><div class="item">sample</div></template>
         <style scoped>
         ::v-global(.foo .bar) {}
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><div class="item">sample</div></template>
             <style scoped>
             ::v-global {}
             ::v-global() {}
             </style>
             `,
-            errors: [
-                {
-                    message:
-                        "Need to pass argument to the `::v-global` pseudo-element.",
-                    line: 4,
-                    column: 13,
-                    endLine: 4,
-                    endColumn: 23,
-                },
-                {
-                    message:
-                        "Need to pass argument to the `::v-global` pseudo-element.",
-                    line: 5,
-                    column: 13,
-                    endLine: 5,
-                    endColumn: 25,
-                },
-            ],
+      errors: [
+        {
+          message: "Need to pass argument to the `::v-global` pseudo-element.",
+          line: 4,
+          column: 13,
+          endLine: 4,
+          endColumn: 23,
         },
-    ],
-})
+        {
+          message: "Need to pass argument to the `::v-global` pseudo-element.",
+          line: 5,
+          column: 13,
+          endLine: 5,
+          endColumn: 25,
+        },
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/rules/require-v-slotted-argument.ts b/tests/lib/rules/require-v-slotted-argument.ts
index 34b2da5d..c16236fb 100644
--- a/tests/lib/rules/require-v-slotted-argument.ts
+++ b/tests/lib/rules/require-v-slotted-argument.ts
@@ -1,50 +1,48 @@
-import { RuleTester } from "eslint"
-import rule = require("../../../lib/rules/require-v-slotted-argument")
+import { RuleTester } from "eslint";
+import rule = require("../../../lib/rules/require-v-slotted-argument");
 
 const tester = new RuleTester({
-    parser: require.resolve("vue-eslint-parser"),
-    parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: "module",
-    },
-})
+  parser: require.resolve("vue-eslint-parser"),
+  parserOptions: {
+    ecmaVersion: 2019,
+    sourceType: "module",
+  },
+});
 
 tester.run("require-v-slotted-argument", rule as any, {
-    valid: [
-        `
+  valid: [
+    `
         <template><div class="item">sample</div></template>
         <style scoped>
         .baz .qux ::v-slotted(.foo .bar) {}
         </style>
         `,
-    ],
-    invalid: [
-        {
-            code: `
+  ],
+  invalid: [
+    {
+      code: `
             <template><div class="item">sample</div></template>
             <style scoped>
             .baz .qux ::v-slotted .foo .bar {}
             .baz .qux ::v-slotted() {}
             </style>
             `,
-            errors: [
-                {
-                    message:
-                        "Need to pass argument to the `::v-slotted` pseudo-element.",
-                    line: 4,
-                    column: 23,
-                    endLine: 4,
-                    endColumn: 34,
-                },
-                {
-                    message:
-                        "Need to pass argument to the `::v-slotted` pseudo-element.",
-                    line: 5,
-                    column: 23,
-                    endLine: 5,
-                    endColumn: 36,
-                },
-            ],
+      errors: [
+        {
+          message: "Need to pass argument to the `::v-slotted` pseudo-element.",
+          line: 4,
+          column: 23,
+          endLine: 4,
+          endColumn: 34,
         },
-    ],
-})
+        {
+          message: "Need to pass argument to the `::v-slotted` pseudo-element.",
+          line: 5,
+          column: 23,
+          endLine: 5,
+          endColumn: 36,
+        },
+      ],
+    },
+  ],
+});
diff --git a/tests/lib/styles/parser/index.ts b/tests/lib/styles/parser/index.ts
index c30250e3..23667eac 100644
--- a/tests/lib/styles/parser/index.ts
+++ b/tests/lib/styles/parser/index.ts
@@ -1,18 +1,18 @@
-import assert from "assert"
+import assert from "assert";
 
-import fs from "fs"
-import path from "path"
+import fs from "fs";
+import path from "path";
 
-import css from "postcss"
-import scss from "postcss-scss"
-import stylus from "postcss-styl"
+import css from "postcss";
+import scss from "postcss-scss";
+import stylus from "postcss-styl";
 
-import { getStyleFixtureResults, writeFixture } from "../test-utils"
+import { getStyleFixtureResults, writeFixture } from "../test-utils";
 import type {
-    VCSSNode,
-    VCSSSelectorNode,
-    VCSSAtRule,
-} from "../../../../lib/styles/ast"
+  VCSSNode,
+  VCSSSelectorNode,
+  VCSSAtRule,
+} from "../../../../lib/styles/ast";
 
 // function stringify(node: any, stringifier: any) {
 //     let semicolon = true
@@ -27,16 +27,16 @@ import type {
 // }
 
 const STRINGIFYS = {
-    scss(node: any, builder: any) {
-        scss.stringify(node, builder)
-    },
-    css(node: any, builder: any) {
-        css.stringify(node, builder)
-    },
-    stylus(node: any, builder: any) {
-        stylus.stringify(node, builder)
-    },
-}
+  scss(node: any, builder: any) {
+    scss.stringify(node, builder);
+  },
+  css(node: any, builder: any) {
+    css.stringify(node, builder);
+  },
+  stylus(node: any, builder: any) {
+    stylus.stringify(node, builder);
+  },
+};
 
 /**
  * Remove `parent` proeprties from the given AST.
@@ -45,256 +45,241 @@ const STRINGIFYS = {
  * @returns {any} The value of the key to output.
  */
 function replacer(key: string, value: any): any {
-    if (key === "parent" || key === "node" || key === "lang") {
-        return undefined
-    }
-    return value
+  if (key === "parent" || key === "node" || key === "lang") {
+    return undefined;
+  }
+  return value;
 }
 
 function simpleReplacer(key: string, value: any): any {
-    if (key === "parent" || key === "node" || key === "lang") {
-        return undefined
-    }
-    if (key === "loc" || key === "range" || key === "start" || key === "end") {
-        return undefined
-    }
-    return value
+  if (key === "parent" || key === "node" || key === "lang") {
+    return undefined;
+  }
+  if (key === "loc" || key === "range" || key === "start" || key === "end") {
+    return undefined;
+  }
+  return value;
 }
 
 describe("CSS Nodes Test.", () => {
-    for (const { name, style, source, dir } of getStyleFixtureResults()) {
-        describe(`'styles/fixtures/${name}/source.vue'`, () => {
-            it("should be parsed to valid location.", () => {
-                if (!style.cssNode) {
-                    throw new Error("invalid")
-                }
-                if (style.cssNode.errors.length) {
-                    return
-                }
-                checkCSSNodeLocations(source, style.cssNode, style.lang)
-            })
-            it("should be parsed to valid AST.", () => {
-                const resultPath = path.join(dir, "ast.json")
+  for (const { name, style, source, dir } of getStyleFixtureResults()) {
+    describe(`'styles/fixtures/${name}/source.vue'`, () => {
+      it("should be parsed to valid location.", () => {
+        if (!style.cssNode) {
+          throw new Error("invalid");
+        }
+        if (style.cssNode.errors.length) {
+          return;
+        }
+        checkCSSNodeLocations(source, style.cssNode, style.lang);
+      });
+      it("should be parsed to valid AST.", () => {
+        const resultPath = path.join(dir, "ast.json");
 
-                const actual = JSON.stringify(style.cssNode, replacer, 4)
+        const actual = JSON.stringify(style.cssNode, replacer, 4);
 
-                try {
-                    const expected = fs.readFileSync(resultPath, "utf8")
+        try {
+          const expected = fs.readFileSync(resultPath, "utf8");
 
-                    assert.strictEqual(actual, expected)
-                } catch (e) {
-                    writeFixture(resultPath, actual)
-                    throw e
-                }
-            })
-            it("should be parsed to valid simple AST.", () => {
-                const resultPath = path.join(dir, "ast.json")
+          assert.strictEqual(actual, expected);
+        } catch (e) {
+          writeFixture(resultPath, actual);
+          throw e;
+        }
+      });
+      it("should be parsed to valid simple AST.", () => {
+        const resultPath = path.join(dir, "ast.json");
 
-                const actual = JSON.stringify(style.cssNode, simpleReplacer, 4)
+        const actual = JSON.stringify(style.cssNode, simpleReplacer, 4);
 
-                const expected = JSON.stringify(
-                    JSON.parse(fs.readFileSync(resultPath, "utf8")),
-                    simpleReplacer,
-                    4,
-                )
+        const expected = JSON.stringify(
+          JSON.parse(fs.readFileSync(resultPath, "utf8")),
+          simpleReplacer,
+          4
+        );
 
-                assert.strictEqual(actual, expected)
-            })
-            it("should be copied to valid AST.", () => {
-                const resultPath = path.join(dir, "ast.json")
+        assert.strictEqual(actual, expected);
+      });
+      it("should be copied to valid AST.", () => {
+        const resultPath = path.join(dir, "ast.json");
 
-                const actual = JSON.stringify(
-                    deepCopy(style.cssNode),
-                    replacer,
-                    4,
-                )
+        const actual = JSON.stringify(deepCopy(style.cssNode), replacer, 4);
 
-                const expected = fs.readFileSync(resultPath, "utf8")
+        const expected = fs.readFileSync(resultPath, "utf8");
 
-                assert.strictEqual(actual, expected)
-            })
-        })
-    }
-})
+        assert.strictEqual(actual, expected);
+      });
+    });
+  }
+});
 
 // eslint-disable-next-line complexity -- test
 function checkCSSNodeLocations(
-    code: string,
-    node: VCSSNode | VCSSSelectorNode,
-    lang: string,
+  code: string,
+  node: VCSSNode | VCSSSelectorNode,
+  lang: string
 ) {
-    if (node.node) {
-        let rangeText = code.slice(...node.range)
-        let postcssText = (node.node as any).toString((STRINGIFYS as any)[lang])
-        if (node.type === "VCSSSelector" || node.type === "VCSSClassSelector") {
-            postcssText = postcssText.replace(
-                /\s*\/\*(?![\s\S]*\*\/[\s\S]*\/\*)([\s\S]*?)\*\/\s*$/u,
-                "",
-            )
-            postcssText = postcssText.replace(/^\s*\/\*([\s\S]*?)\*\/\s*/u, "")
-            postcssText = postcssText.replace(/^\s*\/\/([^\n]*)\s*/u, "")
-            // eslint-disable-next-line regexp/no-super-linear-backtracking -- for test
-            postcssText = postcssText.replace(/\s*\/\/([^\n]*)\s*$/u, "")
-        } else if (node.type === "VCSSSelectorCombinator") {
-            postcssText = postcssText.replace(
-                /\/\*(?![\s\S]*\*\/[\s\S]*\/\*)([\s\S]*?)\*\/\s*$/u,
-                "",
-            )
-            postcssText = postcssText.replace(/^\s*\/\*([\s\S]*?)\*\//u, "")
-            // eslint-disable-next-line regexp/no-super-linear-backtracking -- for test
-            postcssText = postcssText.replace(/\/\/([^\n]*)\s*$/u, "")
-            // eslint-disable-next-line regexp/no-super-linear-backtracking -- for test
-            postcssText = postcssText.replace(/\s*\/\/([^\n]*)\s*$/u, "")
-        }
-        if (
-            node.type === "VCSSSelectorCombinator" &&
-            postcssText.trim() === ""
-        ) {
-            // noop
-        } else if (node.type === "VCSSNestingSelector") {
-            rangeText = rangeText.trim()
-            postcssText = postcssText.trim()
-        } else if (node.type === "VCSSStyleSheet") {
-            // noop
-        } else if (node.type === "VCSSDeclarationProperty") {
-            rangeText = rangeText.replace(/^\*|\s*;\s*$/g, "")
-            postcssText = postcssText.trim()
-        } else if (node.type === "VCSSAtRule") {
-            rangeText = rangeText.replace(/\s*;\s*$/g, "")
-            postcssText = postcssText.trim()
-        } else {
-            postcssText = postcssText.trim()
-        }
-        assert.strictEqual(
-            `${node.type}:\n${rangeText}`,
-            `${node.type}:\n${postcssText}`,
-        )
+  if (node.node) {
+    let rangeText = code.slice(...node.range);
+    let postcssText = (node.node as any).toString((STRINGIFYS as any)[lang]);
+    if (node.type === "VCSSSelector" || node.type === "VCSSClassSelector") {
+      postcssText = postcssText.replace(
+        /\s*\/\*(?![\s\S]*\*\/[\s\S]*\/\*)([\s\S]*?)\*\/\s*$/u,
+        ""
+      );
+      postcssText = postcssText.replace(/^\s*\/\*([\s\S]*?)\*\/\s*/u, "");
+      postcssText = postcssText.replace(/^\s*\/\/([^\n]*)\s*/u, "");
+      // eslint-disable-next-line regexp/no-super-linear-backtracking -- for test
+      postcssText = postcssText.replace(/\s*\/\/([^\n]*)\s*$/u, "");
+    } else if (node.type === "VCSSSelectorCombinator") {
+      postcssText = postcssText.replace(
+        /\/\*(?![\s\S]*\*\/[\s\S]*\/\*)([\s\S]*?)\*\/\s*$/u,
+        ""
+      );
+      postcssText = postcssText.replace(/^\s*\/\*([\s\S]*?)\*\//u, "");
+      // eslint-disable-next-line regexp/no-super-linear-backtracking -- for test
+      postcssText = postcssText.replace(/\/\/([^\n]*)\s*$/u, "");
+      // eslint-disable-next-line regexp/no-super-linear-backtracking -- for test
+      postcssText = postcssText.replace(/\s*\/\/([^\n]*)\s*$/u, "");
     }
-    if (node.type === "VCSSStyleSheet") {
-        if (node.errors.length) {
-            return
-        }
-        const text = code.slice(...node.range)
-        assert.strictEqual(text, (node.node as any).source.input.css)
-    } else if (node.type === "VCSSStyleRule") {
-        const text = code.slice(...node.range)
-        assert.strictEqual(
-            text.slice(0, node.rawSelectorText.length),
-            node.rawSelectorText,
-        )
-        if (lang !== "stylus") {
-            assert.strictEqual(text[text.length - 1], "}")
-        }
-        for (const n of node.selectors) {
-            checkCSSNodeLocations(code, n, lang)
-        }
+    if (node.type === "VCSSSelectorCombinator" && postcssText.trim() === "") {
+      // noop
+    } else if (node.type === "VCSSNestingSelector") {
+      rangeText = rangeText.trim();
+      postcssText = postcssText.trim();
+    } else if (node.type === "VCSSStyleSheet") {
+      // noop
     } else if (node.type === "VCSSDeclarationProperty") {
-        const text = code.slice(...node.range)
-        assert.ok(text.includes(node.property), "node.property")
-        assert.ok(text.includes(node.value), "node.value")
-        if (text.indexOf(node.value) !== text.length - node.value.length) {
-            assert.strictEqual(text[text.length - 1], ";")
-        }
+      rangeText = rangeText.replace(/^\*|\s*;\s*$/g, "");
+      postcssText = postcssText.trim();
     } else if (node.type === "VCSSAtRule") {
-        const text = code.slice(...node.range)
-        const expected =
-            lang !== "stylus"
-                ? `@${node.name}`
-                : `${(node.node as any).raws.identifier ?? "@"}${node.name}`
-        assert.strictEqual(text.slice(0, expected.length), expected)
-        if (lang !== "stylus") {
-            const last = text[text.length - 1]
-            assert.ok(
-                last === "}" || last === ";",
-                `act:${text[text.length - 1]}`,
-            )
-        }
-    } else if (node.type === "VCSSSelector") {
-        const parent = node.parent as VCSSAtRule
-
-        if (parent.selectors) {
-            // parent===VCSSStyleRule
-            const selectorTexts = parent.selectors.map((s) =>
-                code.slice(...s.range),
-            )
-            const rawSelectorText = parent.rawSelectorText as string
-            let index = 0
-            for (const selectorText of selectorTexts) {
-                const idx = rawSelectorText.indexOf(selectorText, index)
-                if (idx >= 0) {
-                    assert.strictEqual(
-                        selectorText,
-                        rawSelectorText.slice(idx, idx + selectorText.length),
-                    )
-                    index = idx + selectorText.length
-                } else {
-                    assert.strictEqual(
-                        selectorText,
-                        rawSelectorText.slice(
-                            index,
-                            index + selectorText.length,
-                        ),
-                    )
-                }
-            }
-        }
-    } else if (
-        node.type === "VCSSTypeSelector" ||
-        node.type === "VCSSIDSelector" ||
-        node.type === "VCSSClassSelector" ||
-        node.type === "VCSSUniversalSelector" ||
-        node.type === "VCSSAttributeSelector" ||
-        node.type === "VCSSSelectorCombinator"
-    ) {
-        const text = code.slice(...node.range)
+      rangeText = rangeText.replace(/\s*;\s*$/g, "");
+      postcssText = postcssText.trim();
+    } else {
+      postcssText = postcssText.trim();
+    }
+    assert.strictEqual(
+      `${node.type}:\n${rangeText}`,
+      `${node.type}:\n${postcssText}`
+    );
+  }
+  if (node.type === "VCSSStyleSheet") {
+    if (node.errors.length) {
+      return;
+    }
+    const text = code.slice(...node.range);
+    assert.strictEqual(text, (node.node as any).source.input.css);
+  } else if (node.type === "VCSSStyleRule") {
+    const text = code.slice(...node.range);
+    assert.strictEqual(
+      text.slice(0, node.rawSelectorText.length),
+      node.rawSelectorText
+    );
+    if (lang !== "stylus") {
+      assert.strictEqual(text[text.length - 1], "}");
+    }
+    for (const n of node.selectors) {
+      checkCSSNodeLocations(code, n, lang);
+    }
+  } else if (node.type === "VCSSDeclarationProperty") {
+    const text = code.slice(...node.range);
+    assert.ok(text.includes(node.property), "node.property");
+    assert.ok(text.includes(node.value), "node.value");
+    if (text.indexOf(node.value) !== text.length - node.value.length) {
+      assert.strictEqual(text[text.length - 1], ";");
+    }
+  } else if (node.type === "VCSSAtRule") {
+    const text = code.slice(...node.range);
+    const expected =
+      lang !== "stylus"
+        ? `@${node.name}`
+        : `${(node.node as any).raws.identifier ?? "@"}${node.name}`;
+    assert.strictEqual(text.slice(0, expected.length), expected);
+    if (lang !== "stylus") {
+      const last = text[text.length - 1];
+      assert.ok(last === "}" || last === ";", `act:${text[text.length - 1]}`);
+    }
+  } else if (node.type === "VCSSSelector") {
+    const parent = node.parent as VCSSAtRule;
 
-        if (text.trim()) {
-            assert.strictEqual(text, node.selector)
+    if (parent.selectors) {
+      // parent===VCSSStyleRule
+      const selectorTexts = parent.selectors.map((s) => code.slice(...s.range));
+      const rawSelectorText = parent.rawSelectorText as string;
+      let index = 0;
+      for (const selectorText of selectorTexts) {
+        const idx = rawSelectorText.indexOf(selectorText, index);
+        if (idx >= 0) {
+          assert.strictEqual(
+            selectorText,
+            rawSelectorText.slice(idx, idx + selectorText.length)
+          );
+          index = idx + selectorText.length;
         } else {
-            assert.strictEqual(text.trim(), node.selector.trim())
+          assert.strictEqual(
+            selectorText,
+            rawSelectorText.slice(index, index + selectorText.length)
+          );
         }
-    } else if (node.type === "VCSSNestingSelector") {
-        const text = code.slice(...node.range)
-        assert.strictEqual(text.trim(), node.selector.trim())
-    } else if (node.type === "VCSSSelectorPseudo") {
-        const text = code.slice(...node.range)
-
-        assert.strictEqual(text.slice(0, node.value.length), node.value)
-    } else if (node.type === "VCSSUnknownSelector") {
-        const text = code.slice(...node.range)
+      }
+    }
+  } else if (
+    node.type === "VCSSTypeSelector" ||
+    node.type === "VCSSIDSelector" ||
+    node.type === "VCSSClassSelector" ||
+    node.type === "VCSSUniversalSelector" ||
+    node.type === "VCSSAttributeSelector" ||
+    node.type === "VCSSSelectorCombinator"
+  ) {
+    const text = code.slice(...node.range);
 
-        assert.strictEqual(text, node.value)
+    if (text.trim()) {
+      assert.strictEqual(text, node.selector);
     } else {
-        // Need to add testcase
-        console.log(node)
+      assert.strictEqual(text.trim(), node.selector.trim());
     }
-    if ((node as any).nodes) {
-        for (const n of (node as any).nodes) {
-            checkCSSNodeLocations(code, n, lang)
-        }
+  } else if (node.type === "VCSSNestingSelector") {
+    const text = code.slice(...node.range);
+    assert.strictEqual(text.trim(), node.selector.trim());
+  } else if (node.type === "VCSSSelectorPseudo") {
+    const text = code.slice(...node.range);
+
+    assert.strictEqual(text.slice(0, node.value.length), node.value);
+  } else if (node.type === "VCSSUnknownSelector") {
+    const text = code.slice(...node.range);
+
+    assert.strictEqual(text, node.value);
+  } else {
+    // Need to add testcase
+    console.log(node);
+  }
+  if ((node as any).nodes) {
+    for (const n of (node as any).nodes) {
+      checkCSSNodeLocations(code, n, lang);
     }
+  }
 }
 
 function deepCopy(node: any) {
-    const newNode = node.copy()
-    if (newNode.nodes) {
-        newNode.nodes = newNode.nodes.map(deepCopy).map((c: any) => {
-            c.parent = newNode
-            return c
-        })
-    }
-    if (newNode.comments) {
-        newNode.comments = newNode.comments.map(deepCopy).map((c: any) => {
-            c.parent = newNode
-            return c
-        })
-    }
-    if (newNode.selectors) {
-        newNode.selectors = newNode.selectors.map(deepCopy).map((c: any) => {
-            c.parent = newNode
-            return c
-        })
-    }
+  const newNode = node.copy();
+  if (newNode.nodes) {
+    newNode.nodes = newNode.nodes.map(deepCopy).map((c: any) => {
+      c.parent = newNode;
+      return c;
+    });
+  }
+  if (newNode.comments) {
+    newNode.comments = newNode.comments.map(deepCopy).map((c: any) => {
+      c.parent = newNode;
+      return c;
+    });
+  }
+  if (newNode.selectors) {
+    newNode.selectors = newNode.selectors.map(deepCopy).map((c: any) => {
+      c.parent = newNode;
+      return c;
+    });
+  }
 
-    return newNode
+  return newNode;
 }
diff --git a/tests/lib/styles/selectors/index.ts b/tests/lib/styles/selectors/index.ts
index 83fcbb4b..980239c3 100644
--- a/tests/lib/styles/selectors/index.ts
+++ b/tests/lib/styles/selectors/index.ts
@@ -1,11 +1,11 @@
-import assert from "assert"
+import assert from "assert";
 
-import fs from "fs"
-import path from "path"
+import fs from "fs";
+import path from "path";
 
-import { getStyleFixtureResults, writeFixture } from "../test-utils"
-import { getResolvedSelectors } from "../../../../lib/styles/selectors"
-import type { ValidStyleContext } from "../../../../lib/styles/context"
+import { getStyleFixtureResults, writeFixture } from "../test-utils";
+import { getResolvedSelectors } from "../../../../lib/styles/selectors";
+import type { ValidStyleContext } from "../../../../lib/styles/context";
 
 /**
  * Remove `parent` proeprties from the given AST.
@@ -14,65 +14,65 @@ import type { ValidStyleContext } from "../../../../lib/styles/context"
  * @returns {any} The value of the key to output.
  */
 function replacer(key: string, value: any): any {
-    if (key === "parent" || key === "node" || key === "lang") {
-        return undefined
-    }
-    return value
+  if (key === "parent" || key === "node" || key === "lang") {
+    return undefined;
+  }
+  return value;
 }
 
 describe("CSS Selectors Test.", () => {
-    for (const { name, style, dir } of getStyleFixtureResults()) {
-        describe(`'styles/fixtures/${name}/source.vue'`, () => {
-            it("should be parsed to valid selectors.", () => {
-                const resultPath = path.join(dir, "selectors.json")
+  for (const { name, style, dir } of getStyleFixtureResults()) {
+    describe(`'styles/fixtures/${name}/source.vue'`, () => {
+      it("should be parsed to valid selectors.", () => {
+        const resultPath = path.join(dir, "selectors.json");
 
-                const actual = JSON.stringify(
-                    getResolvedSelectors(style as ValidStyleContext).map(
-                        (r) => r.selector,
-                    ),
-                    replacer,
-                    4,
-                )
+        const actual = JSON.stringify(
+          getResolvedSelectors(style as ValidStyleContext).map(
+            (r) => r.selector
+          ),
+          replacer,
+          4
+        );
 
-                try {
-                    const expected = fs.readFileSync(resultPath, "utf8")
+        try {
+          const expected = fs.readFileSync(resultPath, "utf8");
 
-                    assert.strictEqual(actual, expected)
-                } catch (e) {
-                    writeFixture(resultPath, actual)
-                    throw e
-                }
-            })
-            it("should be parsed to valid selectors text.", () => {
-                const resultPath = path.join(dir, "selectors-text.json")
+          assert.strictEqual(actual, expected);
+        } catch (e) {
+          writeFixture(resultPath, actual);
+          throw e;
+        }
+      });
+      it("should be parsed to valid selectors text.", () => {
+        const resultPath = path.join(dir, "selectors-text.json");
 
-                const actual = JSON.stringify(
-                    getResolvedSelectors(style as ValidStyleContext).map((r) =>
-                        // eslint-disable-next-line max-nested-callbacks -- test
-                        r.selector.map((s) => s.selector),
-                    ),
-                    replacer,
-                    4,
-                )
+        const actual = JSON.stringify(
+          getResolvedSelectors(style as ValidStyleContext).map((r) =>
+            // eslint-disable-next-line max-nested-callbacks -- test
+            r.selector.map((s) => s.selector)
+          ),
+          replacer,
+          4
+        );
 
-                try {
-                    const expected = fs.readFileSync(resultPath, "utf8")
+        try {
+          const expected = fs.readFileSync(resultPath, "utf8");
 
-                    assert.strictEqual(actual, expected)
-                } catch (e) {
-                    writeFixture(resultPath, actual)
-                    throw e
-                }
-            })
-            it("AST should not be changed.", () => {
-                const resultPath = path.join(dir, "ast.json")
+          assert.strictEqual(actual, expected);
+        } catch (e) {
+          writeFixture(resultPath, actual);
+          throw e;
+        }
+      });
+      it("AST should not be changed.", () => {
+        const resultPath = path.join(dir, "ast.json");
 
-                const actual = JSON.stringify(style.cssNode, replacer, 4)
+        const actual = JSON.stringify(style.cssNode, replacer, 4);
 
-                const expected = fs.readFileSync(resultPath, "utf8")
+        const expected = fs.readFileSync(resultPath, "utf8");
 
-                assert.strictEqual(actual, expected)
-            })
-        })
-    }
-})
+        assert.strictEqual(actual, expected);
+      });
+    });
+  }
+});
diff --git a/tests/lib/styles/selectors/query.ts b/tests/lib/styles/selectors/query.ts
index 89e95386..e79dd5ca 100644
--- a/tests/lib/styles/selectors/query.ts
+++ b/tests/lib/styles/selectors/query.ts
@@ -1,29 +1,29 @@
-import assert from "assert"
+import assert from "assert";
 
-import fs from "fs"
-import path from "path"
+import fs from "fs";
+import path from "path";
 
-import { createQueryContext } from "../../../../lib/styles/selectors/query"
-import { getResolvedSelectors } from "../../../../lib/styles/selectors"
+import { createQueryContext } from "../../../../lib/styles/selectors/query";
+import { getResolvedSelectors } from "../../../../lib/styles/selectors";
 
 import {
-    getStyleFixtureResults,
-    writeFixture,
-    deleteFixture,
-    isExistsPath,
-} from "../test-utils"
-import type { AST, RuleContext, VDirectiveKey } from "../../../../lib/types"
+  getStyleFixtureResults,
+  writeFixture,
+  deleteFixture,
+  isExistsPath,
+} from "../test-utils";
+import type { AST, RuleContext, VDirectiveKey } from "../../../../lib/types";
 import type {
-    StyleContext,
-    ValidStyleContext,
-} from "../../../../lib/styles/context"
-import { parseQueryOptions } from "../../../../lib/options"
+  StyleContext,
+  ValidStyleContext,
+} from "../../../../lib/styles/context";
+import { parseQueryOptions } from "../../../../lib/options";
 import {
-    isVDirective,
-    isVDirectiveKeyV6,
-} from "../../../../lib/utils/templates"
+  isVDirective,
+  isVDirectiveKeyV6,
+} from "../../../../lib/utils/templates";
 
-const ROOT = path.join(__dirname, "../fixtures/selectors/query")
+const ROOT = path.join(__dirname, "../fixtures/selectors/query");
 
 /**
  * Remove `parent` properties from the given AST.
@@ -32,210 +32,193 @@ const ROOT = path.join(__dirname, "../fixtures/selectors/query")
  * @returns {any} The value of the key to output.
  */
 function replacer(key: string, value: any): any {
-    if (key === "parent" || key === "node" || key === "lang") {
-        return undefined
-    }
-    return value
+  if (key === "parent" || key === "node" || key === "lang") {
+    return undefined;
+  }
+  return value;
 }
 
 function queries(style: StyleContext, context: RuleContext) {
-    const selectors = getResolvedSelectors(style as ValidStyleContext)
-    return selectors
-        .map((r) => r.selector)
-        .reduce((result, selector) => {
-            let q = createQueryContext(context, parseQueryOptions({}))
-            for (const node of selector) {
-                q = q.queryStep(node)
-            }
-            const elementsTexts = q.elements.map((e) =>
-                buildElementText(e, context),
-            )
-            const selectorText = selector.map((s) => s.selector).join("")
-            result[selectorText] = elementsTexts
-            return result
-        }, {} as { [key: string]: string[] })
+  const selectors = getResolvedSelectors(style as ValidStyleContext);
+  return selectors
+    .map((r) => r.selector)
+    .reduce((result, selector) => {
+      let q = createQueryContext(context, parseQueryOptions({}));
+      for (const node of selector) {
+        q = q.queryStep(node);
+      }
+      const elementsTexts = q.elements.map((e) => buildElementText(e, context));
+      const selectorText = selector.map((s) => s.selector).join("");
+      result[selectorText] = elementsTexts;
+      return result;
+    }, {} as { [key: string]: string[] });
 }
 
 function reverseQueries(style: StyleContext, context: RuleContext) {
-    const selectors = getResolvedSelectors(style as ValidStyleContext)
-    return selectors
-        .map((r) => r.selector)
-        .reduce((result, selector) => {
-            const document = createQueryContext(context, parseQueryOptions({}))
-            const elementQueries = document.split()
-            const elementsTexts = elementQueries
-                .filter((elementQuery) => {
-                    // Set dummy document
-                    ;(elementQuery as any).document = elementQuery
-                    ;(elementQuery as any).context = (document as any).context
-                    ;(elementQuery as any).options = (document as any).options
-                    ;(elementQuery as any).docsModifiers = (
-                        document as any
-                    ).docsModifiers
-                    let q = elementQuery
-                    for (let index = selector.length - 1; index >= 0; index--) {
-                        q = q.reverseQueryStep(selector[index])
-                    }
-                    return Boolean(q.elements.length)
-                })
-                .map((elementQuery) => elementQuery.elements[0])
-                .map((e) => buildElementText(e, context))
-            const selectorText = selector.map((s) => s.selector).join("")
-            result[selectorText] = elementsTexts
-            return result
-        }, {} as { [key: string]: string[] })
+  const selectors = getResolvedSelectors(style as ValidStyleContext);
+  return selectors
+    .map((r) => r.selector)
+    .reduce((result, selector) => {
+      const document = createQueryContext(context, parseQueryOptions({}));
+      const elementQueries = document.split();
+      const elementsTexts = elementQueries
+        .filter((elementQuery) => {
+          // Set dummy document
+          (elementQuery as any).document = elementQuery;
+          (elementQuery as any).context = (document as any).context;
+          (elementQuery as any).options = (document as any).options;
+          (elementQuery as any).docsModifiers = (document as any).docsModifiers;
+          let q = elementQuery;
+          for (let index = selector.length - 1; index >= 0; index--) {
+            q = q.reverseQueryStep(selector[index]);
+          }
+          return Boolean(q.elements.length);
+        })
+        .map((elementQuery) => elementQuery.elements[0])
+        .map((e) => buildElementText(e, context));
+      const selectorText = selector.map((s) => s.selector).join("");
+      result[selectorText] = elementsTexts;
+      return result;
+    }, {} as { [key: string]: string[] });
 }
 
 function buildElementText(e: AST.VElement, context: RuleContext): string {
-    const id = getAttrText(e, "id", context)
-    const className = getAttrText(e, "class", context)
-    const idText = id
-        ? `#${id.type === "value" ? id.value : `{${id.value}}`}`
-        : ""
-    const classText = className
-        ? `.${
-              className.type === "value"
-                  ? className.value.split(/\s+/u).join(".")
-                  : `{${className.value}}`
-          }`
-        : ""
-    const text = `${e.name}${idText}${classText}`
-    if (
-        e.parent &&
-        e.parent.parent &&
-        e.parent.parent.parent // e.parent.parent === tempalte
-    ) {
-        return `${buildElementText(e.parent, context)}>${text}`
-    }
-    return text
+  const id = getAttrText(e, "id", context);
+  const className = getAttrText(e, "class", context);
+  const idText = id
+    ? `#${id.type === "value" ? id.value : `{${id.value}}`}`
+    : "";
+  const classText = className
+    ? `.${
+        className.type === "value"
+          ? className.value.split(/\s+/u).join(".")
+          : `{${className.value}}`
+      }`
+    : "";
+  const text = `${e.name}${idText}${classText}`;
+  if (
+    e.parent &&
+    e.parent.parent &&
+    e.parent.parent.parent // e.parent.parent === tempalte
+  ) {
+    return `${buildElementText(e.parent, context)}>${text}`;
+  }
+  return text;
 }
 
 // eslint-disable-next-line complexity -- test
 function getAttrText(
-    element: AST.VElement,
-    name: string,
-    context: RuleContext,
+  element: AST.VElement,
+  name: string,
+  context: RuleContext
 ) {
-    const { startTag } = element
-    for (const attr of startTag.attributes) {
-        if (!isVDirective(attr)) {
-            const { key, value } = attr
-            if (key.name === name) {
-                return {
-                    type: "value",
-                    value: (value && value.value) || "",
-                }
-            }
-        } else {
-            const key = attr.key as VDirectiveKey
-            const { value } = attr
-            if (isVDirectiveKeyV6(key)) {
-                if (key.name.name !== "bind") {
-                    continue
-                }
-                if (
-                    key.argument &&
-                    (key.argument.type !== "VIdentifier" ||
-                        key.argument.name !== name)
-                ) {
-                    continue
-                }
-                return {
-                    type: "expr",
-                    value:
-                        (value &&
-                            value.expression &&
-                            context
-                                .getSourceCode()
-                                .getText(value.expression)) ||
-                        "",
-                }
-            }
-            // vue-eslint-parser@<6.0.0
-            if (key.name !== "bind") {
-                continue
-            }
-            if (key.argument !== name) {
-                continue
-            }
-            return {
-                type: "expr",
-                value:
-                    (value &&
-                        value.expression &&
-                        context.getSourceCode().getText(value.expression)) ||
-                    "",
-            }
+  const { startTag } = element;
+  for (const attr of startTag.attributes) {
+    if (!isVDirective(attr)) {
+      const { key, value } = attr;
+      if (key.name === name) {
+        return {
+          type: "value",
+          value: (value && value.value) || "",
+        };
+      }
+    } else {
+      const key = attr.key as VDirectiveKey;
+      const { value } = attr;
+      if (isVDirectiveKeyV6(key)) {
+        if (key.name.name !== "bind") {
+          continue;
         }
+        if (
+          key.argument &&
+          (key.argument.type !== "VIdentifier" || key.argument.name !== name)
+        ) {
+          continue;
+        }
+        return {
+          type: "expr",
+          value:
+            (value &&
+              value.expression &&
+              context.getSourceCode().getText(value.expression)) ||
+            "",
+        };
+      }
+      // vue-eslint-parser@<6.0.0
+      if (key.name !== "bind") {
+        continue;
+      }
+      if (key.argument !== name) {
+        continue;
+      }
+      return {
+        type: "expr",
+        value:
+          (value &&
+            value.expression &&
+            context.getSourceCode().getText(value.expression)) ||
+          "",
+      };
     }
-    return null
+  }
+  return null;
 }
 
 describe("CSS Query Test.", () => {
-    for (const { name, style, context, dir } of getStyleFixtureResults(ROOT)) {
-        describe(`'styles/selectors/query/fixtures/${name}/source.vue'`, () => {
-            it("should be query results to valid ressults.", () => {
-                const resultPath = path.join(dir, "query-result.json")
-
-                const actual = JSON.stringify(
-                    queries(style, context),
-                    replacer,
-                    4,
-                )
-
-                try {
-                    const expected = fs.readFileSync(resultPath, "utf8")
-
-                    assert.strictEqual(actual, expected)
-                } catch (e) {
-                    writeFixture(resultPath, actual)
-                    throw e
-                }
-            })
-
-            it("should be reverse query results to valid ressults.", () => {
-                const resultPathNormal = path.join(dir, "query-result.json")
-                const resultPathReverse = path.join(
-                    dir,
-                    "reverse-query-result.json",
-                )
-
-                const actual = JSON.stringify(
-                    reverseQueries(style, context),
-                    replacer,
-                    4,
-                )
-                const expectedNormal = fs.readFileSync(resultPathNormal, "utf8")
-                if (isExistsPath(resultPathReverse)) {
-                    let expectedReverse = null
-                    try {
-                        expectedReverse = fs.readFileSync(
-                            resultPathReverse,
-                            "utf8",
-                        )
-                        assert.strictEqual(actual, expectedReverse)
-                    } catch (e) {
-                        writeFixture(resultPathReverse, actual)
-                        throw e
-                    }
-
-                    try {
-                        assert.notStrictEqual(expectedReverse, expectedNormal)
-                    } catch (e) {
-                        if (expectedReverse) {
-                            deleteFixture(resultPathReverse)
-                        }
-                        throw e
-                    }
-                } else {
-                    try {
-                        assert.strictEqual(actual, expectedNormal)
-                    } catch (e) {
-                        writeFixture(resultPathReverse, actual)
-                        throw e
-                    }
-                }
-            })
-        })
-    }
-})
+  for (const { name, style, context, dir } of getStyleFixtureResults(ROOT)) {
+    describe(`'styles/selectors/query/fixtures/${name}/source.vue'`, () => {
+      it("should be query results to valid ressults.", () => {
+        const resultPath = path.join(dir, "query-result.json");
+
+        const actual = JSON.stringify(queries(style, context), replacer, 4);
+
+        try {
+          const expected = fs.readFileSync(resultPath, "utf8");
+
+          assert.strictEqual(actual, expected);
+        } catch (e) {
+          writeFixture(resultPath, actual);
+          throw e;
+        }
+      });
+
+      it("should be reverse query results to valid ressults.", () => {
+        const resultPathNormal = path.join(dir, "query-result.json");
+        const resultPathReverse = path.join(dir, "reverse-query-result.json");
+
+        const actual = JSON.stringify(
+          reverseQueries(style, context),
+          replacer,
+          4
+        );
+        const expectedNormal = fs.readFileSync(resultPathNormal, "utf8");
+        if (isExistsPath(resultPathReverse)) {
+          let expectedReverse = null;
+          try {
+            expectedReverse = fs.readFileSync(resultPathReverse, "utf8");
+            assert.strictEqual(actual, expectedReverse);
+          } catch (e) {
+            writeFixture(resultPathReverse, actual);
+            throw e;
+          }
+
+          try {
+            assert.notStrictEqual(expectedReverse, expectedNormal);
+          } catch (e) {
+            if (expectedReverse) {
+              deleteFixture(resultPathReverse);
+            }
+            throw e;
+          }
+        } else {
+          try {
+            assert.strictEqual(actual, expectedNormal);
+          } catch (e) {
+            writeFixture(resultPathReverse, actual);
+            throw e;
+          }
+        }
+      });
+    });
+  }
+});
diff --git a/tests/lib/styles/test-utils.ts b/tests/lib/styles/test-utils.ts
index 851d6c86..354ab9dd 100644
--- a/tests/lib/styles/test-utils.ts
+++ b/tests/lib/styles/test-utils.ts
@@ -1,104 +1,104 @@
-import eslint from "eslint"
+import eslint from "eslint";
 
-import fs from "fs"
-import path from "path"
+import fs from "fs";
+import path from "path";
 
-import type { RuleContext } from "../../../lib/types"
-import type { StyleContext } from "../../../lib/styles/context"
-import { getStyleContexts } from "../../../lib/styles/context"
+import type { RuleContext } from "../../../lib/types";
+import type { StyleContext } from "../../../lib/styles/context";
+import { getStyleContexts } from "../../../lib/styles/context";
 
-const ROOT = path.join(__dirname, "./fixtures/index")
+const ROOT = path.join(__dirname, "./fixtures/index");
 
-const ruleId = "test"
+const ruleId = "test";
 
 const config = {
-    parser: "vue-eslint-parser",
-    parserOptions: { ecmaVersion: 2019, sourceType: "module" },
-    rules: {
-        [ruleId]: "error",
-    },
-}
+  parser: "vue-eslint-parser",
+  parserOptions: { ecmaVersion: 2019, sourceType: "module" },
+  rules: {
+    [ruleId]: "error",
+  },
+};
 
 /**
  * Execute eslint
  * @param {string} source the source code
  */
 function executeLint(
-    source: string,
-    sourcePath: string,
-    _name: string,
+  source: string,
+  sourcePath: string,
+  _name: string
 ): { style: StyleContext; context: RuleContext } {
-    const linter = new eslint.Linter()
-    let style: StyleContext | null = null
-    let context: RuleContext | null = null
-    let err = null
-    linter.defineParser("vue-eslint-parser", require("vue-eslint-parser"))
-    linter.defineRule(ruleId, {
-        create(ctx: RuleContext) {
-            try {
-                context = ctx
-                style = getStyleContexts(ctx)[0]
-            } catch (e) {
-                err = e
-            }
-            return {}
-        },
-    } as any)
-    linter.verifyAndFix(source, config as any, sourcePath)
-    if (err) {
-        throw err
-    }
-    if (!style || !context) {
-        throw new Error("invalid state")
-    }
-    return { style, context }
+  const linter = new eslint.Linter();
+  let style: StyleContext | null = null;
+  let context: RuleContext | null = null;
+  let err = null;
+  linter.defineParser("vue-eslint-parser", require("vue-eslint-parser"));
+  linter.defineRule(ruleId, {
+    create(ctx: RuleContext) {
+      try {
+        context = ctx;
+        style = getStyleContexts(ctx)[0];
+      } catch (e) {
+        err = e;
+      }
+      return {};
+    },
+  } as any);
+  linter.verifyAndFix(source, config as any, sourcePath);
+  if (err) {
+    throw err;
+  }
+  if (!style || !context) {
+    throw new Error("invalid state");
+  }
+  return { style, context };
 }
 
 export function* getStyleFixtureResults(rootDir = ROOT): IterableIterator<{
-    name: string
-    style: StyleContext
-    source: string
-    context: RuleContext
-    dir: string
+  name: string;
+  style: StyleContext;
+  source: string;
+  context: RuleContext;
+  dir: string;
 }> {
-    for (const name of fs.readdirSync(rootDir)) {
-        if (name === ".DS_Store") {
-            continue
-        }
-        const sourcePath = path.join(rootDir, `${name}/source.vue`)
-        const source = fs.readFileSync(sourcePath, "utf8")
-
-        const { style, context } = executeLint(source, sourcePath, name)
-        yield {
-            name,
-            style,
-            source,
-            context,
-            dir: path.join(rootDir, `${name}`),
-        }
+  for (const name of fs.readdirSync(rootDir)) {
+    if (name === ".DS_Store") {
+      continue;
     }
+    const sourcePath = path.join(rootDir, `${name}/source.vue`);
+    const source = fs.readFileSync(sourcePath, "utf8");
+
+    const { style, context } = executeLint(source, sourcePath, name);
+    yield {
+      name,
+      style,
+      source,
+      context,
+      dir: path.join(rootDir, `${name}`),
+    };
+  }
 }
 
 export function writeFixture(expectFilepath: string, content: string): void {
-    // eslint-disable-next-line no-process-env -- test
-    if (process.env.UPDATE_FIXTURE) {
-        fs.writeFileSync(expectFilepath, content, "utf8")
-    }
+  // eslint-disable-next-line no-process-env -- test
+  if (process.env.UPDATE_FIXTURE) {
+    fs.writeFileSync(expectFilepath, content, "utf8");
+  }
 }
 export function deleteFixture(filepath: string): void {
-    // eslint-disable-next-line no-process-env -- test
-    if (process.env.UPDATE_FIXTURE) {
-        fs.unlinkSync(filepath)
-    }
+  // eslint-disable-next-line no-process-env -- test
+  if (process.env.UPDATE_FIXTURE) {
+    fs.unlinkSync(filepath);
+  }
 }
 export function isExistsPath(filepath: string): boolean {
-    try {
-        fs.statSync(filepath)
-        return true
-    } catch (error: any) {
-        if (error.code === "ENOENT") {
-            return false
-        }
-        throw error
+  try {
+    fs.statSync(filepath);
+    return true;
+  } catch (error: any) {
+    if (error.code === "ENOENT") {
+      return false;
     }
+    throw error;
+  }
 }
diff --git a/tests/lib/utils/rules.ts b/tests/lib/utils/rules.ts
index 70b154c3..548e7082 100644
--- a/tests/lib/utils/rules.ts
+++ b/tests/lib/utils/rules.ts
@@ -1,60 +1,57 @@
-import assert from "assert"
-import path from "path"
-import fs from "fs"
+import assert from "assert";
+import path from "path";
+import fs from "fs";
 
-import { collectRules, rules as allRules } from "../../../lib/utils/rules"
+import { collectRules, rules as allRules } from "../../../lib/utils/rules";
 
 /**
  * @returns {Array} Get the list of rules placed in the directory.
  */
 function getDirRules() {
-    const rulesRoot = path.resolve(__dirname, "../../../lib/rules")
-    const result = fs.readdirSync(rulesRoot)
-    const rules: { [key: string]: any } = {}
-    for (const name of result) {
-        const ruleName = name.replace(/\.ts$/u, "")
-        const ruleId = `vue-scoped-css/${ruleName}`
-        const rule = require(path.join(rulesRoot, name))
-        rules[ruleId] = rule
-    }
-    return rules
+  const rulesRoot = path.resolve(__dirname, "../../../lib/rules");
+  const result = fs.readdirSync(rulesRoot);
+  const rules: { [key: string]: any } = {};
+  for (const name of result) {
+    const ruleName = name.replace(/\.ts$/u, "");
+    const ruleId = `vue-scoped-css/${ruleName}`;
+    const rule = require(path.join(rulesRoot, name));
+    rules[ruleId] = rule;
+  }
+  return rules;
 }
 
-const dirRules = getDirRules()
+const dirRules = getDirRules();
 
 describe("Check if the struct of all rules is correct", () => {
-    it("rule count equals (collectRules)", () => {
-        const collect = collectRules()
+  it("rule count equals (collectRules)", () => {
+    const collect = collectRules();
 
-        const deprecatedRules = allRules.filter((r) => r.meta.deprecated)
-        assert.ok(
-            Object.keys(collect).length + deprecatedRules.length ===
-                Object.keys(dirRules).length,
-            `Did not equal the number of rules. expect:${
-                Object.keys(dirRules).length
-            } actual:${Object.keys(collect).length}`,
-        )
-    })
-    it("rule count equals (rules)", () => {
-        assert.ok(
-            allRules.length === Object.keys(dirRules).length,
-            `Did not equal the number of rules. expect:${
-                Object.keys(dirRules).length
-            } actual:${allRules.length}`,
-        )
-    })
+    const deprecatedRules = allRules.filter((r) => r.meta.deprecated);
+    assert.ok(
+      Object.keys(collect).length + deprecatedRules.length ===
+        Object.keys(dirRules).length,
+      `Did not equal the number of rules. expect:${
+        Object.keys(dirRules).length
+      } actual:${Object.keys(collect).length}`
+    );
+  });
+  it("rule count equals (rules)", () => {
+    assert.ok(
+      allRules.length === Object.keys(dirRules).length,
+      `Did not equal the number of rules. expect:${
+        Object.keys(dirRules).length
+      } actual:${allRules.length}`
+    );
+  });
 
-    for (const rule of allRules) {
-        it(rule.meta.docs?.ruleId || "", () => {
-            assert.ok(Boolean(rule.meta.docs.ruleId), "Did not set `ruleId`")
-            assert.ok(
-                Boolean(rule.meta.docs.ruleName),
-                "Did not set `ruleName`",
-            )
-            assert.ok(
-                Boolean(dirRules[rule.meta.docs?.ruleId || ""]),
-                "Did not exist rule",
-            )
-        })
-    }
-})
+  for (const rule of allRules) {
+    it(rule.meta.docs?.ruleId || "", () => {
+      assert.ok(Boolean(rule.meta.docs.ruleId), "Did not set `ruleId`");
+      assert.ok(Boolean(rule.meta.docs.ruleName), "Did not set `ruleName`");
+      assert.ok(
+        Boolean(dirRules[rule.meta.docs?.ruleId || ""]),
+        "Did not exist rule"
+      );
+    });
+  }
+});
diff --git a/tests/regressions/reporter.ts b/tests/regressions/reporter.ts
index 3a91a831..1c0c8590 100644
--- a/tests/regressions/reporter.ts
+++ b/tests/regressions/reporter.ts
@@ -1,8 +1,8 @@
-import assert from "assert"
-import plugin from "../../lib/index"
-import eslint from "eslint"
+import assert from "assert";
+import plugin from "../../lib/index";
+import eslint from "eslint";
 
-type LinterMessages = Partial<eslint.Linter.LintMessage>
+type LinterMessages = Partial<eslint.Linter.LintMessage>;
 
 /**
  * Assert the messages
@@ -11,62 +11,62 @@ type LinterMessages = Partial<eslint.Linter.LintMessage>
  * @returns {void}
  */
 function assertMessages(actual: LinterMessages[], expected: LinterMessages[]) {
-    const length = Math.max(actual.length, expected.length)
-    const expected2: LinterMessages[] = []
-    for (let i = 0; i < length; i++) {
-        expected2.push(
-            expected[i] ? { ...actual[i], ...expected[i] } : expected[i],
-        )
-    }
+  const length = Math.max(actual.length, expected.length);
+  const expected2: LinterMessages[] = [];
+  for (let i = 0; i < length; i++) {
+    expected2.push(
+      expected[i] ? { ...actual[i], ...expected[i] } : expected[i]
+    );
+  }
 
-    assert.deepStrictEqual(actual, expected2)
-    assert.strictEqual(actual.length, expected.length)
+  assert.deepStrictEqual(actual, expected2);
+  assert.strictEqual(actual.length, expected.length);
 }
 
 describe("reporter test", () => {
-    it("The report must be valid.", () => {
-        const linter = new eslint.Linter()
-        const config = {
-            parser: "vue-eslint-parser",
-            parserOptions: { ecmaVersion: 2015 },
-            rules: {
-                "vue-scoped-css/no-unused-selector": "error",
-                "vue-scoped-css/require-selector-used-inside": "error",
-            },
-        }
-        linter.defineParser("vue-eslint-parser", require("vue-eslint-parser"))
-        linter.defineRule(
-            "vue-scoped-css/no-unused-selector",
-            plugin.rules["no-unused-selector"] as any,
-        )
-        linter.defineRule(
-            "vue-scoped-css/require-selector-used-inside",
-            plugin.rules["require-selector-used-inside"] as any,
-        )
+  it("The report must be valid.", () => {
+    const linter = new eslint.Linter();
+    const config = {
+      parser: "vue-eslint-parser",
+      parserOptions: { ecmaVersion: 2015 },
+      rules: {
+        "vue-scoped-css/no-unused-selector": "error",
+        "vue-scoped-css/require-selector-used-inside": "error",
+      },
+    };
+    linter.defineParser("vue-eslint-parser", require("vue-eslint-parser"));
+    linter.defineRule(
+      "vue-scoped-css/no-unused-selector",
+      plugin.rules["no-unused-selector"] as any
+    );
+    linter.defineRule(
+      "vue-scoped-css/require-selector-used-inside",
+      plugin.rules["require-selector-used-inside"] as any
+    );
 
-        const messages = linter.verify(
-            "<template><input></template><style scoped> .a {} /* */ </style>",
-            config as any,
-            {
-                filename: "test.vue",
-            },
-        )
+    const messages = linter.verify(
+      "<template><input></template><style scoped> .a {} /* */ </style>",
+      config as any,
+      {
+        filename: "test.vue",
+      }
+    );
 
-        assertMessages(messages, [
-            {
-                ruleId: "vue-scoped-css/no-unused-selector",
-                column: 44,
-                endColumn: 46,
-                endLine: 1,
-                line: 1,
-            },
-            {
-                ruleId: "vue-scoped-css/require-selector-used-inside",
-                column: 44,
-                endColumn: 46,
-                endLine: 1,
-                line: 1,
-            },
-        ])
-    })
-})
+    assertMessages(messages, [
+      {
+        ruleId: "vue-scoped-css/no-unused-selector",
+        column: 44,
+        endColumn: 46,
+        endLine: 1,
+        line: 1,
+      },
+      {
+        ruleId: "vue-scoped-css/require-selector-used-inside",
+        column: 44,
+        endColumn: 46,
+        endLine: 1,
+        line: 1,
+      },
+    ]);
+  });
+});
diff --git a/tools/lib/categories.ts b/tools/lib/categories.ts
index 1001f64a..ca6e1579 100644
--- a/tools/lib/categories.ts
+++ b/tools/lib/categories.ts
@@ -1,45 +1,43 @@
-import { rules } from "../../lib/utils/rules"
-import type { Rule } from "../../lib/types"
+import { rules } from "../../lib/utils/rules";
+import type { Rule } from "../../lib/types";
 
 const categoryTitles = {
-    base: "Base Rules (Enabling Plugin)",
-    "vue3-recommended": "Recommended for Vue.js 3.x",
-    recommended: "Recommended for Vue.js 2.x",
-} as { [key: string]: string }
+  base: "Base Rules (Enabling Plugin)",
+  "vue3-recommended": "Recommended for Vue.js 3.x",
+  recommended: "Recommended for Vue.js 2.x",
+} as { [key: string]: string };
 
 const categoryConfigDescriptions = {
-    base: "Enable this plugin using with:",
-    "vue3-recommended": "Enforce all the rules in this category with:",
-    recommended: "Enforce all the rules in this category with:",
-} as { [key: string]: string }
+  base: "Enable this plugin using with:",
+  "vue3-recommended": "Enforce all the rules in this category with:",
+  recommended: "Enforce all the rules in this category with:",
+} as { [key: string]: string };
 
-const categoryIds = Object.keys(categoryTitles)
+const categoryIds = Object.keys(categoryTitles);
 const categoryRules: { [key: string]: Rule[] } = rules.reduce((obj, rule) => {
-    const categoryNames = rule.meta.docs.categories.length
-        ? rule.meta.docs.categories
-        : ["uncategorized"]
-    for (const cat of categoryNames) {
-        const categories = obj[cat] || (obj[cat] = [])
-        categories.push(rule)
-    }
-    return obj
-}, {} as { [key: string]: Rule[] })
+  const categoryNames = rule.meta.docs.categories.length
+    ? rule.meta.docs.categories
+    : ["uncategorized"];
+  for (const cat of categoryNames) {
+    const categories = obj[cat] || (obj[cat] = []);
+    categories.push(rule);
+  }
+  return obj;
+}, {} as { [key: string]: Rule[] });
 
 // Throw if no title is defined for a category
 for (const categoryId of Object.keys(categoryRules)) {
-    if (categoryId !== "uncategorized" && !categoryTitles[categoryId]) {
-        throw new Error(
-            `Category "${categoryId}" does not have a title defined.`,
-        )
-    }
+  if (categoryId !== "uncategorized" && !categoryTitles[categoryId]) {
+    throw new Error(`Category "${categoryId}" does not have a title defined.`);
+  }
 }
 
 export default categoryIds.map((categoryId) => ({
-    categoryId,
-    title: categoryTitles[categoryId],
-    configDescription: categoryConfigDescriptions[categoryId],
-    rules: (categoryRules[categoryId] || []).filter(
-        (rule) => !rule.meta.deprecated,
-    ),
-}))
+  categoryId,
+  title: categoryTitles[categoryId],
+  configDescription: categoryConfigDescriptions[categoryId],
+  rules: (categoryRules[categoryId] || []).filter(
+    (rule) => !rule.meta.deprecated
+  ),
+}));
 // .filter(category => category.rules.length >= 1)
diff --git a/tools/lib/load-configs.ts b/tools/lib/load-configs.ts
index 94bdd9b2..c498de7f 100644
--- a/tools/lib/load-configs.ts
+++ b/tools/lib/load-configs.ts
@@ -1,50 +1,50 @@
-import path from "path"
-import fs from "fs"
-import { isDefined } from "../../lib/utils/utils"
+import path from "path";
+import fs from "fs";
+import { isDefined } from "../../lib/utils/utils";
 
 type Config = {
-    name: string
-    configId: string
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- tools
-    config: any
-    path: string
-    extends: Config[]
-}
+  name: string;
+  configId: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- tools
+  config: any;
+  path: string;
+  extends: Config[];
+};
 
 /**
  * Get the all configs
  * @returns {Array} The all configs
  */
 function readConfigs(): Config[] {
-    const configsRoot = path.resolve(__dirname, "../../lib/configs")
-    const result = fs.readdirSync(configsRoot)
-    const configs = []
-    for (const name of result) {
-        const configName = name.replace(/\.ts$/u, "")
-        const configId = `plugin:vue-scoped-css/${configName}`
-        const configPath = require.resolve(path.join(configsRoot, name))
+  const configsRoot = path.resolve(__dirname, "../../lib/configs");
+  const result = fs.readdirSync(configsRoot);
+  const configs = [];
+  for (const name of result) {
+    const configName = name.replace(/\.ts$/u, "");
+    const configId = `plugin:vue-scoped-css/${configName}`;
+    const configPath = require.resolve(path.join(configsRoot, name));
 
-        const config = require(configPath)
-        configs.push({
-            name: configName,
-            configId,
-            config,
-            path: configPath,
-            extends: [],
-        })
-    }
-    return configs
+    const config = require(configPath);
+    configs.push({
+      name: configName,
+      configId,
+      config,
+      path: configPath,
+      extends: [],
+    });
+  }
+  return configs;
 }
 
-export const configs = readConfigs()
+export const configs = readConfigs();
 
 for (const config of configs) {
-    const extendsList: string[] = !config.config.extends
-        ? []
-        : Array.isArray(config.config.extends)
-        ? config.config.extends
-        : [config.config.extends]
-    config.extends = extendsList
-        .map((p) => configs.find((c) => c.path === p))
-        .filter(isDefined)
+  const extendsList: string[] = !config.config.extends
+    ? []
+    : Array.isArray(config.config.extends)
+    ? config.config.extends
+    : [config.config.extends];
+  config.extends = extendsList
+    .map((p) => configs.find((c) => c.path === p))
+    .filter(isDefined);
 }
diff --git a/tools/lib/load-rules.ts b/tools/lib/load-rules.ts
index b4551c2f..bbe5a296 100644
--- a/tools/lib/load-rules.ts
+++ b/tools/lib/load-rules.ts
@@ -1,26 +1,26 @@
-import path from "path"
-import fs from "fs"
+import path from "path";
+import fs from "fs";
 
 /**
  * Get the all rules
  * @returns {Array} The all rules
  */
 function readRules() {
-    // const rulesDistRoot = path.resolve(__dirname, "../../dist/rules")
-    const rulesLibRoot = path.resolve(__dirname, "../../lib/rules")
-    const result = fs.readdirSync(rulesLibRoot)
-    const rules = []
-    for (const name of result) {
-        const ruleName = name.replace(/\.ts$/u, "")
-        const ruleId = `vue-scoped-css/${ruleName}`
-        const rule = require(path.join(rulesLibRoot, name))
+  // const rulesDistRoot = path.resolve(__dirname, "../../dist/rules")
+  const rulesLibRoot = path.resolve(__dirname, "../../lib/rules");
+  const result = fs.readdirSync(rulesLibRoot);
+  const rules = [];
+  for (const name of result) {
+    const ruleName = name.replace(/\.ts$/u, "");
+    const ruleId = `vue-scoped-css/${ruleName}`;
+    const rule = require(path.join(rulesLibRoot, name));
 
-        rule.meta.docs.ruleName = ruleName
-        rule.meta.docs.ruleId = ruleId
+    rule.meta.docs.ruleName = ruleName;
+    rule.meta.docs.ruleId = ruleId;
 
-        rules.push(rule)
-    }
-    return rules
+    rules.push(rule);
+  }
+  return rules;
 }
 
-export const rules = readRules()
+export const rules = readRules();
diff --git a/tools/new-rule.ts b/tools/new-rule.ts
index 07a0cdb5..9ff1bed6 100644
--- a/tools/new-rule.ts
+++ b/tools/new-rule.ts
@@ -1,28 +1,28 @@
-import path from "path"
-import fs from "fs"
-import cp from "child_process"
-const logger = console
+import path from "path";
+import fs from "fs";
+import cp from "child_process";
+const logger = console;
 
 // main
-;((ruleId) => {
-    if (ruleId == null) {
-        logger.error("Usage: npm run new <RuleID>")
-        process.exitCode = 1
-        return
-    }
-    if (!/^[\w-]+$/u.test(ruleId)) {
-        logger.error("Invalid RuleID '%s'.", ruleId)
-        process.exitCode = 1
-        return
-    }
-
-    const ruleFile = path.resolve(__dirname, `../lib/rules/${ruleId}.ts`)
-    const testFile = path.resolve(__dirname, `../tests/lib/rules/${ruleId}.ts`)
-    const docFile = path.resolve(__dirname, `../docs/rules/${ruleId}.md`)
-
-    fs.writeFileSync(
-        ruleFile,
-        `
+((ruleId) => {
+  if (ruleId == null) {
+    logger.error("Usage: npm run new <RuleID>");
+    process.exitCode = 1;
+    return;
+  }
+  if (!/^[\w-]+$/u.test(ruleId)) {
+    logger.error("Invalid RuleID '%s'.", ruleId);
+    process.exitCode = 1;
+    return;
+  }
+
+  const ruleFile = path.resolve(__dirname, `../lib/rules/${ruleId}.ts`);
+  const testFile = path.resolve(__dirname, `../tests/lib/rules/${ruleId}.ts`);
+  const docFile = path.resolve(__dirname, `../docs/rules/${ruleId}.md`);
+
+  fs.writeFileSync(
+    ruleFile,
+    `
 import {
     getStyleContexts,
     getCommentDirectivesReporter,
@@ -89,11 +89,11 @@ module.exports = {
         }
     },
 }
-`,
-    )
-    fs.writeFileSync(
-        testFile,
-        `import { RuleTester } from "eslint"
+`
+  );
+  fs.writeFileSync(
+    testFile,
+    `import { RuleTester } from "eslint"
 import rule = require("../../../lib/rules/${ruleId}")
 
 const tester = new RuleTester({
@@ -138,11 +138,11 @@ tester.run("${ruleId}", rule as any, {
         },
     ],
 })
-`,
-    )
-    fs.writeFileSync(
-        docFile,
-        `#  (vue-scoped-css/${ruleId})
+`
+  );
+  fs.writeFileSync(
+    docFile,
+    `#  (vue-scoped-css/${ruleId})
 
 > foo
 
@@ -183,9 +183,9 @@ This rule reports ??? as errors.
 
 - None
 
-`,
-    )
-    cp.execSync(`code "${ruleFile}"`)
-    cp.execSync(`code "${testFile}"`)
-    cp.execSync(`code "${docFile}"`)
-})(process.argv[2])
+`
+  );
+  cp.execSync(`code "${ruleFile}"`);
+  cp.execSync(`code "${testFile}"`);
+  cp.execSync(`code "${docFile}"`);
+})(process.argv[2]);
diff --git a/tools/render-rules.ts b/tools/render-rules.ts
index ad329103..9a6f898d 100644
--- a/tools/render-rules.ts
+++ b/tools/render-rules.ts
@@ -1,51 +1,49 @@
-import categories from "./lib/categories"
-import type { Rule } from "../lib/types"
-import { rules } from "../lib/utils/rules"
+import categories from "./lib/categories";
+import type { Rule } from "../lib/types";
+import { rules } from "../lib/utils/rules";
 
 //eslint-disable-next-line require-jsdoc -- tools
 export default function renderRulesTableContent(
-    buildRulePath = (ruleName: string) => `./${ruleName}.md`,
+  buildRulePath = (ruleName: string) => `./${ruleName}.md`
 ): string {
-    const uncategorizedRules = rules.filter(
-        (rule) => !rule.meta.docs.categories.length && !rule.meta.deprecated,
-    )
-    const deprecatedRules = rules.filter((rule) => rule.meta.deprecated)
-
-    // -----------------------------------------------------------------------------
-
-    //eslint-disable-next-line require-jsdoc -- tools
-    function toRuleRow(rule: Rule) {
-        const mark = `${rule.meta.fixable ? ":wrench:" : ""}${
-            rule.meta.deprecated ? ":warning:" : ""
-        }`
-        const link = `[${rule.meta.docs.ruleId}](${buildRulePath(
-            rule.meta.docs.ruleName || "",
-        )})`
-        const description = rule.meta.docs.description || "(no description)"
-
-        return `| ${link} | ${description} | ${mark} |`
-    }
-
-    //eslint-disable-next-line require-jsdoc -- tools
-    function toDeprecatedRuleRow(rule: Rule) {
-        const link = `[${rule.meta.docs.ruleId}](${buildRulePath(
-            rule.meta.docs.ruleName || "",
-        )})`
-        const replacedRules = rule.meta.docs.replacedBy || []
-        const replacedBy = replacedRules
-            .map(
-                (name) => `[vue-scoped-css/${name}](${buildRulePath(name)}.md)`,
-            )
-            .join(", ")
-
-        return `| ${link} | ${replacedBy || "(no replacement)"} |`
-    }
-
-    // -----------------------------------------------------------------------------
-    let rulesTableContent = categories
-        .map((category) =>
-            category.rules.length
-                ? `
+  const uncategorizedRules = rules.filter(
+    (rule) => !rule.meta.docs.categories.length && !rule.meta.deprecated
+  );
+  const deprecatedRules = rules.filter((rule) => rule.meta.deprecated);
+
+  // -----------------------------------------------------------------------------
+
+  //eslint-disable-next-line require-jsdoc -- tools
+  function toRuleRow(rule: Rule) {
+    const mark = `${rule.meta.fixable ? ":wrench:" : ""}${
+      rule.meta.deprecated ? ":warning:" : ""
+    }`;
+    const link = `[${rule.meta.docs.ruleId}](${buildRulePath(
+      rule.meta.docs.ruleName || ""
+    )})`;
+    const description = rule.meta.docs.description || "(no description)";
+
+    return `| ${link} | ${description} | ${mark} |`;
+  }
+
+  //eslint-disable-next-line require-jsdoc -- tools
+  function toDeprecatedRuleRow(rule: Rule) {
+    const link = `[${rule.meta.docs.ruleId}](${buildRulePath(
+      rule.meta.docs.ruleName || ""
+    )})`;
+    const replacedRules = rule.meta.docs.replacedBy || [];
+    const replacedBy = replacedRules
+      .map((name) => `[vue-scoped-css/${name}](${buildRulePath(name)}.md)`)
+      .join(", ");
+
+    return `| ${link} | ${replacedBy || "(no replacement)"} |`;
+  }
+
+  // -----------------------------------------------------------------------------
+  let rulesTableContent = categories
+    .map((category) =>
+      category.rules.length
+        ? `
 ## ${category.title}
 
 ${category.configDescription}
@@ -60,13 +58,13 @@ ${category.configDescription}
 |:--------|:------------|:---|
 ${category.rules.map(toRuleRow).join("\n")}
 `
-                : "",
-        )
-        .join("")
+        : ""
+    )
+    .join("");
 
-    // -----------------------------------------------------------------------------
-    if (uncategorizedRules.length >= 1) {
-        rulesTableContent += `
+  // -----------------------------------------------------------------------------
+  if (uncategorizedRules.length >= 1) {
+    rulesTableContent += `
 ## Uncategorized
 
 No preset enables the rules in this category.
@@ -85,12 +83,12 @@ For example:
 | Rule ID | Description |    |
 |:--------|:------------|:---|
 ${uncategorizedRules.map(toRuleRow).join("\n")}
-`
-    }
+`;
+  }
 
-    // -----------------------------------------------------------------------------
-    if (deprecatedRules.length >= 1) {
-        rulesTableContent += `
+  // -----------------------------------------------------------------------------
+  if (deprecatedRules.length >= 1) {
+    rulesTableContent += `
 ## Deprecated
 
 - :warning: We're going to remove deprecated rules in the next major release. Please migrate to successor/new rules.
@@ -99,7 +97,7 @@ ${uncategorizedRules.map(toRuleRow).join("\n")}
 | Rule ID | Replaced by |
 |:--------|:------------|
 ${deprecatedRules.map(toDeprecatedRuleRow).join("\n")}
-`
-    }
-    return rulesTableContent
+`;
+  }
+  return rulesTableContent;
 }
diff --git a/tools/update-docs-rules-index.ts b/tools/update-docs-rules-index.ts
index b77168df..a5111803 100644
--- a/tools/update-docs-rules-index.ts
+++ b/tools/update-docs-rules-index.ts
@@ -1,17 +1,17 @@
-import path from "path"
-import fs from "fs"
-import renderRulesTableContent from "./render-rules"
+import path from "path";
+import fs from "fs";
+import renderRulesTableContent from "./render-rules";
 
 // -----------------------------------------------------------------------------
-const readmeFilePath = path.resolve(__dirname, "../docs/rules/README.md")
+const readmeFilePath = path.resolve(__dirname, "../docs/rules/README.md");
 fs.writeFileSync(
-    readmeFilePath,
-    `---
+  readmeFilePath,
+  `---
 sidebarDepth: 0
 ---
 
 # Available Rules
 
 <!-- This file is automatically generated in tools/update-docs-rules-index.js, do not change! -->
-${renderRulesTableContent()}`,
-)
+${renderRulesTableContent()}`
+);
diff --git a/tools/update-docs.ts b/tools/update-docs.ts
index cff9dab5..49538d95 100644
--- a/tools/update-docs.ts
+++ b/tools/update-docs.ts
@@ -1,214 +1,210 @@
-import path from "path"
-import fs from "fs"
-import { rules } from "../lib/utils/rules"
-import { configs } from "./lib/load-configs"
-import type { Rule } from "../lib/types"
+import path from "path";
+import fs from "fs";
+import { rules } from "../lib/utils/rules";
+import { configs } from "./lib/load-configs";
+import type { Rule } from "../lib/types";
 
 //eslint-disable-next-line require-jsdoc -- tools
 function formatItems(items: string[]) {
-    if (items.length <= 2) {
-        return items.join(" and ")
-    }
-    return `all of ${items.slice(0, -1).join(", ")} and ${
-        items[items.length - 1]
-    }`
+  if (items.length <= 2) {
+    return items.join(" and ");
+  }
+  return `all of ${items.slice(0, -1).join(", ")} and ${
+    items[items.length - 1]
+  }`;
 }
 
 //eslint-disable-next-line require-jsdoc -- tools
 function getPresets(categories: string[]) {
-    const categoryConfigs = configs.filter((conf) =>
-        categories.includes(conf.name),
-    )
-    if (!categoryConfigs.length) {
-        return []
-    }
-
-    const presets = new Set<string>(categoryConfigs.map((cat) => cat.configId))
-    const subTargets = configs.filter((conf) =>
-        conf.extends.find((ext) => categories.includes(ext.name)),
-    )
-    for (const name of getPresets(subTargets.map((s) => s.name))) {
-        presets.add(name)
-    }
-    return [...presets]
+  const categoryConfigs = configs.filter((conf) =>
+    categories.includes(conf.name)
+  );
+  if (!categoryConfigs.length) {
+    return [];
+  }
+
+  const presets = new Set<string>(categoryConfigs.map((cat) => cat.configId));
+  const subTargets = configs.filter((conf) =>
+    conf.extends.find((ext) => categories.includes(ext.name))
+  );
+  for (const name of getPresets(subTargets.map((s) => s.name))) {
+    presets.add(name);
+  }
+  return [...presets];
 }
 
 //eslint-disable-next-line require-jsdoc, @typescript-eslint/no-explicit-any -- tools
 function yamlValue(val: any) {
-    if (typeof val === "string") {
-        return `"${val.replace(/"/gu, '\\"')}"`
-    }
-    return val
+  if (typeof val === "string") {
+    return `"${val.replace(/"/gu, '\\"')}"`;
+  }
+  return val;
 }
 
-const ROOT = path.resolve(__dirname, "../docs/rules")
+const ROOT = path.resolve(__dirname, "../docs/rules");
 
 class DocFile {
-    private readonly rule: Rule
-
-    private readonly filePath: string
-
-    private content: string
-
-    public constructor(rule: Rule) {
-        this.rule = rule
-        this.filePath = path.join(ROOT, `${rule.meta.docs.ruleName}.md`)
-        this.content = fs.readFileSync(this.filePath, "utf8")
+  private readonly rule: Rule;
+
+  private readonly filePath: string;
+
+  private content: string;
+
+  public constructor(rule: Rule) {
+    this.rule = rule;
+    this.filePath = path.join(ROOT, `${rule.meta.docs.ruleName}.md`);
+    this.content = fs.readFileSync(this.filePath, "utf8");
+  }
+
+  public static read(rule: Rule) {
+    return new DocFile(rule);
+  }
+
+  public updateHeader() {
+    const {
+      meta: {
+        fixable,
+        deprecated,
+        docs: { ruleId, description, categories, replacedBy },
+      },
+    } = this.rule;
+    const title = `# ${ruleId}\n\n> ${description}`;
+    const notes = [];
+
+    if (deprecated) {
+      if (replacedBy) {
+        const replacedRules = replacedBy.map(
+          (name) => `[vue-scoped-css/${name}](${name}.md) rule`
+        );
+        notes.push(
+          `- :warning: This rule was **deprecated** and replaced by ${formatItems(
+            replacedRules
+          )}.`
+        );
+      } else {
+        notes.push("- :warning: This rule was **deprecated**.");
+      }
+    } else {
+      const presets = Array.from(
+        new Set(getPresets(categories).concat(["plugin:vue-scoped-css/all"]))
+      );
+
+      if (presets.length) {
+        notes.push(
+          `- :gear: This rule is included in ${formatItems(
+            presets.map((c) => `\`"${c}"\``)
+          )}.`
+        );
+      }
+      // const presets = categories
+      //     .slice(categoryIndex)
+      //     .map(category => `\`"plugin:vue/${category.categoryId}"\``)
+      // notes.push(
+      //     `- :gear: This rule is included in ${formatItems(presets)}.`
+      // )
+    }
+    if (fixable) {
+      notes.push(
+        "- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) can automatically fix some of the problems reported by this rule."
+      );
     }
 
-    public static read(rule: Rule) {
-        return new DocFile(rule)
+    // Add an empty line after notes.
+    if (notes.length >= 1) {
+      notes.push("", "");
     }
 
-    public updateHeader() {
-        const {
-            meta: {
-                fixable,
-                deprecated,
-                docs: { ruleId, description, categories, replacedBy },
-            },
-        } = this.rule
-        const title = `# ${ruleId}\n\n> ${description}`
-        const notes = []
-
-        if (deprecated) {
-            if (replacedBy) {
-                const replacedRules = replacedBy.map(
-                    (name) => `[vue-scoped-css/${name}](${name}.md) rule`,
-                )
-                notes.push(
-                    `- :warning: This rule was **deprecated** and replaced by ${formatItems(
-                        replacedRules,
-                    )}.`,
-                )
-            } else {
-                notes.push("- :warning: This rule was **deprecated**.")
-            }
-        } else {
-            const presets = Array.from(
-                new Set(
-                    getPresets(categories).concat([
-                        "plugin:vue-scoped-css/all",
-                    ]),
-                ),
-            )
-
-            if (presets.length) {
-                notes.push(
-                    `- :gear: This rule is included in ${formatItems(
-                        presets.map((c) => `\`"${c}"\``),
-                    )}.`,
-                )
-            }
-            // const presets = categories
-            //     .slice(categoryIndex)
-            //     .map(category => `\`"plugin:vue/${category.categoryId}"\``)
-            // notes.push(
-            //     `- :gear: This rule is included in ${formatItems(presets)}.`
-            // )
-        }
-        if (fixable) {
-            notes.push(
-                "- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) can automatically fix some of the problems reported by this rule.",
-            )
-        }
-
-        // Add an empty line after notes.
-        if (notes.length >= 1) {
-            notes.push("", "")
-        }
-
-        const headerPattern = /#.+\n+[^\n]*\n+(?:- .+\n+)*\n*/u
-        const header = `${title}\n\n${notes.join("\n")}`
-        if (headerPattern.test(this.content)) {
-            this.content = this.content.replace(headerPattern, header)
-        } else {
-            this.content = `${header}${this.content.trim()}\n`
-        }
-
-        return this
+    const headerPattern = /#.+\n+[^\n]*\n+(?:- .+\n+)*\n*/u;
+    const header = `${title}\n\n${notes.join("\n")}`;
+    if (headerPattern.test(this.content)) {
+      this.content = this.content.replace(headerPattern, header);
+    } else {
+      this.content = `${header}${this.content.trim()}\n`;
     }
 
-    public updateFooter() {
-        const { ruleName } = this.rule.meta.docs
-        const footerPattern = /## Implementation[\s\S]+$/u
-        const footer = `## Implementation
+    return this;
+  }
+
+  public updateFooter() {
+    const { ruleName } = this.rule.meta.docs;
+    const footerPattern = /## Implementation[\s\S]+$/u;
+    const footer = `## Implementation
 
 - [Rule source](https://github.com/future-architect/eslint-plugin-vue-scoped-css/blob/master/lib/rules/${ruleName}.ts)
 - [Test source](https://github.com/future-architect/eslint-plugin-vue-scoped-css/blob/master/tests/lib/rules/${ruleName}.js)
-`
-        if (footerPattern.test(this.content)) {
-            this.content = this.content.replace(footerPattern, footer)
-        } else {
-            this.content = `${this.content.trim()}\n\n${footer}`
-        }
-
-        return this
+`;
+    if (footerPattern.test(this.content)) {
+      this.content = this.content.replace(footerPattern, footer);
+    } else {
+      this.content = `${this.content.trim()}\n\n${footer}`;
     }
 
-    public updateCodeBlocks() {
-        const { meta } = this.rule
-
-        this.content = this.content.replace(
-            /<eslint-code-block\s(:?fix\S*)?\s*/gu,
-            `<eslint-code-block ${meta.fixable ? "fix " : ""}`,
-        )
-        return this
+    return this;
+  }
+
+  public updateCodeBlocks() {
+    const { meta } = this.rule;
+
+    this.content = this.content.replace(
+      /<eslint-code-block\s(:?fix\S*)?\s*/gu,
+      `<eslint-code-block ${meta.fixable ? "fix " : ""}`
+    );
+    return this;
+  }
+
+  public adjustCodeBlocks() {
+    // Adjust the necessary blank lines before and after the code block so that GitHub can recognize `.md`.
+    this.content = this.content.replace(
+      /(<eslint-code-block[\s\S]*?>)\n+```/gu,
+      "$1\n\n```"
+    );
+    this.content = this.content.replace(
+      /```\n+<\/eslint-code-block>/gu,
+      "```\n\n</eslint-code-block>"
+    );
+    return this;
+  }
+
+  public updateFileIntro() {
+    const { ruleId, description } = this.rule.meta.docs;
+
+    const fileIntro = {
+      pageClass: "rule-details",
+      sidebarDepth: 0,
+      title: ruleId,
+      description,
+    };
+    const computed = `---\n${Object.keys(fileIntro)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- tools
+      .map((key) => `${key}: ${yamlValue((fileIntro as any)[key])}`)
+      .join("\n")}\n---\n`;
+
+    const fileIntroPattern = /^---\n(.*\n)+---\n*/gu;
+
+    if (fileIntroPattern.test(this.content)) {
+      this.content = this.content.replace(fileIntroPattern, computed);
+    } else {
+      this.content = `${computed}${this.content.trim()}\n`;
     }
 
-    public adjustCodeBlocks() {
-        // Adjust the necessary blank lines before and after the code block so that GitHub can recognize `.md`.
-        this.content = this.content.replace(
-            /(<eslint-code-block[\s\S]*?>)\n+```/gu,
-            "$1\n\n```",
-        )
-        this.content = this.content.replace(
-            /```\n+<\/eslint-code-block>/gu,
-            "```\n\n</eslint-code-block>",
-        )
-        return this
-    }
+    return this;
+  }
 
-    public updateFileIntro() {
-        const { ruleId, description } = this.rule.meta.docs
-
-        const fileIntro = {
-            pageClass: "rule-details",
-            sidebarDepth: 0,
-            title: ruleId,
-            description,
-        }
-        const computed = `---\n${Object.keys(fileIntro)
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- tools
-            .map((key) => `${key}: ${yamlValue((fileIntro as any)[key])}`)
-            .join("\n")}\n---\n`
-
-        const fileIntroPattern = /^---\n(.*\n)+---\n*/gu
-
-        if (fileIntroPattern.test(this.content)) {
-            this.content = this.content.replace(fileIntroPattern, computed)
-        } else {
-            this.content = `${computed}${this.content.trim()}\n`
-        }
-
-        return this
-    }
-
-    public write() {
-        const isWin = require("os").platform().startsWith("win")
+  public write() {
+    const isWin = require("os").platform().startsWith("win");
 
-        this.content = this.content.replace(/\r?\n/gu, isWin ? "\r\n" : "\n")
+    this.content = this.content.replace(/\r?\n/gu, isWin ? "\r\n" : "\n");
 
-        fs.writeFileSync(this.filePath, this.content)
-    }
+    fs.writeFileSync(this.filePath, this.content);
+  }
 }
 
 for (const rule of rules) {
-    DocFile.read(rule)
-        .updateHeader()
-        .updateFooter()
-        .updateCodeBlocks()
-        .updateFileIntro()
-        .adjustCodeBlocks()
-        .write()
+  DocFile.read(rule)
+    .updateHeader()
+    .updateFooter()
+    .updateCodeBlocks()
+    .updateFileIntro()
+    .adjustCodeBlocks()
+    .write();
 }
diff --git a/tools/update-readme.ts b/tools/update-readme.ts
index 4af252ad..587b431e 100644
--- a/tools/update-readme.ts
+++ b/tools/update-readme.ts
@@ -1,47 +1,47 @@
-import path from "path"
-import fs from "fs"
-import os from "os"
-import renderRulesTableContent from "./render-rules"
-const isWin = os.platform().startsWith("win")
+import path from "path";
+import fs from "fs";
+import os from "os";
+import renderRulesTableContent from "./render-rules";
+const isWin = os.platform().startsWith("win");
 
 let insertText = `\n${renderRulesTableContent(
-    (name) =>
-        `https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/${name}.html`,
-)}\n`
+  (name) =>
+    `https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/${name}.html`
+)}\n`;
 if (isWin) {
-    insertText = insertText
-        .replace(/\r?\n/gu, "\n")
-        .replace(/\r/gu, "\n")
-        .replace(/\n/gu, "\r\n")
+  insertText = insertText
+    .replace(/\r?\n/gu, "\n")
+    .replace(/\r/gu, "\n")
+    .replace(/\n/gu, "\r\n");
 }
 
-const readmeFilePath = path.resolve(__dirname, "../README.md")
+const readmeFilePath = path.resolve(__dirname, "../README.md");
 const newReadme = fs
-    .readFileSync(readmeFilePath, "utf8")
-    .replace(
-        /<!--RULES_TABLE_START-->[\s\S]*<!--RULES_TABLE_END-->/u,
-        `<!--RULES_TABLE_START-->${insertText}<!--RULES_TABLE_END-->`,
-    )
-fs.writeFileSync(readmeFilePath, newReadme)
+  .readFileSync(readmeFilePath, "utf8")
+  .replace(
+    /<!--RULES_TABLE_START-->[\s\S]*<!--RULES_TABLE_END-->/u,
+    `<!--RULES_TABLE_START-->${insertText}<!--RULES_TABLE_END-->`
+  );
+fs.writeFileSync(readmeFilePath, newReadme);
 
-const docsReadmeFilePath = path.resolve(__dirname, "../docs/README.md")
+const docsReadmeFilePath = path.resolve(__dirname, "../docs/README.md");
 
 fs.writeFileSync(
-    docsReadmeFilePath,
-    newReadme
-        .replace("# eslint-plugin-vue-scoped-css\n", "# Introduction\n")
-        .replace(
-            /<!--RULES_SECTION_START-->[\s\S]*<!--RULES_SECTION_END-->/u,
-            "See [Available Rules](./rules/README.md).",
-        )
-        .replace(
-            /<!--USAGE_SECTION_START-->[\s\S]*<!--USAGE_SECTION_END-->/u,
-            "See [User Guide](./user-guide/README.md).",
-        )
-        .replace(/<!--DOCS_IGNORE_START-->[\s\S]*?<!--DOCS_IGNORE_END-->/gu, "")
-        .replace(
-            /\(https:\/\/future-architect.github.io\/eslint-plugin-vue-scoped-css/gu,
-            "(.",
-        )
-        .replace(/\n{3,}/gu, "\n\n"),
-)
+  docsReadmeFilePath,
+  newReadme
+    .replace("# eslint-plugin-vue-scoped-css\n", "# Introduction\n")
+    .replace(
+      /<!--RULES_SECTION_START-->[\s\S]*<!--RULES_SECTION_END-->/u,
+      "See [Available Rules](./rules/README.md)."
+    )
+    .replace(
+      /<!--USAGE_SECTION_START-->[\s\S]*<!--USAGE_SECTION_END-->/u,
+      "See [User Guide](./user-guide/README.md)."
+    )
+    .replace(/<!--DOCS_IGNORE_START-->[\s\S]*?<!--DOCS_IGNORE_END-->/gu, "")
+    .replace(
+      /\(https:\/\/future-architect.github.io\/eslint-plugin-vue-scoped-css/gu,
+      "(."
+    )
+    .replace(/\n{3,}/gu, "\n\n")
+);
diff --git a/tools/update-rules.ts b/tools/update-rules.ts
index 684ac183..a303adca 100644
--- a/tools/update-rules.ts
+++ b/tools/update-rules.ts
@@ -1,24 +1,24 @@
-import path from "path"
-import fs from "fs"
-import os from "os"
+import path from "path";
+import fs from "fs";
+import os from "os";
 // import eslint from "eslint"
-import { rules } from "./lib/load-rules"
-const isWin = os.platform().startsWith("win")
+import { rules } from "./lib/load-rules";
+const isWin = os.platform().startsWith("win");
 
 let content = `
 import type { Rule } from "../types"
 
 const baseRules = [
     ${rules
-        .map(
-            (rule) => `{
+      .map(
+        (rule) => `{
     rule: require("../rules/${rule.meta.docs.ruleName}"),
     ruleName: "${rule.meta.docs.ruleName}",
     ruleId: "${rule.meta.docs.ruleId}",
     },
-    `,
-        )
-        .join("")}
+    `
+      )
+      .join("")}
 ]
 
 export const rules = baseRules.map(obj => {
@@ -46,19 +46,19 @@ export function collectRules(
         return obj
     }, {} as { [key: string]: string })
 }
-`
+`;
 
-const filePath = path.resolve(__dirname, "../lib/utils/rules.ts")
+const filePath = path.resolve(__dirname, "../lib/utils/rules.ts");
 
 if (isWin) {
-    content = content
-        .replace(/\r?\n/gu, "\n")
-        .replace(/\r/gu, "\n")
-        .replace(/\n/gu, "\r\n")
+  content = content
+    .replace(/\r?\n/gu, "\n")
+    .replace(/\r/gu, "\n")
+    .replace(/\n/gu, "\r\n");
 }
 
 // Update file.
-fs.writeFileSync(filePath, content)
+fs.writeFileSync(filePath, content);
 
 // Format files.
 // const linter = new eslint.CLIEngine({ fix: true })
diff --git a/tools/update.ts b/tools/update.ts
index 9aa00379..8ee77012 100644
--- a/tools/update.ts
+++ b/tools/update.ts
@@ -1,4 +1,4 @@
-import "./update-rules"
-import "./update-docs"
-import "./update-readme"
-import "./update-docs-rules-index"
+import "./update-rules";
+import "./update-docs";
+import "./update-readme";
+import "./update-docs-rules-index";
diff --git a/typings/eslint-scope/index.d.ts b/typings/eslint-scope/index.d.ts
index 873a5d53..d9f54fca 100644
--- a/typings/eslint-scope/index.d.ts
+++ b/typings/eslint-scope/index.d.ts
@@ -1,74 +1,74 @@
-import type * as estree from "estree"
+import type * as estree from "estree";
 
 export interface AnalysisOptions {
-    optimistic?: boolean
-    directive?: boolean
-    ignoreEval?: boolean
-    nodejsScope?: boolean
-    impliedStrict?: boolean
-    // fallback?: string | Function
-    sourceType?: "script" | "module"
-    ecmaVersion?: number
+  optimistic?: boolean;
+  directive?: boolean;
+  ignoreEval?: boolean;
+  nodejsScope?: boolean;
+  impliedStrict?: boolean;
+  // fallback?: string | Function
+  sourceType?: "script" | "module";
+  ecmaVersion?: number;
 }
 
 export interface ScopeManager {
-    scopes: Scope[]
-    globalScope: Scope
-    acquire(node: estree.Node, inner: boolean): Scope | null
-    acquireAll(node: estree.Node): Scope[]
+  scopes: Scope[];
+  globalScope: Scope;
+  acquire(node: estree.Node, inner: boolean): Scope | null;
+  acquireAll(node: estree.Node): Scope[];
 }
 
 export interface Scope {
-    block: estree.Node
-    childScopes: Scope[]
-    directCallToEcalScope: boolean
-    dynamic: boolean
-    functionExpressionScope: boolean
-    isStrict: boolean
-    references: Reference[]
-    set: Map<string, Variable>
-    taints: Map<string, boolean>
-    thisFound: boolean
-    through: Reference[]
-    type: string
-    upper: Scope | null
-    variables: Variable[]
-    variableScope: Scope
+  block: estree.Node;
+  childScopes: Scope[];
+  directCallToEcalScope: boolean;
+  dynamic: boolean;
+  functionExpressionScope: boolean;
+  isStrict: boolean;
+  references: Reference[];
+  set: Map<string, Variable>;
+  taints: Map<string, boolean>;
+  thisFound: boolean;
+  through: Reference[];
+  type: string;
+  upper: Scope | null;
+  variables: Variable[];
+  variableScope: Scope;
 }
 
 export interface Variable {
-    defs: VariableDefinition[]
-    identifiers: estree.Identifier[]
-    name: string
-    references: Reference[]
-    scope: Scope
-    stack: boolean
+  defs: VariableDefinition[];
+  identifiers: estree.Identifier[];
+  name: string;
+  references: Reference[];
+  scope: Scope;
+  stack: boolean;
 }
 
 export interface VariableDefinition {
-    type: string
-    name: estree.Identifier
-    node: estree.Node
-    parent?: estree.Node
+  type: string;
+  name: estree.Identifier;
+  node: estree.Node;
+  parent?: estree.Node;
 }
 
 export interface Reference {
-    from: Scope
-    identifier: estree.Identifier
-    partial: boolean
-    resolved: Variable | null
-    tainted: boolean
-    writeExpr: estree.Expression
+  from: Scope;
+  identifier: estree.Identifier;
+  partial: boolean;
+  resolved: Variable | null;
+  tainted: boolean;
+  writeExpr: estree.Expression;
 
-    isRead(): boolean
-    isReadOnly(): boolean
-    isReadWrite(): boolean
-    isStatic(): boolean
-    isWrite(): boolean
-    isWriteOnly(): boolean
+  isRead(): boolean;
+  isReadOnly(): boolean;
+  isReadWrite(): boolean;
+  isStatic(): boolean;
+  isWrite(): boolean;
+  isWriteOnly(): boolean;
 }
 
 declare const eslintScope: {
-    analyze(ast: unknown, options?: AnalysisOptions): ScopeManager
-}
-export default eslintScope
+  analyze(ast: unknown, options?: AnalysisOptions): ScopeManager;
+};
+export default eslintScope;
diff --git a/typings/eslint-utils/index.d.ts b/typings/eslint-utils/index.d.ts
index 63e93944..998bf0a6 100644
--- a/typings/eslint-utils/index.d.ts
+++ b/typings/eslint-utils/index.d.ts
@@ -1,13 +1,13 @@
-import type { AST } from "../../lib/types"
-import type { Scope } from "eslint-scope"
+import type { AST } from "../../lib/types";
+import type { Scope } from "eslint-scope";
 
 declare const utils: {
-    getStaticValue: (
-        node: AST.ESLintExpression,
-        scope: Scope,
-    ) => null | {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
-        value: any
-    }
-}
-export default utils
+  getStaticValue: (
+    node: AST.ESLintExpression,
+    scope: Scope
+  ) => null | {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+    value: any;
+  };
+};
+export default utils;
diff --git a/typings/postcss-safe-parser/index.d.ts b/typings/postcss-safe-parser/index.d.ts
index 94eb55ed..b340c57c 100644
--- a/typings/postcss-safe-parser/index.d.ts
+++ b/typings/postcss-safe-parser/index.d.ts
@@ -1,3 +1,3 @@
-import postcss from "postcss"
+import postcss from "postcss";
 
-export default postcss.parse
+export default postcss.parse;
diff --git a/typings/postcss-scss/index.d.ts b/typings/postcss-scss/index.d.ts
index 7a9d284e..0f6873cd 100644
--- a/typings/postcss-scss/index.d.ts
+++ b/typings/postcss-scss/index.d.ts
@@ -1,5 +1,5 @@
-import type * as postcss from "postcss"
+import type * as postcss from "postcss";
 
 declare module "postcss-scss" {
-    const parse: postcss.Parser, stringify: postcss.Stringifier
+  const parse: postcss.Parser, stringify: postcss.Stringifier;
 }
diff --git a/typings/postcss-styl/index.d.ts b/typings/postcss-styl/index.d.ts
index 0b4471d7..787edc90 100644
--- a/typings/postcss-styl/index.d.ts
+++ b/typings/postcss-styl/index.d.ts
@@ -1,5 +1,5 @@
-import type * as postcss from "postcss"
+import type * as postcss from "postcss";
 
 declare module "postcss-styl" {
-    const parse: postcss.Parser, stringify: postcss.Stringifier
+  const parse: postcss.Parser, stringify: postcss.Stringifier;
 }