@marko/language-server 1.0.1 → 1.0.3

package/dist/index.js

@@ -27,17 +27,31 @@ var import_util2 = require("util");
 var import_node = require("vscode-languageserver/node");
 
 // src/utils/project.ts
+var import_path = __toESM(require("path"));
 var defaultCompiler = __toESM(require("@marko/compiler"));
 var defaultTranslator = __toESM(require("@marko/translator-default"));
-var import_lasso_package_root = __toESM(require("lasso-package-root"));
 var import_resolve_from = __toESM(require("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
 };
@@ -53,55 +67,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 = import_lasso_package_root.default.getRootDir(dir) || cwd;
-  const pkgPath = import_resolve_from.default.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((0, import_resolve_from.default)(dir, "@marko/compiler/config")).translator;
+  try {
+    const compilerConfigPath = (0, import_resolve_from.default)(dir, "@marko/compiler/config");
+    const cachedProject = projectsByCompiler.get(compilerConfigPath);
+    if (cachedProject)
+      return cachedProject;
+    const [compiler, translator] = [
+      require(import_path.default.join(compilerConfigPath, "..")),
+      require((0, import_resolve_from.default)(
+        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
+var import_path2 = __toESM(require("path"));
+var import_language_tools = require("@marko/language-tools");
+var import_vscode_uri = require("vscode-uri");
+var processorCaches = /* @__PURE__ */ new WeakMap();
+function getFSPath(doc) {
+  return import_vscode_uri.URI.parse(doc.uri).fsPath;
+}
+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;
+  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);
+    cache.set(
+      doc,
+      file = {
+        project,
+        uri,
+        scheme,
+        version,
+        lookup,
+        filename,
+        dirname,
+        parsed,
+        code
       }
-      [compiler, translator] = [
-        require((0, import_resolve_from.default)(dir, "@marko/compiler")),
-        require((0, import_resolve_from.default)(dir, checkTranslator))
-      ];
-    } catch {
+    );
+  }
+  return file;
+}
+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;
+  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
 var import_fs = __toESM(require("fs"));
-var import_vscode_uri = require("vscode-uri");
+var import_vscode_uri2 = require("vscode-uri");
 var import_vscode_languageserver = require("vscode-languageserver");
 var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
 var docs = /* @__PURE__ */ new Map();
@@ -119,7 +197,7 @@ function get(uri) {
   const doc = docs.get(uri);
   if (doc)
     return doc;
-  const { fsPath, scheme } = import_vscode_uri.URI.parse(uri);
+  const { fsPath, scheme } = import_vscode_uri2.URI.parse(uri);
   if (scheme === "file") {
     if (fileExists.get(uri) === false)
       return void 0;
@@ -142,7 +220,7 @@ function exists(uri) {
   const cached = fileExists.get(uri);
   if (cached !== void 0)
     return cached;
-  const { fsPath, scheme } = import_vscode_uri.URI.parse(uri);
+  const { fsPath, scheme } = import_vscode_uri2.URI.parse(uri);
   if (scheme === "file") {
     try {
       import_fs.default.accessSync(fsPath);
@@ -196,7 +274,7 @@ function setup(connection4) {
     if (doc) {
       projectVersion++;
       openDocs.delete(doc);
-      if (import_vscode_uri.URI.parse(ref.uri).scheme !== "file") {
+      if (import_vscode_uri2.URI.parse(ref.uri).scheme !== "file") {
         docs.delete(ref.uri);
       }
     }
@@ -299,62 +377,6 @@ function display(type, data) {
   setImmediate(() => connection2.sendNotification(type, msg));
 }
 
-// src/utils/file.ts
-var import_path = __toESM(require("path"));
-var import_language_tools = require("@marko/language-tools");
-var import_vscode_uri2 = require("vscode-uri");
-var processorCaches = /* @__PURE__ */ new WeakMap();
-function getFSDir(doc) {
-  const filename = getFSPath(doc);
-  return filename ? import_path.default.dirname(filename) : void 0;
-}
-function getFSPath(doc) {
-  return import_vscode_uri2.URI.parse(doc.uri).fsPath;
-}
-function getMarkoFile(doc) {
-  const { uri } = doc;
-  const { fsPath: filename, scheme } = import_vscode_uri2.URI.parse(uri);
-  const dirname = filename && import_path.default.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 = (0, import_language_tools.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
 var import_vscode_languageserver12 = require("vscode-languageserver");
 
@@ -366,10 +388,7 @@ var import_vscode_languageserver2 = require("vscode-languageserver");
 function AttrName({
   offset,
   node,
-  file: {
-    parsed,
-    project: { lookup }
-  }
+  file: { parsed, lookup }
 }) {
   let name = parsed.read(node);
   const modifierIndex = name.indexOf(":");
@@ -466,7 +485,7 @@ function isExternalModule(file) {
 }
 
 // src/service/marko/complete/AttrValue.ts
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 var import_vscode_languageserver3 = require("vscode-languageserver");
 
 // src/service/marko/util/is-document-link-attr.ts
@@ -576,7 +595,7 @@ async function AttrValue({
     const resolved = resolveUrl(req, uri);
     if (resolved) {
       const result = [];
-      const curFile = req === "." ? import_path2.default.basename(uri) : void 0;
+      const curFile = req === "." ? import_path3.default.basename(uri) : void 0;
       const replaceRange = parsed.locationAt({
         start: start + segmentStart + 1,
         end: start + rawValue.length
@@ -609,7 +628,7 @@ async function AttrValue({
 var import_vscode_languageserver5 = require("vscode-languageserver");
 
 // src/service/marko/util/get-tag-name-completion.ts
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 var import_vscode_languageserver4 = require("vscode-languageserver");
 var import_vscode_uri3 = require("vscode-uri");
 var deprecated = [import_vscode_languageserver4.CompletionItemTag.Deprecated];
@@ -632,7 +651,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_path3.default.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
+[${importer ? import_path4.default.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
   };
   if (tag.description) {
     documentation.value += `
@@ -669,11 +688,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);
@@ -705,11 +720,7 @@ function Import({
 var import_language_tools3 = require("@marko/language-tools");
 function OpenTagName({
   node,
-  file: {
-    parsed,
-    filename,
-    project: { lookup }
-  }
+  file: { parsed, filename, lookup }
 }) {
   var _a;
   const tag = node.parent;
@@ -826,14 +837,14 @@ var doComplete = async (doc, params) => {
 };
 
 // src/service/marko/validate.ts
-var import_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 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_path4.default.dirname(filename)
+    filename && import_path5.default.dirname(filename)
   );
   try {
     compiler.compileSync(doc.getText(), filename || "untitled.marko", {
@@ -889,11 +900,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);
@@ -965,10 +972,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);
@@ -1007,15 +1011,12 @@ function AttrName2({
 
 // src/service/marko/definition/OpenTagName.ts
 var import_fs3 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 var import_vscode_uri5 = require("vscode-uri");
 var import_language_tools8 = require("@marko/language-tools");
 function OpenTagName3({
   node,
-  file: {
-    parsed,
-    project: { lookup }
-  }
+  file: { parsed, lookup }
 }) {
   const tag = node.parent;
   let tagDef;
@@ -1032,7 +1033,7 @@ function OpenTagName3({
     return;
   }
   const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!import_path5.default.isAbsolute(tagEntryFile)) {
+  if (!import_path6.default.isAbsolute(tagEntryFile)) {
     return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
@@ -1087,7 +1088,7 @@ function extractDocumentLinks({
   scheme,
   parsed,
   code,
-  project: { lookup }
+  lookup
 }) {
   if (scheme !== "file") {
     return [];
@@ -1163,7 +1164,7 @@ function extractDocumentSymbols({
   uri,
   scheme,
   parsed,
-  project: { lookup }
+  lookup
 }) {
   if (scheme !== "file") {
     return [];
@@ -1244,7 +1245,7 @@ var marko_default = {
 };
 
 // src/service/script/index.ts
-var import_path9 = __toESM(require("path"));
+var import_path10 = __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");
@@ -1253,27 +1254,42 @@ var prettier2 = __toESM(require("prettier"));
 var import_language_tools14 = require("@marko/language-tools");
 
 // src/ts-plugin/host.ts
-var import_path8 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_language_tools13 = require("@marko/language-tools");
 
 // src/utils/get-runtime-types.ts
-var import_path6 = __toESM(require("path"));
-var internalTypesFile = import_path6.default.join(__dirname, "marko.internal.d.ts");
-var defaultMarkoTypesFile = import_path6.default.join(__dirname, "marko.runtime.d.ts");
-function getProjectTypeLibs(project, ts2, host) {
+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 { resolvedTypeReferenceDirective } = ts2.resolveTypeReferenceDirective(
+    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",
-      import_path6.default.join(project.rootDir, "_.d.ts"),
-      host.getCompilationSettings(),
+      resolveFromFile,
+      compilerOptions,
       host
     );
-    const markoTypesFile = (resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName) || defaultMarkoTypesFile;
+    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") || ""
+      markoTypesCode: host.readFile(markoTypesFile, "utf-8") || "",
+      markoRunTypesFile,
+      markoRunGeneratedTypesFile: host.fileExists(markoRunGeneratedTypesFile) ? markoRunGeneratedTypesFile : void 0
     };
     project.cache.set(getProjectTypeLibs, cached);
   }
@@ -1304,24 +1320,29 @@ function getScriptLang(filename, ts2, host, projectScriptLang) {
 }
 
 // src/utils/get-component-filename.ts
-var import_path7 = __toESM(require("path"));
-function getComponentFilename(from, host) {
-  const dir = import_path7.default.dirname(from);
-  const nameNoExt = import_path7.default.basename(from, ".marko");
+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 = import_path7.default.join(dir, `${nameNoExt}.component.`);
-  const componentBrowserFull = import_path7.default.join(
-    dir,
-    `${nameNoExt}.component-browser.`
-  );
-  const componentPartial = isEntry ? import_path7.default.join(dir, "component.") : void 0;
-  const componentBrowserPartial = isEntry ? import_path7.default.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 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";
@@ -1330,19 +1351,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) === import_language_tools13.ScriptLang.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) {
@@ -1356,27 +1385,41 @@ function patch(ts2, scriptLang, cache, host) {
       let cached = cache.get(filename);
       if (!cached) {
         const code = host.readFile(filename, "utf-8") || "";
-        const markoProject = getMarkoProject(import_path8.default.dirname(filename));
-        cached = (0, import_language_tools13.extractScript)({
-          ts: ts2,
-          parsed: (0, import_language_tools13.parse)(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 = import_path9.default.dirname(filename);
+        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.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,
@@ -1387,31 +1430,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 = import_path8.default.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 = import_path9.default.resolve(containingFile, "..", moduleName);
+          } else {
             const [, nodeModuleName, relativeModulePath] = modulePartsReg.exec(moduleName);
             const { resolvedModule } = ts2.resolveModuleName(
               `${nodeModuleName}/package.json`,
@@ -1420,31 +1448,70 @@ function patch(ts2, scriptLang, cache, host) {
               host
             );
             if (resolvedModule) {
-              const resolvedFileName = import_path8.default.join(
+              resolvedFileName = import_path9.default.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);
         }
       }
-      return resolvedModules;
+      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 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();
@@ -1454,6 +1521,34 @@ var optionalModifierReg = /\boptional\b/;
 var deprecatedModifierReg = /\bdeprecated\b/;
 var colorModifierReg = /\bcolor\b/;
 var localInternalsPrefix = "__marko_internal_";
+var requiredTSCompilerOptions = {
+  module: import_tsserverlibrary.default.ModuleKind.ESNext,
+  moduleResolution: import_tsserverlibrary.default.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: import_tsserverlibrary.default.ScriptKind.Deferred
+  }
+];
 var ScriptService = {
   commands: {
     "$/showScriptOutput": async (uri) => {
@@ -1538,7 +1633,7 @@ var ScriptService = {
       let source = completion.source;
       if (source && completion.hasAction) {
         if (source[0] === ".") {
-          source = import_path9.default.resolve(fileName, "..", source);
+          source = import_path10.default.resolve(fileName, "..", source);
         }
         detail = (0, import_relative_import_path.relativeImportPath)(fileName, source);
         sortText = `\uFFFF${sortText}`;
@@ -1842,19 +1937,26 @@ ${documentation}`;
   }
 };
 function processScript(doc, tsProject) {
-  return processDoc(doc, ({ parsed, filename, project: markoProject }) => {
-    var _a;
-    const { lookup } = markoProject;
-    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(markoProject, import_tsserverlibrary.default, 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 (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)
+      });
+    }
+  );
 }
 function getInsertModuleStatementOffset(parsed) {
   const { program } = parsed;
@@ -1923,7 +2025,7 @@ function getTSProject(docFsPath) {
       );
     }
   }
-  const rootDir = configPath && import_path9.default.dirname(configPath) || process.cwd();
+  const rootDir = configPath && import_path10.default.dirname(configPath) || process.cwd();
   const markoProject = getMarkoProject(configPath && rootDir);
   let projectCache = markoProject.cache.get(getTSProject);
   let cached;
@@ -1936,32 +2038,21 @@ function getTSProject(docFsPath) {
     markoProject.cache.set(getTSProject, projectCache);
   }
   const { fileNames, options, projectReferences } = import_tsserverlibrary.default.parseJsonConfigFileContent(
-    configPath && import_tsserverlibrary.default.readConfigFile(configPath, import_tsserverlibrary.default.sys.readFile).config || {
-      compilerOptions: { lib: ["dom", "node", "esnext"] }
-    },
+    configPath && import_tsserverlibrary.default.readConfigFile(configPath, import_tsserverlibrary.default.sys.readFile).config || defaultTSConfig,
     import_tsserverlibrary.default.sys,
     rootDir,
-    void 0,
+    requiredTSCompilerOptions,
     configPath,
     void 0,
-    [
-      {
-        extension: ".marko",
-        isMixedContent: false,
-        scriptKind: import_tsserverlibrary.default.ScriptKind.Deferred
-      }
-    ]
+    extraTSCompilerExtensions
   );
+  options.rootDir ??= rootDir;
   const potentialGlobalFiles = new Set(
     fileNames.filter((file) => /\.[cm]?ts$/.test(file))
   );
-  options.rootDir ??= rootDir;
-  options.module = import_tsserverlibrary.default.ModuleKind.ESNext;
-  options.moduleResolution = import_tsserverlibrary.default.ModuleResolutionKind.NodeJs;
-  options.noEmit = options.allowJs = options.declaration = options.skipLibCheck = options.isolatedModules = options.resolveJsonModule = options.skipDefaultLibCheck = options.allowNonTsExtensions = true;
   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_path9.default.join(
-    tsPkgFile ? import_path9.default.join(tsPkgFile, "../lib") : __dirname,
+  const defaultLibFile = import_path10.default.join(
+    tsPkgFile ? import_path10.default.join(tsPkgFile, "../lib") : __dirname,
     import_tsserverlibrary.default.getDefaultLibFileName(options)
   );
   const host = patch(
@@ -2015,12 +2106,16 @@ function getTSProject(docFsPath) {
         return `${((_a2 = get(filenameToURI(filename))) == null ? void 0 : _a2.version) ?? -1}`;
       },
       getScriptKind(filename) {
-        switch (import_path9.default.extname(filename)) {
+        switch (import_path10.default.extname(filename)) {
           case import_tsserverlibrary.default.Extension.Js:
+          case import_tsserverlibrary.default.Extension.Cjs:
+          case import_tsserverlibrary.default.Extension.Mjs:
             return import_tsserverlibrary.default.ScriptKind.JS;
           case import_tsserverlibrary.default.Extension.Jsx:
             return import_tsserverlibrary.default.ScriptKind.JSX;
           case import_tsserverlibrary.default.Extension.Ts:
+          case import_tsserverlibrary.default.Extension.Cts:
+          case import_tsserverlibrary.default.Extension.Mts:
             return import_tsserverlibrary.default.ScriptKind.TS;
           case import_tsserverlibrary.default.Extension.Tsx:
             return import_tsserverlibrary.default.ScriptKind.TSX;
@@ -2049,7 +2144,12 @@ function getTSProject(docFsPath) {
     service: import_tsserverlibrary.default.createLanguageService(host),
     markoProject,
     markoScriptLang,
-    markoProjectTypeLibs: getProjectTypeLibs(markoProject, import_tsserverlibrary.default, host)
+    markoProjectTypeLibs: getProjectTypeLibs(
+      options.rootDir,
+      markoProject,
+      import_tsserverlibrary.default,
+      host
+    )
   };
   projectCache.set(rootDir, tsProject);
   return tsProject;
@@ -2516,7 +2616,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 (0, import_language_tools15.extractStyle)({
@@ -2994,7 +3094,7 @@ setup(connection3);
 onFileChange((changeDoc) => {
   if (changeDoc) {
     queueDiagnostic();
-    getMarkoProject(getFSDir(changeDoc)).cache.delete(changeDoc);
+    clearMarkoCacheForFile(changeDoc);
   } else {
     validateDocs();
   }
@@ -3091,10 +3191,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);