marko 6.0.121 → 6.0.123

package/dist/translator/index.js

@@ -30,14 +30,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/translator/index.ts
 var index_exports = {};
 __export(index_exports, {
-  analyze: () => analyze,
-  getRuntimeEntryFiles: () => getRuntimeEntryFiles,
+  analyze: () => analyze2,
+  createInteropTranslator: () => createInteropTranslator,
+  getRuntimeEntryFiles: () => getRuntimeEntryFiles2,
   internalEntryBuilder: () => entry_builder_default,
   preferAPI: () => preferAPI,
-  tagDiscoveryDirs: () => tagDiscoveryDirs,
-  taglibs: () => taglibs,
-  transform: () => transform,
-  translate: () => translate
+  tagDiscoveryDirs: () => tagDiscoveryDirs2,
+  taglibs: () => taglibs2,
+  transform: () => transform2,
+  translate: () => translate2
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -747,22 +748,22 @@ function getAttributeTagParent(tag) {
 }
 
 // src/translator/util/get-root.ts
-function getMarkoRoot(path5) {
-  let curPath = path5;
+function getMarkoRoot(path7) {
+  let curPath = path7;
   do
     curPath = curPath.parentPath;
   while (curPath && !isMarko(curPath));
   return curPath;
 }
-function getExprRoot(path5) {
-  let curPath = path5;
+function getExprRoot(path7) {
+  let curPath = path7;
   while (!isMarko(curPath.parentPath)) {
     curPath = curPath.parentPath;
   }
   return curPath;
 }
-function getFnRoot(path5) {
-  let curPath = path5;
+function getFnRoot(path7) {
+  let curPath = path7;
   let fnPath;
   while (!isMarko(curPath)) {
     if (isFunction(curPath)) {
@@ -785,8 +786,8 @@ function getFnRoot(path5) {
   }
   return fnPath;
 }
-function getFnParent(path5) {
-  let curPath = path5;
+function getFnParent(path7) {
+  let curPath = path7;
   while (!isMarko(curPath)) {
     if (isFunction(curPath)) {
       return curPath;
@@ -799,8 +800,8 @@ function getFnParent(path5) {
     }
   }
 }
-function getDeclarationRoot(path5) {
-  let curPath = path5;
+function getDeclarationRoot(path7) {
+  let curPath = path7;
   let declPath;
   while (!isMarko(curPath)) {
     if (isFunctionOrVariableDeclaration(curPath)) {
@@ -815,8 +816,8 @@ function getDeclarationRoot(path5) {
   }
   return declPath;
 }
-function isMarko(path5) {
-  switch (path5.type) {
+function isMarko(path7) {
+  switch (path7.type) {
     case "MarkoTag":
     case "MarkoTagBody":
     case "MarkoAttribute":
@@ -830,10 +831,10 @@ function isMarko(path5) {
       return false;
   }
 }
-function isFunction(path5) {
-  switch (path5.type) {
+function isFunction(path7) {
+  switch (path7.type) {
     case "FunctionDeclaration":
-      return !path5.node.declare;
+      return !path7.node.declare;
     case "FunctionExpression":
     case "ArrowFunctionExpression":
     case "ObjectMethod":
@@ -842,10 +843,10 @@ function isFunction(path5) {
       return false;
   }
 }
-function isFunctionOrVariableDeclaration(path5) {
-  switch (path5.type) {
+function isFunctionOrVariableDeclaration(path7) {
+  switch (path7.type) {
     case "FunctionDeclaration":
-      return !path5.node.declare;
+      return !path7.node.declare;
     case "VariableDeclaration":
       return true;
     default:
@@ -873,14 +874,12 @@ function getTagName(tag) {
 // src/translator/util/is-core-tag.ts
 var { taglibId } = runtime_info_default;
 var htmlTaglibId = "marko-html";
-var interopTaglibId = "@marko/translator-interop-class-tags";
 function isCoreTag(tag) {
   if (tag.isMarkoTag()) {
     const tagDef = (0, import_babel_utils6.getTagDef)(tag);
     if (tagDef) {
       switch (tagDef.taglibId) {
         case taglibId:
-        case interopTaglibId:
           return true;
         case htmlTaglibId:
           switch (tagDef.name) {
@@ -1635,37 +1634,37 @@ function analyzeTagNameType(tag, allowDynamic) {
 }
 function analyzeExpressionTagName(name2, extra) {
   const pending = [name2];
-  let path5;
+  let path7;
   let type;
   let nullable = false;
   let tagNameImported;
-  while ((path5 = pending.pop()) && type !== 2 /* DynamicTag */) {
-    if (path5.isConditionalExpression()) {
-      pending.push(path5.get("consequent"));
-      if (path5.node.alternate) {
-        pending.push(path5.get("alternate"));
-      }
-    } else if (path5.isLogicalExpression()) {
-      if (path5.node.operator === "||") {
-        pending.push(path5.get("left"));
+  while ((path7 = pending.pop()) && type !== 2 /* DynamicTag */) {
+    if (path7.isConditionalExpression()) {
+      pending.push(path7.get("consequent"));
+      if (path7.node.alternate) {
+        pending.push(path7.get("alternate"));
+      }
+    } else if (path7.isLogicalExpression()) {
+      if (path7.node.operator === "||") {
+        pending.push(path7.get("left"));
       } else {
         nullable = true;
       }
-      pending.push(path5.get("right"));
-    } else if (path5.isAssignmentExpression()) {
-      pending.push(path5.get("right"));
-    } else if (path5.isBinaryExpression()) {
-      type = path5.node.operator !== "+" || type === void 0 || type === 0 /* NativeTag */ ? 0 /* NativeTag */ : 2 /* DynamicTag */;
-    } else if (path5.isStringLiteral() || path5.isTemplateLiteral()) {
+      pending.push(path7.get("right"));
+    } else if (path7.isAssignmentExpression()) {
+      pending.push(path7.get("right"));
+    } else if (path7.isBinaryExpression()) {
+      type = path7.node.operator !== "+" || type === void 0 || type === 0 /* NativeTag */ ? 0 /* NativeTag */ : 2 /* DynamicTag */;
+    } else if (path7.isStringLiteral() || path7.isTemplateLiteral()) {
       type = type === void 0 || type === 0 /* NativeTag */ ? 0 /* NativeTag */ : 2 /* DynamicTag */;
-    } else if (path5.isNullLiteral()) {
+    } else if (path7.isNullLiteral()) {
       nullable = true;
-    } else if (path5.isIdentifier()) {
-      if (path5.node.name === "undefined") {
+    } else if (path7.isIdentifier()) {
+      if (path7.node.name === "undefined") {
         nullable = true;
         continue;
       }
-      const binding = path5.scope.getBinding(path5.node.name);
+      const binding = path7.scope.getBinding(path7.node.name);
       if (!binding) {
         type = 2 /* DynamicTag */;
         continue;
@@ -1719,16 +1718,16 @@ function analyzeExpressionTagName(name2, extra) {
 var sectionUtil = new Sorted(function compareSections(a, b) {
   return a.id - b.id;
 });
-function startSection(path5) {
-  const extra = path5.node.extra ??= {};
+function startSection(path7) {
+  const extra = path7.node.extra ??= {};
   let section = extra.section;
-  if (!section && (path5.type === "Program" || path5.get("body").length)) {
-    const parentTag = path5.parentPath?.isMarkoTag() ? path5.parentPath : void 0;
-    const parentSection = path5.parentPath ? getOrCreateSection(path5.parentPath) : void 0;
+  if (!section && (path7.type === "Program" || path7.get("body").length)) {
+    const parentTag = path7.parentPath?.isMarkoTag() ? path7.parentPath : void 0;
+    const parentSection = path7.parentPath ? getOrCreateSection(path7.parentPath) : void 0;
     const sectionName = parentTag ? generateUid(
       (isCoreTagName(parentTag, "define") && import_compiler7.types.isIdentifier(parentTag.node.var) ? parentTag.node.var.name : parentTag.get("name").toString()) + "_content"
     ) : "";
-    const programExtra = path5.hub.file.path.node.extra ??= {};
+    const programExtra = path7.hub.file.path.node.extra ??= {};
     const sections = programExtra.sections ??= [];
     section = extra.section = {
       id: sections.length,
@@ -1750,7 +1749,7 @@ function startSection(path5) {
       serializeReasons: /* @__PURE__ */ new Map(),
       paramReasonGroups: void 0,
       returnSerializeReason: void 0,
-      content: getContentInfo(path5),
+      content: getContentInfo(path7),
       upstreamExpression: void 0,
       downstreamBinding: void 0,
       hasAbortSignal: false,
@@ -1760,11 +1759,11 @@ function startSection(path5) {
   }
   return section;
 }
-function getOrCreateSection(path5) {
-  let cur = path5;
+function getOrCreateSection(path7) {
+  let cur = path7;
   while (true) {
     if (cur.type === "Program" || cur.type === "MarkoTagBody" && !cur.node.attributeTags && !isNativeNode(cur.parentPath)) {
-      return (path5.node.extra ??= {}).section = startSection(cur);
+      return (path7.node.extra ??= {}).section = startSection(cur);
     }
     cur = cur.parentPath;
   }
@@ -1772,9 +1771,9 @@ function getOrCreateSection(path5) {
 function getSectionForBody(body) {
   return body.node.extra?.section;
 }
-function getSection(path5) {
+function getSection(path7) {
   let section;
-  let currentPath = path5;
+  let currentPath = path7;
   while ((section = currentPath.node.extra?.section) === void 0) {
     currentPath = currentPath.parentPath;
   }
@@ -1800,8 +1799,8 @@ function forEachSectionReverse(fn) {
     fn(sections[i]);
   }
 }
-function getContentInfo(path5) {
-  const body = path5.get("body");
+function getContentInfo(path7) {
+  const body = path7.get("body");
   const contentInfo = {
     startType: null,
     endType: null,
@@ -1828,8 +1827,8 @@ function getContentInfo(path5) {
   }
   return null;
 }
-function getNodeContentType(path5, extraMember, contentInfo) {
-  switch (path5.type) {
+function getNodeContentType(path7, extraMember, contentInfo) {
+  switch (path7.type) {
     case "MarkoText":
       return 4 /* Text */;
     case "MarkoPlaceholder":
@@ -1842,7 +1841,7 @@ function getNodeContentType(path5, extraMember, contentInfo) {
     case "ExportDefaultDeclaration":
       return null;
     case "MarkoTag": {
-      const tag = path5;
+      const tag = path7;
       if (isCoreTag(tag)) {
         switch (tag.node.name.value) {
           case "html-comment":
@@ -2064,8 +2063,8 @@ function canIgnoreRegister(markoRoot, exprRoot) {
     /^on[A-Z-]/.test(markoRoot.node.name) || isCoreTagName(markoRoot.parentPath, "script") || isCoreTagName(markoRoot.parentPath, "lifecycle") || isCoreTagName(markoRoot.parentPath, "for"))
   );
 }
-function getStaticDeclRefs(fnExtra, path5, refs = /* @__PURE__ */ new Set()) {
-  const decl = getDeclarationRoot(path5);
+function getStaticDeclRefs(fnExtra, path7, refs = /* @__PURE__ */ new Set()) {
+  const decl = getDeclarationRoot(path7);
   if (decl) {
     const ids = decl.getOuterBindingIdentifiers();
     if (ids) {
@@ -2132,13 +2131,13 @@ function registerFunction(fnExtra, reason) {
     `${fnExtra.section.id}/${fnExtra.name.slice(1)}`
   );
 }
-function isMarkoAttribute(path5) {
-  return path5 ? path5.isMarkoAttribute() : false;
+function isMarkoAttribute(path7) {
+  return path7 ? path7.isMarkoAttribute() : false;
 }
-function isStaticRoot(path5) {
-  switch (path5.type) {
+function isStaticRoot(path7) {
+  switch (path7.type) {
     case "MarkoScriptlet":
-      return path5.node.static;
+      return path7.node.static;
     case "ExportDefaultDeclaration":
     case "ExportNamedDeclaration":
       return true;
@@ -2663,29 +2662,29 @@ var import_babel_utils14 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/plugin-hooks.ts
 var import_compiler12 = require("@marko/compiler");
-function enter(modulePlugin, path5) {
+function enter(modulePlugin, path7) {
   if (!modulePlugin) {
     return false;
   }
-  const { node } = path5;
+  const { node } = path7;
   const plugin = isModulePlugin(modulePlugin) ? modulePlugin.default : modulePlugin;
   if (isFunctionPlugin(plugin)) {
-    plugin(path5, import_compiler12.types);
+    plugin(path7, import_compiler12.types);
   } else if (plugin.enter) {
-    plugin.enter(path5, import_compiler12.types);
+    plugin.enter(path7, import_compiler12.types);
   }
-  return node !== path5.node;
+  return node !== path7.node;
 }
-function exit(modulePlugin, path5) {
+function exit(modulePlugin, path7) {
   if (!modulePlugin) {
     return false;
   }
-  const { node } = path5;
+  const { node } = path7;
   const plugin = isModulePlugin(modulePlugin) ? modulePlugin.default : modulePlugin;
   if (!isFunctionPlugin(plugin) && plugin.exit) {
-    plugin.exit(path5, import_compiler12.types);
+    plugin.exit(path7, import_compiler12.types);
   }
-  return node !== path5.node;
+  return node !== path7.node;
 }
 function isModulePlugin(plugin) {
   return Boolean(plugin.default);
@@ -2717,11 +2716,11 @@ function translateByTarget({
   dom
 }) {
   return {
-    enter(path5) {
-      enter(isOutputHTML() ? html : dom, path5);
+    enter(path7) {
+      enter(isOutputHTML() ? html : dom, path7);
     },
-    exit(path5) {
-      exit(isOutputHTML() ? html : dom, path5);
+    exit(path7) {
+      exit(isOutputHTML() ? html : dom, path7);
     }
   };
 }
@@ -2896,16 +2895,16 @@ var walkCodeToName = {
   [116 /* OutEnd */]: "outEnd",
   [126 /* MultiplierEnd */]: "multiplierEnd"
 };
-function enter2(path5) {
-  const steps = getSteps(getSection(path5));
+function enter2(path7) {
+  const steps = getSteps(getSection(path7));
   steps.push(0 /* Enter */);
 }
-function exit2(path5) {
-  const steps = getSteps(getSection(path5));
+function exit2(path7) {
+  const steps = getSteps(getSection(path7));
   steps.push(1 /* Exit */);
 }
-function enterShallow(path5) {
-  const section = getSection(path5);
+function enterShallow(path7) {
+  const section = getSection(path7);
   const steps = getSteps(section);
   steps.push(0 /* Enter */, 1 /* Exit */);
 }
@@ -2926,16 +2925,16 @@ function injectWalks(tag, name2, expr) {
   }
   walks.push(String.fromCharCode(38 /* EndChild */));
 }
-function visit(path5, code) {
+function visit(path7, code) {
   if (isOutputHTML()) {
     return;
   }
-  const section = getSection(path5);
+  const section = getSection(path7);
   const walks = getWalks(section);
   const walkComment = getWalkComment(section);
   visitInternal(section);
   if (code !== 32 /* Get */) {
-    writeTo(path5)`<!>`;
+    writeTo(path7)`<!>`;
   }
   walkComment.push(`${walkCodeToName[code]}`);
   appendLiteral(walks, String.fromCharCode(code));
@@ -3029,8 +3028,8 @@ var [getTrailerWrites] = createSectionState(
   "trailerWrites",
   () => [""]
 );
-function writeTo(path5, trailer) {
-  const section = getSection(path5);
+function writeTo(path7, trailer) {
+  const section = getSection(path7);
   const get = trailer ? getTrailerWrites : getWrites;
   return (strs, ...exprs) => {
     const exprsLen = exprs.length;
@@ -3041,8 +3040,8 @@ function writeTo(path5, trailer) {
     }
   };
 }
-function consumeHTML(path5) {
-  const section = getSection(path5);
+function consumeHTML(path7) {
+  const section = getSection(path7);
   const writes = getWrites(section);
   const trailers = getTrailerWrites(section);
   const writeResult = normalizeStringExpression(writes.map(unwrapWrite));
@@ -3064,14 +3063,14 @@ function consumeHTML(path5) {
     return import_compiler16.types.expressionStatement(callRuntime("_trailers", trailerResult));
   }
 }
-function flushBefore(path5) {
-  const expr = consumeHTML(path5);
+function flushBefore(path7) {
+  const expr = consumeHTML(path7);
   if (expr) {
-    path5.insertBefore(expr)[0].skip();
+    path7.insertBefore(expr)[0].skip();
   }
 }
-function flushInto(path5) {
-  const target = path5.isProgram() ? path5 : path5.get("body");
+function flushInto(path7) {
+  const target = path7.isProgram() ? path7 : path7.get("body");
   const expr = consumeHTML(target);
   if (expr) {
     target.node.body.push(expr);
@@ -3116,16 +3115,16 @@ function getSectionMetaIdentifiers(section) {
   }
   return meta;
 }
-function markNode(path5, nodeBinding, reason) {
+function markNode(path7, nodeBinding, reason) {
   if (nodeBinding.type !== 0 /* dom */) {
-    throw path5.buildCodeFrameError(
+    throw path7.buildCodeFrameError(
       "POTENTIAL MARKO BUG: Tried to mark a node that was not determined to need a mark during analyze."
     );
   }
   if (isOutputHTML()) {
     if (reason) {
-      const section = getSection(path5);
-      writeTo(path5)`${callRuntime(
+      const section = getSection(path7);
+      writeTo(path7)`${callRuntime(
         "_el_resume",
         getScopeIdIdentifier(section),
         getScopeAccessorLiteral(nodeBinding),
@@ -4021,10 +4020,10 @@ function toReturnedFunction(rawFn) {
 function addHTMLEffectCall(section, referencedBindings) {
   addStatement("effect", section, referencedBindings, void 0, false);
 }
-function writeHTMLResumeStatements(path5) {
-  const section = getSectionForBody(path5);
+function writeHTMLResumeStatements(path7) {
+  const section = getSectionForBody(path7);
   if (!section) return;
-  const body = path5.node.body;
+  const body = path7.node.body;
   const allSignals = Array.from(getSignals(section).values());
   const scopeIdIdentifier = getScopeIdIdentifier(section);
   forEach(section.referencedClosures, (closure) => {
@@ -4174,7 +4173,7 @@ function writeHTMLResumeStatements(path5) {
     ];
     if (debug) {
       writeScopeArgs.push(
-        import_compiler22.types.stringLiteral(path5.hub.file.opts.filenameRelative),
+        import_compiler22.types.stringLiteral(path7.hub.file.opts.filenameRelative),
         section.loc && section.loc.start.line != null ? import_compiler22.types.stringLiteral(
           `${section.loc.start.line}:${section.loc.start.column + 1}`
         ) : import_compiler22.types.numericLiteral(0)
@@ -4587,8 +4586,8 @@ var dom_default = {
 var import_compiler24 = require("@marko/compiler");
 
 // src/translator/util/is-static.ts
-function isStatic(path5) {
-  return path5.isImportDeclaration() || path5.isExportDeclaration() || path5.isMarkoScriptlet({ static: true });
+function isStatic(path7) {
+  return path7.isImportDeclaration() || path7.isExportDeclaration() || path7.isMarkoScriptlet({ static: true });
 }
 
 // src/translator/visitors/program/html.ts
@@ -5052,8 +5051,8 @@ function getChangeHandlerFromObjectPattern(parent) {
   }
   return changeKey;
 }
-function getStringOrIdentifierValue(path5) {
-  return getLiteralName(path5.node);
+function getStringOrIdentifierValue(path7) {
+  return getLiteralName(path7.node);
 }
 function getLiteralName(node) {
   switch (node.type) {
@@ -8385,8 +8384,8 @@ function trackAssignment(assignment, binding) {
     }
   });
 }
-function setReferencesScope(path5) {
-  const fnRoot = getFnRoot(path5);
+function setReferencesScope(path7) {
+  const fnRoot = getFnRoot(path7);
   if (fnRoot) {
     (fnRoot.node.extra ??= {}).referencesScope = true;
   }
@@ -11521,15 +11520,15 @@ function isStaticText(node) {
     }
   }
 }
-function getPrev(path5) {
-  let prev = path5.getPrevSibling();
+function getPrev(path7) {
+  let prev = path7.getPrevSibling();
   while (prev.node && (prev.isMarkoComment() || prev.isMarkoPlaceholder() && isEmptyPlaceholder(prev.node))) {
     prev = prev.getPrevSibling();
   }
   return prev.node;
 }
-function getNext(path5) {
-  let next = path5.getNextSibling();
+function getNext(path7) {
+  let next = path7.getNextSibling();
   while (next.node && (next.isMarkoComment() || next.isMarkoPlaceholder() && isEmptyPlaceholder(next.node))) {
     next = next.getNextSibling();
   }
@@ -12338,6 +12337,510 @@ var text_default = {
   }
 };
 
+// src/translator/interop/index.ts
+var import_generator = __toESM(require("@babel/generator"));
+var import_compiler65 = require("@marko/compiler");
+var import_babel_utils53 = require("@marko/compiler/babel-utils");
+var translate6 = __toESM(require("@marko/runtime-tags/translator"));
+var import_path6 = __toESM(require("path"));
+
+// src/translator/interop/feature-detection.ts
+var import_babel_utils52 = require("@marko/compiler/babel-utils");
+
+// src/translator/interop/build-aggregate-error.ts
+var import_code_frame = require("@babel/code-frame");
+var import_path5 = __toESM(require("path"));
+var CWD = process.cwd();
+function buildAggregateError(file, rootMsg, ...paths) {
+  const err = new SyntaxError();
+  const fileName = import_path5.default.relative(CWD, file.opts.filename);
+  const finalMsg = `${rootMsg}:
+
+${paths.map(
+    ([msg, path7]) => `\x1B[90m${msg} at ${getFileNameWithLoc(
+      fileName,
+      path7
+    )}:\x1B[0m
+${getFrame(file, path7)}`
+  ).join("\n\n")}`;
+  if (!("MARKO_DEBUG" in process.env)) {
+    err.stack = finalMsg;
+  }
+  Object.defineProperty(err, "message", {
+    get() {
+      return finalMsg;
+    },
+    set() {
+    }
+  });
+  return err;
+}
+function getFrame(file, { node: { loc } }) {
+  return loc ? (0, import_code_frame.codeFrameColumns)(
+    file.code,
+    {
+      start: {
+        line: loc.start.line,
+        column: loc.start.column + 1
+      },
+      end: loc.end && loc.start.line === loc.end.line ? {
+        line: loc.end.line,
+        column: loc.end.column + 1
+      } : void 0
+    },
+    { highlightCode: true }
+  ) : "";
+}
+function getFileNameWithLoc(fileName, { node: { loc } }) {
+  if (loc) {
+    return `${fileName}(${loc.start.line},${loc.start.column + 1})`;
+  }
+  return fileName;
+}
+
+// src/translator/interop/feature-detection.ts
+function isTagsAPI(file = (0, import_babel_utils52.getFile)()) {
+  const program = file.path;
+  const programExtra = program.node.extra ??= {};
+  let { featureType } = programExtra;
+  if (!featureType) {
+    const lookup = (0, import_babel_utils52.getTaglibLookup)(file);
+    const tagsDir = getTagsDir(file.opts.filename);
+    const state = {};
+    if (tagsDir && !lookup.manualTagsDirs?.has(tagsDir)) {
+      addFeature(
+        state,
+        "tags" /* Tags */,
+        "Template file within a tags directory",
+        program
+      );
+    }
+    scanBody(state, program.get("body"));
+    featureType = file.metadata.marko.api = programExtra.featureType = state.feature?.type || (lookup.exclusiveTagDiscoveryDirs === "tags" ? "tags" /* Tags */ : "class" /* Class */);
+  }
+  return featureType === "tags" /* Tags */;
+}
+function getTagsDir(filename) {
+  const pathSeparator = /\/|\\/.exec(filename)?.[0];
+  if (pathSeparator) {
+    let previousIndex = filename.length - 1;
+    while (previousIndex > 0) {
+      const index = filename.lastIndexOf(pathSeparator, previousIndex);
+      switch (previousIndex - index) {
+        case 4: {
+          if (filename.startsWith("tags", index + 1)) {
+            return filename.slice(0, index + 5);
+          }
+          break;
+        }
+        case 10: {
+          if (filename.startsWith("components", index + 1)) {
+            return false;
+          }
+          break;
+        }
+      }
+      previousIndex = index - 1;
+    }
+  }
+  return false;
+}
+function scanBody(state, body) {
+  if (body?.length) {
+    for (const child of body) {
+      switch (child.type) {
+        case "MarkoTag":
+          scanTag(state, child);
+          break;
+        case "MarkoComment":
+          if (/^\s*use tags\s*$/.test(child.node.value)) {
+            addFeature(state, "tags" /* Tags */, "<!-- use tags -->", child);
+          } else if (/^\s*use class\s*$/.test(child.node.value)) {
+            addFeature(state, "class" /* Class */, "<!-- use class -->", child);
+          }
+          break;
+        case "MarkoScriptlet":
+          if (!child.node.static) {
+            addFeature(state, "class" /* Class */, "Scriptlet", child);
+          }
+          break;
+        case "MarkoClass":
+          addFeature(
+            state,
+            "class" /* Class */,
+            "Class block",
+            child.get("body")
+          );
+          break;
+      }
+    }
+  }
+}
+function scanTag(state, tag) {
+  if (tag.node.var) {
+    addFeature(
+      state,
+      "tags" /* Tags */,
+      "Tag variable",
+      tag.get("var")
+    );
+  }
+  const tagDef = (0, import_babel_utils52.getTagDef)(tag);
+  if (tagDef) {
+    if (tagDef.name === "style") {
+      if (/^style(?:(?:\.[^.\s\\/:*?"<>|({]+)+)?\s*\{/.test(
+        tag.node.rawValue || ""
+      )) {
+        addFeature(state, "class" /* Class */, `style block`, tag.get("name"));
+      }
+    } else if (tagDef.taglibId === runtime_info_default.taglibId) {
+      const feature = getFeatureTypeFromCoreTagName(tagDef.name);
+      if (feature) {
+        addFeature(state, feature, `<${tagDef.name}> tag`, tag.get("name"));
+      }
+    }
+  }
+  if (!tagDef?.parseOptions?.rawOpenTag) {
+    for (const attr of tag.get("attributes")) {
+      if (attr.isMarkoAttribute()) {
+        if (attr.node.arguments?.length) {
+          addFeature(
+            state,
+            "class" /* Class */,
+            "Attribute arguments",
+            attr.get("arguments")[0]
+          );
+          break;
+        } else if (attr.node.modifier) {
+          addFeature(state, "class" /* Class */, "Attribute modifier", attr);
+          break;
+        } else if (attr.node.bound) {
+          addFeature(state, "tags" /* Tags */, "Bound attribute", attr);
+          break;
+        }
+      }
+    }
+  }
+  scanBody(state, tag.get("body").get("body"));
+  scanBody(state, tag.get("attributeTags"));
+}
+function getFeatureTypeFromCoreTagName(tagName) {
+  switch (tagName) {
+    case "await-reorderer":
+    case "class":
+    case "include-html":
+    case "include-text":
+    case "init-components":
+    case "macro":
+    case "module-code":
+    case "while":
+      return "class" /* Class */;
+    case "const":
+    case "debug":
+    case "define":
+    case "id":
+    case "let":
+    case "lifecycle":
+    case "log":
+    case "return":
+    case "try":
+      return "tags" /* Tags */;
+    default:
+      return void 0;
+  }
+}
+function addFeature(state, type, name2, path7) {
+  if (state.feature) {
+    if (state.feature.type !== type) {
+      throw buildAggregateError(
+        path7.hub.file,
+        "Cannot mix Tags API and Class API features in the same file",
+        [state.feature.name, state.feature.path],
+        [name2, path7]
+      );
+    }
+  } else {
+    state.feature = {
+      name: name2,
+      path: path7,
+      type
+    };
+  }
+}
+
+// src/translator/interop/index.ts
+function createInteropTranslator(translate5) {
+  return {
+    preferAPI: translate5.preferAPI,
+    transform: mergeVisitors(translate5.transform, translate6.transform),
+    analyze: mergeVisitors(translate5.analyze, translate6.analyze),
+    translate: patchTranslateProgram(
+      mergeVisitors(translate5.translate, translate6.translate)
+    ),
+    tagDiscoveryDirs: [
+      ...translate6.tagDiscoveryDirs,
+      ...translate5.tagDiscoveryDirs
+    ],
+    taglibs: mergeTaglibs(
+      import_compiler65.taglib.resolveOptionalTaglibs(translate5.optionalTaglibs).concat(translate5.taglibs),
+      translate6.taglibs
+    ),
+    getRuntimeEntryFiles(output, optimize) {
+      return [
+        ...translate5.getRuntimeEntryFiles(output, optimize),
+        ...translate6.getRuntimeEntryFiles(output, optimize)
+      ];
+    }
+  };
+  function patchTranslateProgram(visitor) {
+    const { Program } = visitor;
+    const kState2 = Symbol();
+    const entryBuilder = {
+      build(entryFile) {
+        const state = entryFile[kState2];
+        if (!state) {
+          throw entryFile.path.buildCodeFrameError(
+            "Unable to build hydrate code, no files were visited before finalizing the build"
+          );
+        }
+        if (state.has5) {
+          if (state.has6) {
+            const filename = entryFile.opts.filename;
+            const baseName = `./${import_path6.default.basename(filename)}`;
+            const generatorOpts = {
+              ...entryFile.opts.generatorOpts,
+              sourceMaps: false
+            };
+            const { resolveVirtualDependency } = entryFile.markoOpts;
+            const importHydrateProgram = (name2, statements) => {
+              return import_compiler65.types.importDeclaration(
+                [import_compiler65.types.importDefaultSpecifier(import_compiler65.types.identifier(`init${name2}`))],
+                import_compiler65.types.stringLiteral(
+                  resolveVirtualDependency(filename, {
+                    code: (0, import_generator.default)(import_compiler65.types.program(statements), generatorOpts).code,
+                    virtualPath: `${baseName}.hydrate-${name2}.js`
+                  })
+                )
+              );
+            };
+            return [
+              importHydrateProgram(
+                "6",
+                translate6.internalEntryBuilder.build(entryFile, true)
+              ),
+              importHydrateProgram(
+                "5",
+                translate5.internalEntryBuilder.build(entryFile, true)
+              ),
+              import_compiler65.types.expressionStatement(
+                import_compiler65.types.callExpression(import_compiler65.types.identifier("init6"), [])
+              ),
+              import_compiler65.types.expressionStatement(
+                import_compiler65.types.callExpression(import_compiler65.types.identifier("init5"), [])
+              )
+            ];
+          } else {
+            return translate5.internalEntryBuilder.build(entryFile);
+          }
+        } else {
+          return translate6.internalEntryBuilder.build(entryFile);
+        }
+      },
+      visit(file, entryFile, visitChild) {
+        const state = entryFile[kState2] ||= {
+          has5: false,
+          has6: false
+        };
+        if (isTagsAPI(file)) {
+          state.has6 = true;
+          translate6.internalEntryBuilder.visit(file, entryFile, visitChild);
+        } else {
+          state.has5 = true;
+          translate5.internalEntryBuilder.visit(file, entryFile, visitChild);
+        }
+      }
+    };
+    const enterProgram = getVisitorEnter(Program);
+    return {
+      ...visitor,
+      Program: {
+        enter(program, state) {
+          const entryFile = program.hub.file;
+          if (entryFile.markoOpts.output !== "hydrate") {
+            return enterProgram?.call(this, program, state);
+          }
+          const visitedFiles = /* @__PURE__ */ new Set([
+            (0, import_babel_utils53.resolveRelativePath)(entryFile, entryFile.opts.filename)
+          ]);
+          entryBuilder.visit(
+            entryFile,
+            entryFile,
+            function visitChild(resolved) {
+              if (!visitedFiles.has(resolved)) {
+                visitedFiles.add(resolved);
+                const file = (0, import_babel_utils53.loadFileForImport)(entryFile, resolved);
+                if (file) {
+                  entryBuilder.visit(
+                    file,
+                    entryFile,
+                    (id) => visitChild(resolveRelativeToEntry2(entryFile, file, id))
+                  );
+                }
+              }
+            }
+          );
+          program.node.body = entryBuilder.build(entryFile);
+          program.skip();
+        },
+        exit: getVisitorExit(Program)
+      }
+    };
+  }
+}
+function mergeVisitors(visitor5, visitor6) {
+  return mergeObjects(
+    visitor5,
+    visitor6,
+    (_, value5, value6) => mergeVisit(value5, value6)
+  );
+}
+function mergeVisit(visit5, visit6) {
+  const enter5 = getVisitorEnter(visit5);
+  const enter6 = getVisitorEnter(visit6);
+  const enter3 = (enter5 || enter6) && function enter4(path7, state) {
+    return (isTagsAPI() ? enter6 : enter5)?.call(this, path7, state);
+  };
+  const exit5 = getVisitorExit(visit5);
+  const exit6 = getVisitorExit(visit6);
+  const exit3 = (exit5 || exit6) && function exit4(path7, state) {
+    return (isTagsAPI() ? exit6 : exit5)?.call(this, path7, state);
+  };
+  return exit3 ? enter3 ? { enter: enter3, exit: exit3 } : { exit: exit3 } : enter3;
+}
+function mergeTaglibs(libs5, libs6) {
+  const libs5Map = new Map(libs5);
+  const libs6Map = new Map(libs6);
+  const merged = [];
+  for (const taglibId2 of /* @__PURE__ */ new Set([...libs5Map.keys(), ...libs6Map.keys()])) {
+    merged.push([
+      taglibId2,
+      mergeObjects(
+        libs5Map.get(taglibId2),
+        libs6Map.get(taglibId2),
+        (key, value5, value6) => {
+          switch (key) {
+            case "migrate":
+            case "analyze":
+            case "transform":
+            case "translate":
+              return mergeVisitors(
+                normalizeVisitor(value5),
+                normalizeVisitor(value6)
+              );
+            default:
+              if (key[0] === "<") {
+                return mergeTagDef(
+                  value5,
+                  value6
+                );
+              }
+              return value5 ?? value6;
+          }
+        }
+      )
+    ]);
+  }
+  return merged;
+}
+function mergeTagDef(def5, def6) {
+  return mergeObjects(
+    normalizeTagDef(def5),
+    normalizeTagDef(def6),
+    (key, value5, value6) => {
+      switch (key) {
+        case "parse":
+        case "migrate":
+        case "transform":
+        case "analyze":
+        case "translate":
+          return mergeVisit(normalizeVisit(value5), normalizeVisit(value6));
+        default:
+          return value5 ?? value6;
+      }
+    }
+  );
+}
+function mergeObjects(a, b, cb) {
+  const merged = {};
+  if (a) {
+    if (b) {
+      for (const key in a) {
+        merged[key] = cb(key, a[key], b[key]);
+      }
+      for (const key in b) {
+        if (!(key in a)) {
+          merged[key] = cb(key, void 0, b[key]);
+        }
+      }
+    } else {
+      for (const key in a) {
+        merged[key] = cb(key, a[key], void 0);
+      }
+    }
+  } else if (b) {
+    for (const key in b) {
+      merged[key] = cb(key, void 0, b[key]);
+    }
+  }
+  return merged;
+}
+function normalizeTagDef(tagDef) {
+  if (tagDef) {
+    const normalized = {};
+    for (const key in tagDef) {
+      normalized[normalizeTagDefKey(key)] = tagDef[key];
+    }
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeTagDefKey(key) {
+  switch (key) {
+    case "code-generator":
+    case "codeGenerator":
+      return "translate";
+    case "migrator":
+      return "migrate";
+    case "node-factory":
+    case "nodeFactory":
+      return "parse";
+    case "parse-options":
+      return "parseOptions";
+    case "transformer":
+      return "transform";
+    default:
+      return key;
+  }
+}
+function normalizeVisitor(visitor) {
+  return visitor?.default ?? visitor;
+}
+function normalizeVisit(visitor) {
+  return typeof visitor === "function" ? visitor : normalizeVisitor(visitor);
+}
+function getVisitorEnter(visit2) {
+  return typeof visit2 === "function" ? visit2 : visit2?.enter;
+}
+function getVisitorExit(visit2) {
+  return typeof visit2 === "object" ? visit2?.exit : void 0;
+}
+function resolveRelativeToEntry2(entryFile, file, req) {
+  return file === entryFile ? (0, import_babel_utils53.resolveRelativePath)(file, req) : (0, import_babel_utils53.resolveRelativePath)(
+    entryFile,
+    req[0] === "." ? import_path6.default.join(file.opts.filename, "..", req) : req
+  );
+}
+
 // src/translator/index.ts
 var visitors = extractVisitors({
   Program: program_default,
@@ -12353,10 +12856,10 @@ var visitors = extractVisitors({
   MarkoScriptlet: scriptlet_default,
   MarkoComment: comment_default
 });
-var tagDiscoveryDirs = ["tags"];
+var tagDiscoveryDirs2 = ["tags"];
 var preferAPI = "tags";
-var { transform, analyze, translate } = visitors;
-var taglibs = [
+var { transform: transform2, analyze: analyze2, translate: translate2 } = visitors;
+var taglibs2 = [
   [
     core_default.taglibId,
     {
@@ -12365,7 +12868,7 @@ var taglibs = [
     }
   ]
 ];
-function getRuntimeEntryFiles(output, optimize) {
+function getRuntimeEntryFiles2(output, optimize) {
   return [
     `${runtime_info_default.name}${optimize ? "" : "/debug"}/${output === "html" ? "html" : "dom"}`
   ];
@@ -12373,6 +12876,7 @@ function getRuntimeEntryFiles(output, optimize) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   analyze,
+  createInteropTranslator,
   getRuntimeEntryFiles,
   internalEntryBuilder,
   preferAPI,