astro-eslint-parser 0.12.0 → 0.13.1

package/lib/index.d.ts

@@ -41,6 +41,7 @@ declare class Context {
 }
 declare class LinesAndColumns {
     private readonly lineStartIndices;
+    private readonly code;
     private readonly normalizedLineFeed;
     constructor(origCode: string);
     getLocFromIndex(index: number): {

package/lib/index.js

@@ -64,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) {
@@ -127,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;
@@ -164,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;
     }
@@ -1335,6 +1621,7 @@ ${next}`;
       }
     }
     this.lineStartIndices = lineStartIndices;
+    this.code = origCode;
     this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
   }
   getLocFromIndex(index) {
@@ -1348,9 +1635,15 @@ ${next}`;
     };
   }
   getIndexFromLoc(loc) {
-    const lineStartIndex = this.lineStartIndices[loc.line - 1];
-    const positionIndex = lineStartIndex + loc.column;
-    return positionIndex;
+    const lineIndex = loc.line - 1;
+    if (this.lineStartIndices.length > lineIndex) {
+      const lineStartIndex = this.lineStartIndices[lineIndex];
+      const positionIndex = lineStartIndex + loc.column;
+      return positionIndex;
+    } else if (this.lineStartIndices.length === lineIndex) {
+      return this.code.length + loc.column;
+    }
+    return this.code.length + loc.column;
   }
   getNormalizedLineFeed() {
     return this.normalizedLineFeed;
@@ -1726,18 +2019,18 @@ 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 (
     // ESLint 6 and above
-    p.includes(`eslint${import_path2.default.sep}lib${import_path2.default.sep}linter${import_path2.default.sep}linter.js`) || // ESLint 5
-    p.includes(`eslint${import_path2.default.sep}lib${import_path2.default.sep}linter.js`)
+    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() {
@@ -1815,39 +2108,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());
   }
 };
 

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;
     }
@@ -1301,6 +1587,7 @@ ${next}`;
       }
     }
     this.lineStartIndices = lineStartIndices;
+    this.code = origCode;
     this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
   }
   getLocFromIndex(index) {
@@ -1314,9 +1601,15 @@ ${next}`;
     };
   }
   getIndexFromLoc(loc) {
-    const lineStartIndex = this.lineStartIndices[loc.line - 1];
-    const positionIndex = lineStartIndex + loc.column;
-    return positionIndex;
+    const lineIndex = loc.line - 1;
+    if (this.lineStartIndices.length > lineIndex) {
+      const lineStartIndex = this.lineStartIndices[lineIndex];
+      const positionIndex = lineStartIndex + loc.column;
+      return positionIndex;
+    } else if (this.lineStartIndices.length === lineIndex) {
+      return this.code.length + loc.column;
+    }
+    return this.code.length + loc.column;
   }
   getNormalizedLineFeed() {
     return this.normalizedLineFeed;
@@ -1692,18 +1985,18 @@ 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 (
     // ESLint 6 and above
-    p.includes(`eslint${path2.sep}lib${path2.sep}linter${path2.sep}linter.js`) || // ESLint 5
-    p.includes(`eslint${path2.sep}lib${path2.sep}linter.js`)
+    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() {
@@ -1781,39 +2074,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());
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-eslint-parser",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "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,8 +69,8 @@
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.0.0",
     "@types/semver": "^7.3.9",
-    "@typescript-eslint/eslint-plugin": "~5.54.0",
-    "@typescript-eslint/parser": "~5.54.0",
+    "@typescript-eslint/eslint-plugin": "~5.56.0",
+    "@typescript-eslint/parser": "~5.56.0",
     "astro": "^2.0.0",
     "astro-eslint-parser": ">=0.1.0",
     "benchmark": "^2.1.4",
@@ -80,7 +81,7 @@
     "eslint": "^8.15.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-formatter-codeframe": "^7.32.1",
-    "eslint-plugin-astro": "^0.23.0",
+    "eslint-plugin-astro": "^0.26.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-json-schema-validator": "^4.0.0",
     "eslint-plugin-jsonc": "^2.0.0",
@@ -101,11 +102,11 @@
     "prettier": "^2.0.5",
     "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"