@marko/language-tools 2.5.57 → 2.5.59

package/dist/index.mjs

@@ -690,6 +690,7 @@ var Extracted = class {
       );
     }
   }
+  parsed;
   #generated;
   #sourceToGenerated;
   #generatedToSource;
@@ -823,7 +824,10 @@ function sortBySourceThenGenerated(a, b) {
 }
 
 // src/extractors/html/keywords.ts
-var builtinTagsRegex = /^(?:a(?:(?:bbr|cronym|ddress|pplet|r(?:ea|ticle)|side|udio))?|b(?:(?:ase(?:font)?|d[io]|gsound|ig|l(?:ink|ockquote)|ody|r|utton))?|c(?:a(?:nvas|ption)|enter|ite|o(?:de|l(?:group)?|mmand|ntent))|d(?:ata(?:list)?|d|e(?:l|tails)|fn|i(?:alog|r|v)|l|t)|e(?:lement|m(?:bed)?)|f(?:i(?:eldset|g(?:caption|ure))|o(?:nt|oter|rm)|rame(?:set)?)|h(?:1|2|3|4|5|6|ead(?:er)?|group|r|tml)|i(?:(?:frame|m(?:age|g)|n(?:put|s)|sindex))?|k(?:bd|eygen)|l(?:abel|egend|i(?:(?:nk|sting))?)|m(?:a(?:in|p|r(?:k|quee)|th)|e(?:nu(?:item)?|t(?:a|er))|ulticol)|n(?:av|extid|o(?:br|embed|frames|script))|o(?:bject|l|pt(?:group|ion)|utput)|p(?:(?:aram|icture|laintext|r(?:e|ogress)))?|q|r(?:bc?|p|tc?|uby)|s(?:(?:amp|cript|e(?:ction|lect)|hadow|lot|mall|ource|pa(?:cer|n)|t(?:r(?:ike|ong)|yle)|u(?:b|mmary|p)|vg))?|t(?:able|body|d|e(?:mplate|xtarea)|foot|h(?:ead)?|i(?:me|tle)|r(?:ack)?|t)|ul?|v(?:ar|ideo)|wbr|xmp)$/;
+var builtinTagsRegex = (
+  /* cspell:disable-next-line */
+  /^(?:a(?:(?:bbr|cronym|ddress|pplet|r(?:ea|ticle)|side|udio))?|b(?:(?:ase(?:font)?|d[io]|gsound|ig|l(?:ink|ockquote)|ody|r|utton))?|c(?:a(?:nvas|ption)|enter|ite|o(?:de|l(?:group)?|mmand|ntent))|d(?:ata(?:list)?|d|e(?:l|tails)|fn|i(?:alog|r|v)|l|t)|e(?:lement|m(?:bed)?)|f(?:i(?:eldset|g(?:caption|ure))|o(?:nt|oter|rm)|rame(?:set)?)|h(?:1|2|3|4|5|6|ead(?:er)?|group|r|tml)|i(?:(?:frame|m(?:age|g)|n(?:put|s)|sindex))?|k(?:bd|eygen)|l(?:abel|egend|i(?:(?:nk|sting))?)|m(?:a(?:in|p|r(?:k|quee)|th)|e(?:nu(?:item)?|t(?:a|er))|ulticol)|n(?:av|extid|o(?:br|embed|frames|script))|o(?:bject|l|pt(?:group|ion)|utput)|p(?:(?:aram|icture|laintext|r(?:e|ogress)))?|q|r(?:bc?|p|tc?|uby)|s(?:(?:amp|cript|e(?:ction|lect)|hadow|lot|mall|ource|pa(?:cer|n)|t(?:r(?:ike|ong)|yle)|u(?:b|mmary|p)|vg))?|t(?:able|body|d|e(?:mplate|xtarea)|foot|h(?:ead)?|i(?:me|tle)|r(?:ack)?|t)|ul?|v(?:ar|ideo)|wbr|xmp)$/
+);
 function isHTMLTag(tag) {
   return builtinTagsRegex.test(tag);
 }
@@ -1023,6 +1027,12 @@ import { relativeImportPath } from "relative-import-path";
 // src/extractors/script/util/attach-scopes.ts
 import { types as t } from "@marko/compiler";
 
