@marko/language-server 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -15,17 +15,31 @@ import {
 } from "vscode-languageserver/node";
 
 // src/utils/project.ts
+import path from "path";
 import * as defaultCompiler from "@marko/compiler";
 import * as defaultTranslator from "@marko/translator-default";
-import lassoPackageRoot from "lasso-package-root";
 import resolveFrom from "resolve-from";
-var cwd = process.cwd();
-var kTaglib = Symbol("taglib");
+var ignoreErrors = (_err) => {
+};
 var projectsByDir = /* @__PURE__ */ new Map();
+var projectsByCompiler = /* @__PURE__ */ new Map();
 var defaultProject = {
-  rootDir: cwd,
   cache: /* @__PURE__ */ new Map(),
-  lookup: defaultCompiler.taglib.buildLookup(cwd, 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;
+  },
   compiler: defaultCompiler,
   translator: defaultTranslator
 };
@@ -41,55 +55,119 @@ function getMarkoProject(dir) {
   return project;
 }
 function getMarkoProjects() {
-  return new Set(projectsByDir.values());
+  return projectsByCompiler.values();
+}
+function clearMarkoProjectCaches() {
+  for (const project of getMarkoProjects()) {
+    project.cache.clear();
+    project.compiler.taglib.clearCaches();
+  }
 }
 function loadProject(dir) {
-  const rootDir = lassoPackageRoot.getRootDir(dir) || cwd;
-  const pkgPath = resolveFrom.silent(rootDir, "@marko/compiler/package.json");
-  const pkg = pkgPath && __require(pkgPath);
-  const cache = /* @__PURE__ */ new Map();
-  let translator = defaultTranslator;
-  let compiler = defaultCompiler;
-  if (pkg && /^5\./.test(pkg.version)) {
-    try {
-      let checkTranslator = [].concat(
-        Object.keys(pkg.dependencies),
-        Object.keys(pkg.peerDependencies),
-        Object.keys(pkg.devDependencies)
-      ).find((name) => /^marko$|^(@\/marko\/|marko-)translator-/.test(name));
-      if (checkTranslator === "marko" || !checkTranslator) {
-        checkTranslator = __require(resolveFrom(dir, "@marko/compiler/config")).translator;
+  try {
+    const compilerConfigPath = resolveFrom(dir, "@marko/compiler/config");
+    const cachedProject = projectsByCompiler.get(compilerConfigPath);
+    if (cachedProject)
+      return cachedProject;
+    const [compiler, translator] = [
+      __require(path.join(compilerConfigPath, "..")),
+      __require(resolveFrom(
+        dir,
+        interopDefault(__require(compilerConfigPath)).translator
+      ))
+    ];
+    const project = {
+      cache: /* @__PURE__ */ new Map(),
+      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;
+      },
+      compiler,
+      translator
+    };
+    projectsByCompiler.set(compilerConfigPath, project);
+    return project;
+  } catch {
+    return defaultProject;
+  }
+}
+function interopDefault(mod) {
+  return mod.default || mod;
+}
+
+// src/utils/file.ts
+import path2 from "path";
+import { parse } from "@marko/language-tools";
+import { URI } from "vscode-uri";
+var processorCaches = /* @__PURE__ */ new WeakMap();
+function getFSPath(doc) {
+  return URI.parse(doc.uri).fsPath;
+}
+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;
+  let file = cache.get(doc);
+  if (!file) {
+    const { version } = doc;
+    const code = doc.getText();
+    const parsed = parse(code, filename);
+    const lookup = project.getLookup(dirname);
+    cache.set(
+      doc,
+      file = {
+        project,
+        uri,
+        scheme,
+        version,
+        lookup,
+        filename,
+        dirname,
+        parsed,
+        code
       }
-      [compiler, translator] = [
-        __require(resolveFrom(dir, "@marko/compiler")),
-        __require(resolveFrom(dir, checkTranslator))
-      ];
-    } catch {
+    );
+  }
+  return file;
+}
+function clearMarkoCacheForFile(doc) {
+  const { fsPath: filename } = URI.parse(doc.uri);
+  const dirname = filename && path2.dirname(filename);
+  const project = getMarkoProject(dirname);
+  const cache = project.cache;
+  cache.delete(doc);
+}
+function processDoc(doc, process2) {
+  const file = getMarkoFile(doc);
+  const cache = processorCaches.get(file.parsed);
+  let result;
+  if (cache) {
+    result = cache.get(process2);
+    if (!result) {
+      result = process2(file);
+      cache.set(process2, result);
     }
+  } else {
+    result = process2(file);
+    processorCaches.set(file.parsed, /* @__PURE__ */ new Map([[process2, result]]));
   }
-  return {
-    rootDir,
-    cache,
-    get lookup() {
-      let lookup = cache.get(kTaglib);
-      if (lookup === void 0) {
-        try {
-          lookup = compiler.taglib.buildLookup(dir, translator);
-        } catch {
-          lookup = defaultProject.lookup;
-        }
-        cache.set(kTaglib, lookup);
-      }
-      return lookup;
-    },
-    compiler,
-    translator
-  };
+  return result;
 }
 
 // src/utils/text-documents.ts
 import fs from "fs";
-import { URI } from "vscode-uri";
+import { URI as URI2 } from "vscode-uri";
 import { FileChangeType } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
 var docs = /* @__PURE__ */ new Map();
@@ -107,7 +185,7 @@ function get(uri) {
   const doc = docs.get(uri);
   if (doc)
     return doc;
-  const { fsPath, scheme } = URI.parse(uri);
+  const { fsPath, scheme } = URI2.parse(uri);
   if (scheme === "file") {
     if (fileExists.get(uri) === false)
       return void 0;
@@ -130,7 +208,7 @@ function exists(uri) {
   const cached = fileExists.get(uri);
   if (cached !== void 0)
     return cached;
-  const { fsPath, scheme } = URI.parse(uri);
+  const { fsPath, scheme } = URI2.parse(uri);
   if (scheme === "file") {
     try {
       fs.accessSync(fsPath);
@@ -184,7 +262,7 @@ function setup(connection4) {
     if (doc) {
       projectVersion++;
       openDocs.delete(doc);
-      if (URI.parse(ref.uri).scheme !== "file") {
+      if (URI2.parse(ref.uri).scheme !== "file") {
         docs.delete(ref.uri);
       }
     }
@@ -287,62 +365,6 @@ function display(type, data) {
   setImmediate(() => connection2.sendNotification(type, msg));
 }
 
-// src/utils/file.ts
-import path from "path";
-import { parse } from "@marko/language-tools";
-import { URI as URI2 } from "vscode-uri";
-var processorCaches = /* @__PURE__ */ new WeakMap();
-function getFSDir(doc) {
-  const filename = getFSPath(doc);
-  return filename ? path.dirname(filename) : void 0;
-}
-function getFSPath(doc) {
-  return URI2.parse(doc.uri).fsPath;
-}
-function getMarkoFile(doc) {
-  const { uri } = doc;
-  const { fsPath: filename, scheme } = URI2.parse(uri);
-  const dirname = filename && path.dirname(filename);
-  const project = getMarkoProject(dirname);
-  const cache = project.cache;
-  let file = cache.get(doc);
-  if (!file) {
-    const { version } = doc;
-    const code = doc.getText();
-    const parsed = parse(code, filename);
-    cache.set(
-      doc,
-      file = {
-        project,
-        uri,
-        scheme,
-        version,
-        filename,
-        dirname,
-        parsed,
-        code
-      }
-    );
-  }
-  return file;
-}
-function processDoc(doc, process2) {
-  const file = getMarkoFile(doc);
-  const cache = processorCaches.get(file.parsed);
-  let result;
-  if (cache) {
-    result = cache.get(process2);
-    if (!result) {
-      result = process2(file);
-      cache.set(process2, result);
-    }
-  } else {
-    result = process2(file);
-    processorCaches.set(file.parsed, /* @__PURE__ */ new Map([[process2, result]]));
-  }
-  return result;
-}
-
 // src/service/index.ts
 import { MarkupContent, MarkupKind as MarkupKind3 } from "vscode-languageserver";
 
@@ -359,10 +381,7 @@ import {
 function AttrName({
   offset,
   node,
-  file: {
-    parsed,
-    project: { lookup }
-  }
+  file: { parsed, lookup }
 }) {
   let name = parsed.read(node);
   const modifierIndex = name.indexOf(":");
@@ -459,7 +478,7 @@ function isExternalModule(file) {
 }
 
 // src/service/marko/complete/AttrValue.ts
-import path2 from "path";
+import path3 from "path";
 import {
   CompletionItemKind as CompletionItemKind2,
   TextEdit as TextEdit2
@@ -572,7 +591,7 @@ async function AttrValue({
     const resolved = resolveUrl(req, uri);
     if (resolved) {
       const result = [];
-      const curFile = req === "." ? path2.basename(uri) : void 0;
+      const curFile = req === "." ? path3.basename(uri) : void 0;
       const replaceRange = parsed.locationAt({
         start: start + segmentStart + 1,
         end: start + rawValue.length
@@ -605,7 +624,7 @@ async function AttrValue({
 import { TextEdit as TextEdit4 } from "vscode-languageserver";
 
 // src/service/marko/util/get-tag-name-completion.ts
-import path3 from "path";
+import path4 from "path";
 import {
   CompletionItemKind as CompletionItemKind3,
   CompletionItemTag,
@@ -634,7 +653,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 ? path3.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
+[${importer ? path4.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
   };
   if (tag.description) {
     documentation.value += `
@@ -671,11 +690,7 @@ ${autocomplete.description}`;
 var importTagReg = /(['"])<((?:[^\1\\>]+|\\.)*)>?\1/;
 function Import({
   node,
-  file: {
-    parsed,
-    filename,
-    project: { lookup }
-  }
+  file: { parsed, filename, lookup }
 }) {
   var _a;
   const value = parsed.read(node);
@@ -707,11 +722,7 @@ function Import({
 import { NodeType as NodeType2 } from "@marko/language-tools";
 function OpenTagName({
   node,
-  file: {
-    parsed,
-    filename,
-    project: { lookup }
-  }
+  file: { parsed, filename, lookup }
 }) {
   var _a;
   const tag = node.parent;
@@ -832,14 +843,14 @@ var doComplete = async (doc, params) => {
 };
 
 // src/service/marko/validate.ts
-import path4 from "path";
+import path5 from "path";
 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 && path4.dirname(filename)
+    filename && path5.dirname(filename)
   );
   try {
     compiler.compileSync(doc.getText(), filename || "untitled.marko", {
@@ -895,11 +906,7 @@ var START_LOCATION = {
 // src/service/marko/hover/OpenTagName.ts
 function OpenTagName2({
   node,
-  file: {
-    parsed,
-    filename,
-    project: { lookup }
-  }
+  file: { parsed, filename, lookup }
 }) {
   const tag = node.parent;
   const range = parsed.locationAt(node);
@@ -971,10 +978,7 @@ function escape(val) {
 // src/service/marko/definition/AttrName.ts
 function AttrName2({
   node,
-  file: {
-    parsed,
-    project: { lookup }
-  }
+  file: { parsed, lookup }
 }) {
   const tagName = node.parent.parent.nameText;
   const attrName = parsed.read(node);
@@ -1013,7 +1017,7 @@ function AttrName2({
 
 // src/service/marko/definition/OpenTagName.ts
 import fs4 from "fs";
-import path5 from "path";
+import path6 from "path";
 import { URI as URI5 } from "vscode-uri";
 import {
   NodeType as NodeType5,
@@ -1022,10 +1026,7 @@ import {
 } from "@marko/language-tools";
 function OpenTagName3({
   node,
-  file: {
-    parsed,
-    project: { lookup }
-  }
+  file: { parsed, lookup }
 }) {
   const tag = node.parent;
   let tagDef;
@@ -1042,7 +1043,7 @@ function OpenTagName3({
     return;
   }
   const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!path5.isAbsolute(tagEntryFile)) {
+  if (!path6.isAbsolute(tagEntryFile)) {
     return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
@@ -1097,7 +1098,7 @@ function extractDocumentLinks({
   scheme,
   parsed,
   code,
-  project: { lookup }
+  lookup
 }) {
   if (scheme !== "file") {
     return [];
@@ -1173,7 +1174,7 @@ function extractDocumentSymbols({
   uri,
   scheme,
   parsed,
-  project: { lookup }
+  lookup
 }) {
   if (scheme !== "file") {
     return [];
@@ -1254,7 +1255,7 @@ var marko_default = {
 };
 
 // src/service/script/index.ts
-import path9 from "path";
+import path10 from "path";
 import { relativeImportPath } from "relative-import-path";
 import ts from "typescript/lib/tsserverlibrary";
 import {
@@ -1273,7 +1274,7 @@ import {
 } from "@marko/language-tools";
 
 // src/ts-plugin/host.ts
-import path8 from "path";
+import path9 from "path";
 import {
   ScriptLang as ScriptLang2,
   extractScript,
@@ -1281,23 +1282,38 @@ import {
 } from "@marko/language-tools";
 
 // src/utils/get-runtime-types.ts
-import path6 from "path";
-var internalTypesFile = path6.join(__dirname, "marko.internal.d.ts");
-var defaultMarkoTypesFile = path6.join(__dirname, "marko.runtime.d.ts");
-function getProjectTypeLibs(project, ts2, host) {
+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 { resolvedTypeReferenceDirective } = ts2.resolveTypeReferenceDirective(
+    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",
-      path6.join(project.rootDir, "_.d.ts"),
-      host.getCompilationSettings(),
+      resolveFromFile,
+      compilerOptions,
+      host
+    );
+    const { resolvedTypeReferenceDirective: resolvedMarkoRunTypes } = ts2.resolveTypeReferenceDirective(
+      "@marko/run",
+      resolveFromFile,
+      compilerOptions,
       host
     );
-    const markoTypesFile = (resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName) || defaultMarkoTypesFile;
+    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") || ""
+      markoTypesCode: host.readFile(markoTypesFile, "utf-8") || "",
+      markoRunTypesFile,
+      markoRunGeneratedTypesFile: host.fileExists(markoRunGeneratedTypesFile) ? markoRunGeneratedTypesFile : void 0
     };
     project.cache.set(getProjectTypeLibs, cached);
   }
@@ -1328,24 +1344,29 @@ function getScriptLang(filename, ts2, host, projectScriptLang) {
 }
 
 // src/utils/get-component-filename.ts
-import path7 from "path";
-function getComponentFilename(from, host) {
-  const dir = path7.dirname(from);
-  const nameNoExt = path7.basename(from, ".marko");
+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 = path7.join(dir, `${nameNoExt}.component.`);
-  const componentBrowserFull = path7.join(
-    dir,
-    `${nameNoExt}.component-browser.`
-  );
-  const componentPartial = isEntry ? path7.join(dir, "component.") : void 0;
-  const componentBrowserPartial = isEntry ? path7.join(dir, "component-browser.") : void 0;
-  for (const entry of host.readDirectory(dir)) {
+  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 entry;
+      return path8.join(dir, entry);
     }
   }
 }
+function tryReaddirSync(dir) {
+  try {
+    return fs5.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
 
 // src/ts-plugin/host.ts
 var markoExt = ".marko";
@@ -1354,19 +1375,27 @@ var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
 var fsPathReg = /^(?:[./\\]|[A-Z]:)/i;
 function patch(ts2, scriptLang, cache, host) {
   var _a, _b, _c;
+  const rootDir = host.getCurrentDirectory();
   const projectTypeLibs = getProjectTypeLibs(
-    getMarkoProject(host.getCurrentDirectory()),
+    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 getScriptFileNames = host.getScriptFileNames.bind(host);
   host.getScriptFileNames = () => [
-    .../* @__PURE__ */ new Set([
-      ...getScriptFileNames(),
-      projectTypeLibs.internalTypesFile,
-      projectTypeLibs.markoTypesFile
-    ])
+    ...new Set(projectTypeLibsFiles.concat(getScriptFileNames()))
   ];
   const getScriptKind = (_a = host.getScriptKind) == null ? void 0 : _a.bind(host);
   if (getScriptKind) {
@@ -1380,27 +1409,41 @@ function patch(ts2, scriptLang, cache, host) {
       let cached = cache.get(filename);
       if (!cached) {
         const code = host.readFile(filename, "utf-8") || "";
-        const markoProject = getMarkoProject(path8.dirname(filename));
-        cached = extractScript({
-          ts: ts2,
-          parsed: parse2(code, filename),
-          lookup: markoProject.lookup,
-          scriptLang: getScriptLang(filename, ts2, host, scriptLang),
-          runtimeTypesCode: projectTypeLibs.markoTypesCode,
-          componentFilename: getComponentFilename(filename, host)
-        });
-        cached.snapshot = ts2.ScriptSnapshot.fromString(cached.toString());
+        const dir = path9.dirname(filename);
+        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.snapshot = ts2.ScriptSnapshot.fromString(cached.toString());
+        } catch {
+          cached = { snapshot: ts2.ScriptSnapshot.fromString("") };
+        }
         cache.set(filename, cached);
       }
       return cached.snapshot;
     }
     return getScriptSnapshot(filename);
   };
+  if (host.getProjectVersion) {
+    const getScriptVersion = host.getScriptVersion.bind(host);
+    host.getScriptVersion = (filename) => {
+      if (markoExtReg.test(filename)) {
+        return host.getProjectVersion();
+      }
+      return getScriptVersion(filename);
+    };
+  }
   const readDirectory2 = (_b = host.readDirectory) == null ? void 0 : _b.bind(host);
   if (readDirectory2) {
-    host.readDirectory = (path10, extensions, exclude, include, depth) => {
+    host.readDirectory = (path11, extensions, exclude, include, depth) => {
       return readDirectory2(
-        path10,
+        path11,
         extensions == null ? void 0 : extensions.concat(markoExt),
         exclude,
         include,
@@ -1411,31 +1454,16 @@ function patch(ts2, scriptLang, cache, host) {
   const resolveModuleNames = (_c = host.resolveModuleNames) == null ? void 0 : _c.bind(host);
   if (resolveModuleNames) {
     host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, sourceFile) => {
-      const resolvedModules = resolveModuleNames(
-        moduleNames,
-        containingFile,
-        reusedNames,
-        redirectedReference,
-        options,
-        sourceFile
-      );
-      for (let i = resolvedModules.length; i--; ) {
+      let normalModuleNames = moduleNames;
+      let resolvedModules;
+      for (let i = 0; i < moduleNames.length; i++) {
         const moduleName = moduleNames[i];
-        if (!resolvedModules[i] && markoExtReg.test(moduleName)) {
+        const shouldProcess = moduleName[0] !== "*" ? markoExtReg.test(moduleName) : void 0;
+        if (shouldProcess) {
+          let resolvedFileName;
           if (fsPathReg.test(moduleName)) {
-            const resolvedFileName = path8.resolve(
-              containingFile,
-              "..",
-              moduleName
-            );
-            if (host.fileExists(resolvedFileName)) {
-              resolvedModules[i] = {
-                resolvedFileName,
-                extension: isMarkoTSFile(resolvedFileName) ? ts2.Extension.Ts : ts2.Extension.Js,
-                isExternalLibraryImport: false
-              };
-            }
-          } else if (moduleName[0] !== "*") {
+            resolvedFileName = path9.resolve(containingFile, "..", moduleName);
+          } else {
             const [, nodeModuleName, relativeModulePath] = modulePartsReg.exec(moduleName);
             const { resolvedModule } = ts2.resolveModuleName(
               `${nodeModuleName}/package.json`,
@@ -1444,31 +1472,70 @@ function patch(ts2, scriptLang, cache, host) {
               host
             );
             if (resolvedModule) {
-              const resolvedFileName = path8.join(
+              resolvedFileName = path9.join(
                 resolvedModule.resolvedFileName,
                 "..",
                 relativeModulePath
               );
-              if (host.fileExists(resolvedFileName)) {
-                const isTS = isMarkoTSFile(resolvedFileName);
-                resolvedModules[i] = {
-                  resolvedFileName,
-                  extension: isTS ? ts2.Extension.Ts : ts2.Extension.Js,
-                  isExternalLibraryImport: isTS
-                };
-              }
+            }
+          }
+          if (!resolvedModules) {
+            resolvedModules = [];
+            normalModuleNames = [];
+            for (let j = 0; j < i; j++) {
+              resolvedModules.push(void 0);
+              normalModuleNames.push(moduleNames[j]);
+            }
+          }
+          resolvedModules.push(
+            resolvedFileName && host.fileExists(resolvedFileName) ? {
+              resolvedFileName,
+              extension: isMarkoTSFile(resolvedFileName) ? ts2.Extension.Ts : ts2.Extension.Js,
+              isExternalLibraryImport: false
+            } : null
+          );
+        } else if (resolvedModules) {
+          resolvedModules.push(void 0);
+        }
+      }
+      const normalResolvedModules = normalModuleNames.length ? resolveModuleNames(
+        normalModuleNames,
+        containingFile,
+        reusedNames,
+        redirectedReference,
+        options,
+        sourceFile
+      ) : 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;
             }
           }
         }
+        return resolvedModules;
+      } else {
+        return normalResolvedModules;
       }
-      return resolvedModules;
     };
   }
   return host;
 }
 
 // src/service/script/index.ts
-var IGNORE_DIAG_REG = /^(?:Expression|Identifier|['"][^\w]['"]) expected.$/;
+var IGNORE_DIAG_REG = /^(?:(?:Expression|Identifier|['"][^\w]['"]) expected|Invalid character)\b/i;
 var extractCache = /* @__PURE__ */ new Map();
 var snapshotCache = /* @__PURE__ */ new Map();
 var insertModuleStatementLocCache = /* @__PURE__ */ new WeakMap();
@@ -1478,6 +1545,34 @@ var optionalModifierReg = /\boptional\b/;
 var deprecatedModifierReg = /\bdeprecated\b/;
 var colorModifierReg = /\bcolor\b/;
 var localInternalsPrefix = "__marko_internal_";
+var requiredTSCompilerOptions = {
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.NodeJs,
+  noEmit: true,
+  allowJs: true,
+  composite: false,
+  declaration: false,
+  skipLibCheck: true,
+  isolatedModules: true,
+  resolveJsonModule: true,
+  skipDefaultLibCheck: true,
+  emitDeclarationOnly: false,
+  allowNonTsExtensions: true,
+  emitDecoratorMetadata: false
+};
+var defaultTSConfig = {
+  include: [],
+  compilerOptions: {
+    lib: ["dom", "node", "esnext"]
+  }
+};
+var extraTSCompilerExtensions = [
+  {
+    extension: ".marko",
+    isMixedContent: false,
+    scriptKind: ts.ScriptKind.Deferred
+  }
+];
 var ScriptService = {
   commands: {
     "$/showScriptOutput": async (uri) => {
@@ -1562,7 +1657,7 @@ var ScriptService = {
       let source = completion.source;
       if (source && completion.hasAction) {
         if (source[0] === ".") {
-          source = path9.resolve(fileName, "..", source);
+          source = path10.resolve(fileName, "..", source);
         }
         detail = relativeImportPath(fileName, source);
         sortText = `\uFFFF${sortText}`;
@@ -1866,19 +1961,26 @@ ${documentation}`;
   }
 };
 function processScript(doc, tsProject) {
-  return processDoc(doc, ({ parsed, filename, project: markoProject }) => {
-    var _a;
-    const { lookup } = markoProject;
-    const { host, markoScriptLang } = tsProject;
-    return extractScript2({
-      ts,
-      parsed,
-      lookup,
-      scriptLang: getScriptLang(filename, ts, host, markoScriptLang),
-      runtimeTypesCode: (_a = getProjectTypeLibs(markoProject, ts, host)) == null ? void 0 : _a.markoTypesCode,
-      componentFilename: getComponentFilename(filename, host)
-    });
-  });
+  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)
+      });
+    }
+  );
 }
 function getInsertModuleStatementOffset(parsed) {
   const { program } = parsed;
@@ -1947,7 +2049,7 @@ function getTSProject(docFsPath) {
       );
     }
   }
-  const rootDir = configPath && path9.dirname(configPath) || process.cwd();
+  const rootDir = configPath && path10.dirname(configPath) || process.cwd();
   const markoProject = getMarkoProject(configPath && rootDir);
   let projectCache = markoProject.cache.get(getTSProject);
   let cached;
@@ -1960,32 +2062,21 @@ function getTSProject(docFsPath) {
     markoProject.cache.set(getTSProject, projectCache);
   }
   const { fileNames, options, projectReferences } = ts.parseJsonConfigFileContent(
-    configPath && ts.readConfigFile(configPath, ts.sys.readFile).config || {
-      compilerOptions: { lib: ["dom", "node", "esnext"] }
-    },
+    configPath && ts.readConfigFile(configPath, ts.sys.readFile).config || defaultTSConfig,
     ts.sys,
     rootDir,
-    void 0,
+    requiredTSCompilerOptions,
     configPath,
     void 0,
-    [
-      {
-        extension: ".marko",
-        isMixedContent: false,
-        scriptKind: ts.ScriptKind.Deferred
-      }
-    ]
+    extraTSCompilerExtensions
   );
+  options.rootDir ??= rootDir;
   const potentialGlobalFiles = new Set(
     fileNames.filter((file) => /\.[cm]?ts$/.test(file))
   );
-  options.rootDir ??= rootDir;
-  options.module = ts.ModuleKind.ESNext;
-  options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
-  options.noEmit = options.allowJs = options.declaration = options.skipLibCheck = options.isolatedModules = options.resolveJsonModule = options.skipDefaultLibCheck = options.allowNonTsExtensions = true;
   const tsPkgFile = configPath && ((_a = ts.resolveModuleName("typescript/package.json", configPath, options, ts.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
-  const defaultLibFile = path9.join(
-    tsPkgFile ? path9.join(tsPkgFile, "../lib") : __dirname,
+  const defaultLibFile = path10.join(
+    tsPkgFile ? path10.join(tsPkgFile, "../lib") : __dirname,
     ts.getDefaultLibFileName(options)
   );
   const host = patch(
@@ -2039,12 +2130,16 @@ function getTSProject(docFsPath) {
         return `${((_a2 = get(filenameToURI(filename))) == null ? void 0 : _a2.version) ?? -1}`;
       },
       getScriptKind(filename) {
-        switch (path9.extname(filename)) {
+        switch (path10.extname(filename)) {
           case ts.Extension.Js:
+          case ts.Extension.Cjs:
+          case ts.Extension.Mjs:
             return ts.ScriptKind.JS;
           case ts.Extension.Jsx:
             return ts.ScriptKind.JSX;
           case ts.Extension.Ts:
+          case ts.Extension.Cts:
+          case ts.Extension.Mts:
             return ts.ScriptKind.TS;
           case ts.Extension.Tsx:
             return ts.ScriptKind.TSX;
@@ -2073,7 +2168,12 @@ function getTSProject(docFsPath) {
     service: ts.createLanguageService(host),
     markoProject,
     markoScriptLang,
-    markoProjectTypeLibs: getProjectTypeLibs(markoProject, ts, host)
+    markoProjectTypeLibs: getProjectTypeLibs(
+      options.rootDir,
+      markoProject,
+      ts,
+      host
+    )
   };
   projectCache.set(rootDir, tsProject);
   return tsProject;
@@ -2546,7 +2646,7 @@ var StyleSheetService = {
   }
 };
 function processStyle(doc) {
-  return processDoc(doc, ({ uri, version, parsed, project: { lookup } }) => {
+  return processDoc(doc, ({ uri, version, parsed, lookup }) => {
     var _a;
     const result = [];
     for (const [ext, extracted] of extractStyle({
@@ -3024,7 +3124,7 @@ setup(connection3);
 onFileChange((changeDoc) => {
   if (changeDoc) {
     queueDiagnostic();
-    getMarkoProject(getFSDir(changeDoc)).cache.delete(changeDoc);
+    clearMarkoCacheForFile(changeDoc);
   } else {
     validateDocs();
   }
@@ -3121,10 +3221,7 @@ for (const command in service.commands) {
 }
 function validateDocs() {
   queueDiagnostic();
-  for (const project of getMarkoProjects()) {
-    project.cache.clear();
-    project.compiler.taglib.clearCaches();
-  }
+  clearMarkoProjectCaches();
 }
 function queueDiagnostic() {
   clearTimeout(diagnosticTimeout);