@marko/language-server 1.0.6 → 1.0.7

package/dist/index.js

@@ -25,95 +25,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/index.ts
 var import_util2 = require("util");
 var import_node = require("vscode-languageserver/node");
-
-// src/utils/project.ts
-var import_path = __toESM(require("path"));
-var import_module = require("module");
-var defaultCompiler = __toESM(require("@marko/compiler"));
-var defaultTranslator = __toESM(require("@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 = (0, import_module.createRequire)(dir);
-    const compilerConfigPath = require2.resolve("@marko/compiler/config");
-    const cachedProject = projectsByCompiler.get(compilerConfigPath);
-    if (cachedProject)
-      return cachedProject;
-    const compiler = require2(import_path.default.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;
-}
+var import_language_tools16 = require("@marko/language-tools");
 
 // src/utils/file.ts
-var import_path2 = __toESM(require("path"));
+var import_path = __toESM(require("path"));
 var import_language_tools = require("@marko/language-tools");
 var import_vscode_uri = require("vscode-uri");
 var processorCaches = /* @__PURE__ */ new WeakMap();
@@ -123,19 +38,17 @@ function getFSPath(doc) {
 function getMarkoFile(doc) {
   const { uri } = doc;
   const { fsPath: filename, scheme } = import_vscode_uri.URI.parse(uri);
-  const dirname = filename && import_path2.default.dirname(filename);
-  const project = getMarkoProject(dirname);
-  const cache = project.cache;
+  const dirname = filename && import_path.default.dirname(filename);
+  const cache = import_language_tools.Project.getCache(dirname);
   let file = cache.get(doc);
   if (!file) {
     const { version } = doc;
     const code = doc.getText();
     const parsed = (0, import_language_tools.parse)(code, filename);
-    const lookup = project.getLookup(dirname);
+    const lookup = import_language_tools.Project.getTagLookup(dirname);
     cache.set(
       doc,
       file = {
-        project,
         uri,
         scheme,
         version,
@@ -151,9 +64,8 @@ function getMarkoFile(doc) {
 }
 function clearMarkoCacheForFile(doc) {
   const { fsPath: filename } = import_vscode_uri.URI.parse(doc.uri);
-  const dirname = filename && import_path2.default.dirname(filename);
-  const project = getMarkoProject(dirname);
-  const cache = project.cache;
+  const dirname = filename && import_path.default.dirname(filename);
+  const cache = import_language_tools.Project.getCache(dirname);
   cache.delete(doc);
 }
 function processDoc(doc, process2) {
@@ -481,7 +393,7 @@ function isExternalModule(file) {
 }
 
 // src/service/marko/complete/AttrValue.ts
-var import_path3 = __toESM(require("path"));
+var import_path2 = __toESM(require("path"));
 var import_vscode_languageserver3 = require("vscode-languageserver");
 
 // src/service/marko/util/is-document-link-attr.ts
@@ -591,7 +503,7 @@ async function AttrValue({
     const resolved = resolveUrl(req, uri);
     if (resolved) {
       const result = [];
-      const curFile = req === "." ? import_path3.default.basename(uri) : void 0;
+      const curFile = req === "." ? import_path2.default.basename(uri) : void 0;
       const replaceRange = parsed.locationAt({
         start: start + segmentStart + 1,
         end: start + rawValue.length
@@ -624,7 +536,7 @@ async function AttrValue({
 var import_vscode_languageserver5 = require("vscode-languageserver");
 
 // src/service/marko/util/get-tag-name-completion.ts
-var import_path4 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 var import_vscode_languageserver4 = require("vscode-languageserver");
 var import_vscode_uri3 = require("vscode-uri");
 var deprecated = [import_vscode_languageserver4.CompletionItemTag.Deprecated];
@@ -647,7 +559,7 @@ function getTagNameCompletion({
     kind: import_vscode_languageserver4.MarkupKind.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 ? import_path4.default.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
+[${importer ? import_path3.default.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
   };
   if (tag.description) {
     documentation.value += `
@@ -833,32 +745,32 @@ var doComplete = async (doc, params) => {
 };
 
 // src/service/marko/validate.ts
-var import_path5 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
+var import_language_tools6 = require("@marko/language-tools");
 var import_vscode_languageserver7 = require("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 && import_path5.default.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
+    import_language_tools6.Project.getCompiler(filename && import_path4.default.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)) {
@@ -881,7 +793,7 @@ var doValidate = (doc) => {
 };
 
 // src/service/marko/hover/index.ts
-var import_language_tools6 = require("@marko/language-tools");
+var import_language_tools7 = require("@marko/language-tools");
 
 // src/utils/constants.ts
 var START_POSITION = {
@@ -925,7 +837,7 @@ var doHover = async (doc, params) => {
   const file = getMarkoFile(doc);
   const offset = doc.offsetAt(params.position);
   const node = file.parsed.nodeAt(offset);
-  return await ((_a = handlers2[import_language_tools6.NodeType[node.type]]) == null ? void 0 : _a.call(handlers2, {
+  return await ((_a = handlers2[import_language_tools7.NodeType[node.type]]) == null ? void 0 : _a.call(handlers2, {
     file,
     params,
     offset,
@@ -934,12 +846,12 @@ var doHover = async (doc, params) => {
 };
 
 // src/service/marko/definition/index.ts
-var import_language_tools9 = require("@marko/language-tools");
+var import_language_tools10 = require("@marko/language-tools");
 
 // src/service/marko/definition/AttrName.ts
 var import_fs2 = __toESM(require("fs"));
 var import_vscode_uri4 = require("vscode-uri");
-var import_language_tools7 = require("@marko/language-tools");
+var import_language_tools8 = require("@marko/language-tools");
 
 // src/utils/regexp-builder.ts
 function RegExpBuilder(strings, ...expressions) {
@@ -988,8 +900,8 @@ function AttrName2({
       tagDefSource
     );
     if (match && match.index) {
-      range = (0, import_language_tools7.getLocation)(
-        (0, import_language_tools7.getLines)(tagDefSource),
+      range = (0, import_language_tools8.getLocation)(
+        (0, import_language_tools8.getLines)(tagDefSource),
         match.index,
         match.index + match[0].length
       );
@@ -1007,9 +919,9 @@ function AttrName2({
 
 // src/service/marko/definition/OpenTagName.ts
 var import_fs3 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 var import_vscode_uri5 = require("vscode-uri");
-var import_language_tools8 = require("@marko/language-tools");
+var import_language_tools9 = require("@marko/language-tools");
 function OpenTagName3({
   node,
   file: { parsed, lookup }
@@ -1017,9 +929,9 @@ function OpenTagName3({
   const tag = node.parent;
   let tagDef;
   let range = START_LOCATION;
-  if (tag.type === import_language_tools8.NodeType.AttrTag) {
+  if (tag.type === import_language_tools9.NodeType.AttrTag) {
     let parentTag = tag.owner;
-    while ((parentTag == null ? void 0 : parentTag.type) === import_language_tools8.NodeType.AttrTag)
+    while ((parentTag == null ? void 0 : parentTag.type) === import_language_tools9.NodeType.AttrTag)
       parentTag = parentTag.owner;
     tagDef = parentTag && parentTag.nameText ? lookup.getTag(parentTag.nameText) : void 0;
   } else {
@@ -1029,7 +941,7 @@ function OpenTagName3({
     return;
   }
   const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!import_path6.default.isAbsolute(tagEntryFile)) {
+  if (!import_path5.default.isAbsolute(tagEntryFile)) {
     return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
@@ -1038,8 +950,8 @@ function OpenTagName3({
       tagDefSource
     );
     if (match && match.index) {
-      range = (0, import_language_tools8.getLocation)(
-        (0, import_language_tools8.getLines)(tagDefSource),
+      range = (0, import_language_tools9.getLocation)(
+        (0, import_language_tools9.getLines)(tagDefSource),
         match.index,
         match.index + match[0].length
       );
@@ -1065,7 +977,7 @@ var findDefinition = async (doc, params) => {
   const file = getMarkoFile(doc);
   const offset = doc.offsetAt(params.position);
   const node = file.parsed.nodeAt(offset);
-  return await ((_a = handlers3[import_language_tools9.NodeType[node.type]]) == null ? void 0 : _a.call(handlers3, {
+  return await ((_a = handlers3[import_language_tools10.NodeType[node.type]]) == null ? void 0 : _a.call(handlers3, {
     file,
     params,
     offset,
@@ -1074,7 +986,7 @@ var findDefinition = async (doc, params) => {
 };
 
 // src/service/marko/document-links.ts
-var import_language_tools10 = require("@marko/language-tools");
+var import_language_tools11 = require("@marko/language-tools");
 var importTagReg2 = /(['"])<((?:[^\1\\>]+|\\.)*)>?\1/g;
 var findDocumentLinks = async (doc) => {
   return processDoc(doc, extractDocumentLinks);
@@ -1093,14 +1005,14 @@ function extractDocumentLinks({
   const { program, read } = parsed;
   const visit = (node) => {
     switch (node.type) {
-      case import_language_tools10.NodeType.AttrTag:
+      case import_language_tools11.NodeType.AttrTag:
         if (node.body) {
           for (const child of node.body) {
             visit(child);
           }
         }
         break;
-      case import_language_tools10.NodeType.Tag:
+      case import_language_tools11.NodeType.Tag:
         if (node.attrs && node.nameText) {
           for (const attr of node.attrs) {
             if (isDocumentLinkAttr(code, node, attr)) {
@@ -1126,7 +1038,7 @@ function extractDocumentLinks({
     }
   };
   for (const node of program.static) {
-    if (node.type === import_language_tools10.NodeType.Import) {
+    if (node.type === import_language_tools11.NodeType.Import) {
       importTagReg2.lastIndex = 0;
       const value = parsed.read(node);
       const match = importTagReg2.exec(value);
@@ -1154,7 +1066,7 @@ function extractDocumentLinks({
 
 // src/service/marko/document-symbols.ts
 var import_vscode_languageserver8 = require("vscode-languageserver");
-var import_language_tools11 = require("@marko/language-tools");
+var import_language_tools12 = require("@marko/language-tools");
 var findDocumentSymbols = async (doc) => processDoc(doc, extractDocumentSymbols);
 function extractDocumentSymbols({
   uri,
@@ -1170,10 +1082,10 @@ function extractDocumentSymbols({
   const visit = (node) => {
     var _a, _b;
     switch (node.type) {
-      case import_language_tools11.NodeType.Tag:
-      case import_language_tools11.NodeType.AttrTag:
+      case import_language_tools12.NodeType.Tag:
+      case import_language_tools12.NodeType.AttrTag:
         symbols.push({
-          name: (node.type === import_language_tools11.NodeType.AttrTag ? (_a = node.nameText) == null ? void 0 : _a.slice(node.nameText.indexOf("@")) : node.nameText) || "<${...}>",
+          name: (node.type === import_language_tools12.NodeType.AttrTag ? (_a = node.nameText) == null ? void 0 : _a.slice(node.nameText.indexOf("@")) : node.nameText) || "<${...}>",
           kind: node.nameText && ((_b = lookup.getTag(node.nameText)) == null ? void 0 : _b.html) && import_vscode_languageserver8.SymbolKind.Property || import_vscode_languageserver8.SymbolKind.Class,
           location: {
             uri,
@@ -1241,7 +1153,7 @@ var marko_default = {
 };
 
 // src/service/script/index.ts
-var import_path10 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 var import_relative_import_path = require("relative-import-path");
 var import_tsserverlibrary = __toESM(require("typescript/lib/tsserverlibrary"));
 var import_vscode_languageserver10 = require("vscode-languageserver");
@@ -1250,209 +1162,105 @@ var prettier2 = __toESM(require("prettier"));
 var import_language_tools14 = require("@marko/language-tools");
 
 // src/ts-plugin/host.ts
-var import_path9 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 var import_language_tools13 = require("@marko/language-tools");
-
-// src/utils/get-runtime-types.ts
-var import_path7 = __toESM(require("path"));
-var internalTypesFile = import_path7.default.join(__dirname, "marko.internal.d.ts");
-var defaultMarkoTypesFile = import_path7.default.join(__dirname, "marko.runtime.d.ts");
-function getProjectTypeLibs(rootDir, project, ts2, host) {
-  let cached = project.cache.get(getProjectTypeLibs);
-  if (cached === void 0) {
-    const markoRunGeneratedTypesFile = import_path7.default.join(
-      rootDir,
-      ".marko-run/routes.d.ts"
-    );
-    const resolveFromFile = import_path7.default.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
-var import_language_tools12 = require("@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 === import_language_tools12.ScriptLang.ts ? import_language_tools12.ScriptLang.ts : import_language_tools12.ScriptLang.js;
-      }
-    } catch {
-    }
-  }
-  return /[/\\]node_modules[/\\]/.test(filename) ? import_language_tools12.ScriptLang.js : projectScriptLang;
-}
-
-// src/utils/get-component-filename.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path8 = __toESM(require("path"));
-function getComponentFilename(from) {
-  const dir = import_path8.default.dirname(from);
-  const nameNoExt = import_path8.default.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 import_path8.default.join(dir, entry);
-    }
-  }
-}
-function tryReaddirSync(dir) {
-  try {
-    return import_fs4.default.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) === import_language_tools13.ScriptLang.ts;
+  const processors = import_language_tools13.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 = import_path9.default.dirname(filename);
+        const code = host.readFile(fileName, "utf-8") || "";
         try {
-          const markoProject = getMarkoProject(dir);
-          cached = (0, import_language_tools13.extractScript)({
-            ts: ts2,
-            parsed: (0, import_language_tools13.parse)(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(import_language_tools13.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 = import_path9.default.resolve(containingFile, "..", moduleName);
+            resolvedFileName = import_path6.default.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 = import_path9.default.join(
+              resolvedFileName = import_path6.default.join(
                 resolvedModule.resolvedFileName,
                 "..",
                 relativeModulePath
@@ -1461,47 +1269,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]);
             }
           }
-          resolvedModules.push(
-            resolvedFileName && host.fileExists(resolvedFileName) ? {
+          if (resolvedFileName) {
+            if ((0, import_language_tools13.isDefinitionFile)(resolvedFileName)) {
+              if (!host.fileExists(resolvedFileName)) {
+                resolvedFileName = void 0;
+              }
+            } else {
+              const ext = (0, import_language_tools13.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({
+            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++];
             }
           }
         }
@@ -1512,6 +1327,10 @@ function patch(ts2, scriptLang, cache, host, ps) {
     };
   }
   return host;
+  function getProcessor(fileName) {
+    const ext = (0, import_language_tools13.getExt)(fileName);
+    return ext ? processors[ext] : void 0;
+  }
 }
 
 // src/service/script/index.ts
@@ -1527,12 +1346,13 @@ var colorModifierReg = /\bcolor\b/;
 var localInternalsPrefix = "__marko_internal_";
 var requiredTSCompilerOptions = {
   module: import_tsserverlibrary.default.ModuleKind.ESNext,
-  moduleResolution: import_tsserverlibrary.default.ModuleResolutionKind.NodeJs,
+  moduleResolution: import_tsserverlibrary.default.ModuleResolutionKind.Bundler,
   noEmit: true,
   allowJs: true,
   composite: false,
   declaration: false,
   skipLibCheck: true,
+  importHelpers: false,
   isolatedModules: true,
   resolveJsonModule: true,
   skipDefaultLibCheck: true,
@@ -1562,13 +1382,13 @@ 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 = import_language_tools14.Project.getScriptLang(
         filename,
+        tsProject.markoScriptLang,
         import_tsserverlibrary.default,
-        project.host,
-        project.markoScriptLang
+        tsProject.host
       );
       const generated = extracted.toString();
       const content = (() => {
@@ -1637,7 +1457,7 @@ var ScriptService = {
       let source = completion.source;
       if (source && completion.hasAction) {
         if (source[0] === ".") {
-          source = import_path10.default.resolve(fileName, "..", source);
+          source = import_path7.default.resolve(fileName, "..", source);
         }
         detail = (0, import_relative_import_path.relativeImportPath)(fileName, source);
         sortText = `\uFFFF${sortText}`;
@@ -1941,26 +1761,17 @@ ${documentation}`;
   }
 };
 function processScript(doc, tsProject) {
-  return processDoc(
-    doc,
-    ({ filename, parsed, lookup, project: markoProject }) => {
-      var _a;
-      const { host, markoScriptLang } = tsProject;
-      return (0, import_language_tools14.extractScript)({
-        ts: import_tsserverlibrary.default,
-        parsed,
-        lookup,
-        scriptLang: getScriptLang(filename, import_tsserverlibrary.default, host, markoScriptLang),
-        runtimeTypesCode: (_a = getProjectTypeLibs(
-          tsProject.rootDir,
-          markoProject,
-          import_tsserverlibrary.default,
-          host
-        )) == null ? void 0 : _a.markoTypesCode,
-        componentFilename: getComponentFilename(filename)
-      });
-    }
-  );
+  return processDoc(doc, ({ filename, parsed, lookup }) => {
+    var _a;
+    const { host, markoScriptLang } = tsProject;
+    return (0, import_language_tools14.extractScript)({
+      ts: import_tsserverlibrary.default,
+      parsed,
+      lookup,
+      scriptLang: import_language_tools14.Project.getScriptLang(filename, markoScriptLang, import_tsserverlibrary.default, host),
+      runtimeTypesCode: (_a = import_language_tools14.Project.getTypeLibs(tsProject.rootDir, import_tsserverlibrary.default, host)) == null ? void 0 : _a.markoTypesCode
+    });
+  });
 }
 function getInsertModuleStatementOffset(parsed) {
   const { program } = parsed;
@@ -2011,27 +1822,27 @@ function docLocationAtTextSpan(doc, { start, length }) {
 }
 function getTSProject(docFsPath) {
   var _a;
-  let configPath;
+  let configFile;
   let markoScriptLang = import_language_tools14.ScriptLang.js;
   if (docFsPath) {
-    configPath = import_tsserverlibrary.default.findConfigFile(
+    configFile = import_tsserverlibrary.default.findConfigFile(
       docFsPath,
       import_tsserverlibrary.default.sys.fileExists,
       "tsconfig.json"
     );
-    if (configPath) {
+    if (configFile) {
       markoScriptLang = import_language_tools14.ScriptLang.ts;
     } else {
-      configPath = import_tsserverlibrary.default.findConfigFile(
+      configFile = import_tsserverlibrary.default.findConfigFile(
         docFsPath,
         import_tsserverlibrary.default.sys.fileExists,
         "jsconfig.json"
       );
     }
   }
-  const rootDir = configPath && import_path10.default.dirname(configPath) || process.cwd();
-  const markoProject = getMarkoProject(configPath && rootDir);
-  let projectCache = markoProject.cache.get(getTSProject);
+  const rootDir = configFile && import_path7.default.dirname(configFile) || process.cwd();
+  const cache = import_language_tools14.Project.getCache(configFile && rootDir);
+  let projectCache = cache.get(getTSProject);
   let cached;
   if (projectCache) {
     cached = projectCache.get(rootDir);
@@ -2039,14 +1850,14 @@ function getTSProject(docFsPath) {
       return cached;
   } else {
     projectCache = /* @__PURE__ */ new Map();
-    markoProject.cache.set(getTSProject, projectCache);
+    cache.set(getTSProject, projectCache);
   }
   const { fileNames, options, projectReferences } = import_tsserverlibrary.default.parseJsonConfigFileContent(
-    configPath && import_tsserverlibrary.default.readConfigFile(configPath, import_tsserverlibrary.default.sys.readFile).config || defaultTSConfig,
+    configFile && import_tsserverlibrary.default.readConfigFile(configFile, import_tsserverlibrary.default.sys.readFile).config || defaultTSConfig,
     import_tsserverlibrary.default.sys,
     rootDir,
     requiredTSCompilerOptions,
-    configPath,
+    configFile,
     void 0,
     extraTSCompilerExtensions
   );
@@ -2054,15 +1865,21 @@ function getTSProject(docFsPath) {
   const potentialGlobalFiles = new Set(
     fileNames.filter((file) => /\.[cm]?ts$/.test(file))
   );
-  const tsPkgFile = configPath && ((_a = import_tsserverlibrary.default.resolveModuleName("typescript/package.json", configPath, options, import_tsserverlibrary.default.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
-  const defaultLibFile = import_path10.default.join(
-    tsPkgFile ? import_path10.default.join(tsPkgFile, "../lib") : __dirname,
+  const tsPkgFile = configFile && ((_a = import_tsserverlibrary.default.resolveModuleName("typescript/package.json", configFile, options, import_tsserverlibrary.default.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
+  const defaultLibFile = import_path7.default.join(
+    tsPkgFile ? import_path7.default.join(tsPkgFile, "../lib") : __dirname,
     import_tsserverlibrary.default.getDefaultLibFileName(options)
   );
+  const resolutionCache = import_tsserverlibrary.default.createModuleResolutionCache(
+    rootDir,
+    getCanonicalFileName,
+    options
+  );
   const host = patch(
     import_tsserverlibrary.default,
-    markoScriptLang,
+    configFile,
     extractCache,
+    resolutionCache,
     {
       getNewLine() {
         return import_tsserverlibrary.default.sys.newLine;
@@ -2085,9 +1902,16 @@ function getTSProject(docFsPath) {
       getProjectReferences() {
         return projectReferences;
       },
-      resolveModuleNames(moduleNames, containingFile) {
-        return moduleNames.map((moduleName) => {
-          return import_tsserverlibrary.default.resolveModuleName(moduleName, containingFile, options, host).resolvedModule;
+      resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options2, _containingSourceFile, _reusedNames) {
+        return moduleLiterals.map((moduleLiteral) => {
+          return import_tsserverlibrary.default.bundlerModuleNameResolver(
+            moduleLiteral.text,
+            containingFile,
+            options2,
+            host,
+            resolutionCache,
+            redirectedReference
+          );
         });
       },
       readDirectory: import_tsserverlibrary.default.sys.readDirectory,
@@ -2110,7 +1934,7 @@ function getTSProject(docFsPath) {
         return `${((_a2 = get(filenameToURI(filename))) == null ? void 0 : _a2.version) ?? -1}`;
       },
       getScriptKind(filename) {
-        switch (import_path10.default.extname(filename)) {
+        switch (import_path7.default.extname(filename)) {
           case import_tsserverlibrary.default.Extension.Js:
           case import_tsserverlibrary.default.Extension.Cjs:
           case import_tsserverlibrary.default.Extension.Mjs:
@@ -2146,14 +1970,7 @@ function getTSProject(docFsPath) {
     host,
     rootDir: options.rootDir,
     service: import_tsserverlibrary.default.createLanguageService(host),
-    markoProject,
-    markoScriptLang,
-    markoProjectTypeLibs: getProjectTypeLibs(
-      options.rootDir,
-      markoProject,
-      import_tsserverlibrary.default,
-      host
-    )
+    markoScriptLang
   };
   projectCache.set(rootDir, tsProject);
   return tsProject;
@@ -2311,6 +2128,9 @@ function getTSTriggerChar(char) {
   if (char && tsTriggerChars.has(char))
     return char;
 }
+function getCanonicalFileName(fileName) {
+  return import_tsserverlibrary.default.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+}
 
 // src/service/style/index.ts
 var import_vscode_css_languageservice2 = require("vscode-css-languageservice");
@@ -3195,7 +3015,7 @@ for (const command in service.commands) {
 }
 function validateDocs() {
   queueDiagnostic();
-  clearMarkoProjectCaches();
+  import_language_tools16.Project.clearCaches();
 }
 function queueDiagnostic() {
   clearTimeout(diagnosticTimeout);