+// src/extractors/script/util/script-parser.ts
+import {
+  parse as parseStatement,
+  parseExpression
+} from "@marko/compiler/internal/babel";
+
 // src/extractors/script/util/is-text-only-script.ts
 function isTextOnlyScript(tag) {
   if (tag.nameText !== "script" || tag.args || tag.attrs || !tag.body) {
@@ -1036,17 +1046,198 @@ function isTextOnlyScript(tag) {
   return true;
 }
 
+// src/extractors/script/util/script-parser.ts
+var plugins = ["exportDefaultFrom", "importAssertions", "typescript"];
+var ScriptParser = class {
+  #parsed;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(parsed) {
+    this.#parsed = parsed;
+  }
+  tagName(name) {
+    return this.#templateExpressions(name);
+  }
+  tagShorthandId(shorthandId) {
+    return this.#templateExpressions(shorthandId);
+  }
+  tagShorthandClassName(node) {
+    return this.#templateExpressions(node);
+  }
+  tagVar(node) {
+    const start = node.value.start - 1;
+    const expr = this.#cache.get(start) ?? this.#expressionAt(start, `(${this.#parsed.read(node.value)})=>0`);
+    if (expr) {
+      return expr.params[0];
+    }
+  }
+  tagParams(node) {
+    const start = node.start;
+    const expr = this.#cache.get(start) ?? this.#expressionAt(start, `(${this.#parsed.read(node.value)})=>0`);
+    if (expr) {
+      return expr.params;
+    }
+  }
+  tagTypeParams(node) {
+    const start = node.value.start - 1;
+    const expr = this.#cache.get(start) ?? this.#expressionAt(start, `<${this.#parsed.read(node.value)}>()=>0`);
+    if (expr) {
+      return expr.typeParameters;
+    }
+  }
+  tagArgs(node) {
+    const start = node.value.start - 2;
+    const expr = this.#cache.get(start) ?? this.#expressionAt(start, `_(${this.#parsed.read(node.value)})`);
+    if (expr) {
+      return expr.arguments;
+    }
+  }
+  tagTypeArgs(node) {
+    const start = node.value.start - 2;
+    const expr = this.#cache.get(start) ?? this.#expressionAt(start, `_<${this.#parsed.read(node.value)}>()`);
+    if (expr) {
+      return expr.typeParameters;
+    }
+  }
+  attrValue(node) {
+    const start = node.value.start;
+    return (this.#cache.get(start) ?? this.#expressionAt(start, this.#parsed.read(node.value))) || void 0;
+  }
+  attrSpread(node) {
+    const start = node.value.start;
+    return (this.#cache.get(start) ?? this.#expressionAt(start, this.#parsed.read(node.value))) || void 0;
+  }
+  attrMethod(node) {
+    const start = node.params.start - 2;
+    const expr = this.#cache.get(start) ?? this.#expressionAt(
+      start,
+      `{_${this.#parsed.read({ start: node.params.start, end: node.body.end })}}`
+    );
+    if (expr) {
+      return expr.properties[0];
+    }
+  }
+  attrArgs(node) {
+    const start = node.value.start;
+    return (this.#cache.get(start) ?? this.#expressionAt(start, this.#parsed.read(node.value))) || void 0;
+  }
+  placeholder(node) {
+    const start = node.value.start;
+    return (this.#cache.get(start) ?? this.#expressionAt(start, this.#parsed.read(node.value))) || void 0;
+  }
+  scriptBody(node) {
+    if (!isTextOnlyScript(node)) return;
+    const start = node.body[0].start;
+    const statements = this.#cache.get(start) ?? this.#statementsAt(
+      start,
+      this.#parsed.read({ start, end: node.body[node.body.length - 1].end })
+    );
+    if (statements) {
+      return statements;
+    }
+  }
+  scriptlet(node) {
+    const start = node.value.start;
+    const statements = this.#cache.get(start) ?? this.#statementsAt(start, this.#parsed.read(node.value));
+    if (statements) {
+      return statements;
+    }
+  }
+  import(node) {
+    const statements = this.#cache.get(node.start) ?? this.#statementsAt(node.start, this.#parsed.read(node));
+    if (statements) {
+      return statements[0];
+    }
+  }
+  export(node) {
+    const statements = this.#cache.get(node.start) ?? this.#statementsAt(node.start, this.#parsed.read(node));
+    if (statements) {
+      return statements[0];
+    }
+  }
+  class(node) {
+    const expr = this.#cache.get(node.start) ?? this.#expressionAt(node.start, this.#parsed.read(node));
+    return expr || void 0;
+  }
+  static(node) {
+    const start = node.start + "static ".length;
+    const statements = this.#cache.get(start) ?? this.#statementsAt(start, this.#parsed.read({ start, end: node.end }));
+    if (statements) {
+      return statements;
+    }
+  }
+  #templateExpressions(template) {
+    const { expressions } = template;
+    if (!expressions.length) return;
+    const result = [];
+    for (const expr of expressions) {
+      const start = expr.value.start;
+      const parsed = this.#cache.get(start) ?? this.#expressionAt(start, this.#parsed.read(expr.value));
+      if (!parsed) return;
+      result.push(parsed);
+    }
+    if (result.length) return result;
+  }
+  #statementsAt(startIndex, src) {
+    try {
+      const pos = this.#parsed.positionAt(startIndex);
+      const result = parseStatement(src, {
+        plugins,
+        startIndex,
+        startLine: pos.line + 1,
+        startColumn: pos.character,
+        strictMode: true,
+        errorRecovery: true,
+        sourceType: "module",
+        allowUndeclaredExports: true,
+        allowSuperOutsideMethod: true,
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true,
+        sourceFilename: this.#parsed.filename
+      }).program.body;
+      if (result.length) {
+        this.#cache.set(startIndex, result);
+        return result;
+      }
+    } catch {
+    }
+    this.#cache.set(startIndex, false);
+  }
+  #expressionAt(startIndex, src) {
+    try {
+      const pos = this.#parsed.positionAt(startIndex);
+      const result = parseExpression(src, {
+        plugins,
+        startIndex,
+        startLine: pos.line + 1,
+        startColumn: pos.character,
+        strictMode: true,
+        errorRecovery: true,
+        sourceType: "module",
+        allowUndeclaredExports: true,
+        allowSuperOutsideMethod: true,
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true,
+        sourceFilename: this.#parsed.filename
+      });
+      this.#cache.set(startIndex, result);
+      return result;
+    } catch {
+      this.#cache.set(startIndex, false);
+    }
+  }
+};
+
 // src/extractors/script/util/attach-scopes.ts
 var VISITOR_KEYS = t.VISITOR_KEYS;
