astro-eslint-parser 0.11.0 → 0.13.0

package/lib/index.d.ts

@@ -348,10 +348,11 @@ declare class ParseError extends SyntaxError {
     }, ctx: Context);
 }
 
+declare const name = "astro-eslint-parser";
 /**
  * Parse source code
  */
 declare function parseForESLint(code: string, options?: any): ReturnType<typeof parseForESLint$1>;
 declare const VisitorKeys: eslint.SourceCode.VisitorKeys;
 
-export { index as AST, ParseError, ParseTemplateResult, VisitorKeys, parseForESLint, parseTemplate, traverseNodes };
+export { index as AST, ParseError, ParseTemplateResult, VisitorKeys, name, parseForESLint, parseTemplate, traverseNodes };

package/lib/index.js

@@ -6,8 +6,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -29,6 +33,7 @@ __export(src_exports, {
   AST: () => ast_exports,
   ParseError: () => ParseError,
   VisitorKeys: () => VisitorKeys,
+  name: () => name,
   parseForESLint: () => parseForESLint2,
   parseTemplate: () => parseTemplate2,
   traverseNodes: () => traverseNodes
@@ -59,55 +64,327 @@ var debug = (0, import_debug.default)("astro-eslint-parser");
 
 // src/parser/ts-patch.ts
 var import_module = require("module");
-var import_path = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
+var import_semver = require("semver");
+
+// src/parser/ts-for-v5/get-project-config-files.ts
 var import_fs = __toESM(require("fs"));
-function tsPatch(scriptParserOptions) {
+var import_path = __toESM(require("path"));
+function getProjectConfigFiles(options) {
+  const tsconfigRootDir = typeof options.tsconfigRootDir === "string" ? options.tsconfigRootDir : process.cwd();
+  if (options.project !== true) {
+    return Array.isArray(options.project) ? options.project : [options.project];
+  }
+  let directory = import_path.default.dirname(options.filePath);
+  const checkedDirectories = [directory];
+  do {
+    const tsconfigPath = import_path.default.join(directory, "tsconfig.json");
+    if (import_fs.default.existsSync(tsconfigPath)) {
+      return [tsconfigPath];
+    }
+    directory = import_path.default.dirname(directory);
+    checkedDirectories.push(directory);
+  } while (directory.length > 1 && directory.length >= tsconfigRootDir.length);
+  throw new Error(
+    `project was set to \`true\` but couldn't find any tsconfig.json relative to '${options.filePath}' within '${tsconfigRootDir}'.`
+  );
+}
+
+// src/parser/ts-for-v5/programs.ts
+var import_path2 = __toESM(require("path"));
+var tsServices = /* @__PURE__ */ new Map();
+function getTSProgram(code, options, ts) {
+  const tsconfigPath = options.project;
+  let service2 = tsServices.get(tsconfigPath);
+  if (!service2) {
+    service2 = new TSService(tsconfigPath, ts);
+    tsServices.set(tsconfigPath, service2);
+  }
+  return service2.getProgram(code, options.filePath);
+}
+var TSService = class {
+  constructor(tsconfigPath, ts) {
+    this.patchedHostSet = /* @__PURE__ */ new WeakSet();
+    this.currTarget = {
+      code: "",
+      filePath: ""
+    };
+    this.fileWatchCallbacks = /* @__PURE__ */ new Map();
+    this.ts = ts;
+    this.watch = this.createWatch(tsconfigPath);
+  }
+  getProgram(code, filePath) {
+    const normalized = normalizeFileName(this.ts, filePath);
+    const lastTarget = this.currTarget;
+    this.currTarget = {
+      code,
+      filePath: normalized
+    };
+    for (const { filePath: targetPath } of [this.currTarget, lastTarget]) {
+      if (!targetPath)
+        continue;
+      this.fileWatchCallbacks.get(targetPath)?.update();
+    }
+    const program = this.watch.getProgram().getProgram();
+    program.getTypeChecker();
+    return program;
+  }
+  createWatch(tsconfigPath) {
+    const { ts } = this;
+    const watchCompilerHost = ts.createWatchCompilerHost(
+      tsconfigPath,
+      {
+        noEmit: true,
+        jsx: ts.JsxEmit.Preserve,
+        // This option is required if `includes` only includes `*.astro` files.
+        // However, the option is not in the documentation.
+        // https://github.com/microsoft/TypeScript/issues/28447
+        allowNonTsExtensions: true
+      },
+      ts.sys,
+      (rootNames, options, argHost, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+        const host = argHost;
+        if (!this.patchedHostSet.has(host)) {
+          this.patchedHostSet.add(host);
+          const getTargetSourceFile = (fileName, languageVersionOrOptions) => {
+            var _a;
+            if (this.currTarget.filePath === normalizeFileName(ts, fileName)) {
+              return (_a = this.currTarget).sourceFile ?? (_a.sourceFile = ts.createSourceFile(
+                this.currTarget.filePath,
+                this.currTarget.code,
+                languageVersionOrOptions,
+                true,
+                ts.ScriptKind.TSX
+              ));
+            }
+            return null;
+          };
+          const original2 = {
+            getSourceFile: host.getSourceFile,
+            getSourceFileByPath: host.getSourceFileByPath
+          };
+          host.getSourceFile = (fileName, languageVersionOrOptions, ...args) => {
+            return getTargetSourceFile(fileName, languageVersionOrOptions) ?? original2.getSourceFile.call(
+              host,
+              fileName,
+              languageVersionOrOptions,
+              ...args
+            );
+          };
+          host.getSourceFileByPath = (fileName, path6, languageVersionOrOptions, ...args) => {
+            return getTargetSourceFile(fileName, languageVersionOrOptions) ?? original2.getSourceFileByPath.call(
+              host,
+              fileName,
+              path6,
+              languageVersionOrOptions,
+              ...args
+            );
+          };
+        }
+        return ts.createAbstractBuilder(
+          rootNames,
+          options,
+          host,
+          oldProgram,
+          configFileParsingDiagnostics,
+          projectReferences
+        );
+      },
+      (diagnostic) => {
+        throw new Error(formatDiagnostics(ts, [diagnostic]));
+      },
+      () => {
+      },
+      void 0,
+      [
+        {
+          extension: ".astro",
+          isMixedContent: true,
+          scriptKind: ts.ScriptKind.Deferred
+        }
+      ]
+    );
+    const original = {
+      readFile: watchCompilerHost.readFile
+    };
+    watchCompilerHost.readFile = (fileName, ...args) => {
+      const normalized = normalizeFileName(ts, fileName);
+      if (this.currTarget.filePath === normalized) {
+        return this.currTarget.code;
+      }
+      return original.readFile.call(watchCompilerHost, fileName, ...args);
+    };
+    watchCompilerHost.watchFile = (fileName, callback) => {
+      const normalized = normalizeFileName(ts, fileName);
+      this.fileWatchCallbacks.set(normalized, {
+        update: () => callback(fileName, ts.FileWatcherEventKind.Changed)
+      });
+      return {
+        close: () => {
+          this.fileWatchCallbacks.delete(normalized);
+        }
+      };
+    };
+    watchCompilerHost.watchDirectory = () => {
+      return {
+        close: () => {
+        }
+      };
+    };
+    watchCompilerHost.afterProgramCreate = (program) => {
+      const originalDiagnostics = program.getConfigFileParsingDiagnostics();
+      const configFileDiagnostics = originalDiagnostics.filter(
+        (diag) => diag.category === ts.DiagnosticCategory.Error && diag.code !== 18003
+      );
+      if (configFileDiagnostics.length > 0) {
+        throw new Error(formatDiagnostics(ts, configFileDiagnostics));
+      }
+    };
+    const watch = ts.createWatchProgram(watchCompilerHost);
+    return watch;
+  }
+};
+function formatDiagnostics(ts, diagnostics) {
+  return ts.formatDiagnostics(diagnostics, {
+    getCanonicalFileName: (f) => f,
+    getCurrentDirectory: () => process.cwd(),
+    getNewLine: () => "\n"
+  });
+}
+function normalizeFileName(ts, fileName) {
+  let normalized = import_path2.default.normalize(fileName);
+  if (normalized.endsWith(import_path2.default.sep)) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (ts.sys.useCaseSensitiveFileNames) {
+    return toAbsolutePath(normalized, null);
+  }
+  return toAbsolutePath(normalized.toLowerCase(), null);
+}
+function toAbsolutePath(filePath, baseDir) {
+  return import_path2.default.isAbsolute(filePath) ? filePath : import_path2.default.join(baseDir || process.cwd(), filePath);
+}
+
+// src/parser/ts-for-v5/parse-tsx-for-typescript.ts
+var DEFAULT_EXTRA_FILE_EXTENSIONS = [".vue", ".svelte", ".astro"];
+function parseTsxForTypeScript(code, options, tsEslintParser, ts) {
+  const programs = [];
+  for (const option of iterateOptions(options)) {
+    programs.push(getTSProgram(code, option, ts));
+  }
+  const parserOptions = {
+    ...options,
+    programs
+  };
+  return tsEslintParser.parseForESLint(code, parserOptions);
+}
+function* iterateOptions(options) {
+  if (!options) {
+    throw new Error("`parserOptions` is required.");
+  }
+  if (!options.filePath) {
+    throw new Error("`filePath` is required.");
+  }
+  if (!options.project) {
+    throw new Error(
+      "Specify `parserOptions.project`. Otherwise there is no point in using this parser."
+    );
+  }
+  for (const project of getProjectConfigFiles(options)) {
+    yield {
+      project,
+      filePath: options.filePath,
+      extraFileExtensions: options.extraFileExtensions || DEFAULT_EXTRA_FILE_EXTENSIONS
+    };
+  }
+}
+
+// src/parser/ts-patch.ts
+function tsPatch(scriptParserOptions, tsParserName) {
+  if (tsParserName === "typescript-eslint-parser-for-extra-files") {
+    return {
+      terminate() {
+      }
+    };
+  }
   let targetExt = ".astro";
   if (scriptParserOptions.filePath) {
-    const ext = import_path.default.extname(scriptParserOptions.filePath);
+    const ext = import_path3.default.extname(scriptParserOptions.filePath);
     if (ext) {
       targetExt = ext;
     }
   }
   try {
     const cwd = process.cwd();
-    const relativeTo = import_path.default.join(cwd, "__placeholder__.js");
+    const relativeTo = import_path3.default.join(cwd, "__placeholder__.js");
     const ts = (0, import_module.createRequire)(relativeTo)("typescript");
-    const { ensureScriptKind, getScriptKindFromFileName } = ts;
-    if (typeof ensureScriptKind === "function" && typeof getScriptKindFromFileName === "function") {
-      ts.ensureScriptKind = function(fileName, ...args) {
-        if (fileName.endsWith(targetExt)) {
-          return ts.ScriptKind.TSX;
-        }
-        return ensureScriptKind.call(this, fileName, ...args);
-      };
-      ts.getScriptKindFromFileName = function(fileName, ...args) {
-        if (fileName.endsWith(targetExt)) {
-          return ts.ScriptKind.TSX;
-        }
-        return getScriptKindFromFileName.call(this, fileName, ...args);
-      };
-      return {
-        terminate() {
-          ts.ensureScriptKind = ensureScriptKind;
-          ts.getScriptKindFromFileName = getScriptKindFromFileName;
-        }
-      };
+    if ((0, import_semver.satisfies)(ts.version, ">=5")) {
+      const result = tsPatchForV5(ts, scriptParserOptions);
+      if (result) {
+        return result;
+      }
+    } else {
+      const result = tsPatchForV4(ts, targetExt);
+      if (result) {
+        return result;
+      }
     }
   } catch {
   }
   const tsxFilePath = `${scriptParserOptions.filePath}.tsx`;
   scriptParserOptions.filePath = tsxFilePath;
-  if (!import_fs.default.existsSync(tsxFilePath)) {
-    import_fs.default.writeFileSync(tsxFilePath, "/* temp for astro-eslint-parser */");
+  if (!import_fs2.default.existsSync(tsxFilePath)) {
+    import_fs2.default.writeFileSync(tsxFilePath, "/* temp for astro-eslint-parser */");
     return {
       terminate() {
-        import_fs.default.unlinkSync(tsxFilePath);
+        import_fs2.default.unlinkSync(tsxFilePath);
       }
     };
   }
   return null;
 }
+function tsPatchForV5(ts, scriptParserOptions) {
+  return {
+    terminate() {
+    },
+    parse(code, parser) {
+      return parseTsxForTypeScript(
+        code,
+        scriptParserOptions,
+        parser,
+        ts
+      );
+    }
+  };
+}
+function tsPatchForV4(ts, targetExt) {
+  const { ensureScriptKind, getScriptKindFromFileName } = ts;
+  if (typeof ensureScriptKind !== "function" || typeof getScriptKindFromFileName !== "function") {
+    return null;
+  }
+  ts.ensureScriptKind = function(fileName, ...args) {
+    if (fileName.endsWith(targetExt)) {
+      return ts.ScriptKind.TSX;
+    }
+    return ensureScriptKind.call(this, fileName, ...args);
+  };
+  ts.getScriptKindFromFileName = function(fileName, ...args) {
+    if (fileName.endsWith(targetExt)) {
+      return ts.ScriptKind.TSX;
+    }
+    return getScriptKindFromFileName.call(this, fileName, ...args);
+  };
+  if (ts.ensureScriptKind === ensureScriptKind || ts.getScriptKindFromFileName === getScriptKindFromFileName) {
+    return null;
+  }
+  return {
+    terminate() {
+      ts.ensureScriptKind = ensureScriptKind;
+      ts.getScriptKindFromFileName = getScriptKindFromFileName;
+    }
+  };
+}
 
 // src/context/resolve-parser/parser-object.ts
 function isParserObject(value) {
@@ -122,9 +399,23 @@ function isBasicParserObject(value) {
 function maybeTSESLintParserObject(value) {
   return isEnhancedParserObject(value) && isBasicParserObject(value) && typeof value.createProgram === "function" && typeof value.clearCaches === "function" && typeof value.version === "string";
 }
+function getTSParserNameFromObject(value) {
+  if (!isEnhancedParserObject(value)) {
+    return null;
+  }
+  if (value.name === "typescript-eslint-parser-for-extra-files")
+    return "typescript-eslint-parser-for-extra-files";
+  if (value.meta?.name === "typescript-eslint/parser")
+    return "@typescript-eslint/parser";
+  return null;
+}
 function isTSESLintParserObject(value) {
   if (!isEnhancedParserObject(value))
     return false;
+  if (value.name === "typescript-eslint-parser-for-extra-files")
+    return true;
+  if (value.meta?.name === "typescript-eslint/parser")
+    return true;
   try {
     const result = value.parseForESLint("", {});
     const services = result.services;
@@ -159,9 +450,9 @@ function parseScriptInternal(code, _ctx, parserOptionsCtx) {
   try {
     const parserOptions = parserOptionsCtx.parserOptions;
     if (parserOptionsCtx.isTypeScript() && parserOptions.filePath && parserOptions.project) {
-      patchResult = tsPatch(parserOptions);
+      patchResult = tsPatch(parserOptions, parserOptionsCtx.getTSParserName());
     }
-    const result = isEnhancedParserObject(parser) ? parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
+    const result = isEnhancedParserObject(parser) ? patchResult?.parse ? patchResult.parse(code, parser) : parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
     if ("ast" in result && result.ast != null) {
       return result;
     }
@@ -195,6 +486,9 @@ var import_types = require("@typescript-eslint/types");
 
 // src/errors.ts
 var ParseError = class extends SyntaxError {
+  /**
+   * Initialize this ParseError instance.
+   */
   constructor(message, offset, ctx) {
     super(message);
     if (typeof offset === "number") {
@@ -617,6 +911,9 @@ var RestoreContext = class {
     }
     this.tokens.push(this.ctx.buildToken(type, range));
   }
+  /**
+   * Restore AST nodes
+   */
   restore(result) {
     const nodeMap = remapLocationsAndGetNodeMap(result, this.tokens, {
       remapLocation: (n) => this.remapLocation(n),
@@ -808,6 +1105,7 @@ function processTemplate(ctx, resultTemplate) {
   walkElements(
     resultTemplate.ast,
     ctx.code,
+    // eslint-disable-next-line complexity -- X(
     (node, [parent]) => {
       if (node.type === "frontmatter") {
         const start = node.position.start.offset;
@@ -1261,6 +1559,9 @@ var Context = class {
   getIndexFromLoc(loc) {
     return this.locs.getIndexFromLoc(loc);
   }
+  /**
+   * Get the location information of the given indexes.
+   */
   getLocations(start, end) {
     return {
       range: [start, end],
@@ -1270,6 +1571,9 @@ var Context = class {
       }
     };
   }
+  /**
+   * Build token
+   */
   buildToken(type, range) {
     return {
       type,
@@ -1277,6 +1581,9 @@ var Context = class {
       ...this.getLocations(...range)
     };
   }
+  /**
+   * get text
+   */
   getText(range) {
     return this.code.slice(range[0], range[1]);
   }
@@ -1440,6 +1747,7 @@ function fixLocations(node, ctx) {
   walk(
     node,
     ctx.code,
+    // eslint-disable-next-line complexity -- X(
     (node2, [parent]) => {
       if (node2.type === "frontmatter") {
         start = node2.position.start.offset = tokenIndex(ctx, "---", start);
@@ -1704,15 +2012,19 @@ function remap(result, normalized, originalCode, ctxForAstro) {
 }
 
 // src/context/parser-options.ts
-var import_path3 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_fs3 = __toESM(require("fs"));
 
 // src/context/resolve-parser/espree.ts
 var import_module2 = require("module");
-var import_path2 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 var espreeCache = null;
 function isLinterPath(p) {
-  return p.includes(`eslint${import_path2.default.sep}lib${import_path2.default.sep}linter${import_path2.default.sep}linter.js`) || p.includes(`eslint${import_path2.default.sep}lib${import_path2.default.sep}linter.js`);
+  return (
+    // ESLint 6 and above
+    p.includes(`eslint${import_path4.default.sep}lib${import_path4.default.sep}linter${import_path4.default.sep}linter.js`) || // ESLint 5
+    p.includes(`eslint${import_path4.default.sep}lib${import_path4.default.sep}linter.js`)
+  );
 }
 function getEspree() {
   if (!espreeCache) {
@@ -1773,6 +2085,7 @@ var ParserOptionsContext = class {
       tokens: true,
       comment: true,
       eslintVisitorKeys: true,
+      // eslintScopeManager: true,
       ...options || {}
     };
     parserOptions.ecmaFeatures = {
@@ -1788,39 +2101,59 @@ var ParserOptionsContext = class {
   getParser() {
     return getParser({}, this.parserOptions.parser);
   }
-  isTypeScript() {
-    if (this.state.isTypeScript != null) {
-      return this.state.isTypeScript;
+  getTSParserName() {
+    if (this.state.ts != null) {
+      return this.state.ts === false ? null : this.state.ts.parserName;
     }
     const parserValue = getParserForLang({}, this.parserOptions?.parser);
     if (typeof parserValue !== "string") {
-      return this.state.isTypeScript = maybeTSESLintParserObject(parserValue) || isTSESLintParserObject(parserValue);
+      const name2 = getTSParserNameFromObject(parserValue);
+      if (name2) {
+        this.state.ts = { parserName: name2 };
+        return this.state.ts.parserName;
+      }
+      if (maybeTSESLintParserObject(parserValue) || isTSESLintParserObject(parserValue)) {
+        this.state.ts = { parserName: "$unknown$" };
+        return this.state.ts.parserName;
+      }
+      this.state.ts = false;
+      return null;
     }
     const parserName = parserValue;
     if (TS_PARSER_NAMES.includes(parserName)) {
-      return this.state.isTypeScript = true;
+      this.state.ts = { parserName };
+      return this.state.ts.parserName;
     }
     if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
       let targetPath = parserName;
       while (targetPath) {
-        const pkgPath = import_path3.default.join(targetPath, "package.json");
-        if (import_fs2.default.existsSync(pkgPath)) {
+        const pkgPath = import_path5.default.join(targetPath, "package.json");
+        if (import_fs3.default.existsSync(pkgPath)) {
           try {
-            return this.state.isTypeScript = TS_PARSER_NAMES.includes(
-              JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf-8"))?.name
-            );
+            const pkgName = JSON.parse(import_fs3.default.readFileSync(pkgPath, "utf-8"))?.name;
+            if (TS_PARSER_NAMES.includes(pkgName)) {
+              this.state.ts = { parserName: pkgName };
+              return this.state.ts.parserName;
+            }
+            this.state.ts = false;
+            return null;
           } catch {
-            return this.state.isTypeScript = false;
+            this.state.ts = false;
+            return null;
           }
         }
-        const parent = import_path3.default.dirname(targetPath);
+        const parent = import_path5.default.dirname(targetPath);
         if (targetPath === parent) {
           break;
         }
         targetPath = parent;
       }
     }
-    return this.state.isTypeScript = false;
+    this.state.ts = false;
+    return null;
+  }
+  isTypeScript() {
+    return Boolean(this.getTSParserName());
   }
 };
 
@@ -1875,12 +2208,12 @@ function addVirtualReference(node, variable, scope, readWrite) {
 }
 function addGlobalVariable(reference, scopeManager) {
   const globalScope = scopeManager.globalScope;
-  const name = reference.identifier.name;
-  let variable = globalScope.set.get(name);
+  const name2 = reference.identifier.name;
+  let variable = globalScope.set.get(name2);
   if (!variable) {
-    variable = new import_scope_manager2.Variable(name, globalScope);
+    variable = new import_scope_manager2.Variable(name2, globalScope);
     globalScope.variables.push(variable);
-    globalScope.set.set(name, variable);
+    globalScope.set.set(name2, variable);
   }
   reference.resolved = variable;
   variable.references.push(reference);
@@ -1888,13 +2221,13 @@ function addGlobalVariable(reference, scopeManager) {
 }
 function removeReferenceFromThrough(reference, baseScope) {
   const variable = reference.resolved;
-  const name = reference.identifier.name;
+  const name2 = reference.identifier.name;
   let scope = baseScope;
   while (scope) {
     for (const ref of [...scope.through]) {
       if (reference === ref) {
         scope.through.splice(scope.through.indexOf(ref), 1);
-      } else if (ref.identifier.name === name) {
+      } else if (ref.identifier.name === name2) {
         ref.resolved = variable;
         if (!variable.references.includes(ref)) {
           addReference(variable.references, ref);
@@ -1931,9 +2264,9 @@ function removeReference(reference, baseScope) {
       if (varIndex >= 0) {
         baseScope.variables.splice(varIndex, 1);
       }
-      const name = reference.identifier.name;
-      if (reference.resolved === baseScope.set.get(name)) {
-        baseScope.set.delete(name);
+      const name2 = reference.identifier.name;
+      if (reference.resolved === baseScope.set.get(name2)) {
+        baseScope.set.delete(name2);
       }
     } else {
       const refIndex = reference.resolved.references.indexOf(reference);
@@ -1971,9 +2304,9 @@ function removeIdentifierVariable(node, scope) {
         r.resolved = null;
       });
       scope.variables.splice(varIndex, 1);
-      const name = node.name;
-      if (variable === scope.set.get(name)) {
-        scope.set.delete(name);
+      const name2 = node.name;
+      if (variable === scope.set.get(name2)) {
+        scope.set.delete(name2);
       }
     } else {
       const idIndex = variable.identifiers.indexOf(node);
@@ -2187,6 +2520,7 @@ function parseTemplate2(code) {
 var ast_exports = {};
 
 // src/index.ts
+var name = "astro-eslint-parser";
 function parseForESLint2(code, options) {
   return parseForESLint(code, options);
 }
@@ -2196,6 +2530,7 @@ var VisitorKeys = KEYS;
   AST,
   ParseError,
   VisitorKeys,
+  name,
   parseForESLint,
   parseTemplate,
   traverseNodes

package/lib/index.mjs

@@ -30,55 +30,327 @@ var debug = debugFactory("astro-eslint-parser");
 
 // src/parser/ts-patch.ts
 import { createRequire } from "module";
-import path from "path";
+import path3 from "path";
+import fs2 from "fs";
+import { satisfies } from "semver";
+
+// src/parser/ts-for-v5/get-project-config-files.ts
 import fs from "fs";
-function tsPatch(scriptParserOptions) {
+import path from "path";
+function getProjectConfigFiles(options) {
+  const tsconfigRootDir = typeof options.tsconfigRootDir === "string" ? options.tsconfigRootDir : process.cwd();
+  if (options.project !== true) {
+    return Array.isArray(options.project) ? options.project : [options.project];
+  }
+  let directory = path.dirname(options.filePath);
+  const checkedDirectories = [directory];
+  do {
+    const tsconfigPath = path.join(directory, "tsconfig.json");
+    if (fs.existsSync(tsconfigPath)) {
+      return [tsconfigPath];
+    }
+    directory = path.dirname(directory);
+    checkedDirectories.push(directory);
+  } while (directory.length > 1 && directory.length >= tsconfigRootDir.length);
+  throw new Error(
+    `project was set to \`true\` but couldn't find any tsconfig.json relative to '${options.filePath}' within '${tsconfigRootDir}'.`
+  );
+}
+
+// src/parser/ts-for-v5/programs.ts
+import path2 from "path";
+var tsServices = /* @__PURE__ */ new Map();
+function getTSProgram(code, options, ts) {
+  const tsconfigPath = options.project;
+  let service2 = tsServices.get(tsconfigPath);
+  if (!service2) {
+    service2 = new TSService(tsconfigPath, ts);
+    tsServices.set(tsconfigPath, service2);
+  }
+  return service2.getProgram(code, options.filePath);
+}
+var TSService = class {
+  constructor(tsconfigPath, ts) {
+    this.patchedHostSet = /* @__PURE__ */ new WeakSet();
+    this.currTarget = {
+      code: "",
+      filePath: ""
+    };
+    this.fileWatchCallbacks = /* @__PURE__ */ new Map();
+    this.ts = ts;
+    this.watch = this.createWatch(tsconfigPath);
+  }
+  getProgram(code, filePath) {
+    const normalized = normalizeFileName(this.ts, filePath);
+    const lastTarget = this.currTarget;
+    this.currTarget = {
+      code,
+      filePath: normalized
+    };
+    for (const { filePath: targetPath } of [this.currTarget, lastTarget]) {
+      if (!targetPath)
+        continue;
+      this.fileWatchCallbacks.get(targetPath)?.update();
+    }
+    const program = this.watch.getProgram().getProgram();
+    program.getTypeChecker();
+    return program;
+  }
+  createWatch(tsconfigPath) {
+    const { ts } = this;
+    const watchCompilerHost = ts.createWatchCompilerHost(
+      tsconfigPath,
+      {
+        noEmit: true,
+        jsx: ts.JsxEmit.Preserve,
+        // This option is required if `includes` only includes `*.astro` files.
+        // However, the option is not in the documentation.
+        // https://github.com/microsoft/TypeScript/issues/28447
+        allowNonTsExtensions: true
+      },
+      ts.sys,
+      (rootNames, options, argHost, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+        const host = argHost;
+        if (!this.patchedHostSet.has(host)) {
+          this.patchedHostSet.add(host);
+          const getTargetSourceFile = (fileName, languageVersionOrOptions) => {
+            var _a;
+            if (this.currTarget.filePath === normalizeFileName(ts, fileName)) {
+              return (_a = this.currTarget).sourceFile ?? (_a.sourceFile = ts.createSourceFile(
+                this.currTarget.filePath,
+                this.currTarget.code,
+                languageVersionOrOptions,
+                true,
+                ts.ScriptKind.TSX
+              ));
+            }
+            return null;
+          };
+          const original2 = {
+            getSourceFile: host.getSourceFile,
+            getSourceFileByPath: host.getSourceFileByPath
+          };
+          host.getSourceFile = (fileName, languageVersionOrOptions, ...args) => {
+            return getTargetSourceFile(fileName, languageVersionOrOptions) ?? original2.getSourceFile.call(
+              host,
+              fileName,
+              languageVersionOrOptions,
+              ...args
+            );
+          };
+          host.getSourceFileByPath = (fileName, path6, languageVersionOrOptions, ...args) => {
+            return getTargetSourceFile(fileName, languageVersionOrOptions) ?? original2.getSourceFileByPath.call(
+              host,
+              fileName,
+              path6,
+              languageVersionOrOptions,
+              ...args
+            );
+          };
+        }
+        return ts.createAbstractBuilder(
+          rootNames,
+          options,
+          host,
+          oldProgram,
+          configFileParsingDiagnostics,
+          projectReferences
+        );
+      },
+      (diagnostic) => {
+        throw new Error(formatDiagnostics(ts, [diagnostic]));
+      },
+      () => {
+      },
+      void 0,
+      [
+        {
+          extension: ".astro",
+          isMixedContent: true,
+          scriptKind: ts.ScriptKind.Deferred
+        }
+      ]
+    );
+    const original = {
+      readFile: watchCompilerHost.readFile
+    };
+    watchCompilerHost.readFile = (fileName, ...args) => {
+      const normalized = normalizeFileName(ts, fileName);
+      if (this.currTarget.filePath === normalized) {
+        return this.currTarget.code;
+      }
+      return original.readFile.call(watchCompilerHost, fileName, ...args);
+    };
+    watchCompilerHost.watchFile = (fileName, callback) => {
+      const normalized = normalizeFileName(ts, fileName);
+      this.fileWatchCallbacks.set(normalized, {
+        update: () => callback(fileName, ts.FileWatcherEventKind.Changed)
+      });
+      return {
+        close: () => {
+          this.fileWatchCallbacks.delete(normalized);
+        }
+      };
+    };
+    watchCompilerHost.watchDirectory = () => {
+      return {
+        close: () => {
+        }
+      };
+    };
+    watchCompilerHost.afterProgramCreate = (program) => {
+      const originalDiagnostics = program.getConfigFileParsingDiagnostics();
+      const configFileDiagnostics = originalDiagnostics.filter(
+        (diag) => diag.category === ts.DiagnosticCategory.Error && diag.code !== 18003
+      );
+      if (configFileDiagnostics.length > 0) {
+        throw new Error(formatDiagnostics(ts, configFileDiagnostics));
+      }
+    };
+    const watch = ts.createWatchProgram(watchCompilerHost);
+    return watch;
+  }
+};
+function formatDiagnostics(ts, diagnostics) {
+  return ts.formatDiagnostics(diagnostics, {
+    getCanonicalFileName: (f) => f,
+    getCurrentDirectory: () => process.cwd(),
+    getNewLine: () => "\n"
+  });
+}
+function normalizeFileName(ts, fileName) {
+  let normalized = path2.normalize(fileName);
+  if (normalized.endsWith(path2.sep)) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (ts.sys.useCaseSensitiveFileNames) {
+    return toAbsolutePath(normalized, null);
+  }
+  return toAbsolutePath(normalized.toLowerCase(), null);
+}
+function toAbsolutePath(filePath, baseDir) {
+  return path2.isAbsolute(filePath) ? filePath : path2.join(baseDir || process.cwd(), filePath);
+}
+
+// src/parser/ts-for-v5/parse-tsx-for-typescript.ts
+var DEFAULT_EXTRA_FILE_EXTENSIONS = [".vue", ".svelte", ".astro"];
+function parseTsxForTypeScript(code, options, tsEslintParser, ts) {
+  const programs = [];
+  for (const option of iterateOptions(options)) {
+    programs.push(getTSProgram(code, option, ts));
+  }
+  const parserOptions = {
+    ...options,
+    programs
+  };
+  return tsEslintParser.parseForESLint(code, parserOptions);
+}
+function* iterateOptions(options) {
+  if (!options) {
+    throw new Error("`parserOptions` is required.");
+  }
+  if (!options.filePath) {
+    throw new Error("`filePath` is required.");
+  }
+  if (!options.project) {
+    throw new Error(
+      "Specify `parserOptions.project`. Otherwise there is no point in using this parser."
+    );
+  }
+  for (const project of getProjectConfigFiles(options)) {
+    yield {
+      project,
+      filePath: options.filePath,
+      extraFileExtensions: options.extraFileExtensions || DEFAULT_EXTRA_FILE_EXTENSIONS
+    };
+  }
+}
+
+// src/parser/ts-patch.ts
+function tsPatch(scriptParserOptions, tsParserName) {
+  if (tsParserName === "typescript-eslint-parser-for-extra-files") {
+    return {
+      terminate() {
+      }
+    };
+  }
   let targetExt = ".astro";
   if (scriptParserOptions.filePath) {
-    const ext = path.extname(scriptParserOptions.filePath);
+    const ext = path3.extname(scriptParserOptions.filePath);
     if (ext) {
       targetExt = ext;
     }
   }
   try {
     const cwd = process.cwd();
-    const relativeTo = path.join(cwd, "__placeholder__.js");
+    const relativeTo = path3.join(cwd, "__placeholder__.js");
     const ts = createRequire(relativeTo)("typescript");
-    const { ensureScriptKind, getScriptKindFromFileName } = ts;
-    if (typeof ensureScriptKind === "function" && typeof getScriptKindFromFileName === "function") {
-      ts.ensureScriptKind = function(fileName, ...args) {
-        if (fileName.endsWith(targetExt)) {
-          return ts.ScriptKind.TSX;
-        }
-        return ensureScriptKind.call(this, fileName, ...args);
-      };
-      ts.getScriptKindFromFileName = function(fileName, ...args) {
-        if (fileName.endsWith(targetExt)) {
-          return ts.ScriptKind.TSX;
-        }
-        return getScriptKindFromFileName.call(this, fileName, ...args);
-      };
-      return {
-        terminate() {
-          ts.ensureScriptKind = ensureScriptKind;
-          ts.getScriptKindFromFileName = getScriptKindFromFileName;
-        }
-      };
+    if (satisfies(ts.version, ">=5")) {
+      const result = tsPatchForV5(ts, scriptParserOptions);
+      if (result) {
+        return result;
+      }
+    } else {
+      const result = tsPatchForV4(ts, targetExt);
+      if (result) {
+        return result;
+      }
     }
   } catch {
   }
   const tsxFilePath = `${scriptParserOptions.filePath}.tsx`;
   scriptParserOptions.filePath = tsxFilePath;
-  if (!fs.existsSync(tsxFilePath)) {
-    fs.writeFileSync(tsxFilePath, "/* temp for astro-eslint-parser */");
+  if (!fs2.existsSync(tsxFilePath)) {
+    fs2.writeFileSync(tsxFilePath, "/* temp for astro-eslint-parser */");
     return {
       terminate() {
-        fs.unlinkSync(tsxFilePath);
+        fs2.unlinkSync(tsxFilePath);
       }
     };
   }
   return null;
 }
+function tsPatchForV5(ts, scriptParserOptions) {
+  return {
+    terminate() {
+    },
+    parse(code, parser) {
+      return parseTsxForTypeScript(
+        code,
+        scriptParserOptions,
+        parser,
+        ts
+      );
+    }
+  };
+}
+function tsPatchForV4(ts, targetExt) {
+  const { ensureScriptKind, getScriptKindFromFileName } = ts;
+  if (typeof ensureScriptKind !== "function" || typeof getScriptKindFromFileName !== "function") {
+    return null;
+  }
+  ts.ensureScriptKind = function(fileName, ...args) {
+    if (fileName.endsWith(targetExt)) {
+      return ts.ScriptKind.TSX;
+    }
+    return ensureScriptKind.call(this, fileName, ...args);
+  };
+  ts.getScriptKindFromFileName = function(fileName, ...args) {
+    if (fileName.endsWith(targetExt)) {
+      return ts.ScriptKind.TSX;
+    }
+    return getScriptKindFromFileName.call(this, fileName, ...args);
+  };
+  if (ts.ensureScriptKind === ensureScriptKind || ts.getScriptKindFromFileName === getScriptKindFromFileName) {
+    return null;
+  }
+  return {
+    terminate() {
+      ts.ensureScriptKind = ensureScriptKind;
+      ts.getScriptKindFromFileName = getScriptKindFromFileName;
+    }
+  };
+}
 
 // src/context/resolve-parser/parser-object.ts
 function isParserObject(value) {
@@ -93,9 +365,23 @@ function isBasicParserObject(value) {
 function maybeTSESLintParserObject(value) {
   return isEnhancedParserObject(value) && isBasicParserObject(value) && typeof value.createProgram === "function" && typeof value.clearCaches === "function" && typeof value.version === "string";
 }
+function getTSParserNameFromObject(value) {
+  if (!isEnhancedParserObject(value)) {
+    return null;
+  }
+  if (value.name === "typescript-eslint-parser-for-extra-files")
+    return "typescript-eslint-parser-for-extra-files";
+  if (value.meta?.name === "typescript-eslint/parser")
+    return "@typescript-eslint/parser";
+  return null;
+}
 function isTSESLintParserObject(value) {
   if (!isEnhancedParserObject(value))
     return false;
+  if (value.name === "typescript-eslint-parser-for-extra-files")
+    return true;
+  if (value.meta?.name === "typescript-eslint/parser")
+    return true;
   try {
     const result = value.parseForESLint("", {});
     const services = result.services;
@@ -130,9 +416,9 @@ function parseScriptInternal(code, _ctx, parserOptionsCtx) {
   try {
     const parserOptions = parserOptionsCtx.parserOptions;
     if (parserOptionsCtx.isTypeScript() && parserOptions.filePath && parserOptions.project) {
-      patchResult = tsPatch(parserOptions);
+      patchResult = tsPatch(parserOptions, parserOptionsCtx.getTSParserName());
     }
-    const result = isEnhancedParserObject(parser) ? parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
+    const result = isEnhancedParserObject(parser) ? patchResult?.parse ? patchResult.parse(code, parser) : parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
     if ("ast" in result && result.ast != null) {
       return result;
     }
@@ -166,6 +452,9 @@ import { AST_TOKEN_TYPES, AST_NODE_TYPES } from "@typescript-eslint/types";
 
 // src/errors.ts
 var ParseError = class extends SyntaxError {
+  /**
+   * Initialize this ParseError instance.
+   */
   constructor(message, offset, ctx) {
     super(message);
     if (typeof offset === "number") {
@@ -588,6 +877,9 @@ var RestoreContext = class {
     }
     this.tokens.push(this.ctx.buildToken(type, range));
   }
+  /**
+   * Restore AST nodes
+   */
   restore(result) {
     const nodeMap = remapLocationsAndGetNodeMap(result, this.tokens, {
       remapLocation: (n) => this.remapLocation(n),
@@ -779,6 +1071,7 @@ function processTemplate(ctx, resultTemplate) {
   walkElements(
     resultTemplate.ast,
     ctx.code,
+    // eslint-disable-next-line complexity -- X(
     (node, [parent]) => {
       if (node.type === "frontmatter") {
         const start = node.position.start.offset;
@@ -1232,6 +1525,9 @@ var Context = class {
   getIndexFromLoc(loc) {
     return this.locs.getIndexFromLoc(loc);
   }
+  /**
+   * Get the location information of the given indexes.
+   */
   getLocations(start, end) {
     return {
       range: [start, end],
@@ -1241,6 +1537,9 @@ var Context = class {
       }
     };
   }
+  /**
+   * Build token
+   */
   buildToken(type, range) {
     return {
       type,
@@ -1248,6 +1547,9 @@ var Context = class {
       ...this.getLocations(...range)
     };
   }
+  /**
+   * get text
+   */
   getText(range) {
     return this.code.slice(range[0], range[1]);
   }
@@ -1411,6 +1713,7 @@ function fixLocations(node, ctx) {
   walk(
     node,
     ctx.code,
+    // eslint-disable-next-line complexity -- X(
     (node2, [parent]) => {
       if (node2.type === "frontmatter") {
         start = node2.position.start.offset = tokenIndex(ctx, "---", start);
@@ -1675,15 +1978,19 @@ function remap(result, normalized, originalCode, ctxForAstro) {
 }
 
 // src/context/parser-options.ts
-import path3 from "path";
-import fs2 from "fs";
+import path5 from "path";
+import fs3 from "fs";
 
 // src/context/resolve-parser/espree.ts
 import { createRequire as createRequire2 } from "module";
-import path2 from "path";
+import path4 from "path";
 var espreeCache = null;
 function isLinterPath(p) {
-  return p.includes(`eslint${path2.sep}lib${path2.sep}linter${path2.sep}linter.js`) || p.includes(`eslint${path2.sep}lib${path2.sep}linter.js`);
+  return (
+    // ESLint 6 and above
+    p.includes(`eslint${path4.sep}lib${path4.sep}linter${path4.sep}linter.js`) || // ESLint 5
+    p.includes(`eslint${path4.sep}lib${path4.sep}linter.js`)
+  );
 }
 function getEspree() {
   if (!espreeCache) {
@@ -1744,6 +2051,7 @@ var ParserOptionsContext = class {
       tokens: true,
       comment: true,
       eslintVisitorKeys: true,
+      // eslintScopeManager: true,
       ...options || {}
     };
     parserOptions.ecmaFeatures = {
@@ -1759,39 +2067,59 @@ var ParserOptionsContext = class {
   getParser() {
     return getParser({}, this.parserOptions.parser);
   }
-  isTypeScript() {
-    if (this.state.isTypeScript != null) {
-      return this.state.isTypeScript;
+  getTSParserName() {
+    if (this.state.ts != null) {
+      return this.state.ts === false ? null : this.state.ts.parserName;
     }
     const parserValue = getParserForLang({}, this.parserOptions?.parser);
     if (typeof parserValue !== "string") {
-      return this.state.isTypeScript = maybeTSESLintParserObject(parserValue) || isTSESLintParserObject(parserValue);
+      const name2 = getTSParserNameFromObject(parserValue);
+      if (name2) {
+        this.state.ts = { parserName: name2 };
+        return this.state.ts.parserName;
+      }
+      if (maybeTSESLintParserObject(parserValue) || isTSESLintParserObject(parserValue)) {
+        this.state.ts = { parserName: "$unknown$" };
+        return this.state.ts.parserName;
+      }
+      this.state.ts = false;
+      return null;
     }
     const parserName = parserValue;
     if (TS_PARSER_NAMES.includes(parserName)) {
-      return this.state.isTypeScript = true;
+      this.state.ts = { parserName };
+      return this.state.ts.parserName;
     }
     if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
       let targetPath = parserName;
       while (targetPath) {
-        const pkgPath = path3.join(targetPath, "package.json");
-        if (fs2.existsSync(pkgPath)) {
+        const pkgPath = path5.join(targetPath, "package.json");
+        if (fs3.existsSync(pkgPath)) {
           try {
-            return this.state.isTypeScript = TS_PARSER_NAMES.includes(
-              JSON.parse(fs2.readFileSync(pkgPath, "utf-8"))?.name
-            );
+            const pkgName = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"))?.name;
+            if (TS_PARSER_NAMES.includes(pkgName)) {
+              this.state.ts = { parserName: pkgName };
+              return this.state.ts.parserName;
+            }
+            this.state.ts = false;
+            return null;
           } catch {
-            return this.state.isTypeScript = false;
+            this.state.ts = false;
+            return null;
           }
         }
-        const parent = path3.dirname(targetPath);
+        const parent = path5.dirname(targetPath);
         if (targetPath === parent) {
           break;
         }
         targetPath = parent;
       }
     }
-    return this.state.isTypeScript = false;
+    this.state.ts = false;
+    return null;
+  }
+  isTypeScript() {
+    return Boolean(this.getTSParserName());
   }
 };
 
@@ -1849,12 +2177,12 @@ function addVirtualReference(node, variable, scope, readWrite) {
 }
 function addGlobalVariable(reference, scopeManager) {
   const globalScope = scopeManager.globalScope;
-  const name = reference.identifier.name;
-  let variable = globalScope.set.get(name);
+  const name2 = reference.identifier.name;
+  let variable = globalScope.set.get(name2);
   if (!variable) {
-    variable = new VariableClass(name, globalScope);
+    variable = new VariableClass(name2, globalScope);
     globalScope.variables.push(variable);
-    globalScope.set.set(name, variable);
+    globalScope.set.set(name2, variable);
   }
   reference.resolved = variable;
   variable.references.push(reference);
@@ -1862,13 +2190,13 @@ function addGlobalVariable(reference, scopeManager) {
 }
 function removeReferenceFromThrough(reference, baseScope) {
   const variable = reference.resolved;
-  const name = reference.identifier.name;
+  const name2 = reference.identifier.name;
   let scope = baseScope;
   while (scope) {
     for (const ref of [...scope.through]) {
       if (reference === ref) {
         scope.through.splice(scope.through.indexOf(ref), 1);
-      } else if (ref.identifier.name === name) {
+      } else if (ref.identifier.name === name2) {
         ref.resolved = variable;
         if (!variable.references.includes(ref)) {
           addReference(variable.references, ref);
@@ -1905,9 +2233,9 @@ function removeReference(reference, baseScope) {
       if (varIndex >= 0) {
         baseScope.variables.splice(varIndex, 1);
       }
-      const name = reference.identifier.name;
-      if (reference.resolved === baseScope.set.get(name)) {
-        baseScope.set.delete(name);
+      const name2 = reference.identifier.name;
+      if (reference.resolved === baseScope.set.get(name2)) {
+        baseScope.set.delete(name2);
       }
     } else {
       const refIndex = reference.resolved.references.indexOf(reference);
@@ -1945,9 +2273,9 @@ function removeIdentifierVariable(node, scope) {
         r.resolved = null;
       });
       scope.variables.splice(varIndex, 1);
-      const name = node.name;
-      if (variable === scope.set.get(name)) {
-        scope.set.delete(name);
+      const name2 = node.name;
+      if (variable === scope.set.get(name2)) {
+        scope.set.delete(name2);
       }
     } else {
       const idIndex = variable.identifiers.indexOf(node);
@@ -2161,6 +2489,7 @@ function parseTemplate2(code) {
 var ast_exports = {};
 
 // src/index.ts
+var name = "astro-eslint-parser";
 function parseForESLint2(code, options) {
   return parseForESLint(code, options);
 }
@@ -2169,6 +2498,7 @@ export {
   ast_exports as AST,
   ParseError,
   VisitorKeys,
+  name,
   parseForESLint2 as parseForESLint,
   parseTemplate2 as parseTemplate,
   traverseNodes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-eslint-parser",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Astro component parser for ESLint",
   "main": "lib/index.js",
   "module": "lib/index.mjs",
@@ -53,7 +53,8 @@
     "astrojs-compiler-sync": "^0.3.0",
     "debug": "^4.3.4",
     "eslint-visitor-keys": "^3.0.0",
-    "espree": "^9.0.0"
+    "espree": "^9.0.0",
+    "semver": "^7.3.8"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.4.6",
@@ -68,20 +69,19 @@
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.0.0",
     "@types/semver": "^7.3.9",
-    "@typescript-eslint/eslint-plugin": "~5.48.0",
-    "@typescript-eslint/parser": "~5.48.0",
-    "astro": "^1.6.1",
+    "@typescript-eslint/eslint-plugin": "~5.55.0",
+    "@typescript-eslint/parser": "~5.55.0",
+    "astro": "^2.0.0",
     "astro-eslint-parser": ">=0.1.0",
     "benchmark": "^2.1.4",
     "chai": "^4.3.4",
-    "code-red": "^0.2.3",
     "env-cmd": "^10.1.0",
-    "esbuild": "^0.16.0",
+    "esbuild": "^0.17.0",
     "esbuild-register": "^3.3.3",
     "eslint": "^8.15.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-formatter-codeframe": "^7.32.1",
-    "eslint-plugin-astro": "^0.22.0",
+    "eslint-plugin-astro": "^0.25.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-json-schema-validator": "^4.0.0",
     "eslint-plugin-jsonc": "^2.0.0",
@@ -91,22 +91,22 @@
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-react": "^7.29.4",
     "eslint-plugin-regexp": "^1.5.0",
-    "eslint-plugin-simple-import-sort": "^9.0.0",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-svelte": "^2.0.0",
     "estree-walker": "^3.0.0",
     "locate-character": "^2.0.5",
-    "magic-string": "^0.27.0",
+    "magic-string": "^0.30.0",
     "mocha": "^10.0.0",
     "mocha-chai-jest-snapshot": "^1.1.3",
     "nyc": "^15.1.0",
     "prettier": "^2.0.5",
-    "prettier-plugin-astro": "^0.7.0",
+    "prettier-plugin-astro": "^0.8.0",
     "prettier-plugin-svelte": "^2.7.0",
-    "semver": "^7.3.5",
     "string-replace-loader": "^3.0.3",
     "svelte": "^3.48.0",
     "tsup": "^6.2.3",
-    "typescript": "~4.9.0"
+    "typescript": "~5.0.0",
+    "typescript-eslint-parser-for-extra-files": "^0.2.0"
   },
   "publishConfig": {
     "access": "public"