@marko/language-tools 1.0.3 → 2.0.1

package/dist/extractors/script/index.d.ts

@@ -14,6 +14,5 @@ export interface ExtractScriptOptions {
     lookup: TaglibLookup;
     scriptLang: ScriptLang;
     runtimeTypesCode?: string;
-    componentFilename?: string | undefined;
 }
 export declare function extractScript(opts: ExtractScriptOptions): import("../../util/extractor").Extracted;

package/dist/extractors/script/util/get-component-filename.d.ts

@@ -0,0 +1 @@
+export declare function getComponentFilename(from: string): string | undefined;

package/dist/extractors/script/util/jsdoc-input-type.d.ts

@@ -1,4 +1,4 @@
-import type TS from "typescript";
+import type TS from "typescript/lib/tsserverlibrary";
 import type { Repeatable } from "../../../parser";
 export default function getJSDocInputType(comment: string, ts: typeof TS): {
     typeParameters: Repeatable<{

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 export * from "./parser";
 export * from "./extractors/style";
 export * from "./extractors/script";
+export * as Project from "./util/project";
+export * as Processors from "./processors";
+export { getExt } from "./util/get-ext";
+export { isDefinitionFile } from "./util/is-definition-file";
 export { type Extracted } from "./util/extractor";

package/dist/index.js

@@ -31,13 +31,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   NodeType: () => NodeType,
+  Processors: () => processors_exports,
+  Project: () => project_exports,
   ScriptLang: () => ScriptLang,
   UNFINISHED: () => UNFINISHED,
   extractScript: () => extractScript,
   extractStyle: () => extractStyle,
+  getExt: () => getExt,
   getLines: () => import_htmljs_parser2.getLines,
   getLocation: () => import_htmljs_parser2.getLocation,
   getPosition: () => import_htmljs_parser2.getPosition,
+  isDefinitionFile: () => isDefinitionFile,
   parse: () => parse
 });
 module.exports = __toCommonJS(src_exports);
@@ -701,13 +705,8 @@ var Extractor = class {
   }
 };
 var Extracted = class {
-  #parsed;
-  #generated;
-  #sourceToGenerated;
-  #generatedToSource;
-  #cachedGeneratedLines;
   constructor(parsed, generated, tokens) {
-    this.#parsed = parsed;
+    this.parsed = parsed;
     this.#generated = generated;
     if (tokens.length === 0) {
       this.#generatedToSource = this.#sourceToGenerated = emptyView;
@@ -718,6 +717,10 @@ var Extracted = class {
       );
     }
   }
+  #generated;
+  #sourceToGenerated;
+  #generatedToSource;
+  #cachedGeneratedLines;
   get #generatedLines() {
     return this.#cachedGeneratedLines || (this.#cachedGeneratedLines = (0, import_htmljs_parser2.getLines)(this.#generated));
   }
