@marko/language-server 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -13,96 +13,11 @@ import {
   TextDocumentSyncKind,
   createConnection
 } from "vscode-languageserver/node";
-
-// src/utils/project.ts
-import path from "path";
-import { createRequire } from "module";
-import * as defaultCompiler from "@marko/compiler";
-import * as defaultTranslator from "@marko/translator-default";
-var ignoreErrors = (_err) => {
-};
-var projectsByDir = /* @__PURE__ */ new Map();
-var projectsByCompiler = /* @__PURE__ */ new Map();
-var defaultProject = {
-  cache: /* @__PURE__ */ new Map(),
-  compiler: defaultCompiler,
-  translator: defaultTranslator,
-  getLookup(dir) {
-    const key = `taglib:${dir}`;
-    let lookup = defaultProject.cache.get(key);
-    if (!lookup) {
-      defaultProject.cache.set(
-        key,
-        lookup = defaultCompiler.taglib.buildLookup(
-          dir,
-          defaultTranslator,
-          ignoreErrors
-        )
-      );
-    }
-    return lookup;
-  }
-};
-defaultCompiler.configure({ translator: defaultTranslator });
-function getMarkoProject(dir) {
-  if (!dir)
-    return defaultProject;
-  let project = projectsByDir.get(dir);
-  if (!project) {
-    project = loadProject(dir);
-    projectsByDir.set(dir, project);
-  }
-  return project;
-}
-function getMarkoProjects() {
-  return projectsByCompiler.values();
-}
-function clearMarkoProjectCaches() {
-  for (const project of getMarkoProjects()) {
-    project.cache.clear();
-    project.compiler.taglib.clearCaches();
-  }
-}
-function loadProject(dir) {
-  try {
-    const require2 = createRequire(dir);
-    const compilerConfigPath = require2.resolve("@marko/compiler/config");
-    const cachedProject = projectsByCompiler.get(compilerConfigPath);
-    if (cachedProject)
-      return cachedProject;
-    const compiler = require2(path.join(compilerConfigPath, ".."));
-    const translator = require2(interopDefault(require2(compilerConfigPath)).translator);
-    const project = {
-      cache: /* @__PURE__ */ new Map(),
-      compiler,
-      translator,
-      getLookup(dir2) {
-        const key = `taglib:${dir2}`;
-        let lookup = project.cache.get(key);
-        if (lookup === void 0) {
-          try {
-            lookup = compiler.taglib.buildLookup(dir2, translator, ignoreErrors);
-          } catch {
-            lookup = defaultProject.getLookup(dir2);
-          }
-          project.cache.set(key, lookup);
-        }
-        return lookup;
-      }
-    };
-    projectsByCompiler.set(compilerConfigPath, project);
-    return project;
-  } catch {
-    return defaultProject;
-  }
-}
-function interopDefault(mod) {
-  return mod.default || mod;
-}
+import { Project as Project4 } from "@marko/language-tools";
 
 // src/utils/file.ts