-var ATTR_UNAMED = "value";
+var ATTR_UNNAMED = "value";
 var Scopes = /* @__PURE__ */ new WeakMap();
 var BoundAttrValueRange = /* @__PURE__ */ new WeakMap();
-function crawlProgramScope(parsed, scriptParser) {
+function crawlProgramScope(parsed, ast) {
   var _a;
-  const { program, read } = parsed;
+  const { program } = parsed;
   const mutations = [];
   const potentialHoists = [];
-  const nodesToCheckForMutations = /* @__PURE__ */ new Map();
+  const potentialMutations = /* @__PURE__ */ new Map();
   const programScope = {
     parent: void 0,
     hoists: false,
@@ -1094,10 +1285,13 @@ function crawlProgramScope(parsed, scriptParser) {
       }
     }
   }
-  for (const [scope, nodes] of nodesToCheckForMutations) {
+  for (const [scope, nodes] of potentialMutations) {
+    const shadows = /* @__PURE__ */ new Set();
+    const blockMutations = [];
     for (const node of nodes) {
-      trackMutationsInClosures(node, scope, mutations);
+      trackMutations(node, scope, mutations, shadows, blockMutations);
     }
+    flushMutations(scope, mutations, shadows, blockMutations);
   }
   if (mutations.length) {
     return mutations.sort(byStart);
@@ -1110,18 +1304,14 @@ function crawlProgramScope(parsed, scriptParser) {
         case 16 /* AttrTag */: {
           if (child.var) {
             parentScope.bindings ??= {};
-            const parsedFn = scriptParser.expressionAt(
-              child.var.value.start - 1,
-              `(${read(child.var.value)})=>0`
-            );
-            if (parsedFn) {
-              const lVal = parsedFn.params[0];
-              checkForMutations(parentScope, lVal);
+            const tagVar = ast.tagVar(child.var);
+            if (tagVar) {
+              checkForMutations(parentScope, tagVar);
               for (const id of getVarIdentifiers(
                 parsed,
-                lVal,
+                tagVar,
                 "",
-                ATTR_UNAMED
+                ATTR_UNNAMED
               )) {
                 const { name, objectPath, sourceName } = id;
                 const binding = parentScope.bindings[name] = {
@@ -1146,12 +1336,9 @@ function crawlProgramScope(parsed, scriptParser) {
             };
             if (child.params) {
               bodyScope.bindings ??= {};
-              const parsedFn = scriptParser.expressionAt(
-                child.params.start,
-                `(${read(child.params.value)})=>{}`
-              );
-              if (parsedFn) {
-                for (const param of parsedFn.params) {
+              const parsedParams = ast.tagParams(child.params);
+              if (parsedParams) {
+                for (const param of parsedParams) {
                   checkForMutations(bodyScope, param);
                   for (const name of getIdentifiers(param)) {
                     bodyScope.bindings[name] = {
@@ -1165,19 +1352,16 @@ function crawlProgramScope(parsed, scriptParser) {
                 }
               }
             }
-            if (isTextOnlyScript(child)) {
-              checkForMutations(
-                parentScope,
-                scriptParser.expressionAt(
-                  child.body[0].start - "async ()=>{\n".length,
-                  `async ()=>{
-${read({
-                    start: child.body[0].start,
-                    end: child.body[child.body.length - 1].end
-                  })}
-}`
-                )
-              );
+            const scriptBody = ast.scriptBody(child);
+            if (scriptBody) {
+              const nodes = potentialMutations.get(parentScope);
+              if (nodes) {
+                nodes.push(...scriptBody);
+              } else {
+                potentialMutations.set(parentScope, [
+                  ...scriptBody
+                ]);
+              }
             } else {
               visit(child.body, bodyScope);
             }
@@ -1187,22 +1371,13 @@ ${read({
             for (const attr of child.attrs) {
               switch (attr.type) {
                 case 15 /* AttrSpread */: {
-                  checkForMutations(
-                    parentScope,
-                    scriptParser.expressionAt(
-                      attr.value.start,
-                      read(attr.value)
-                    )
-                  );
+                  checkForMutations(parentScope, ast.attrSpread(attr));
                   break;
                 }
                 case 10 /* AttrNamed */: {
                   switch ((_a2 = attr.value) == null ? void 0 : _a2.type) {
                     case 13 /* AttrValue */: {
-                      let parsedValue = scriptParser.expressionAt(
-                        attr.value.value.start,
-                        read(attr.value.value)
-                      );
+                      let parsedValue = ast.attrValue(attr.value);
                       if (parsedValue) {
                         if (!attr.value.bound) {
                           checkForMutations(parentScope, parsedValue);
@@ -1252,13 +1427,7 @@ ${read({
                     case 14 /* AttrMethod */: {
                       checkForMutations(
                         parentScope,
-                        scriptParser.expressionAt(
-                          attr.value.params.start - 2,
-                          `{_${read({
-                            start: attr.value.params.start,
-                            end: attr.value.body.end
-                          })}}`
-                        )
+                        ast.attrMethod(attr.value)
                       );
                       break;
                     }
@@ -1275,12 +1444,24 @@ ${read({
   }
   function checkForMutations(scope, node) {
     if (node) {
-      const nodes = nodesToCheckForMutations.get(scope);
-      if (nodes) {
-        nodes.push(node);
-      } else {
-        nodesToCheckForMutations.set(scope, [node]);
-      }
+      traverse(node, (child) => {
+        switch (child.type) {
+          case "FunctionDeclaration":
+          case "FunctionExpression":
+          case "ObjectMethod":
+          case "ArrowFunctionExpression":
+          case "ClassMethod":
+          case "ClassPrivateMethod": {
+            const nodes = potentialMutations.get(scope);
+            if (nodes) {
+              nodes.push(child);
+            } else {
+              potentialMutations.set(scope, [child]);
+            }
+            return true;
+          }
+        }
+      });
     }
   }
 }
@@ -1459,32 +1640,13 @@ function* getVarIdentifiers(parsed, lVal, objectPath, sourceName) {
       break;
   }
 }
-function trackMutationsInClosures(root, scope, mutations) {
-  traverse(root, (node) => {
-    switch (node.type) {
-      // Since the root will always be an expression it's impossible
-      // to hit a "FunctionDeclaration" without first going through
-      // a a different function context. So we don't need to track it.
-      // case "FunctionDeclaration":
-      case "FunctionExpression":
-      case "ObjectMethod":
-      case "ArrowFunctionExpression":
-      case "ClassMethod":
-      case "ClassPrivateMethod":
-        trackMutations(node, scope, mutations, node, /* @__PURE__ */ new Set(), []);
-        return true;
-    }
-  });
-}
-function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows, parentBlockMutations) {
+function trackMutations(node, scope, mutations, parentBlockShadows, parentBlockMutations) {
   if (!node) return;
-  let block = parentBlock;
   let blockShadows = parentBlockShadows;
   let blockMutations = parentBlockMutations;
   switch (node.type) {
     case "BlockStatement":
-      if (block !== node) {
-        block = node;
+      if (blockMutations === parentBlockMutations) {
         blockShadows = new Set(blockShadows);
         blockMutations = [];
       }
@@ -1492,12 +1654,10 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
     case "ForStatement":
     case "ForInStatement":
     case "ForOfStatement":
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       break;
     case "ArrowFunctionExpression":
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       for (const param of node.params) {
@@ -1507,7 +1667,6 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
     case "ObjectMethod":
     case "ClassMethod":
     case "ClassPrivateMethod":
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       for (const param of node.params) {
@@ -1515,7 +1674,6 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
       }
       break;
     case "FunctionExpression":
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       if (node.id) {
@@ -1527,7 +1685,6 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
       break;
     case "FunctionDeclaration":
       trackShadows(node.id, scope, parentBlockShadows);
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       for (const param of node.params) {
@@ -1535,7 +1692,6 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
       }
       break;
     case "ClassExpression":
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       if (node.id) {
@@ -1546,12 +1702,10 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
       if (node.id) {
         trackShadows(node.id, scope, parentBlockShadows);
       }
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       break;
     case "CatchClause":
-      block = node.body;
       blockShadows = new Set(blockShadows);
       blockMutations = [];
       if (node.param) {
@@ -1578,34 +1732,23 @@ function trackMutations(node, scope, mutations, parentBlock, parentBlockShadows,
     const child = node[key];
     if (Array.isArray(child)) {
       for (const item of child) {
-        trackMutations(
-          item,
-          scope,
-          mutations,
-          block,
-          blockShadows,
-          blockMutations
-        );
+        trackMutations(item, scope, mutations, blockShadows, blockMutations);
       }
     } else {
-      trackMutations(
-        child,
-        scope,
-        mutations,
-        block,
-        blockShadows,
-        blockMutations
-      );
+      trackMutations(child, scope, mutations, blockShadows, blockMutations);
     }
   }
-  if (block !== parentBlock && blockMutations.length) {
-    for (const { name, start } of blockMutations) {
-      if (start == null || blockShadows.has(name)) continue;
-      const binding = resolveWritableVar(scope, name);
-      if (binding) {
-        binding.mutated = true;
-        mutations.push({ start, binding });
-      }
+  if (blockMutations !== parentBlockMutations && blockMutations.length) {
+    flushMutations(scope, mutations, blockShadows, blockMutations);
+  }
+}
+function flushMutations(scope, mutations, blockShadows, blockMutations) {
+  for (const { name, start } of blockMutations) {
+    if (start == null || blockShadows.has(name)) continue;
+    const binding = resolveWritableVar(scope, name);
+    if (binding) {
+      binding.mutated = true;
+      mutations.push({ start, binding });
     }
   }
 }
@@ -1901,61 +2044,6 @@ function getRuntimeOverrides(api, runtimeTypes, generics, applyGenerics, returnT
   return result;
 }
 
-// src/extractors/script/util/script-parser.ts
-import {
-  parse as parseStatement,
-  parseExpression
-} from "@marko/compiler/internal/babel";
-var plugins = ["exportDefaultFrom", "importAssertions", "typescript"];
-var ScriptParser = class {
-  #parsed;
-  constructor(parsed) {
-    this.#parsed = parsed;
-  }
-  statementAt(startIndex, src) {
-    const pos = this.#parsed.positionAt(startIndex);
-    try {
-      return parseStatement(src, {
-        plugins,
-        startIndex,
-        startLine: pos.line + 1,
-        startColumn: pos.character,
-        strictMode: true,
-        errorRecovery: true,
-        sourceType: "module",
-        allowUndeclaredExports: true,
-        allowSuperOutsideMethod: true,
-        allowAwaitOutsideFunction: true,
-        allowReturnOutsideFunction: true,
-        sourceFilename: this.#parsed.filename
-      }).program.body;
-    } catch {
-      return [];
-    }
-  }
-  expressionAt(startIndex, src) {
-    const pos = this.#parsed.positionAt(startIndex);
-    try {
-      return parseExpression(src, {
-        plugins,
-        startIndex,
-        startLine: pos.line + 1,
-        startColumn: pos.character,
-        strictMode: true,
-        errorRecovery: true,
-        sourceType: "module",
-        allowUndeclaredExports: true,
-        allowSuperOutsideMethod: true,
-        allowAwaitOutsideFunction: true,
-        allowReturnOutsideFunction: true,
-        sourceFilename: this.#parsed.filename
-      });
-    } catch {
-      return;
-    }
-  }
-};
-
 // src/extractors/script/index.ts
 var SEP_EMPTY = "";
 var SEP_SPACE = " ";
@@ -1963,7 +2051,7 @@ var SEP_COMMA_SPACE = ", ";
 var SEP_COMMA_NEW_LINE = ",\n";
 var VAR_LOCAL_PREFIX = "__marko_internal_";
 var VAR_SHARED_PREFIX = `Marko._.`;
-var ATTR_UNAMED2 = "value";
+var ATTR_UNNAMED2 = "value";
 var REG_EXT = /(?<=[/\\][^/\\]+)\.[^.]+$/;
 var REG_BLOCK = /\s*{/y;
 var REG_NEW_LINE = /^|(\r?\n)/g;
@@ -1994,7 +2082,7 @@ var ScriptExtractor = class {
   #interop;
   #parsed;
   #extractor;
-  #scriptParser;
+  #ast;
   #read;
   #lookup;
   #scriptLang;
@@ -2020,9 +2108,9 @@ var ScriptExtractor = class {
     this.#ts = opts.ts;
     this.#runtimeTypes = opts.runtimeTypesCode;
     this.#extractor = new Extractor(parsed);
-    this.#scriptParser = new ScriptParser(parsed);
+    this.#ast = new ScriptParser(parsed);
     this.#read = parsed.read.bind(parsed);
-    this.#mutations = crawlProgramScope(this.#parsed, this.#scriptParser);
+    this.#mutations = crawlProgramScope(this.#parsed, this.#ast);
     this.#writeProgram(parsed.program);
   }
   end() {
@@ -2322,8 +2410,10 @@ function ${templateName}() {
     this.#extractor.write(`return new (class MarkoReturn<Return = void> {
 `);
     if (scopeExpr) {
-      this.#extractor.write(`[${varShared("scope")}] = ${scopeExpr};
-`);
+      this.#extractor.write(
+        `readonly [${varShared("scope")}] = ${scopeExpr};
+`
+      );
     }
     this.#extractor.write(`declare return: Return;
 constructor(_?: Return) {}
@@ -2367,7 +2457,7 @@ constructor(_?: Return) {}
               }
               this.#writeComments(child);
               this.#extractor.write("if (").copy(
-                this.#getRangeWithoutTrailingComma((_a = child.args) == null ? void 0 : _a.value) || this.#getAttrValue(child, ATTR_UNAMED2) || "undefined"
+                this.#getRangeWithoutTrailingComma((_a = child.args) == null ? void 0 : _a.value) || this.#getAttrValue(child, ATTR_UNNAMED2) || "undefined"
               ).write(") {\n");
               const ifBody = this.#processBody(child);
               if (ifBody == null ? void 0 : ifBody.content) {
@@ -2647,7 +2737,7 @@ scope: ${scopeExpr}
             const value = attr.value;
             const modifier = !value || value.type === 13 /* AttrValue */ ? this.#getNamedAttrModifier(attr) : void 0;
             const defaultMapPosition = isDefault ? attr.name : void 0;
-            let name = isDefault ? ATTR_UNAMED2 : attr.name;
+            let name = isDefault ? ATTR_UNNAMED2 : attr.name;
             if (modifier) {
               name = { start: attr.name.start, end: modifier.start - 1 };
             }
@@ -2724,10 +2814,10 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
                     stringLiteralFirstArgMatch[2]
                   );
                   if (isValidProperty) {
-                    const propertNameStart = stringLiteralStart + 1;
+                    const propertyNameStart = stringLiteralStart + 1;
                     this.#extractor.write("component.").copy({
-                      start: propertNameStart,
-                      end: propertNameStart + stringLiteralValue.length
+                      start: propertyNameStart,
+                      end: propertyNameStart + stringLiteralValue.length
                     });
                   } else {
                     this.#extractor.write(`component[`).copy({
@@ -2763,7 +2853,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
     );
     return hasAttrs;
   }
-  #writeAttrTags({ staticAttrTags, dynamicAttrTagParents }) {
+  #writeAttrTags({ staticAttrTags, dynamicAttrTagParents }, constraintExpr) {
     let wasMerge = false;
     if (dynamicAttrTagParents) {
       if (staticAttrTags) {
@@ -2784,7 +2874,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
         this.#extractor.write(`}${SEP_COMMA_NEW_LINE}`);
     }
     if (dynamicAttrTagParents) {
-      this.#writeDynamicAttrTagParents(dynamicAttrTagParents);
+      this.#writeDynamicAttrTagParents(dynamicAttrTagParents, constraintExpr);
       if (wasMerge) this.#extractor.write(`)${SEP_COMMA_NEW_LINE}`);
     }
   }
@@ -2800,18 +2890,8 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
       if (isRepeated) {
         const templateVar = this.#getTemplateVar(firstAttrTag.owner);
         if (templateVar) {
-          let accessor = `"${name}"`;
-          let curTag = firstAttrTag.parent;
-          while (curTag) {
-            if (curTag.type === 16 /* AttrTag */) {
-              accessor = `"${this.#getAttrTagName(curTag)}",${accessor}`;
-            } else if (!isControlFlowTag(curTag)) {
-              break;
-            }
-            curTag = curTag.parent;
-          }
           this.#extractor.write(
-            `${varShared("attrTagFor")}(${templateVar},${accessor})(`
+            `${varShared("attrTagFor")}(${templateVar},${this.#getAttrTagPath(firstAttrTag)})(`
           );
         } else {
           this.#extractor.write(`${varShared("attrTag")}(`);
@@ -2833,7 +2913,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
       }
     }
   }
-  #writeDynamicAttrTagParents(dynamicAttrTagParents) {
+  #writeDynamicAttrTagParents(dynamicAttrTagParents, constraintExpr) {
     var _a, _b, _c;
     for (const tag of dynamicAttrTagParents) {
       switch (tag.nameText) {
@@ -2841,7 +2921,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
           const alternates = IF_TAG_ALTERNATES.get(tag);
           this.#writeComments(tag);
           this.#extractor.write("((\n").copy(
-            this.#getRangeWithoutTrailingComma((_a = tag.args) == null ? void 0 : _a.value) || this.#getAttrValue(tag, ATTR_UNAMED2) || "undefined"
+            this.#getRangeWithoutTrailingComma((_a = tag.args) == null ? void 0 : _a.value) || this.#getAttrValue(tag, ATTR_UNNAMED2) || "undefined"
           ).write("\n) ? ");
           this.#writeDynamicAttrTagBody(tag);
           let needsAlternate = true;
@@ -2875,8 +2955,12 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
           this.#extractor.write("\n}, \n");
           this.#writeComments(tag);
           this.#extractor.copy(tag.typeParams).write("(\n").copy((_b = tag.params) == null ? void 0 : _b.value).write("\n) => (");
-          this.#writeDynamicAttrTagBody(tag);
-          this.#extractor.write("))");
+          this.#writeDynamicAttrTagBody(tag, constraintExpr);
+          this.#extractor.write(")");
+          if (constraintExpr) {
+            this.#extractor.write(`,${constraintExpr}`);
+          }
+          this.#extractor.write(")");
           break;
         }
         case "while": {
@@ -2934,7 +3018,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
       this.#extractor.write(`}${SEP_COMMA_NEW_LINE}`);
     } else if (body) {
       hasInput = true;
-      this.#writeAttrTags(body);
+      this.#writeAttrTags(body, this.#getTagInputType(tag));
       hasBodyContent = body.content !== void 0;
     } else if (tag.close) {
       hasBodyContent = true;
@@ -3097,7 +3181,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
                         const alternate = {
                           condition: this.#getRangeWithoutTrailingComma(
                             (_a = nextChild.args) == null ? void 0 : _a.value
-                          ) || this.#getAttrValue(nextChild, ATTR_UNAMED2),
+                          ) || this.#getAttrValue(nextChild, ATTR_UNNAMED2),
                           node: nextChild
                         };
                         hasDynamicAttrTags ||= nextChild.hasAttrTags;
@@ -3170,7 +3254,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
       return { content, staticAttrTags, dynamicAttrTagParents };
     }
   }
-  #writeDynamicAttrTagBody(tag) {
+  #writeDynamicAttrTagBody(tag, constraintExpr) {
     const body = this.#processBody(tag);
     if (body) {
       if (body.content) {
@@ -3179,7 +3263,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
         this.#extractor.write("return ");
       }
       this.#extractor.write("{\n");
-      this.#writeAttrTags(body);
+      this.#writeAttrTags(body, constraintExpr);
       this.#extractor.write("}");
       if (body.content) {
         this.#endChildren();
@@ -3192,7 +3276,7 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
   #getAttrValue(tag, name) {
     if (tag.attrs) {
       for (const attr of tag.attrs) {
-        if (isValueAttribute(attr) && (this.#read(attr.name) || ATTR_UNAMED2) === name) {
+        if (isValueAttribute(attr) && (this.#read(attr.name) || ATTR_UNNAMED2) === name) {
           return attr.value.value;
         }
       }
@@ -3230,9 +3314,9 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
     var _a;
     for (const node of program.static) {
       if (node.type === 25 /* Export */) {
-        const start = node.start + "export ".length;
-        if (this.#testAtIndex(REG_INPUT_TYPE, start)) {
-          const [inputType] = this.#scriptParser.statementAt(start, this.#read({ start, end: node.end }));
+        if (this.#testAtIndex(REG_INPUT_TYPE, node.start + "export ".length)) {
+          const exported = this.#ast.export(node);
+          const inputType = exported == null ? void 0 : exported.declaration;
           return {
             typeParameters: (_a = inputType == null ? void 0 : inputType.typeParameters) == null ? void 0 : _a.params.map((param) => {
               return {
@@ -3339,6 +3423,30 @@ ${isMutatedVar(tag.parent, valueLiteral) ? varLocal(`change__${valueLiteral}.`)
     const { nameText } = tag;
     return ((_a = this.#lookup.getTag(nameText)) == null ? void 0 : _a.targetProperty) || nameText.slice(nameText.lastIndexOf(":") + 1);
   }
+  #getAttrTagPath(tag) {
+    let path4 = `"${this.#getAttrTagName(tag)}"`;
+    let curTag = tag.parent;
+    while (curTag) {
+      if (curTag.type === 16 /* AttrTag */) {
+        path4 = `"${this.#getAttrTagName(curTag)}",${path4}`;
+      } else if (!isControlFlowTag(curTag)) {
+        break;
+      }
+      curTag = curTag.parent;
+    }
+    return path4;
+  }
+  #getTagInputType(tag) {
+    if (tag.type === 16 /* AttrTag */) {
+      if (!tag.owner) return;
+      const templateVar2 = this.#getTemplateVar(tag.owner);
+      if (!templateVar2) return;
+      return `${varShared("inputForAttr")}(${templateVar2},${this.#getAttrTagPath(tag)})`;
+    }
+    const templateVar = this.#getTemplateVar(tag);
+    if (!templateVar) return;
+    return `${varShared("input")}(${templateVar})`;
+  }
   #writeAttrTagTree(tree, valueExpression, nested) {
     this.#extractor.write(
       `${varShared(nested ? "nestedAttrTagNames" : "attrTagNames")}(${valueExpression},input=>{
@@ -3928,7 +4036,7 @@ var marko_default = {
           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.
+          isExportInputTypeAsComponentInput(statement) || // skips outputting `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;