@@ -727,7 +730,7 @@ var Extracted = class {
   sourcePositionAt(generatedOffset) {
     const sourceOffset = this.sourceOffsetAt(generatedOffset);
     if (sourceOffset !== void 0)
-      return this.#parsed.positionAt(sourceOffset);
+      return this.parsed.positionAt(sourceOffset);
   }
   sourceLocationAt(generatedStart, generatedEnd) {
     const sourceRange = this.#generatedToSource.rangeAt(
@@ -735,7 +738,7 @@ var Extracted = class {
       generatedEnd
     );
     if (sourceRange) {
-      return this.#parsed.locationAt(sourceRange);
+      return this.parsed.locationAt(sourceRange);
     }
   }
   generatedOffsetAt(sourceOffset) {
@@ -1525,6 +1528,31 @@ function traverse(node, enter) {
   }
 }
 
+// src/extractors/script/util/get-component-filename.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+function getComponentFilename(from) {
+  const dir = import_path.default.dirname(from);
+  const nameNoExt = import_path.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_path.default.join(dir, entry);
+    }
+  }
+}
+function tryReaddirSync(dir) {
+  try {
+    return import_fs.default.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
 // src/extractors/script/util/runtime-overrides.ts
 var RuntimeOverloads = /* @__PURE__ */ new Map();
 var commentsReg = /\/\*(?:[^*]+|\*[^/])*\*\//gm;
@@ -1684,13 +1712,14 @@ var ScriptExtractor = class {
     this.#scriptParser = new ScriptParser(parsed.filename, parsed.code);
     this.#read = parsed.read.bind(parsed);
     this.#mutationOffsets = crawlProgramScope(this.#parsed, this.#scriptParser);
-    this.#writeProgram(parsed.program, opts.componentFilename);
+    this.#writeProgram(parsed.program);
   }
   end() {
     return this.#extractor.end();
   }
-  #writeProgram(program, componentFileName) {
+  #writeProgram(program) {
     this.#writeCommentPragmas(program);
+    const componentFileName = getComponentFilename(this.#filename);
     const inputType = this.#getInputType(program);
     let componentClassBody;
     for (const node of program.static) {
@@ -2848,15 +2877,422 @@ function removeNewLines(str) {
 function isEmptyRange(range) {
   return range.start === range.end;
 }
+
+// src/util/project.ts
+var project_exports = {};
+__export(project_exports, {
+  clearCaches: () => clearCaches,
+  getCache: () => getCache,
+  getCompiler: () => getCompiler,
+  getConfig: () => getConfig,
+  getScriptLang: () => getScriptLang,
+  getTagLookup: () => getTagLookup,
+  getTypeLibs: () => getTypeLibs,
+  setDefaultTypePaths: () => setDefaultTypePaths
+});
+var import_path2 = __toESM(require("path"));
+var import_module = require("module");
+var defaultCompiler = __toESM(require("@marko/compiler"));
+var defaultConfig = __toESM(require("@marko/compiler/config"));
+var defaultTranslator = __toESM(require("@marko/translator-default"));
+var import_strip_json_comments = __toESM(require("strip-json-comments"));
+var defaultTypeLibs = {};
+var ignoreErrors = (_err) => {
+};
+var metaByDir = /* @__PURE__ */ new Map();
+var metaByCompiler = /* @__PURE__ */ new Map();
+var defaultMeta = {
+  compiler: defaultCompiler,
+  config: {
+    ...defaultConfig,
+    cache: /* @__PURE__ */ new Map(),
+    translator: defaultTranslator
+  }
+};
+defaultCompiler.configure(defaultMeta.config);
+function getCompiler(dir) {
+  return getMeta(dir).compiler;
+}
+function getCache(dir) {
+  return getMeta(dir).config.cache;
+}
+function getConfig(dir) {
+  return getMeta(dir).config;
+}
+function getTagLookup(dir) {
+  return getTagLookupForProject(getMeta(dir), dir);
+}
+function getTypeLibs(rootDir, ts, host) {
+  const config = getConfig(rootDir);
+  let typeLibs = config.cache.get(getTypeLibs);
+  if (typeLibs)
+    return typeLibs;
+  const resolveTypeCompilerOptions = {
+    moduleResolution: ts.ModuleResolutionKind.Bundler
+  };
+  const markoRunGeneratedTypesFile = import_path2.default.join(
+    rootDir,
+    ".marko-run/routes.d.ts"
+  );
+  const resolveFromFile = import_path2.default.join(rootDir, "_.d.ts");
+  const { resolvedTypeReferenceDirective: resolvedInternalTypes } = ts.resolveTypeReferenceDirective(
+    "@marko/language-tools/marko.internal.d.ts",
+    resolveFromFile,
+    resolveTypeCompilerOptions,
+    host
+  );
+  const { resolvedTypeReferenceDirective: resolvedMarkoTypes } = ts.resolveTypeReferenceDirective(
+    config.translator.runtimeTypes || "marko",
+    resolveFromFile,
+    resolveTypeCompilerOptions,
+    host
+  );
+  const { resolvedTypeReferenceDirective: resolvedMarkoRunTypes } = ts.resolveTypeReferenceDirective(
+    "@marko/run",
+    resolveFromFile,
+    resolveTypeCompilerOptions,
+    host
+  );
+  const internalTypesFile = (resolvedInternalTypes == null ? void 0 : resolvedInternalTypes.resolvedFileName) || defaultTypeLibs.internalTypesFile;
+  const markoTypesFile = (resolvedMarkoTypes == null ? void 0 : resolvedMarkoTypes.resolvedFileName) || defaultTypeLibs.markoTypesFile;
+  const markoRunTypesFile = resolvedMarkoRunTypes == null ? void 0 : resolvedMarkoRunTypes.resolvedFileName;
+  if (!internalTypesFile || !markoTypesFile) {
+    throw new Error("Could not resolve marko type files.");
+  }
+  config.cache.set(
+    getTypeLibs,
+    typeLibs = {
+      internalTypesFile,
+      markoTypesFile,
+      markoTypesCode: host.readFile(markoTypesFile) || "",
+      markoRunTypesFile,
+      markoRunGeneratedTypesFile: host.fileExists(markoRunGeneratedTypesFile) ? markoRunGeneratedTypesFile : void 0
+    }
+  );
+  return typeLibs;
+}
+function getScriptLang(fileName, defaultScriptLang, ts, host) {
+  if (fileName.endsWith(".d.marko"))
+    return "ts" /* ts */;
+  const dir = import_path2.default.dirname(fileName);
+  const config = getConfig(dir);
+  const cache = config.cache.get(getScriptLang);
+  let scriptLang = cache == null ? void 0 : cache.get(dir);
+  if (!scriptLang) {
+    const configPath = ts.findConfigFile(
+      dir,
+      host.fileExists.bind(host),
+      "marko.json"
+    );
+    if (configPath) {
+      try {
+        const configSource = host.readFile(configPath);
+        if (configSource) {
+          const config2 = tryParseJSONWithComments(configSource);
+          if (config2) {
+            const definedScriptLang = config2["script-lang"] || config2.scriptLang;
+            if (definedScriptLang !== void 0) {
+              scriptLang = definedScriptLang === "ts" /* ts */ ? "ts" /* ts */ : "js" /* js */;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (scriptLang === void 0) {
+      scriptLang = /[/\\]node_modules[/\\]/.test(dir) ? "js" /* js */ : defaultScriptLang;
+    }
+    if (cache) {
+      cache.set(dir, scriptLang);
+    } else {
+      config.cache.set(getScriptLang, /* @__PURE__ */ new Map([[dir, scriptLang]]));
+    }
+  }
+  return scriptLang;
+}
+function clearCaches() {
+  clearCacheForMeta(defaultMeta);
+  for (const project of metaByCompiler.values()) {
+    clearCacheForMeta(project);
+  }
+}
+function setDefaultTypePaths(defaults) {
+  Object.assign(defaultTypeLibs, defaults);
+}
+function getMeta(dir) {
+  if (!dir)
+    return defaultMeta;
+  let cached = metaByDir.get(dir);
+  if (!cached) {
+    try {
+      const require2 = (0, import_module.createRequire)(dir);
+      const compilerConfigPath = require2.resolve("@marko/compiler/config");
+      cached = metaByCompiler.get(compilerConfigPath);
+      if (!cached) {
+        const compiler = require2(import_path2.default.join(
+          compilerConfigPath,
+          ".."
+        ));
+        const config = interopDefault(
+          require2(compilerConfigPath)
+        );
+        cached = {
+          compiler,
+          config: {
+            ...config,
+            cache: /* @__PURE__ */ new Map(),
+            translator: require2(config.translator)
+          }
+        };
+        compiler.configure(cached.config);
+        metaByCompiler.set(compilerConfigPath, cached);
+      }
+    } catch {
+      cached = defaultMeta;
+    }
+    metaByDir.set(dir, cached);
+  }
+  return cached;
+}
+function getTagLookupForProject(meta, dir) {
+  const cache = meta.config.cache.get(getTagLookupForProject);
+  let lookup = cache == null ? void 0 : cache.get(dir);
+  if (lookup === void 0) {
+    try {
+      lookup = meta.compiler.taglib.buildLookup(
+        dir,
+        meta.config.translator,
+        ignoreErrors
+      );
+    } catch {
+      if (meta !== defaultMeta) {
+        lookup = getTagLookupForProject(defaultMeta, dir);
+      }
+    }
+    if (cache) {
+      cache.set(dir, lookup);
+    } else {
+      meta.config.cache.set(getTagLookupForProject, /* @__PURE__ */ new Map([[dir, lookup]]));
+    }
+  }
+  return lookup;
+}
+function clearCacheForMeta(meta) {
+  meta.config.cache.clear();
+  meta.compiler.taglib.clearCaches();
+}
+function tryParseJSONWithComments(content) {
+  try {
+    return JSON.parse((0, import_strip_json_comments.default)(content));
+  } catch {
+    return void 0;
+  }
+}
+function interopDefault(mod) {
+  return mod.default || mod;
+}
+
+// src/processors/index.ts
+var processors_exports = {};
+__export(processors_exports, {
+  create: () => create,
+  extensions: () => extensions,
+  has: () => has
+});
+
+// src/util/get-ext.ts
+function getExt(fileName) {
+  const extIndex = fileName.lastIndexOf(".");
+  if (extIndex !== -1)
+    return fileName.slice(extIndex);
+}
+
+// src/processors/marko.ts
+var import_path3 = __toESM(require("path"));
+var marko_default = {
+  extension: ".marko",
+  create({ ts, host, configFile }) {
+    const currentDirectory = host.getCurrentDirectory ? host.getCurrentDirectory() : ts.sys.getCurrentDirectory();
+    const defaultScriptLang = configFile && /tsconfig.json$/.test(configFile) ? "ts" /* ts */ : "js" /* js */;
+    const runtimeTypes = getTypeLibs(currentDirectory, ts, host);
+    const rootNames = [
+      runtimeTypes.internalTypesFile,
+      runtimeTypes.markoTypesFile
+    ];
+    if (runtimeTypes.markoRunTypesFile) {
+      rootNames.push(runtimeTypes.markoRunTypesFile);
+    }
+    if (runtimeTypes.markoRunGeneratedTypesFile) {
+      rootNames.push(runtimeTypes.markoRunGeneratedTypesFile);
+    }
+    return {
+      getRootNames() {
+        return rootNames;
+      },
+      getScriptExtension(fileName) {
+        return getScriptLang(fileName, defaultScriptLang, ts, host) === "ts" /* ts */ ? ts.Extension.Ts : ts.Extension.Js;
+      },
+      getScriptKind(fileName) {
+        return getScriptLang(fileName, defaultScriptLang, ts, host) === "ts" /* ts */ ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+      },
+      extract(fileName, code) {
+        const dir = import_path3.default.dirname(fileName);
+        const parsed = parse(code, fileName);
+        return extractScript({
+          ts,
+          parsed,
+          lookup: getTagLookup(dir),
+          scriptLang: getScriptLang(
+            fileName,
+            defaultScriptLang,
+            ts,
+            host
+          ),
+          runtimeTypesCode: runtimeTypes.markoTypesCode
+        });
+      },
+      print({ extracted: { parsed } }) {
+        const { code, map } = getCompiler(
+          import_path3.default.dirname(parsed.filename)
+        ).compileSync(parsed.code, parsed.filename, {
+          output: "source",
+          stripTypes: true,
+          sourceMaps: true
+        });
+        return { code, map };
+      },
+      printTypes({ printer, typeChecker, sourceFile, formatSettings }) {
+        var _a, _b, _c;
+        let code = "";
+        const nlChar = formatSettings.newLineCharacter;
+        const tabChar = formatSettings.convertTabsToSpaces ? " ".repeat(formatSettings.indentSize) : "	";
+        let defaultExport;
+        let defaultExportId;
+        let componentImpl;
+        let internalRenderImpl;
+        for (const statement of sourceFile.statements) {
+          if (ts.isExportAssignment(statement)) {
+            defaultExport = statement;
+            defaultExportId = ts.isIdentifier(statement.expression) ? statement.expression.escapedText : void 0;
+          } else if (ts.isClassDeclaration(statement) && ((_a = statement.name) == null ? void 0 : _a.escapedText) === "Component") {
+            componentImpl = statement;
+          } else if (ts.isFunctionDeclaration(statement) && ((_b = statement.name) == null ? void 0 : _b.escapedText) === "___marko_internal_template") {
+            internalRenderImpl = statement;
+          }
+        }
+        for (const statement of sourceFile.statements) {
+          if (statement === defaultExport || // skips the generated `export default ...`.
+          statement === componentImpl || // skips the generated `class {}` since it needs special processing.
+          statement === internalRenderImpl || // skips the internal template render code.
+          isExportComponentType(statement) || // skips the generated `export { type Component }`.
+          isImportComponentType(statement) || // skips the generated `import type Component from "..."`.
+          isExportEmptyInputType(statement) || // skips empty exported Input, eg `export type Input = {}` or `export interface Input {}`.
+          isExportInputTypeAsComponentInput(statement) || // skips outputing `export type Input = Component["input"]` since it's inferred.
+          defaultExportId && // If the `export default` was an identifier, we also remove the variable that declared the identifier.
+          isVariableStatementForName(statement, defaultExportId)) {
+            continue;
+          }
+          const printed = printer.printNode(
+            ts.EmitHint.Unspecified,
+            statement,
+            sourceFile
+          );
+          if (!/^(?:import|export) /.test(printed))
+            code += "static ";
+          code += printed + nlChar;
+        }
+        if (componentImpl == null ? void 0 : componentImpl.members.length) {
+          code += `class {${nlChar}`;
+          for (const member of componentImpl.members) {
+            if (ts.isPropertyDeclaration(member)) {
+              code += `${tabChar}declare ${printer.printNode(ts.EmitHint.Unspecified, member, sourceFile) + nlChar}`;
+            } else if (ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
+              code += `${tabChar + printer.printNode(ts.EmitHint.Unspecified, member, sourceFile).replace(/;\s*$/, "")} { return ${castType("any")}; }${nlChar}`;
+            } else if (ts.isIndexSignatureDeclaration(member)) {
+              code += tabChar + printer.printNode(ts.EmitHint.Unspecified, member, sourceFile) + nlChar;
+            }
+          }
+          code += `}${nlChar}`;
+        }
+        if (internalRenderImpl) {
+          const returnType = (_c = typeChecker.getSignatureFromDeclaration(internalRenderImpl)) == null ? void 0 : _c.getReturnType();
+          if (returnType) {
+            const props = returnType.getProperties();
+            const valueType = props.length === 1 && props[0].name === "value" && typeChecker.getPropertyOfType(returnType, "value") || void 0;
+            code += "<return ";
+            if (valueType) {
+              code += `= ${castType(
+                typeChecker.typeToString(typeChecker.getTypeOfSymbol(valueType))
+              )}`;
+            } else {
+              code += `...${castType(typeChecker.typeToString(returnType))}`;
+            }
+            code += `/>${nlChar}`;
+          }
+        }
+        return { code };
+      }
+    };
+    function isImportComponentType(statement) {
+      var _a, _b;
+      return ts.isImportDeclaration(statement) && ((_b = (_a = statement.importClause) == null ? void 0 : _a.name) == null ? void 0 : _b.escapedText) === "Component";
+    }
+    function isExportInputTypeAsComponentInput(statement) {
+      return ts.isTypeAliasDeclaration(statement) && statement.name.escapedText === "Input" && ts.isIndexedAccessTypeNode(statement.type) && ts.isTypeReferenceNode(statement.type.objectType) && ts.isIdentifier(statement.type.objectType.typeName) && statement.type.objectType.typeName.escapedText === "Component" && ts.isLiteralTypeNode(statement.type.indexType) && ts.isStringLiteral(statement.type.indexType.literal) && statement.type.indexType.literal.text === "input";
+    }
+    function isExportEmptyInputType(statement) {
+      return ts.isTypeAliasDeclaration(statement) && statement.name.escapedText === "Input" && ts.isTypeLiteralNode(statement.type) && !statement.typeParameters && statement.type.members.length === 0 || ts.isInterfaceDeclaration(statement) && statement.name.escapedText === "Input" && !statement.typeParameters && statement.members.length === 0;
+    }
+    function isExportComponentType(statement) {
+      return ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause) && statement.exportClause.elements.length === 1 && statement.exportClause.elements[0].name.escapedText === "Component";
+    }
+    function isVariableStatementForName(statement, name) {
+      if (ts.isVariableStatement(statement)) {
+        for (const decl of statement.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.name.escapedText === name) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+};
+function castType(type) {
+  if (type === "any") {
+    return "1 as any";
+  }
+  return `(1 as any as ${type})`;
+}
+
+// src/processors/index.ts
+var extensions = [marko_default.extension];
+function create(options) {
+  return {
+    [marko_default.extension]: marko_default.create(options)
+  };
+}
+function has(fileName) {
+  const ext = getExt(fileName);
+  return !!(ext && extensions.includes(ext));
+}
+
+// src/util/is-definition-file.ts
+function isDefinitionFile(fileName) {
+  return /\.d\.[^.]+$/.test(fileName);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   NodeType,
+  Processors,
+  Project,
   ScriptLang,
   UNFINISHED,
   extractScript,
   extractStyle,
+  getExt,
   getLines,
   getLocation,
   getPosition,
+  isDefinitionFile,
   parse
 });

package/dist/index.mjs

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/parser.ts
 import { TagType, createParser } from "htmljs-parser";
 
@@ -661,13 +667,8 @@ var Extractor = class {
   }
 };
 var Extracted = class {
-  #parsed;
-  #generated;
-  #sourceToGenerated;
-  #generatedToSource;
-  #cachedGeneratedLines;
   constructor(parsed, generated, tokens) {
-    this.#parsed = parsed;
+    this.parsed = parsed;
     this.#generated = generated;
     if (tokens.length === 0) {
       this.#generatedToSource = this.#sourceToGenerated = emptyView;
@@ -678,6 +679,10 @@ var Extracted = class {
       );
     }
   }
+  #generated;
+  #sourceToGenerated;
+  #generatedToSource;
+  #cachedGeneratedLines;
   get #generatedLines() {
     return this.#cachedGeneratedLines || (this.#cachedGeneratedLines = getLines(this.#generated));
   }
@@ -687,7 +692,7 @@ var Extracted = class {
   sourcePositionAt(generatedOffset) {
     const sourceOffset = this.sourceOffsetAt(generatedOffset);
     if (sourceOffset !== void 0)
-      return this.#parsed.positionAt(sourceOffset);
+      return this.parsed.positionAt(sourceOffset);
   }
   sourceLocationAt(generatedStart, generatedEnd) {
     const sourceRange = this.#generatedToSource.rangeAt(
@@ -695,7 +700,7 @@ var Extracted = class {
       generatedEnd
     );
     if (sourceRange) {
-      return this.#parsed.locationAt(sourceRange);
+      return this.parsed.locationAt(sourceRange);
     }
   }
   generatedOffsetAt(sourceOffset) {
@@ -1492,6 +1497,31 @@ function traverse(node, enter) {
   }
 }
 
+// src/extractors/script/util/get-component-filename.ts
+import fs from "fs";
+import path from "path";
+function getComponentFilename(from) {
+  const dir = path.dirname(from);
+  const nameNoExt = path.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 path.join(dir, entry);
+    }
+  }
+}
+function tryReaddirSync(dir) {
+  try {
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
 // src/extractors/script/util/runtime-overrides.ts
 var RuntimeOverloads = /* @__PURE__ */ new Map();
 var commentsReg = /\/\*(?:[^*]+|\*[^/])*\*\//gm;
@@ -1651,13 +1681,14 @@ var ScriptExtractor = class {
     this.#scriptParser = new ScriptParser(parsed.filename, parsed.code);
     this.#read = parsed.read.bind(parsed);
     this.#mutationOffsets = crawlProgramScope(this.#parsed, this.#scriptParser);
-    this.#writeProgram(parsed.program, opts.componentFilename);
+    this.#writeProgram(parsed.program);
   }
   end() {
     return this.#extractor.end();
   }
-  #writeProgram(program, componentFileName) {
+  #writeProgram(program) {
     this.#writeCommentPragmas(program);
+    const componentFileName = getComponentFilename(this.#filename);
     const inputType = this.#getInputType(program);
     let componentClassBody;
     for (const node of program.static) {
@@ -2815,14 +2846,421 @@ function removeNewLines(str) {
 function isEmptyRange(range) {
   return range.start === range.end;
 }
+
+// src/util/project.ts
+var project_exports = {};
+__export(project_exports, {
+  clearCaches: () => clearCaches,
+  getCache: () => getCache,
+  getCompiler: () => getCompiler,
+  getConfig: () => getConfig,
+  getScriptLang: () => getScriptLang,
+  getTagLookup: () => getTagLookup,
+  getTypeLibs: () => getTypeLibs,
+  setDefaultTypePaths: () => setDefaultTypePaths
+});
+import path2 from "path";
+import { createRequire } from "module";
+import * as defaultCompiler from "@marko/compiler";
+import * as defaultConfig from "@marko/compiler/config";
+import * as defaultTranslator from "@marko/translator-default";
+import stripJSONComments from "strip-json-comments";
+var defaultTypeLibs = {};
+var ignoreErrors = (_err) => {
+};
+var metaByDir = /* @__PURE__ */ new Map();
+var metaByCompiler = /* @__PURE__ */ new Map();
+var defaultMeta = {
+  compiler: defaultCompiler,
+  config: {
+    ...defaultConfig,
+    cache: /* @__PURE__ */ new Map(),
+    translator: defaultTranslator
+  }
+};
+defaultCompiler.configure(defaultMeta.config);
+function getCompiler(dir) {
+  return getMeta(dir).compiler;
+}
+function getCache(dir) {
+  return getMeta(dir).config.cache;
+}
+function getConfig(dir) {
+  return getMeta(dir).config;
+}
+function getTagLookup(dir) {
+  return getTagLookupForProject(getMeta(dir), dir);
+}
+function getTypeLibs(rootDir, ts, host) {
+  const config = getConfig(rootDir);
+  let typeLibs = config.cache.get(getTypeLibs);
+  if (typeLibs)
+    return typeLibs;
+  const resolveTypeCompilerOptions = {
+    moduleResolution: ts.ModuleResolutionKind.Bundler
+  };
+  const markoRunGeneratedTypesFile = path2.join(
+    rootDir,
+    ".marko-run/routes.d.ts"
+  );
+  const resolveFromFile = path2.join(rootDir, "_.d.ts");
+  const { resolvedTypeReferenceDirective: resolvedInternalTypes } = ts.resolveTypeReferenceDirective(
+    "@marko/language-tools/marko.internal.d.ts",
+    resolveFromFile,
+    resolveTypeCompilerOptions,
+    host
+  );
+  const { resolvedTypeReferenceDirective: resolvedMarkoTypes } = ts.resolveTypeReferenceDirective(
+    config.translator.runtimeTypes || "marko",
+    resolveFromFile,
+    resolveTypeCompilerOptions,
+    host
+  );
+  const { resolvedTypeReferenceDirective: resolvedMarkoRunTypes } = ts.resolveTypeReferenceDirective(
+    "@marko/run",
+    resolveFromFile,
+    resolveTypeCompilerOptions,
+    host
+  );
+  const internalTypesFile = (resolvedInternalTypes == null ? void 0 : resolvedInternalTypes.resolvedFileName) || defaultTypeLibs.internalTypesFile;
+  const markoTypesFile = (resolvedMarkoTypes == null ? void 0 : resolvedMarkoTypes.resolvedFileName) || defaultTypeLibs.markoTypesFile;
+  const markoRunTypesFile = resolvedMarkoRunTypes == null ? void 0 : resolvedMarkoRunTypes.resolvedFileName;
+  if (!internalTypesFile || !markoTypesFile) {
+    throw new Error("Could not resolve marko type files.");
+  }
+  config.cache.set(
+    getTypeLibs,
+    typeLibs = {
+      internalTypesFile,
+      markoTypesFile,
+      markoTypesCode: host.readFile(markoTypesFile) || "",
+      markoRunTypesFile,
+      markoRunGeneratedTypesFile: host.fileExists(markoRunGeneratedTypesFile) ? markoRunGeneratedTypesFile : void 0
+    }
+  );
+  return typeLibs;
+}
+function getScriptLang(fileName, defaultScriptLang, ts, host) {
+  if (fileName.endsWith(".d.marko"))
+    return "ts" /* ts */;
+  const dir = path2.dirname(fileName);
+  const config = getConfig(dir);
+  const cache = config.cache.get(getScriptLang);
+  let scriptLang = cache == null ? void 0 : cache.get(dir);
+  if (!scriptLang) {
+    const configPath = ts.findConfigFile(
+      dir,
+      host.fileExists.bind(host),
+      "marko.json"
+    );
+    if (configPath) {
+      try {
+        const configSource = host.readFile(configPath);
+        if (configSource) {
+          const config2 = tryParseJSONWithComments(configSource);
+          if (config2) {
+            const definedScriptLang = config2["script-lang"] || config2.scriptLang;
+            if (definedScriptLang !== void 0) {
+              scriptLang = definedScriptLang === "ts" /* ts */ ? "ts" /* ts */ : "js" /* js */;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (scriptLang === void 0) {
+      scriptLang = /[/\\]node_modules[/\\]/.test(dir) ? "js" /* js */ : defaultScriptLang;
+    }
+    if (cache) {
+      cache.set(dir, scriptLang);
+    } else {
+      config.cache.set(getScriptLang, /* @__PURE__ */ new Map([[dir, scriptLang]]));
+    }
+  }
+  return scriptLang;
+}
+function clearCaches() {
+  clearCacheForMeta(defaultMeta);
+  for (const project of metaByCompiler.values()) {
+    clearCacheForMeta(project);
+  }
+}
+function setDefaultTypePaths(defaults) {
+  Object.assign(defaultTypeLibs, defaults);
+}
+function getMeta(dir) {
+  if (!dir)
+    return defaultMeta;
+  let cached = metaByDir.get(dir);
+  if (!cached) {
+    try {
+      const require2 = createRequire(dir);
+      const compilerConfigPath = require2.resolve("@marko/compiler/config");
+      cached = metaByCompiler.get(compilerConfigPath);
+      if (!cached) {
+        const compiler = require2(path2.join(
+          compilerConfigPath,
+          ".."
+        ));
+        const config = interopDefault(
+          require2(compilerConfigPath)
+        );
+        cached = {
+          compiler,
+          config: {
+            ...config,
+            cache: /* @__PURE__ */ new Map(),
+            translator: require2(config.translator)
+          }
+        };
+        compiler.configure(cached.config);
+        metaByCompiler.set(compilerConfigPath, cached);
+      }
+    } catch {
+      cached = defaultMeta;
+    }
+    metaByDir.set(dir, cached);
+  }
+  return cached;
+}
+function getTagLookupForProject(meta, dir) {
+  const cache = meta.config.cache.get(getTagLookupForProject);
+  let lookup = cache == null ? void 0 : cache.get(dir);
+  if (lookup === void 0) {
+    try {
+      lookup = meta.compiler.taglib.buildLookup(
+        dir,
+        meta.config.translator,
+        ignoreErrors
+      );
+    } catch {
+      if (meta !== defaultMeta) {
+        lookup = getTagLookupForProject(defaultMeta, dir);
+      }
+    }
+    if (cache) {
+      cache.set(dir, lookup);
+    } else {
+      meta.config.cache.set(getTagLookupForProject, /* @__PURE__ */ new Map([[dir, lookup]]));
+    }
+  }
+  return lookup;
+}
+function clearCacheForMeta(meta) {
+  meta.config.cache.clear();
+  meta.compiler.taglib.clearCaches();
+}
+function tryParseJSONWithComments(content) {
+  try {
+    return JSON.parse(stripJSONComments(content));
+  } catch {
+    return void 0;
+  }
+}
+function interopDefault(mod) {
+  return mod.default || mod;
+}
+
+// src/processors/index.ts
+var processors_exports = {};
+__export(processors_exports, {
+  create: () => create,
+  extensions: () => extensions,
+  has: () => has
+});
+
+// src/util/get-ext.ts
+function getExt(fileName) {
+  const extIndex = fileName.lastIndexOf(".");
+  if (extIndex !== -1)
+    return fileName.slice(extIndex);
+}
+
+// src/processors/marko.ts
+import path3 from "path";
+var marko_default = {
+  extension: ".marko",
+  create({ ts, host, configFile }) {
+    const currentDirectory = host.getCurrentDirectory ? host.getCurrentDirectory() : ts.sys.getCurrentDirectory();
+    const defaultScriptLang = configFile && /tsconfig.json$/.test(configFile) ? "ts" /* ts */ : "js" /* js */;
+    const runtimeTypes = getTypeLibs(currentDirectory, ts, host);
+    const rootNames = [
+      runtimeTypes.internalTypesFile,
+      runtimeTypes.markoTypesFile
+    ];
+    if (runtimeTypes.markoRunTypesFile) {
+      rootNames.push(runtimeTypes.markoRunTypesFile);
+    }
+    if (runtimeTypes.markoRunGeneratedTypesFile) {
+      rootNames.push(runtimeTypes.markoRunGeneratedTypesFile);
+    }
+    return {
+      getRootNames() {
+        return rootNames;
+      },
+      getScriptExtension(fileName) {
+        return getScriptLang(fileName, defaultScriptLang, ts, host) === "ts" /* ts */ ? ts.Extension.Ts : ts.Extension.Js;
+      },
+      getScriptKind(fileName) {
+        return getScriptLang(fileName, defaultScriptLang, ts, host) === "ts" /* ts */ ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+      },
+      extract(fileName, code) {
+        const dir = path3.dirname(fileName);
+        const parsed = parse(code, fileName);
+        return extractScript({
+          ts,
+          parsed,
+          lookup: getTagLookup(dir),
+          scriptLang: getScriptLang(
+            fileName,
+            defaultScriptLang,
+            ts,
+            host
+          ),
+          runtimeTypesCode: runtimeTypes.markoTypesCode
+        });
+      },
+      print({ extracted: { parsed } }) {
+        const { code, map } = getCompiler(
+          path3.dirname(parsed.filename)
+        ).compileSync(parsed.code, parsed.filename, {
+          output: "source",
+          stripTypes: true,
+          sourceMaps: true
+        });
+        return { code, map };
+      },
+      printTypes({ printer, typeChecker, sourceFile, formatSettings }) {
+        var _a, _b, _c;
+        let code = "";
+        const nlChar = formatSettings.newLineCharacter;
+        const tabChar = formatSettings.convertTabsToSpaces ? " ".repeat(formatSettings.indentSize) : "	";
+        let defaultExport;
+        let defaultExportId;
+        let componentImpl;
+        let internalRenderImpl;
+        for (const statement of sourceFile.statements) {
+          if (ts.isExportAssignment(statement)) {
+            defaultExport = statement;
+            defaultExportId = ts.isIdentifier(statement.expression) ? statement.expression.escapedText : void 0;
+          } else if (ts.isClassDeclaration(statement) && ((_a = statement.name) == null ? void 0 : _a.escapedText) === "Component") {
+            componentImpl = statement;
+          } else if (ts.isFunctionDeclaration(statement) && ((_b = statement.name) == null ? void 0 : _b.escapedText) === "___marko_internal_template") {
+            internalRenderImpl = statement;
+          }
+        }
+        for (const statement of sourceFile.statements) {
+          if (statement === defaultExport || // skips the generated `export default ...`.
+          statement === componentImpl || // skips the generated `class {}` since it needs special processing.
+          statement === internalRenderImpl || // skips the internal template render code.
+          isExportComponentType(statement) || // skips the generated `export { type Component }`.
+          isImportComponentType(statement) || // skips the generated `import type Component from "..."`.
+          isExportEmptyInputType(statement) || // skips empty exported Input, eg `export type Input = {}` or `export interface Input {}`.
+          isExportInputTypeAsComponentInput(statement) || // skips outputing `export type Input = Component["input"]` since it's inferred.
+          defaultExportId && // If the `export default` was an identifier, we also remove the variable that declared the identifier.
+          isVariableStatementForName(statement, defaultExportId)) {
+            continue;
+          }
+          const printed = printer.printNode(
+            ts.EmitHint.Unspecified,
+            statement,
+            sourceFile
+          );
+          if (!/^(?:import|export) /.test(printed))
+            code += "static ";
+          code += printed + nlChar;
+        }
+        if (componentImpl == null ? void 0 : componentImpl.members.length) {
+          code += `class {${nlChar}`;
+          for (const member of componentImpl.members) {
+            if (ts.isPropertyDeclaration(member)) {
+              code += `${tabChar}declare ${printer.printNode(ts.EmitHint.Unspecified, member, sourceFile) + nlChar}`;
+            } else if (ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
+              code += `${tabChar + printer.printNode(ts.EmitHint.Unspecified, member, sourceFile).replace(/;\s*$/, "")} { return ${castType("any")}; }${nlChar}`;
+            } else if (ts.isIndexSignatureDeclaration(member)) {
+              code += tabChar + printer.printNode(ts.EmitHint.Unspecified, member, sourceFile) + nlChar;
+            }
+          }
+          code += `}${nlChar}`;
+        }
+        if (internalRenderImpl) {
+          const returnType = (_c = typeChecker.getSignatureFromDeclaration(internalRenderImpl)) == null ? void 0 : _c.getReturnType();
+          if (returnType) {
+            const props = returnType.getProperties();
+            const valueType = props.length === 1 && props[0].name === "value" && typeChecker.getPropertyOfType(returnType, "value") || void 0;
+            code += "<return ";
+            if (valueType) {
+              code += `= ${castType(
+                typeChecker.typeToString(typeChecker.getTypeOfSymbol(valueType))
+              )}`;
+            } else {
+              code += `...${castType(typeChecker.typeToString(returnType))}`;
+            }
+            code += `/>${nlChar}`;
+          }
+        }
+        return { code };
+      }
+    };
+    function isImportComponentType(statement) {
+      var _a, _b;
+      return ts.isImportDeclaration(statement) && ((_b = (_a = statement.importClause) == null ? void 0 : _a.name) == null ? void 0 : _b.escapedText) === "Component";
+    }
+    function isExportInputTypeAsComponentInput(statement) {
+      return ts.isTypeAliasDeclaration(statement) && statement.name.escapedText === "Input" && ts.isIndexedAccessTypeNode(statement.type) && ts.isTypeReferenceNode(statement.type.objectType) && ts.isIdentifier(statement.type.objectType.typeName) && statement.type.objectType.typeName.escapedText === "Component" && ts.isLiteralTypeNode(statement.type.indexType) && ts.isStringLiteral(statement.type.indexType.literal) && statement.type.indexType.literal.text === "input";
+    }
+    function isExportEmptyInputType(statement) {
+      return ts.isTypeAliasDeclaration(statement) && statement.name.escapedText === "Input" && ts.isTypeLiteralNode(statement.type) && !statement.typeParameters && statement.type.members.length === 0 || ts.isInterfaceDeclaration(statement) && statement.name.escapedText === "Input" && !statement.typeParameters && statement.members.length === 0;
+    }
+    function isExportComponentType(statement) {
+      return ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause) && statement.exportClause.elements.length === 1 && statement.exportClause.elements[0].name.escapedText === "Component";
+    }
+    function isVariableStatementForName(statement, name) {
+      if (ts.isVariableStatement(statement)) {
+        for (const decl of statement.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.name.escapedText === name) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+};
+function castType(type) {
+  if (type === "any") {
+    return "1 as any";
+  }
+  return `(1 as any as ${type})`;
+}
+
+// src/processors/index.ts
+var extensions = [marko_default.extension];
+function create(options) {
+  return {
+    [marko_default.extension]: marko_default.create(options)
+  };
+}
+function has(fileName) {
+  const ext = getExt(fileName);
+  return !!(ext && extensions.includes(ext));
+}
+
+// src/util/is-definition-file.ts
+function isDefinitionFile(fileName) {
+  return /\.d\.[^.]+$/.test(fileName);
+}
 export {
   NodeType,
+  processors_exports as Processors,
+  project_exports as Project,
   ScriptLang,
   UNFINISHED,
   extractScript,
   extractStyle,
+  getExt,
   getLines,
   getLocation,
   getPosition,
+  isDefinitionFile,
   parse
 };

package/dist/processors/index.d.ts

@@ -0,0 +1,36 @@
+import type ts from "typescript/lib/tsserverlibrary";
+import { Extracted } from "../util/extractor";
+export type ProcessorExtension = `.${string}`;
+export interface ProcessorConfig {
+    extension: ProcessorExtension;
+    create(options: CreateProcessorOptions): Processor;
+}
+export interface CreateProcessorOptions {
+    ts: typeof ts;
+    host: ts.ModuleResolutionHost;
+    configFile: string | undefined;
+}
+export interface Processor {
+    getRootNames?(): string[];
+    getScriptExtension(fileName: string): ts.Extension;
+    getScriptKind(fileName: string): ts.ScriptKind;
+    extract(fileName: string, code: string): Extracted;
+    print(context: PrintContext): {
+        code: string;
+        map?: any;
+    };
+    printTypes(context: PrintContext): {
+        code: string;
+        map?: any;
+    };
+}
+export interface PrintContext {
+    extracted: Extracted;
+    printer: ts.Printer;
+    sourceFile: ts.SourceFile;
+    typeChecker: ts.TypeChecker;
+    formatSettings: Required<ts.FormatCodeSettings>;
+}
+export declare const extensions: `.${string}`[];
+export declare function create(options: Parameters<ProcessorConfig["create"]>[0]): Record<`.${string}`, Processor>;
+export declare function has(fileName: string): boolean;

package/dist/processors/marko.d.ts

@@ -0,0 +1,18 @@
+import type ts from "typescript/lib/tsserverlibrary";
+declare const _default: {
+    extension: ".marko";
+    create({ ts, host, configFile }: import(".").CreateProcessorOptions): {
+        getRootNames(): string[];
+        getScriptExtension(fileName: string): ts.Extension.Ts | ts.Extension.Js;
+        getScriptKind(fileName: string): ts.ScriptKind.JS | ts.ScriptKind.TS;
+        extract(fileName: string, code: string): import("..").Extracted;
+        print({ extracted: { parsed } }: import(".").PrintContext): {
+            code: string;
+            map: import("magic-string").SourceMap;
+        };
+        printTypes({ printer, typeChecker, sourceFile, formatSettings }: import(".").PrintContext): {
+            code: string;
+        };
+    };
+};
+export default _default;

package/dist/util/extractor.d.ts

@@ -16,6 +16,7 @@ export declare class Extractor {
 }
 export declare class Extracted {
     #private;
+    parsed: Parsed;
     constructor(parsed: Parsed, generated: string, tokens: Token[]);
     sourceOffsetAt(generatedOffset: number): number | undefined;
     sourcePositionAt(generatedOffset: number): Position | undefined;

package/dist/util/get-ext.d.ts

@@ -0,0 +1 @@
+export declare function getExt(fileName: string): `.${string}` | undefined;

package/dist/util/is-definition-file.d.ts

@@ -0,0 +1 @@
+export declare function isDefinitionFile(fileName: string): boolean;

package/dist/util/project.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+import type TS from "typescript/lib/tsserverlibrary";
+import type { TaglibLookup } from "@marko/babel-utils";
+import * as defaultCompiler from "@marko/compiler";
+import { ScriptLang } from "../extractors/script";
+export interface Meta {
+    compiler: typeof defaultCompiler;
+    config: Omit<defaultCompiler.Config, "cache" | "translator"> & {
+        cache: Map<any, any>;
+        translator: {
+            runtimeTypes?: string;
+            [x: string]: unknown;
+        };
+    };
+}
+interface TypeLibs {
+    internalTypesFile: string | undefined;
+    markoRunTypesFile: string | undefined;
+    markoRunGeneratedTypesFile: string | undefined;
+    markoTypesFile: string | undefined;
+    markoTypesCode: string | undefined;
+}
+declare const defaultTypeLibs: Partial<TypeLibs>;
+export declare function getCompiler(dir?: string): typeof defaultCompiler;
+export declare function getCache(dir?: string): Map<any, any>;
+export declare function getConfig(dir?: string): Omit<{
+    output?: "source" | "html" | "dom" | "hydrate" | "migrate" | undefined;
+    stripTypes?: boolean | undefined;
+    runtimeId?: string | null | undefined;
+    ast?: boolean | undefined;
+    code?: boolean | undefined;
+    writeVersionComment?: boolean | undefined;
+    ignoreUnrecognizedTags?: boolean | undefined;
+    sourceMaps?: boolean | "inline" | "both" | undefined;
+    translator?: any;
+    fileSystem?: typeof import("fs") | undefined;
+    modules?: "esm" | "cjs" | undefined;
+    resolveVirtualDependency?: ((filename: string, dep: {
+        virtualPath: string;
+        code: string;
+        map?: any;
+    }) => string) | null | undefined;
+    hydrateIncludeImports?: RegExp | ((request: string) => boolean) | undefined;
+    optimize?: boolean | undefined;
+    cache?: Map<unknown, unknown> | undefined;
+    hot?: boolean | undefined;
+    meta?: boolean | undefined;
+    babelConfig?: {
+        [x: string]: unknown;
+        ast?: boolean | null | undefined;
+        code?: boolean | null | undefined;
+        comments?: boolean | null | undefined;
+        compact?: boolean | "auto" | null | undefined;
+        caller?: {
+            [x: string]: unknown;
+            name?: string | undefined;
+        } | undefined;
+        minified?: boolean | null | undefined;
+    } | undefined;
+}, "cache" | "translator"> & {
+    cache: Map<any, any>;
+    translator: {
+        [x: string]: unknown;
+        runtimeTypes?: string | undefined;
+    };
+};
+export declare function getTagLookup(dir: string): TaglibLookup;
+export declare function getTypeLibs(rootDir: string, ts: typeof TS, host: TS.ModuleResolutionHost): {
+    internalTypesFile: string;
+    markoRunTypesFile: string | undefined;
+    markoRunGeneratedTypesFile: string | undefined;
+    markoTypesFile: string;
+    markoTypesCode: string;
+};
+export declare function getScriptLang(fileName: string, defaultScriptLang: ScriptLang, ts: typeof TS, host: TS.ModuleResolutionHost): ScriptLang;
+export declare function clearCaches(): void;
+export declare function setDefaultTypePaths(defaults: typeof defaultTypeLibs): void;
+export {};

package/package.json

@@ -1,23 +1,25 @@
 {
   "name": "@marko/language-tools",
   "description": "Marko Language Tools",
-  "version": "1.0.3",
+  "version": "2.0.1",
   "bugs": "https://github.com/marko-js/language-server/issues/new?template=Bug_report.md",
   "dependencies": {
     "@babel/helper-validator-identifier": "^7.19.1",
-    "@babel/parser": "^7.21.3",
+    "@babel/parser": "^7.21.4",
+    "@marko/compiler": "5.27.4",
+    "@marko/translator-default": "5.25.4",
     "htmljs-parser": "^5.4.3",
     "relative-import-path": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/code-frame": "^7.18.6",
-    "@marko/compiler": "^5.27.1",
+    "@babel/code-frame": "^7.21.4",
+    "@marko/compiler": "^5.27.4",
     "@types/babel__code-frame": "^7.0.3",
     "@types/babel__helper-validator-identifier": "^7.15.0",
     "@typescript/vfs": "^1.4.0",
-    "marko": "^5.25.1",
+    "marko": "^5.25.4",
     "mitata": "^0.1.6",
-    "tsx": "^3.12.5"
+    "tsx": "^3.12.6"
   },
   "exports": {
     ".": {