-import path2 from "path";
-import { parse } from "@marko/language-tools";
+import path from "path";
+import { Project, parse } from "@marko/language-tools";
 import { URI } from "vscode-uri";
 var processorCaches = /* @__PURE__ */ new WeakMap();
 function getFSPath(doc) {
@@ -111,19 +26,17 @@ function getFSPath(doc) {
 function getMarkoFile(doc) {
   const { uri } = doc;
   const { fsPath: filename, scheme } = URI.parse(uri);
-  const dirname = filename && path2.dirname(filename);
-  const project = getMarkoProject(dirname);
-  const cache = project.cache;
+  const dirname = filename && path.dirname(filename);
+  const cache = Project.getCache(dirname);
   let file = cache.get(doc);
   if (!file) {
     const { version } = doc;
     const code = doc.getText();
     const parsed = parse(code, filename);
-    const lookup = project.getLookup(dirname);
+    const lookup = Project.getTagLookup(dirname);
     cache.set(
       doc,
       file = {
-        project,
         uri,
         scheme,
         version,
@@ -139,9 +52,8 @@ function getMarkoFile(doc) {
 }
 function clearMarkoCacheForFile(doc) {
   const { fsPath: filename } = URI.parse(doc.uri);
-  const dirname = filename && path2.dirname(filename);
-  const project = getMarkoProject(dirname);
-  const cache = project.cache;
+  const dirname = filename && path.dirname(filename);
+  const cache = Project.getCache(dirname);
   cache.delete(doc);
 }
 function processDoc(doc, process2) {
@@ -474,7 +386,7 @@ function isExternalModule(file) {
 }
 
 // src/service/marko/complete/AttrValue.ts
-import path3 from "path";
+import path2 from "path";
 import {
   CompletionItemKind as CompletionItemKind2,
   TextEdit as TextEdit2
@@ -587,7 +499,7 @@ async function AttrValue({
     const resolved = resolveUrl(req, uri);
     if (resolved) {
       const result = [];
-      const curFile = req === "." ? path3.basename(uri) : void 0;
+      const curFile = req === "." ? path2.basename(uri) : void 0;
       const replaceRange = parsed.locationAt({
         start: start + segmentStart + 1,
         end: start + rawValue.length
@@ -620,7 +532,7 @@ async function AttrValue({
 import { TextEdit as TextEdit4 } from "vscode-languageserver";
 
 // src/service/marko/util/get-tag-name-completion.ts
-import path4 from "path";
+import path3 from "path";
 import {
   CompletionItemKind as CompletionItemKind3,
   CompletionItemTag,
@@ -649,7 +561,7 @@ function getTagNameCompletion({
     kind: MarkupKind2.Markdown,
     value: tag.html ? `Built in [<${tag.name}>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/${tag.name}) HTML tag.` : isCoreTag ? `Core Marko <${tag.name}> tag.` : nodeModuleName ? `Custom Marko tag discovered from the ["${nodeModuleName}"](${fileURIForTag}) npm package.` : `Custom Marko tag discovered from:
 
-[${importer ? path4.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
+[${importer ? path3.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
   };
   if (tag.description) {
     documentation.value += `
@@ -839,32 +751,32 @@ var doComplete = async (doc, params) => {
 };
 
 // src/service/marko/validate.ts
-import path5 from "path";
+import path4 from "path";
+import { Project as Project2 } from "@marko/language-tools";
 import { DiagnosticSeverity } from "vscode-languageserver";
 var markoErrorRegExp = /^(.+?)\.marko(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
 var doValidate = (doc) => {
   const filename = getFSPath(doc);
   const diagnostics = [];
-  const { compiler, translator, cache } = getMarkoProject(
-    filename && path5.dirname(filename)
-  );
   try {
-    compiler.compileSync(doc.getText(), filename || "untitled.marko", {
-      cache,
-      translator,
-      code: false,
-      output: "source",
-      sourceMaps: false,
-      babelConfig: {
-        caller: {
-          name: "@marko/language-server",
-          supportsStaticESM: true,
-          supportsDynamicImport: true,
-          supportsTopLevelAwait: true,
-          supportsExportNamespaceFrom: true
+    Project2.getCompiler(filename && path4.dirname(filename)).compileSync(
+      doc.getText(),
+      filename || "untitled.marko",
+      {
+        code: false,
+        output: "source",
+        sourceMaps: false,
+        babelConfig: {
+          caller: {
+            name: "@marko/language-server",
+            supportsStaticESM: true,
+            supportsDynamicImport: true,
+            supportsTopLevelAwait: true,
+            supportsExportNamespaceFrom: true
+          }
         }
       }
-    });
+    );
   } catch (e) {
     let match;
     while (match = markoErrorRegExp.exec(e.message)) {
@@ -1013,7 +925,7 @@ function AttrName2({
 
 // src/service/marko/definition/OpenTagName.ts
 import fs4 from "fs";
-import path6 from "path";
+import path5 from "path";
 import { URI as URI5 } from "vscode-uri";
 import {
   NodeType as NodeType5,
@@ -1039,7 +951,7 @@ function OpenTagName3({
     return;
   }
   const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!path6.isAbsolute(tagEntryFile)) {
+  if (!path5.isAbsolute(tagEntryFile)) {
     return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
@@ -1251,7 +1163,7 @@ var marko_default = {
 };
 
 // src/service/script/index.ts
-import path10 from "path";
+import path7 from "path";
 import { relativeImportPath } from "relative-import-path";
 import ts from "typescript/lib/tsserverlibrary";
 import {
@@ -1265,218 +1177,115 @@ import { URI as URI6 } from "vscode-uri";
 import * as prettier2 from "prettier";
 import {
   NodeType as NodeType9,
-  ScriptLang as ScriptLang3,
-  extractScript as extractScript2
+  Project as Project3,
+  ScriptLang,
+  extractScript
 } from "@marko/language-tools";
 
 // src/ts-plugin/host.ts
-import path9 from "path";
+import path6 from "path";
 import {
-  ScriptLang as ScriptLang2,
-  extractScript,
-  parse as parse2
+  Processors,
+  getExt,
+  isDefinitionFile
 } from "@marko/language-tools";
-
-// src/utils/get-runtime-types.ts
-import path7 from "path";
-var internalTypesFile = path7.join(__dirname, "marko.internal.d.ts");
-var defaultMarkoTypesFile = path7.join(__dirname, "marko.runtime.d.ts");
-function getProjectTypeLibs(rootDir, project, ts2, host) {
-  let cached = project.cache.get(getProjectTypeLibs);
-  if (cached === void 0) {
-    const markoRunGeneratedTypesFile = path7.join(
-      rootDir,
-      ".marko-run/routes.d.ts"
-    );
-    const resolveFromFile = path7.join(host.getCurrentDirectory(), "_.d.ts");
-    const compilerOptions = host.getCompilationSettings();
-    const { resolvedTypeReferenceDirective: resolvedMarkoTypes } = ts2.resolveTypeReferenceDirective(
-      project.translator.runtimeTypes || "marko",
-      resolveFromFile,
-      compilerOptions,
-      host
-    );
-    const { resolvedTypeReferenceDirective: resolvedMarkoRunTypes } = ts2.resolveTypeReferenceDirective(
-      "@marko/run",
-      resolveFromFile,
-      compilerOptions,
-      host
-    );
-    const markoTypesFile = (resolvedMarkoTypes == null ? void 0 : resolvedMarkoTypes.resolvedFileName) || defaultMarkoTypesFile;
-    const markoRunTypesFile = resolvedMarkoRunTypes == null ? void 0 : resolvedMarkoRunTypes.resolvedFileName;
-    cached = {
-      internalTypesFile,
-      markoTypesFile,
-      markoTypesCode: host.readFile(markoTypesFile, "utf-8") || "",
-      markoRunTypesFile,
-      markoRunGeneratedTypesFile: host.fileExists(markoRunGeneratedTypesFile) ? markoRunGeneratedTypesFile : void 0
-    };
-    project.cache.set(getProjectTypeLibs, cached);
-  }
-  return cached;
-}
-
-// src/utils/get-script-lang.ts
-import { ScriptLang } from "@marko/language-tools";
-function getScriptLang(filename, ts2, host, projectScriptLang) {
-  const configPath = ts2.findConfigFile(
-    filename,
-    host.fileExists.bind(host),
-    "marko.json"
-  );
-  if (configPath) {
-    try {
-      const markoConfig = JSON.parse(
-        host.readFile(configPath, "utf-8") || "{}"
-      );
-      const scriptLang = markoConfig["script-lang"] || markoConfig.scriptLang;
-      if (scriptLang !== void 0) {
-        return scriptLang === ScriptLang.ts ? ScriptLang.ts : ScriptLang.js;
-      }
-    } catch {
-    }
-  }
-  return /[/\\]node_modules[/\\]/.test(filename) ? ScriptLang.js : projectScriptLang;
-}
-
-// src/utils/get-component-filename.ts
-import fs5 from "fs";
-import path8 from "path";
-function getComponentFilename(from) {
-  const dir = path8.dirname(from);
-  const nameNoExt = path8.basename(from, ".marko");
-  const isEntry = nameNoExt === "index";
-  const componentFull = `${nameNoExt}.component.`;
-  const componentBrowserFull = `${nameNoExt}.component-browser.`;
-  const componentPartial = isEntry ? "component." : void 0;
-  const componentBrowserPartial = isEntry ? "component-browser." : void 0;
-  for (const entry of tryReaddirSync(dir)) {
-    if (entry !== from && (isEntry && entry.startsWith(componentBrowserPartial) || entry.startsWith(componentPartial)) || entry.startsWith(componentBrowserFull) || entry.startsWith(componentFull)) {
-      return path8.join(dir, entry);
-    }
-  }
-}
-function tryReaddirSync(dir) {
-  try {
-    return fs5.readdirSync(dir);
-  } catch {
-    return [];
-  }
-}
-
-// src/ts-plugin/host.ts
-var markoExt = ".marko";
-var markoExtReg = /\.marko$/;
-var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
 var fsPathReg = /^(?:[./\\]|[A-Z]:)/i;
-function patch(ts2, scriptLang, cache, host, ps) {
+var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
+function patch(ts2, configFile, extractCache2, resolutionCache, host, ps) {
   var _a, _b, _c;
-  const rootDir = host.getCurrentDirectory();
-  const projectTypeLibs = getProjectTypeLibs(
-    rootDir,
-    getMarkoProject(rootDir),
-    ts2,
-    host
-  );
-  const projectTypeLibsFiles = [
-    projectTypeLibs.internalTypesFile,
-    projectTypeLibs.markoTypesFile
-  ];
-  if (projectTypeLibs.markoRunTypesFile) {
-    projectTypeLibsFiles.push(projectTypeLibs.markoRunTypesFile);
-  }
-  if (projectTypeLibs.markoRunGeneratedTypesFile) {
-    projectTypeLibsFiles.push(projectTypeLibs.markoRunGeneratedTypesFile);
-  }
-  const isMarkoTSFile = (fileName) => getScriptLang(fileName, ts2, host, scriptLang) === ScriptLang2.ts;
+  const processors = Processors.create({
+    ts: ts2,
+    host,
+    configFile
+  });
+  const rootNames = Object.values(processors).map((processor) => {
+    var _a2;
+    return (_a2 = processor.getRootNames) == null ? void 0 : _a2.call(processor);
+  }).flat().filter(Boolean);
   const getScriptFileNames = host.getScriptFileNames.bind(host);
   host.getScriptFileNames = () => [
-    ...new Set(projectTypeLibsFiles.concat(getScriptFileNames()))
+    ...new Set(rootNames.concat(getScriptFileNames()))
   ];
   const getScriptKind = (_a = host.getScriptKind) == null ? void 0 : _a.bind(host);
   if (getScriptKind) {
     host.getScriptKind = (fileName) => {
-      return markoExtReg.test(fileName) ? isMarkoTSFile(fileName) ? ts2.ScriptKind.TS : ts2.ScriptKind.JS : getScriptKind(fileName);
+      const processor = getProcessor(fileName);
+      if (processor)
+        return processor.getScriptKind(fileName);
+      return getScriptKind(fileName);
     };
   }
   const getScriptSnapshot = host.getScriptSnapshot.bind(host);
-  host.getScriptSnapshot = (filename) => {
-    if (markoExtReg.test(filename)) {
-      let cached = cache.get(filename);
+  host.getScriptSnapshot = (fileName) => {
+    const processor = getProcessor(fileName);
+    if (processor) {
+      let cached = extractCache2.get(fileName);
       if (!cached) {
-        const code = host.readFile(filename, "utf-8") || "";
-        const dir = path9.dirname(filename);
+        const code = host.readFile(fileName, "utf-8") || "";
         try {
-          const markoProject = getMarkoProject(dir);
-          cached = extractScript({
-            ts: ts2,
-            parsed: parse2(code, filename),
-            lookup: markoProject.getLookup(dir),
-            scriptLang: getScriptLang(filename, ts2, host, scriptLang),
-            runtimeTypesCode: projectTypeLibs.markoTypesCode,
-            componentFilename: getComponentFilename(filename)
-          });
+          cached = processor.extract(fileName, code);
           cached.snapshot = ts2.ScriptSnapshot.fromString(cached.toString());
         } catch {
           cached = { snapshot: ts2.ScriptSnapshot.fromString("") };
         }
         ps == null ? void 0 : ps.getOrCreateScriptInfoForNormalizedPath(
-          filename,
+          fileName,
           false,
           void 0,
           ts2.ScriptKind.Deferred,
           false,
           host
         );
-        cache.set(filename, cached);
+        extractCache2.set(fileName, cached);
       }
       return cached.snapshot;
     }
-    return getScriptSnapshot(filename);
+    return getScriptSnapshot(fileName);
   };
   if (host.getProjectVersion) {
     const getScriptVersion = host.getScriptVersion.bind(host);
-    host.getScriptVersion = (filename) => {
-      if (markoExtReg.test(filename)) {
+    host.getScriptVersion = (fileName) => {
+      const processor = getProcessor(fileName);
+      if (processor)
         return host.getProjectVersion();
-      }
-      return getScriptVersion(filename);
+      return getScriptVersion(fileName);
     };
   }
   const readDirectory2 = (_b = host.readDirectory) == null ? void 0 : _b.bind(host);
   if (readDirectory2) {
-    host.readDirectory = (path11, extensions, exclude, include, depth) => {
+    host.readDirectory = (path8, extensions, exclude, include, depth) => {
       return readDirectory2(
-        path11,
-        extensions == null ? void 0 : extensions.concat(markoExt),
+        path8,
+        extensions == null ? void 0 : extensions.concat(Processors.extensions),
         exclude,
         include,
         depth
       );
     };
   }
-  const resolveModuleNames = (_c = host.resolveModuleNames) == null ? void 0 : _c.bind(host);
-  if (resolveModuleNames) {
-    host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, sourceFile) => {
-      let normalModuleNames = moduleNames;
+  const resolveModuleNameLiterals = (_c = host.resolveModuleNameLiterals) == null ? void 0 : _c.bind(host);
+  if (resolveModuleNameLiterals) {
+    host.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) => {
+      let normalModuleLiterals = moduleLiterals;
       let resolvedModules;
-      for (let i = 0; i < moduleNames.length; i++) {
-        const moduleName = moduleNames[i];
-        const shouldProcess = moduleName[0] !== "*" ? markoExtReg.test(moduleName) : void 0;
-        if (shouldProcess) {
+      for (let i = 0; i < moduleLiterals.length; i++) {
+        const moduleName = moduleLiterals[i].text;
+        const processor = moduleName[0] !== "*" ? getProcessor(moduleName) : void 0;
+        if (processor) {
           let resolvedFileName;
           if (fsPathReg.test(moduleName)) {
-            resolvedFileName = path9.resolve(containingFile, "..", moduleName);
+            resolvedFileName = path6.resolve(containingFile, "..", moduleName);
           } else {
             const [, nodeModuleName, relativeModulePath] = modulePartsReg.exec(moduleName);
-            const { resolvedModule } = ts2.resolveModuleName(
+            const { resolvedModule } = ts2.bundlerModuleNameResolver(
               `${nodeModuleName}/package.json`,
               containingFile,
               options,
-              host
+              host,
+              resolutionCache
             );
             if (resolvedModule) {
-              resolvedFileName = path9.join(
+              resolvedFileName = path6.join(
                 resolvedModule.resolvedFileName,
                 "..",
                 relativeModulePath
@@ -1485,47 +1294,54 @@ function patch(ts2, scriptLang, cache, host, ps) {
           }
           if (!resolvedModules) {
             resolvedModules = [];
-            normalModuleNames = [];
+            normalModuleLiterals = [];
             for (let j = 0; j < i; j++) {
               resolvedModules.push(void 0);
-              normalModuleNames.push(moduleNames[j]);
+              normalModuleLiterals.push(moduleLiterals[j]);
+            }
+          }
+          if (resolvedFileName) {
+            if (isDefinitionFile(resolvedFileName)) {
+              if (!host.fileExists(resolvedFileName)) {
+                resolvedFileName = void 0;
+              }
+            } else {
+              const ext = getExt(resolvedFileName);
+              const definitionFile = `${resolvedFileName.slice(
+                0,
+                -ext.length
+              )}.d${ext}`;
+              if (host.fileExists(definitionFile)) {
+                resolvedFileName = definitionFile;
+              } else if (!host.fileExists(resolvedFileName)) {
+                resolvedFileName = void 0;
+              }
             }
           }
-          resolvedModules.push(
-            resolvedFileName && host.fileExists(resolvedFileName) ? {
+          resolvedModules.push({
+            resolvedModule: resolvedFileName ? {
               resolvedFileName,
-              extension: isMarkoTSFile(resolvedFileName) ? ts2.Extension.Ts : ts2.Extension.Js,
+              extension: processor.getScriptExtension(resolvedFileName),
               isExternalLibraryImport: false
-            } : null
-          );
+            } : void 0
+          });
         } else if (resolvedModules) {
           resolvedModules.push(void 0);
         }
       }
-      const normalResolvedModules = normalModuleNames.length ? resolveModuleNames(
-        normalModuleNames,
+      const normalResolvedModules = normalModuleLiterals.length ? resolveModuleNameLiterals(
+        normalModuleLiterals,
         containingFile,
-        reusedNames,
         redirectedReference,
         options,
-        sourceFile
+        containingSourceFile,
+        reusedNames
       ) : void 0;
       if (resolvedModules) {
         if (normalResolvedModules) {
           for (let i = 0, j = 0; i < resolvedModules.length; i++) {
-            switch (resolvedModules[i]) {
-              case void 0:
-                resolvedModules[i] = normalResolvedModules[j++];
-                break;
-              case null:
-                resolvedModules[i] = void 0;
-                break;
-            }
-          }
-        } else {
-          for (let i = resolvedModules.length; i--; ) {
-            if (resolvedModules[i] === null) {
-              resolvedModules[i] = void 0;
+            if (!resolvedModules[i]) {
+              resolvedModules[i] = normalResolvedModules[j++];
             }
           }
         }
@@ -1536,6 +1352,10 @@ function patch(ts2, scriptLang, cache, host, ps) {
     };
   }
   return host;
+  function getProcessor(fileName) {
+    const ext = getExt(fileName);
+    return ext ? processors[ext] : void 0;
+  }
 }
 
 // src/service/script/index.ts
@@ -1551,12 +1371,13 @@ var colorModifierReg = /\bcolor\b/;
 var localInternalsPrefix = "__marko_internal_";
 var requiredTSCompilerOptions = {
   module: ts.ModuleKind.ESNext,
-  moduleResolution: ts.ModuleResolutionKind.NodeJs,
+  moduleResolution: ts.ModuleResolutionKind.Bundler,
   noEmit: true,
   allowJs: true,
   composite: false,
   declaration: false,
   skipLibCheck: true,
+  importHelpers: false,
   isolatedModules: true,
   resolveJsonModule: true,
   skipDefaultLibCheck: true,
@@ -1586,26 +1407,26 @@ var ScriptService = {
       const filename = getFSPath(doc);
       if (!filename)
         return;
-      const project = getTSProject(filename);
-      const extracted = processScript(doc, project);
-      const lang = getScriptLang(
+      const tsProject = getTSProject(filename);
+      const extracted = processScript(doc, tsProject);
+      const lang = Project3.getScriptLang(
         filename,
+        tsProject.markoScriptLang,
         ts,
-        project.host,
-        project.markoScriptLang
+        tsProject.host
       );
       const generated = extracted.toString();
       const content = (() => {
         try {
           return prettier2.format(generated, {
-            parser: lang === ScriptLang3.ts ? "typescript" : "babel"
+            parser: lang === ScriptLang.ts ? "typescript" : "babel"
           });
         } catch {
           return generated;
         }
       })();
       return {
-        language: lang === ScriptLang3.ts ? "typescript" : "javascript",
+        language: lang === ScriptLang.ts ? "typescript" : "javascript",
         content
       };
     }
@@ -1661,7 +1482,7 @@ var ScriptService = {
       let source = completion.source;
       if (source && completion.hasAction) {
         if (source[0] === ".") {
-          source = path10.resolve(fileName, "..", source);
+          source = path7.resolve(fileName, "..", source);
         }
         detail = relativeImportPath(fileName, source);
         sortText = `\uFFFF${sortText}`;
@@ -1965,26 +1786,17 @@ ${documentation}`;
   }
 };
 function processScript(doc, tsProject) {
-  return processDoc(
-    doc,
-    ({ filename, parsed, lookup, project: markoProject }) => {
-      var _a;
-      const { host, markoScriptLang } = tsProject;
-      return extractScript2({
-        ts,
-        parsed,
-        lookup,
-        scriptLang: getScriptLang(filename, ts, host, markoScriptLang),
-        runtimeTypesCode: (_a = getProjectTypeLibs(
-          tsProject.rootDir,
-          markoProject,
-          ts,
-          host
-        )) == null ? void 0 : _a.markoTypesCode,
-        componentFilename: getComponentFilename(filename)
-      });
-    }
-  );
+  return processDoc(doc, ({ filename, parsed, lookup }) => {
+    var _a;
+    const { host, markoScriptLang } = tsProject;
+    return extractScript({
+      ts,
+      parsed,
+      lookup,
+      scriptLang: Project3.getScriptLang(filename, markoScriptLang, ts, host),
+      runtimeTypesCode: (_a = Project3.getTypeLibs(tsProject.rootDir, ts, host)) == null ? void 0 : _a.markoTypesCode
+    });
+  });
 }
 function getInsertModuleStatementOffset(parsed) {
   const { program } = parsed;
@@ -2035,27 +1847,27 @@ function docLocationAtTextSpan(doc, { start, length }) {
 }
 function getTSProject(docFsPath) {
   var _a;
-  let configPath;
-  let markoScriptLang = ScriptLang3.js;
+  let configFile;
+  let markoScriptLang = ScriptLang.js;
   if (docFsPath) {
-    configPath = ts.findConfigFile(
+    configFile = ts.findConfigFile(
       docFsPath,
       ts.sys.fileExists,
       "tsconfig.json"
     );
-    if (configPath) {
-      markoScriptLang = ScriptLang3.ts;
+    if (configFile) {
+      markoScriptLang = ScriptLang.ts;
     } else {
-      configPath = ts.findConfigFile(
+      configFile = ts.findConfigFile(
         docFsPath,
         ts.sys.fileExists,
         "jsconfig.json"
       );
     }
   }
-  const rootDir = configPath && path10.dirname(configPath) || process.cwd();
-  const markoProject = getMarkoProject(configPath && rootDir);
-  let projectCache = markoProject.cache.get(getTSProject);
+  const rootDir = configFile && path7.dirname(configFile) || process.cwd();
+  const cache = Project3.getCache(configFile && rootDir);
+  let projectCache = cache.get(getTSProject);
   let cached;
   if (projectCache) {
     cached = projectCache.get(rootDir);
@@ -2063,14 +1875,14 @@ function getTSProject(docFsPath) {
       return cached;
   } else {
     projectCache = /* @__PURE__ */ new Map();
-    markoProject.cache.set(getTSProject, projectCache);
+    cache.set(getTSProject, projectCache);
   }
   const { fileNames, options, projectReferences } = ts.parseJsonConfigFileContent(
-    configPath && ts.readConfigFile(configPath, ts.sys.readFile).config || defaultTSConfig,
+    configFile && ts.readConfigFile(configFile, ts.sys.readFile).config || defaultTSConfig,
     ts.sys,
     rootDir,
     requiredTSCompilerOptions,
-    configPath,
+    configFile,
     void 0,
     extraTSCompilerExtensions
   );
@@ -2078,15 +1890,21 @@ function getTSProject(docFsPath) {
   const potentialGlobalFiles = new Set(
     fileNames.filter((file) => /\.[cm]?ts$/.test(file))
   );
-  const tsPkgFile = configPath && ((_a = ts.resolveModuleName("typescript/package.json", configPath, options, ts.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
-  const defaultLibFile = path10.join(
-    tsPkgFile ? path10.join(tsPkgFile, "../lib") : __dirname,
+  const tsPkgFile = configFile && ((_a = ts.resolveModuleName("typescript/package.json", configFile, options, ts.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
+  const defaultLibFile = path7.join(
+    tsPkgFile ? path7.join(tsPkgFile, "../lib") : __dirname,
     ts.getDefaultLibFileName(options)
   );
+  const resolutionCache = ts.createModuleResolutionCache(
+    rootDir,
+    getCanonicalFileName,
+    options
+  );
   const host = patch(
     ts,
-    markoScriptLang,
+    configFile,
     extractCache,
+    resolutionCache,
     {
       getNewLine() {
         return ts.sys.newLine;
@@ -2109,9 +1927,16 @@ function getTSProject(docFsPath) {
       getProjectReferences() {
         return projectReferences;
       },
-      resolveModuleNames(moduleNames, containingFile) {
-        return moduleNames.map((moduleName) => {
-          return ts.resolveModuleName(moduleName, containingFile, options, host).resolvedModule;
+      resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options2, _containingSourceFile, _reusedNames) {
+        return moduleLiterals.map((moduleLiteral) => {
+          return ts.bundlerModuleNameResolver(
+            moduleLiteral.text,
+            containingFile,
+            options2,
+            host,
+            resolutionCache,
+            redirectedReference
+          );
         });
       },
       readDirectory: ts.sys.readDirectory,
@@ -2134,7 +1959,7 @@ function getTSProject(docFsPath) {
         return `${((_a2 = get(filenameToURI(filename))) == null ? void 0 : _a2.version) ?? -1}`;
       },
       getScriptKind(filename) {
-        switch (path10.extname(filename)) {
+        switch (path7.extname(filename)) {
           case ts.Extension.Js:
           case ts.Extension.Cjs:
           case ts.Extension.Mjs:
@@ -2170,14 +1995,7 @@ function getTSProject(docFsPath) {
     host,
     rootDir: options.rootDir,
     service: ts.createLanguageService(host),
-    markoProject,
-    markoScriptLang,
-    markoProjectTypeLibs: getProjectTypeLibs(
-      options.rootDir,
-      markoProject,
-      ts,
-      host
-    )
+    markoScriptLang
   };
   projectCache.set(rootDir, tsProject);
   return tsProject;
@@ -2187,7 +2005,7 @@ function filenameToURI(filename) {
 }
 async function getPreferences(scriptLang) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const configName = scriptLang === ScriptLang3.js ? "javascript" : "typescript";
+  const configName = scriptLang === ScriptLang.js ? "javascript" : "typescript";
   const [preferencesConfig, suggestConfig, inlayHintsConfig] = await Promise.all([
     getConfig(`${configName}.preferences`),
     getConfig(`${configName}.suggest`),
@@ -2335,6 +2153,9 @@ function getTSTriggerChar(char) {
   if (char && tsTriggerChars.has(char))
     return char;
 }
+function getCanonicalFileName(fileName) {
+  return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+}
 
 // src/service/style/index.ts
 import {
@@ -3225,7 +3046,7 @@ for (const command in service.commands) {
 }
 function validateDocs() {
   queueDiagnostic();
-  clearMarkoProjectCaches();
+  Project4.clearCaches();
 }
 function queueDiagnostic() {
   clearTimeout(diagnosticTimeout);