@marko/language-tools 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2808 @@
+// src/parser.ts
+import { TagType, createParser } from "htmljs-parser";
+
+// src/util/get-node-at-offset.ts
+function getNodeAtOffset(offset, program) {
+  const childNode = childAtOffset(offset, program.body);
+  if (childNode)
+    return visitChildNode(offset, childNode);
+  return childAtOffset(offset, program.static) || program;
+}
+function visitChildNode(offset, child) {
+  switch (child.type) {
+    case 1 /* Tag */:
+    case 16 /* AttrTag */:
+      return visitTag(offset, child);
+    default:
+      return child;
+  }
+}
+function visitTag(offset, tag) {
+  const { body } = tag;
+  if (body && offset > tag.open.end) {
+    const childNode = childAtOffset(offset, body);
+    return childNode ? visitChildNode(offset, childNode) : tag;
+  }
+  const { attrs } = tag;
+  if (attrs && offset > attrs[0].start) {
+    const attrNode = childAtOffset(offset, attrs);
+    return attrNode ? visitAttrNode(offset, attrNode) : tag;
+  }
+  const { var: tagVar } = tag;
+  if (tagVar && offset > tagVar.start && offset <= tagVar.end) {
+    return tagVar;
+  }
+  const { args } = tag;
+  if (args && offset > args.start && offset <= args.end) {
+    return args;
+  }
+  const { params } = tag;
+  if (params && offset > params.start && offset <= params.end) {
+    return params;
+  }
+  const { typeParams } = tag;
+  if (typeParams && offset > typeParams.start && offset <= typeParams.end) {
+    return typeParams;
+  }
+  const { typeArgs } = tag;
+  if (typeArgs && offset > typeArgs.start && offset <= typeArgs.end) {
+    return typeArgs;
+  }
+  const { name } = tag;
+  if (name && offset <= name.end) {
+    return name;
+  }
+  return tag;
+}
+function visitAttrNode(offset, attr) {
+  if (attr.type === 10 /* AttrNamed */) {
+    const { value } = attr;
+    if (value && offset > value.start) {
+      return value;
+    }
+    const { name } = attr;
+    if (offset > name.start && offset <= name.end) {
+      return name;
+    }
+  }
+  return attr;
+}
+function childAtOffset(offset, children) {
+  let max = children.length - 1;
+  if (max === -1)
+    return void 0;
+  let min = 0;
+  while (min < max) {
+    const mid = 1 + min + max >>> 1;
+    if (children[mid].start < offset) {
+      min = mid;
+    } else {
+      max = mid - 1;
+    }
+  }
+  const child = children[min];
+  return offset > child.start && offset <= child.end ? child : void 0;
+}
+
+// src/parser.ts
+import {
+  getLines,
+  getPosition,
+  getLocation
+} from "htmljs-parser";
+var styleBlockReg = /((?:\.[^\s\\/:*?"<>|({]+)*)\s*\{/y;
+var UNFINISHED = Number.MAX_SAFE_INTEGER;
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Program"] = 0] = "Program";
+  NodeType2[NodeType2["Tag"] = 1] = "Tag";
+  NodeType2[NodeType2["OpenTagName"] = 2] = "OpenTagName";
+  NodeType2[NodeType2["ShorthandId"] = 3] = "ShorthandId";
+  NodeType2[NodeType2["ShorthandClassName"] = 4] = "ShorthandClassName";
+  NodeType2[NodeType2["TagTypeArgs"] = 5] = "TagTypeArgs";
+  NodeType2[NodeType2["TagTypeParams"] = 6] = "TagTypeParams";
+  NodeType2[NodeType2["TagVar"] = 7] = "TagVar";
+  NodeType2[NodeType2["TagArgs"] = 8] = "TagArgs";
+  NodeType2[NodeType2["TagParams"] = 9] = "TagParams";
+  NodeType2[NodeType2["AttrNamed"] = 10] = "AttrNamed";
+  NodeType2[NodeType2["AttrName"] = 11] = "AttrName";
+  NodeType2[NodeType2["AttrArgs"] = 12] = "AttrArgs";
+  NodeType2[NodeType2["AttrValue"] = 13] = "AttrValue";
+  NodeType2[NodeType2["AttrMethod"] = 14] = "AttrMethod";
+  NodeType2[NodeType2["AttrSpread"] = 15] = "AttrSpread";
+  NodeType2[NodeType2["AttrTag"] = 16] = "AttrTag";
+  NodeType2[NodeType2["Text"] = 17] = "Text";
+  NodeType2[NodeType2["CDATA"] = 18] = "CDATA";
+  NodeType2[NodeType2["Doctype"] = 19] = "Doctype";
+  NodeType2[NodeType2["Declaration"] = 20] = "Declaration";
+  NodeType2[NodeType2["Comment"] = 21] = "Comment";
+  NodeType2[NodeType2["Placeholder"] = 22] = "Placeholder";
+  NodeType2[NodeType2["Scriptlet"] = 23] = "Scriptlet";
+  NodeType2[NodeType2["Import"] = 24] = "Import";
+  NodeType2[NodeType2["Export"] = 25] = "Export";
+  NodeType2[NodeType2["Class"] = 26] = "Class";
+  NodeType2[NodeType2["Style"] = 27] = "Style";
+  NodeType2[NodeType2["Static"] = 28] = "Static";
+  return NodeType2;
+})(NodeType || {});
+function parse(code, filename = "index.marko") {
+  const builder = new Builder(code);
+  const parser = createParser(builder);
+  parser.parse(code);
+  const program = builder.end();
+  return {
+    read: parser.read,
+    locationAt: parser.locationAt,
+    positionAt: parser.positionAt,
+    nodeAt: (offset) => getNodeAtOffset(offset, program),
+    filename,
+    program,
+    code
+  };
+}
+var Builder = class {
+  #code;
+  #program;
+  #openTagStart;
+  #parentNode;
+  #staticNode;
+  #attrNode;
+  #comments;
+  constructor(code) {
+    this.#code = code;
+    this.#program = this.#parentNode = {
+      type: 0 /* Program */,
+      comments: void 0,
+      parent: void 0,
+      static: [],
+      body: [],
+      start: 0,
+      end: code.length
+    };
+  }
+  end() {
+    this.#program.comments = this.#comments;
+    return this.#program;
+  }
+  onText(range) {
+    pushBody(this.#parentNode, {
+      type: 17 /* Text */,
+      parent: this.#parentNode,
+      start: range.start,
+      end: range.end
+    });
+  }
+  onCDATA(range) {
+    pushBody(this.#parentNode, {
+      type: 18 /* CDATA */,
+      parent: this.#parentNode,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    });
+  }
+  onDoctype(range) {
+    pushBody(this.#parentNode, {
+      type: 19 /* Doctype */,
+      parent: this.#parentNode,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    });
+  }
+  onDeclaration(range) {
+    pushBody(this.#parentNode, {
+      type: 20 /* Declaration */,
+      parent: this.#parentNode,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    });
+  }
+  onComment(range) {
+    const comment = {
+      type: 21 /* Comment */,
+      parent: this.#parentNode,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+    if (this.#comments) {
+      this.#comments.push(comment);
+    } else {
+      this.#comments = [comment];
+    }
+  }
+  onPlaceholder(range) {
+    pushBody(this.#parentNode, {
+      type: 22 /* Placeholder */,
+      parent: this.#parentNode,
+      comments: this.#comments,
+      value: range.value,
+      escape: range.escape,
+      start: range.start,
+      end: range.end
+    });
+    this.#comments = void 0;
+  }
+  onScriptlet(range) {
+    pushBody(this.#parentNode, {
+      type: 23 /* Scriptlet */,
+      parent: this.#parentNode,
+      comments: this.#comments,
+      value: range.value,
+      block: range.block,
+      start: range.start,
+      end: range.end
+    });
+    this.#comments = void 0;
+  }
+  onOpenTagStart(range) {
+    this.#openTagStart = range;
+  }
+  onOpenTagName(range) {
+    let concise = true;
+    let start = range.start;
+    let type = 1 /* Tag */;
+    let bodyType = TagType.html;
+    let nameText = void 0;
+    if (this.#openTagStart) {
+      concise = false;
+      start = this.#openTagStart.start;
+      this.#openTagStart = void 0;
+    }
+    if (!range.expressions.length) {
+      switch (nameText = this.#code.slice(range.start, range.end)) {
+        case "style": {
+          styleBlockReg.lastIndex = range.end;
+          const styleBlockMatch = styleBlockReg.exec(this.#code);
+          if (styleBlockMatch) {
+            const [{ length }, ext] = styleBlockMatch;
+            this.#program.static.push(
+              this.#staticNode = {
+                type: 27 /* Style */,
+                parent: this.#program,
+                comments: this.#comments,
+                ext: ext || void 0,
+                value: {
+                  start: range.end + length,
+                  end: UNFINISHED
+                },
+                start: range.start,
+                end: UNFINISHED
+              }
+            );
+            this.#comments = void 0;
+            return TagType.statement;
+          } else {
+            bodyType = TagType.text;
+            break;
+          }
+        }
+        case "class":
+          this.#program.static.push(
+            this.#staticNode = {
+              type: 26 /* Class */,
+              parent: this.#program,
+              comments: this.#comments,
+              start: range.start,
+              end: UNFINISHED
+            }
+          );
+          this.#comments = void 0;
+          return TagType.statement;
+        case "export":
+          this.#program.static.push(
+            this.#staticNode = {
+              type: 25 /* Export */,
+              parent: this.#program,
+              comments: this.#comments,
+              start: range.start,
+              end: UNFINISHED
+            }
+          );
+          this.#comments = void 0;
+          return TagType.statement;
+        case "import":
+          this.#program.static.push(
+            this.#staticNode = {
+              type: 24 /* Import */,
+              parent: this.#program,
+              comments: this.#comments,
+              start: range.start,
+              end: UNFINISHED
+            }
+          );
+          this.#comments = void 0;
+          return TagType.statement;
+        case "static":
+          this.#program.static.push(
+            this.#staticNode = {
+              type: 28 /* Static */,
+              parent: this.#program,
+              comments: this.#comments,
+              start: range.start,
+              end: UNFINISHED
+            }
+          );
+          this.#comments = void 0;
+          return TagType.statement;
+        case "area":
+        case "base":
+        case "br":
+        case "col":
+        case "embed":
+        case "hr":
+        case "img":
+        case "input":
+        case "link":
+        case "meta":
+        case "param":
+        case "source":
+        case "track":
+        case "wbr":
+          bodyType = TagType.void;
+          break;
+        case "html-comment":
+        case "script":
+        case "textarea":
+          bodyType = TagType.text;
+          break;
+        default:
+          if (nameText[0] === "@") {
+            type = 16 /* AttrTag */;
+          }
+          break;
+      }
+    }
+    const parent = this.#parentNode;
+    const end = UNFINISHED;
+    const name = {
+      type: 2 /* OpenTagName */,
+      parent: void 0,
+      quasis: range.quasis,
+      expressions: range.expressions,
+      start: range.start,
+      end: range.end
+    };
+    const tag = this.#parentNode = name.parent = {
+      type,
+      parent,
+      comments: this.#comments,
+      owner: void 0,
+      concise,
+      selfClosed: false,
+      hasAttrTags: false,
+      open: { start, end },
+      nameText,
+      name,
+      var: void 0,
+      args: void 0,
+      params: void 0,
+      shorthandId: void 0,
+      shorthandClassNames: void 0,
+      typeArgs: void 0,
+      typeParams: void 0,
+      attrs: void 0,
+      bodyType,
+      body: void 0,
+      close: void 0,
+      start,
+      end
+    };
+    this.#comments = void 0;
+    if (tag.type === 16 /* AttrTag */) {
+      let parentTag = parent;
+      let nameText2 = tag.nameText.slice(1);
+      while (parentTag.type === 1 /* Tag */ && isControlFlowTag(parentTag)) {
+        parentTag.hasAttrTags = true;
+        parentTag = parentTag.parent;
+      }
+      switch (parentTag.type) {
+        case 16 /* AttrTag */:
+          tag.owner = parentTag.owner;
+          parentTag.hasAttrTags = true;
+          nameText2 = `${parentTag.nameText}:${nameText2}`;
+          break;
+        case 1 /* Tag */:
+          tag.owner = parentTag;
+          parentTag.hasAttrTags = true;
+          nameText2 = `${parentTag.nameText || "*"}:${nameText2}`;
+          break;
+      }
+      tag.nameText = nameText2;
+    }
+    pushBody(parent, tag);
+    this.#openTagStart = void 0;
+    return bodyType;
+  }
+  onTagShorthandId(range) {
+    const parent = this.#parentNode;
+    parent.shorthandId = {
+      type: 3 /* ShorthandId */,
+      parent,
+      quasis: range.quasis,
+      expressions: range.expressions,
+      start: range.start,
+      end: range.end
+    };
+  }
+  onTagShorthandClass(range) {
+    const parent = this.#parentNode;
+    const shorthandClassName = {
+      type: 4 /* ShorthandClassName */,
+      parent,
+      quasis: range.quasis,
+      expressions: range.expressions,
+      start: range.start,
+      end: range.end
+    };
+    if (parent.shorthandClassNames) {
+      parent.shorthandClassNames.push(shorthandClassName);
+    } else {
+      parent.shorthandClassNames = [shorthandClassName];
+    }
+  }
+  onTagTypeArgs(range) {
+    const parent = this.#parentNode;
+    parent.typeArgs = {
+      type: 5 /* TagTypeArgs */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+  }
+  onTagTypeParams(range) {
+    const parent = this.#parentNode;
+    parent.typeParams = {
+      type: 6 /* TagTypeParams */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+  }
+  onTagVar(range) {
+    const parent = this.#parentNode;
+    parent.var = {
+      type: 7 /* TagVar */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+  }
+  onTagParams(range) {
+    const parent = this.#parentNode;
+    parent.params = {
+      type: 9 /* TagParams */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+  }
+  onTagArgs(range) {
+    const parent = this.#parentNode;
+    parent.args = {
+      type: 8 /* TagArgs */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+  }
+  onAttrName(range) {
+    const parent = this.#parentNode;
+    const name = {
+      type: 11 /* AttrName */,
+      parent: void 0,
+      start: range.start,
+      end: range.end
+    };
+    pushAttr(
+      parent,
+      this.#attrNode = name.parent = {
+        type: 10 /* AttrNamed */,
+        parent,
+        name,
+        value: void 0,
+        args: void 0,
+        start: range.start,
+        end: range.end
+      }
+    );
+  }
+  onAttrArgs(range) {
+    const parent = this.#attrNode;
+    parent.args = {
+      type: 12 /* AttrArgs */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    };
+    parent.end = range.end;
+  }
+  onAttrValue(range) {
+    const parent = this.#attrNode;
+    parent.value = {
+      type: 13 /* AttrValue */,
+      parent,
+      value: range.value,
+      bound: range.bound,
+      start: range.start,
+      end: range.end
+    };
+    parent.end = range.end;
+  }
+  onAttrMethod(range) {
+    const parent = this.#attrNode;
+    parent.value = {
+      type: 14 /* AttrMethod */,
+      parent,
+      typeParams: range.typeParams,
+      params: range.params,
+      body: range.body,
+      start: range.start,
+      end: range.end
+    };
+    parent.end = range.end;
+  }
+  onAttrSpread(range) {
+    const parent = this.#parentNode;
+    pushAttr(parent, {
+      type: 15 /* AttrSpread */,
+      parent,
+      value: range.value,
+      start: range.start,
+      end: range.end
+    });
+  }
+  onOpenTagEnd(range) {
+    if (this.#staticNode) {
+      if (this.#staticNode.type === 27 /* Style */) {
+        this.#staticNode.value.end = range.end - 1;
+      }
+      this.#staticNode.end = range.end;
+      this.#staticNode = void 0;
+    } else {
+      this.#attrNode = void 0;
+      const tag = this.#parentNode;
+      tag.open.end = range.end;
+      if (range.selfClosed || tag.bodyType === TagType.void) {
+        this.#parentNode = tag.parent;
+        tag.end = range.end;
+        tag.selfClosed = range.selfClosed;
+      }
+    }
+  }
+  onCloseTagStart(range) {
+    this.#parentNode.close = {
+      start: range.start,
+      end: UNFINISHED
+    };
+  }
+  onCloseTagEnd(range) {
+    const parent = this.#parentNode;
+    if (hasCloseTag(parent))
+      parent.close.end = range.end;
+    parent.end = range.end;
+    this.#parentNode = parent.parent;
+  }
+};
+function pushBody(parent, node) {
+  if (parent.body) {
+    parent.body.push(node);
+  } else {
+    parent.body = [node];
+  }
+}
+function pushAttr(parent, node) {
+  if (parent.attrs) {
+    parent.attrs.push(node);
+  } else {
+    parent.attrs = [node];
+  }
+}
+function hasCloseTag(parent) {
+  return parent.close !== void 0;
+}
+function isControlFlowTag(node) {
+  switch (node.nameText) {
+    case "if":
+    case "else":
+    case "else-if":
+    case "for":
+    case "while":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/util/extractor.ts
+var emptyView = {
+  offsetAt(_offset) {
+    return;
+  },
+  rangeAt(_start, _end) {
+    return;
+  }
+};
+var Extractor = class {
+  #parsed;
+  #generated = "";
+  #tokens = [];
+  constructor(parsed) {
+    this.#parsed = parsed;
+  }
+  write(str) {
+    this.#generated += str;
+    return this;
+  }
+  copy(range) {
+    if (range) {
+      if (typeof range === "string") {
+        this.#generated += range;
+      } else {
+        this.#tokens.push({
+          generatedStart: this.#generated.length,
+          sourceStart: range.start,
+          length: Math.min(this.#parsed.code.length, range.end) - range.start
+        });
+        this.#generated += this.#parsed.read(range);
+      }
+    }
+    return this;
+  }
+  end() {
+    return new Extracted(this.#parsed, this.#generated, this.#tokens);
+  }
+};
+var Extracted = class {
+  #parsed;
+  #generated;
+  #sourceToGenerated;
+  #generatedToSource;
+  #cachedGeneratedLines;
+  constructor(parsed, generated, tokens) {
+    this.#parsed = parsed;
+    this.#generated = generated;
+    if (tokens.length === 0) {
+      this.#generatedToSource = this.#sourceToGenerated = emptyView;
+    } else {
+      this.#generatedToSource = new GeneratedToSourceView(tokens);
+      this.#sourceToGenerated = new SourceToGeneratedView(
+        [...tokens].sort(sortBySourceThenGenerated)
+      );
+    }
+  }
+  get #generatedLines() {
+    return this.#cachedGeneratedLines || (this.#cachedGeneratedLines = getLines(this.#generated));
+  }
+  sourceOffsetAt(generatedOffset) {
+    return this.#generatedToSource.offsetAt(generatedOffset);
+  }
+  sourcePositionAt(generatedOffset) {
+    const sourceOffset = this.sourceOffsetAt(generatedOffset);
+    if (sourceOffset !== void 0)
+      return this.#parsed.positionAt(sourceOffset);
+  }
+  sourceLocationAt(generatedStart, generatedEnd) {
+    const sourceRange = this.#generatedToSource.rangeAt(
+      generatedStart,
+      generatedEnd
+    );
+    if (sourceRange) {
+      return this.#parsed.locationAt(sourceRange);
+    }
+  }
+  generatedOffsetAt(sourceOffset) {
+    return this.#sourceToGenerated.offsetAt(sourceOffset);
+  }
+  generatedPositionAt(sourceOffset) {
+    const generatedOffset = this.generatedOffsetAt(sourceOffset);
+    if (generatedOffset !== void 0) {
+      return getPosition(this.#generatedLines, generatedOffset);
+    }
+  }
+  generatedLocationAt(sourceStart, sourceEnd) {
+    const generatedRange = this.#sourceToGenerated.rangeAt(
+      sourceStart,
+      sourceEnd
+    );
+    if (generatedRange) {
+      return getLocation(
+        this.#generatedLines,
+        generatedRange.start,
+        generatedRange.end
+      );
+    }
+  }
+  toString() {
+    return this.#generated;
+  }
+};
+var TokenView = class {
+  #tokens;
+  #last;
+  constructor(tokens) {
+    this.#tokens = tokens;
+    this.#last = tokens.length - 1;
+  }
+  offsetAt(offset) {
+    let min = 0;
+    let max = this.#last;
+    while (min < max) {
+      const mid = 1 + min + max >>> 1;
+      if (this.inStart(this.#tokens[mid]) <= offset) {
+        min = mid;
+      } else {
+        max = mid - 1;
+      }
+    }
+    const token = this.#tokens[min];
+    const index = offset - this.inStart(token);
+    if (index >= 0 && index <= token.length) {
+      return this.outStart(token) + index;
+    }
+  }
+  rangeAt(inStart, inEnd) {
+    let min = 0;
+    let max = this.#last;
+    while (min < max) {
+      const mid = min + max >> 1;
+      const token = this.#tokens[mid];
+      const tokenInEnd = this.inStart(token) + token.length;
+      if (tokenInEnd > inStart) {
+        max = mid;
+      } else {
+        min = mid + 1;
+      }
+    }
+    const startToken = this.#tokens[max];
+    const startTokenInStart = this.inStart(startToken);
+    if (startTokenInStart >= inEnd)
+      return;
+    max = this.#last;
+    while (min < max) {
+      const mid = 1 + min + max >>> 1;
+      const token = this.#tokens[mid];
+      const tokenEnd = this.inStart(token) + token.length;
+      if (tokenEnd <= inEnd) {
+        min = mid;
+      } else {
+        max = mid - 1;
+      }
+    }
+    const endToken = this.#tokens[min];
+    const endTokenInStart = this.inStart(endToken);
+    const endTokenInEnd = endTokenInStart + endToken.length;
+    if (endTokenInEnd < inStart)
+      return;
+    const startIndex = inStart - startTokenInStart;
+    const endIndex = inEnd - endTokenInStart;
+    const start = this.outStart(startToken) + Math.max(0, startIndex);
+    const end = this.outStart(endToken) + Math.min(endToken.length, endIndex);
+    return { start, end };
+  }
+};
+var GeneratedToSourceView = class extends TokenView {
+  inStart(token) {
+    return token.generatedStart;
+  }
+  outStart(token) {
+    return token.sourceStart;
+  }
+};
+var SourceToGeneratedView = class extends TokenView {
+  inStart(token) {
+    return token.sourceStart;
+  }
+  outStart(token) {
+    return token.generatedStart;
+  }
+};
+function sortBySourceThenGenerated(a, b) {
+  const delta = a.sourceStart - b.sourceStart;
+  return delta === 0 ? b.generatedStart - a.generatedStart : delta;
+}
+
+// src/extractors/style/index.ts
+function extractStyle(opts) {
+  const { parsed, lookup } = opts;
+  const extractorsByExt = /* @__PURE__ */ new Map();
+  const { read, program, code } = parsed;
+  let placeholderId = 0;
+  for (const node of program.static) {
+    if (node.type === 27 /* Style */) {
+      getExtractor(node.ext || ".css").copy(node.value);
+    }
+  }
+  for (const node of program.body) {
+    visit(node);
+  }
+  const extractedByExt = /* @__PURE__ */ new Map();
+  for (const [ext, extractor] of extractorsByExt) {
+    extractedByExt.set(ext, extractor.end());
+  }
+  return extractedByExt;
+  function visit(node) {
+    var _a, _b;
+    switch (node.type) {
+      case 16 /* AttrTag */:
+        if (node.body) {
+          for (const child of node.body) {
+            visit(child);
+          }
+        }
+        break;
+      case 1 /* Tag */:
+        if (node.body) {
+          if (node.nameText === "style") {
+            const ext = node.shorthandClassNames ? read(node.shorthandClassNames.at(-1)) : ".css";
+            for (const child of node.body) {
+              switch (child.type) {
+                case 17 /* Text */:
+                  getExtractor(ext).copy(child);
+                  break;
+                case 22 /* Placeholder */:
+                  getExtractor(ext).write(`var(--_${placeholderId++})`);
+                  break;
+              }
+            }
+          } else {
+            for (const child of node.body) {
+              visit(child);
+            }
+          }
+        }
+        if (node.attrs) {
+          for (const attr of node.attrs) {
+            if (
+              // Check for string literal attribute values.
+              attr.type === 10 /* AttrNamed */ && ((_a = attr.value) == null ? void 0 : _a.type) === 13 /* AttrValue */ && /^['"]$/.test(code[attr.value.value.start])
+            ) {
+              const name = read(attr.name);
+              if (name === "#style" || name === "style" && node.nameText && name === "style" && ((_b = lookup.getTag(node.nameText)) == null ? void 0 : _b.html)) {
+                getExtractor("css").write(":root{").copy({
+                  start: attr.value.value.start + 1,
+                  end: attr.value.value.end - 1
+                }).write("}");
+              }
+            }
+          }
+        }
+        break;
+    }
+  }
+  function getExtractor(ext) {
+    let extractor = extractorsByExt.get(ext);
+    if (!extractor) {
+      extractorsByExt.set(ext, extractor = new Extractor(parsed));
+    }
+    return extractor;
+  }
+}
+
+// src/extractors/script/index.ts
+import { relativeImportPath } from "relative-import-path";
+
+// src/extractors/script/util/script-parser.ts
+import {
+  parseExpression,
+  parse as parseStatement
+} from "@babel/parser";
+var plugins = [
+  "exportDefaultFrom",
+  "importAssertions",
+  "typescript"
+];
+var ScriptParser = class {
+  #sourceFileName;
+  #whitespace;
+  constructor(sourceFileName, code) {
+    this.#sourceFileName = sourceFileName;
+    this.#whitespace = code.replace(/[^\s]/g, " ");
+  }
+  statementAt(offset, src) {
+    try {
+      return parseStatement(this.#whitespace.slice(0, offset) + src, {
+        plugins,
+        strictMode: true,
+        errorRecovery: true,
+        sourceType: "module",
+        allowUndeclaredExports: true,
+        allowSuperOutsideMethod: true,
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true,
+        sourceFilename: this.#sourceFileName
+      }).program.body;
+    } catch {
+      return [];
+    }
+  }
+  expressionAt(offset, src) {
+    try {
+      return parseExpression(this.#whitespace.slice(0, offset) + src, {
+        plugins,
+        strictMode: true,
+        errorRecovery: true,
+        sourceType: "module",
+        allowUndeclaredExports: true,
+        allowSuperOutsideMethod: true,
+        allowAwaitOutsideFunction: true,
+        allowReturnOutsideFunction: true,
+        sourceFilename: this.#sourceFileName
+      });
+    } catch {
+      return;
+    }
+  }
+};
+
+// src/extractors/script/util/is-valid-identifier.ts
+import {
+  isIdentifierName,
+  isKeyword,
+  isStrictBindReservedWord
+} from "@babel/helper-validator-identifier";
+function isValidIdentifier(name) {
+  return isIdentifierName(name) && !isKeyword(name) && !isStrictBindReservedWord(name, true);
+}
+
+// src/extractors/script/util/attach-scopes.ts
+import * as t from "@babel/types";
+var ATTR_UNAMED = "value";
+var Scopes = /* @__PURE__ */ new WeakMap();
+var BoundAttrMemberExpressionStartOffsets = /* @__PURE__ */ new WeakMap();
+function crawlProgramScope(parsed, scriptParser) {
+  var _a;
+  const { program, read } = parsed;
+  const mutations = [];
+  const potentialHoists = [];
+  const nodesToCheckForMutations = /* @__PURE__ */ new Map();
+  const programScope = {
+    parent: void 0,
+    hoists: false,
+    bindings: {}
+  };
+  programScope.bindings.input = {
+    type: 0 /* var */,
+    name: "input",
+    node: program,
+    scope: programScope,
+    hoisted: false,
+    mutated: false,
+    sourceName: void 0,
+    objectPath: void 0
+  };
+  visit(program.body, programScope);
+  Scopes.set(program.body, programScope);
+  for (const binding of potentialHoists) {
+    const { scope, name } = binding;
+    const parentScope = scope.parent;
+    let curParent = parentScope;
+    while (curParent) {
+      const parentBinding = (_a = curParent.bindings) == null ? void 0 : _a[name];
+      if (parentBinding) {
+        if (parentBinding.type === 2 /* hoisted */) {
+          binding.hoisted = true;
+          parentBinding.bindings.push(binding);
+        }
+        break;
+      }
+      if (curParent === programScope) {
+        binding.hoisted = true;
+        programScope.bindings[name] = {
+          type: 2 /* hoisted */,
+          scope: programScope,
+          bindings: [binding],
+          hoisted: false
+        };
+        break;
+      }
+      curParent = curParent.parent;
+    }
+    if (binding.hoisted) {
+      curParent = scope;
+      while (curParent && !curParent.hoists) {
+        curParent.hoists = true;
+        curParent = curParent.parent;
+      }
+    }
+  }
+  for (const [scope, nodes] of nodesToCheckForMutations) {
+    for (const node of nodes) {
+      trackMutationsInClosures(node, scope, mutations);
+    }
+  }
+  if (mutations.length) {
+    return mutations.sort((a, b) => a - b);
+  }
+  function visit(body, parentScope) {
+    var _a2;
+    for (const child of body) {
+      switch (child.type) {
+        case 1 /* Tag */:
+        case 16 /* AttrTag */: {
+          if (child.var) {
+            parentScope.bindings ??= {};
+            const parsedFn = scriptParser.expressionAt(
+              child.var.value.start - 6,
+              `${read(child.var.value)}=0`
+            );
+            if (parsedFn) {
+              const lVal = parsedFn.left;
+              checkForMutations(parentScope, lVal);
+              for (const id of getVarIdentifiers(
+                parsed,
+                lVal,
+                "",
+                ATTR_UNAMED
+              )) {
+                const { name, objectPath, sourceName } = id;
+                const binding = parentScope.bindings[name] = {
+                  type: 0 /* var */,
+                  name,
+                  node: child,
+                  scope: parentScope,
+                  hoisted: false,
+                  mutated: false,
+                  objectPath,
+                  sourceName
+                };
+                potentialHoists.push(binding);
+              }
+            }
+          }
+          if (child.body) {
+            const bodyScope = {
+              parent: parentScope,
+              hoists: false,
+              bindings: {}
+            };
+            if (child.params) {
+              bodyScope.bindings ??= {};
+              const parsedFn = scriptParser.expressionAt(
+                child.params.start,
+                `(${read(child.params.value)})=>{}`
+              );
+              if (parsedFn) {
+                for (const param of parsedFn.params) {
+                  checkForMutations(bodyScope, param);
+                  for (const name of getIdentifiers(param)) {
+                    bodyScope.bindings[name] = {
+                      type: 1 /* param */,
+                      name,
+                      node: child,
+                      scope: bodyScope,
+                      hoisted: false
+                    };
+                  }
+                }
+              }
+            }
+            visit(child.body, bodyScope);
+            Scopes.set(child.body, bodyScope);
+          }
+          if (child.attrs) {
+            for (const attr of child.attrs) {
+              switch (attr.type) {
+                case 15 /* AttrSpread */: {
+                  checkForMutations(
+                    parentScope,
+                    scriptParser.expressionAt(
+                      attr.value.start,
+                      read(attr.value)
+                    )
+                  );
+                  break;
+                }
+                case 10 /* AttrNamed */: {
+                  switch ((_a2 = attr.value) == null ? void 0 : _a2.type) {
+                    case 13 /* AttrValue */: {
+                      const parsedValue = scriptParser.expressionAt(
+                        attr.value.value.start,
+                        read(attr.value.value)
+                      );
+                      if (parsedValue) {
+                        switch (parsedValue.type) {
+                          case "Identifier":
+                            if (attr.value.bound) {
+                              const binding = resolveWritableVar(
+                                parentScope,
+                                parsedValue.name
+                              );
+                              if (binding) {
+                                binding.mutated = true;
+                              }
+                            }
+                            break;
+                          case "MemberExpression":
+                            if (attr.value.bound) {
+                              BoundAttrMemberExpressionStartOffsets.set(
+                                attr.value,
+                                parsedValue.property.start - 1
+                              );
+                            }
+                            break;
+                          default:
+                            checkForMutations(parentScope, parsedValue);
+                            break;
+                        }
+                      }
+                      break;
+                    }
+                    case 14 /* AttrMethod */: {
+                      checkForMutations(
+                        parentScope,
+                        scriptParser.expressionAt(
+                          attr.value.params.start - 2,
+                          `{_${read({
+                            start: attr.value.params.start,
+                            end: attr.value.body.end
+                          })}}`
+                        )
+                      );
+                      break;
+                    }
+                  }
+                  break;
+                }
+              }
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  function checkForMutations(scope, node) {
+    if (node) {
+      const nodes = nodesToCheckForMutations.get(scope);
+      if (nodes) {
+        nodes.push(node);
+      } else {
+        nodesToCheckForMutations.set(scope, [node]);
+      }
+    }
+  }
+}
+function getHoists(node) {
+  const { bindings } = Scopes.get(node.body);
+  let result;
+  for (const key in bindings) {
+    if (bindings[key].type === 2 /* hoisted */) {
+      if (result) {
+        result.push(key);
+      } else {
+        result = [key];
+      }
+    }
+  }
+  return result;
+}
+function getHoistSources(node) {
+  let result;
+  if (node.body) {
+    const { bindings } = Scopes.get(node.body);
+    for (const key in bindings) {
+      if (bindings[key].hoisted) {
+        if (result) {
+          result.push(key);
+        } else {
+          result = [key];
+        }
+      }
+    }
+  }
+  return result;
+}
+function getMutatedVars(node) {
+  let result;
+  const { bindings } = Scopes.get(node.body);
+  for (const key in bindings) {
+    const binding = bindings[key];
+    if (binding.type === 0 /* var */ && binding.mutated) {
+      if (result) {
+        result.push(binding);
+      } else {
+        result = [binding];
+      }
+    }
+  }
+  return result;
+}
+function isMutatedVar(node, name) {
+  const { bindings } = Scopes.get(node.body);
+  const binding = bindings == null ? void 0 : bindings[name];
+  return (binding == null ? void 0 : binding.type) === 0 /* var */ && binding.mutated;
+}
+function hasHoists(node) {
+  return node.body ? Scopes.get(node.body).hoists : false;
+}
+function getBoundAttrMemberExpressionStartOffset(value) {
+  return BoundAttrMemberExpressionStartOffsets.get(value);
+}
+function resolveWritableVar(scope, name) {
+  var _a;
+  let curScope = scope;
+  do {
+    const binding = (_a = curScope.bindings) == null ? void 0 : _a[name];
+    if ((binding == null ? void 0 : binding.type) === 0 /* var */ && binding.sourceName !== void 0) {
+      return binding;
+    }
+  } while (curScope = curScope.parent);
+}
+function* getIdentifiers(lVal) {
+  switch (lVal.type) {
+    case "Identifier":
+      yield lVal.name;
+      break;
+    case "ObjectPattern":
+      for (const prop of lVal.properties) {
+        if (prop.type === "RestElement") {
+          yield* getIdentifiers(prop.argument);
+        } else {
+          yield* getIdentifiers(prop.value);
+        }
+      }
+      break;
+    case "ArrayPattern":
+      for (const element of lVal.elements) {
+        if (element) {
+          if (element.type === "RestElement") {
+            yield* getIdentifiers(element.argument);
+          } else {
+            yield* getIdentifiers(element);
+          }
+        }
+      }
+      break;
+    case "AssignmentPattern":
+      yield* getIdentifiers(lVal.left);
+      break;
+  }
+}
+function* getVarIdentifiers(parsed, lVal, objectPath, sourceName) {
+  switch (lVal.type) {
+    case "Identifier":
+      yield {
+        name: lVal.name,
+        objectPath,
+        sourceName
+      };
+      break;
+    case "ObjectPattern":
+      for (const prop of lVal.properties) {
+        if (prop.type === "RestElement") {
+          yield* getVarIdentifiers(
+            parsed,
+            prop.argument,
+            objectPath,
+            sourceName
+          );
+        } else {
+          let sourceName2;
+          let accessor;
+          if (prop.key.type === "Identifier") {
+            sourceName2 = prop.key.name;
+            accessor = `.${sourceName2}`;
+          } else {
+            sourceName2 = parsed.read(prop.key);
+            accessor = `[${sourceName2}]`;
+          }
+          yield* getVarIdentifiers(
+            parsed,
+            prop.value,
+            objectPath + accessor,
+            sourceName2
+          );
+        }
+      }
+      break;
+    case "ArrayPattern": {
+      let i = -1;
+      for (const element of lVal.elements) {
+        i++;
+        if (element) {
+          if (element.type === "RestElement") {
+            yield* getVarIdentifiers(parsed, element.argument, objectPath);
+          } else {
+            yield* getVarIdentifiers(parsed, element, objectPath + `[${i}]`);
+          }
+        }
+      }
+      break;
+    }
+    case "AssignmentPattern":
+      yield* getVarIdentifiers(parsed, lVal.left, objectPath, sourceName);
+      break;
+  }
+}
+function trackMutationsInClosures(root, scope, mutations) {
+  traverse(root, (node) => {
+    switch (node.type) {
+      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) {
+  if (!node)
+    return;
+  let block = parentBlock;
+  let blockShadows = parentBlockShadows;
+  let blockMutations = parentBlockMutations;
+  switch (node.type) {
+    case "BlockStatement":
+      if (block !== node) {
+        block = node;
+        blockShadows = new Set(blockShadows);
+        blockMutations = [];
+      }
+      break;
+    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) {
+        trackShadows(param, scope, blockShadows);
+      }
+      break;
+    case "ObjectMethod":
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+      block = node.body;
+      blockShadows = new Set(blockShadows);
+      blockMutations = [];
+      for (const param of node.params) {
+        trackShadows(param, scope, blockShadows);
+      }
+      break;
+    case "FunctionExpression":
+      block = node.body;
+      blockShadows = new Set(blockShadows);
+      blockMutations = [];
+      if (node.id) {
+        trackShadows(node.id, scope, blockShadows);
+      }
+      for (const param of node.params) {
+        trackShadows(param, scope, blockShadows);
+      }
+      break;
+    case "FunctionDeclaration":
+      trackShadows(node.id, scope, parentBlockShadows);
+      block = node.body;
+      blockShadows = new Set(blockShadows);
+      blockMutations = [];
+      for (const param of node.params) {
+        trackShadows(param, scope, blockShadows);
+      }
+      break;
+    case "ClassExpression":
+      block = node.body;
+      blockShadows = new Set(blockShadows);
+      blockMutations = [];
+      if (node.id) {
+        trackShadows(node.id, scope, blockShadows);
+      }
+      break;
+    case "ClassDeclaration":
+      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) {
+        trackShadows(node.param, scope, blockShadows);
+      }
+      break;
+    case "VariableDeclaration":
+      for (const decl of node.declarations) {
+        trackShadows(decl.id, scope, blockShadows);
+      }
+      break;
+    case "UpdateExpression":
+      if (node.argument.type === "Identifier") {
+        parentBlockMutations.push(node.argument);
+      }
+      break;
+    case "AssignmentExpression":
+      if (node.left.type === "Identifier") {
+        parentBlockMutations.push(node.left);
+      }
+      break;
+  }
+  for (const key of t.VISITOR_KEYS[node.type]) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        trackMutations(
+          item,
+          scope,
+          mutations,
+          block,
+          blockShadows,
+          blockMutations
+        );
+      }
+    } else {
+      trackMutations(
+        child,
+        scope,
+        mutations,
+        block,
+        blockShadows,
+        blockMutations
+      );
+    }
+  }
+  if (block !== parentBlock && blockMutations.length) {
+    for (const { name, start } of blockMutations) {
+      if (blockShadows.has(name))
+        continue;
+      const binding = resolveWritableVar(scope, name);
+      if (binding) {
+        binding.mutated = true;
+        mutations.push(start);
+      }
+    }
+  }
+}
+function trackShadows(node, scope, shadows) {
+  for (const name of getIdentifiers(node)) {
+    if (resolveWritableVar(scope, name)) {
+      shadows.add(name);
+    }
+  }
+}
+function traverse(node, enter) {
+  if (!node)
+    return;
+  if (enter(node))
+    return;
+  for (const key of t.VISITOR_KEYS[node.type]) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        traverse(item, enter);
+      }
+    } else {
+      traverse(child, enter);
+    }
+  }
+}
+
+// src/extractors/script/util/runtime-overrides.ts
+var RuntimeOverloads = /* @__PURE__ */ new Map();
+var commentsReg = /\/\*(?:[^*]+|\*[^/])*\*\//gm;
+var replaceTokensReg = /\babstract\s+(\w+)|Marko\.(TemplateInput(?:<[^>]+>)?|Component)/gm;
+var overrideBlockReg = /\/\*[*\s]*@marko-overload-start[*\s]*\*\/([\s\S]+)\/\*[*\s]*@marko-overload-end[*\s]*\*\//g;
+function getRuntimeOverrides(runtimeTypes, generics, applyGenerics) {
+  let overloads = RuntimeOverloads.get(runtimeTypes);
+  if (!overloads) {
+    const match = overrideBlockReg.exec(runtimeTypes);
+    RuntimeOverloads.set(runtimeTypes, overloads = []);
+    if (match) {
+      let [, content] = match;
+      let replaceMatch;
+      let lastIndex = 0;
+      content = content.replace(commentsReg, "");
+      while (replaceMatch = replaceTokensReg.exec(content)) {
+        const [, methodName, propertyName] = replaceMatch;
+        const curText = content.slice(lastIndex, replaceMatch.index);
+        lastIndex = replaceTokensReg.lastIndex;
+        if (methodName) {
+          overloads.push(curText + methodName, 0 /* Generics */);
+        } else {
+          overloads.push(
+            curText,
+            propertyName === "Component" ? 2 /* Component */ : 1 /* Input */
+          );
+        }
+      }
+      overloads.push(content.slice(lastIndex));
+    }
+  }
+  let result = "";
+  const appliedInput = `Marko.TemplateInput<Input${applyGenerics}>`;
+  const appliedComponent = `Component${applyGenerics}`;
+  for (const part of overloads) {
+    switch (part) {
+      case 0 /* Generics */:
+        result += generics;
+        break;
+      case 1 /* Input */:
+        result += appliedInput;
+        break;
+      case 2 /* Component */:
+        result += appliedComponent;
+        break;
+      default:
+        result += part;
+        break;
+    }
+  }
+  return result;
+}
+
+// src/extractors/script/util/jsdoc-input-type.ts
+var MaybeInputTypedefReg = /@typedef\b[\s\S]*\bInput\b/;
+function getJSDocInputType(comment, ts) {
+  var _a, _b, _c, _d;
+  if (!MaybeInputTypedefReg.test(comment))
+    return;
+  const sourceFile = ts.createSourceFile(
+    "_.js",
+    comment,
+    ts.ScriptTarget.Latest,
+    false,
+    ts.ScriptKind.JS
+  );
+  const tags = (_b = (_a = sourceFile.endOfFileToken.jsDoc) == null ? void 0 : _a[0]) == null ? void 0 : _b.tags;
+  if (!(tags && hasInputTypeDef(ts, sourceFile, tags)))
+    return;
+  let typeParameters;
+  for (const tag of tags) {
+    if (isTemplateTag(ts, tag)) {
+      let constraint = (_c = tag.constraint) == null ? void 0 : _c.type.getText(sourceFile);
+      for (const param of tag.typeParameters) {
+        const value = {
+          name: "" + param.name.escapedText,
+          constraint,
+          default: (_d = param.default) == null ? void 0 : _d.getText(sourceFile)
+        };
+        constraint = void 0;
+        if (typeParameters) {
+          typeParameters.push(value);
+        } else {
+          typeParameters = [value];
+        }
+      }
+    }
+  }
+  return { typeParameters };
+}
+function hasInputTypeDef(ts, sourceFile, tags) {
+  var _a;
+  for (const tag of tags) {
+    if (isTypeDefTag(ts, tag) && ((_a = tag.fullName) == null ? void 0 : _a.getText(sourceFile)) === "Input") {
+      return true;
+    }
+  }
+  return false;
+}
+function isTypeDefTag(ts, tag) {
+  return tag.kind === ts.SyntaxKind.JSDocTypedefTag;
+}
+function isTemplateTag(ts, tag) {
+  return tag.kind === ts.SyntaxKind.JSDocTemplateTag;
+}
+
+// src/extractors/script/index.ts
+var SEP_EMPTY = "";
+var SEP_SPACE = " ";
+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 REG_EXT = /(?<=[/\\][^/\\]+)\.[^.]+$/;
+var REG_BLOCK = /\s*{/y;
+var REG_NEW_LINE = /^|(\r?\n)/g;
+var REG_ATTR_ARG_LITERAL = /(?<=\s*)(["'])((?:[^"'\\]+|\\.|(?!\1))*)\1\s*([,)])/my;
+var REG_TAG_IMPORT = /(?<=(['"]))<([^\1>]+)>(?=\1)/;
+var REG_INPUT_TYPE = /\s*(interface|type)\s+Input\b/y;
+var REG_OBJECT_PROPERTY = /^[_$a-z][_$a-z0-9]*$/i;
+var REG_COMMENT_PRAGMA = /\/\/(?:\s*@ts-|\/\s*<)/y;
+var IF_TAG_ALTERNATES = /* @__PURE__ */ new WeakMap();
+var WROTE_COMMENT = /* @__PURE__ */ new WeakSet();
+var ScriptLang = /* @__PURE__ */ ((ScriptLang2) => {
+  ScriptLang2["js"] = "js";
+  ScriptLang2["ts"] = "ts";
+  return ScriptLang2;
+})(ScriptLang || {});
+function extractScript(opts) {
+  return new ScriptExtractor(opts).end();
+}
+var ScriptExtractor = class {
+  #code;
+  #filename;
+  #parsed;
+  #extractor;
+  #scriptParser;
+  #read;
+  #lookup;
+  #renderIds = /* @__PURE__ */ new Map();
+  #scriptLang;
+  #ts;
+  #runtimeTypes;
+  #mutationOffsets;
+  #renderId = 1;
+  constructor(opts) {
+    const { parsed, lookup, scriptLang } = opts;
+    this.#filename = parsed.filename;
+    this.#code = parsed.code;
+    this.#scriptLang = scriptLang;
+    this.#parsed = parsed;
+    this.#lookup = lookup;
+    this.#ts = opts.ts;
+    this.#runtimeTypes = opts.runtimeTypesCode;
+    this.#extractor = new Extractor(parsed);
+    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);
+  }
+  end() {
+    return this.#extractor.end();
+  }
+  #writeProgram(program, componentFileName) {
+    this.#writeCommentPragmas(program);
+    const inputType = this.#getInputType(program);
+    let componentClassBody;
+    for (const node of program.static) {
+      switch (node.type) {
+        case 26 /* Class */:
+          this.#writeComments(node);
+          componentClassBody = {
+            start: node.start + "class".length,
+            end: node.end
+          };
+          break;
+        case 25 /* Export */: {
+          this.#writeComments(node);
+          this.#extractor.copy(node).write("\n");
+          break;
+        }
+        case 24 /* Import */: {
+          const tagImportMatch = REG_TAG_IMPORT.exec(this.#read(node));
+          this.#writeComments(node);
+          if (tagImportMatch) {
+            const [, , tagName] = tagImportMatch;
+            const templatePath = resolveTagImport(
+              this.#filename,
+              this.#lookup.getTag(tagName)
+            );
+            if (templatePath) {
+              const [{ length }] = tagImportMatch;
+              const fromStart = node.start + tagImportMatch.index;
+              this.#extractor.copy({
+                start: node.start,
+                end: fromStart
+              }).write(templatePath).copy({
+                start: fromStart + length,
+                end: node.end
+              }).write("\n");
+              break;
+            }
+          }
+          this.#extractor.copy(node).write("\n");
+          break;
+        }
+        case 28 /* Static */: {
+          let start = node.start + "static ".length;
+          let end = node.end;
+          this.#writeComments(node);
+          if (this.#testAtIndex(REG_BLOCK, start)) {
+            start = REG_BLOCK.lastIndex;
+            end--;
+          }
+          this.#extractor.copy({ start, end }).write("\n");
+          break;
+        }
+      }
+    }
+    let typeParamsStr = "";
+    let typeArgsStr = "";
+    let jsDocTemplateTagsStr = "";
+    if (inputType) {
+      if (inputType.typeParameters) {
+        let sep = SEP_EMPTY;
+        typeParamsStr = typeArgsStr = "<";
+        for (const param of inputType.typeParameters) {
+          typeParamsStr += sep + param.name + (param.constraint ? ` extends ${param.constraint}` : "") + (param.default ? ` = ${param.default}` : "");
+          typeArgsStr += sep + param.name;
+          sep = SEP_COMMA_SPACE;
+        }
+        typeParamsStr += ">";
+        typeArgsStr += ">";
+        if (this.#scriptLang === "js" /* js */) {
+          for (const param of inputType.typeParameters) {
+            jsDocTemplateTagsStr += `
+* @template ${param.constraint ? `{${removeNewLines(param.constraint)}} ` : ""}${param.default ? `[${param.name} = ${removeNewLines(param.default)}]` : param.name}`;
+          }
+        }
+      }
+    } else {
+      const hasComponent = componentClassBody || componentFileName;
+      if (this.#scriptLang === "ts" /* ts */) {
+        this.#extractor.write(
+          hasComponent ? 'export type Input = Component["input"];\n' : `export interface Input {}
+`
+        );
+      } else {
+        this.#extractor.write(
+          `/** @typedef {${hasComponent ? 'Component["input"]' : "Record<string, unknown>"}} Input */
+`
+        );
+      }
+    }
+    if (!componentClassBody && componentFileName) {
+      this.#extractor.write(
+        `import Component from "${stripExt(
+          relativeImportPath(this.#filename, componentFileName)
+        )}";
+`
+      );
+    } else {
+      const body2 = componentClassBody || " {}";
+      if (this.#scriptLang === "ts" /* ts */) {
+        this.#extractor.write(
+          `abstract class Component${typeParamsStr} extends Marko.Component<Input${typeArgsStr}>`
+        ).copy(body2).write("\nexport { type Component }\n");
+      } else {
+        this.#extractor.write(`/**${jsDocTemplateTagsStr}
+  * @extends {Marko.Component<Input${typeArgsStr}>}
+  * @abstract
+  */
+`);
+        this.#extractor.write(`export class Component extends Marko.Component`).copy(body2).write("\n");
+      }
+    }
+    const didReturn = !!getReturnTag(program);
+    const templateName = didReturn ? varLocal("template") : "";
+    if (!didReturn) {
+      this.#extractor.write("(");
+    }
+    if (this.#scriptLang === "ts" /* ts */) {
+      this.#extractor.write(`function ${templateName}${typeParamsStr}(this: void) {
+  const input = 1 as any as Input${typeArgsStr};
+  const component = 1 as any as Component${typeArgsStr};
+`);
+    } else {
+      this.#extractor.write(`/**${jsDocTemplateTagsStr}
+* @this {void}
+*/
+function ${templateName}() {
+  const input = /** @type {Input${typeArgsStr}} */(${varShared("any")});
+  const component = /** @type {Component${typeArgsStr}} */(${varShared(
+        "any"
+      )});
+`);
+    }
+    this.#extractor.write(`  const out = ${varShared("out")};
+  const state = ${varShared("state")}(component);
+  ${varShared("noop")}({ input, out, component, state });
+`);
+    const body = this.#processBody(program);
+    if (body == null ? void 0 : body.renderBody) {
+      this.#writeChildren(program, body.renderBody);
+    }
+    const hoists = getHoists(program);
+    if (hoists) {
+      this.#extractor.write("const ");
+      this.#writeObjectKeys(hoists);
+      this.#extractor.write(
+        ` = ${varShared("readScopes")}(${varShared("rendered")});
+`
+      );
+      this.#extractor.write(`${varShared("noop")}(`);
+      this.#writeObjectKeys(hoists);
+      this.#extractor.write(");\n");
+    }
+    if (didReturn) {
+      this.#extractor.write(`return ${varLocal("return")}.return;
+}
+`);
+    } else {
+      this.#extractor.write("return;\n})();\n");
+    }
+    const templateBaseClass = varShared("Template");
+    const internalInput = varLocal("input");
+    const internalInputWithExtends = `${internalInput} extends unknown`;
+    const internalApply = varLocal("apply");
+    const renderAndReturn = `(input: Input${typeArgsStr} & ${varShared(
+      "Relate"
+    )}<${internalInput}, Input${typeArgsStr}>) => (${varShared(
+      "ReturnWithScope"
+    )}<${internalInput}, ${didReturn ? `typeof ${templateName + typeArgsStr} extends () => infer Return ? Return : never` : "void"}>)`;
+    const templateOverrideClass = `${templateBaseClass}<{${this.#runtimeTypes ? getRuntimeOverrides(this.#runtimeTypes, typeParamsStr, typeArgsStr) : ""}
+  _${typeParamsStr ? `<${internalApply} = 1>(): ${internalApply} extends 0
+    ? ${typeParamsStr}() => <${internalInputWithExtends}>${renderAndReturn}
+    : () => <${internalInputWithExtends}, ${typeParamsStr.slice(
+      1,
+      -1
+    )}>${renderAndReturn};` : `(): () => <${internalInputWithExtends}>${renderAndReturn};`}
+}>`;
+    if (this.#scriptLang === "ts" /* ts */) {
+      this.#extractor.write(`export default new (
+  class Template extends ${templateOverrideClass} {}
+);
+`);
+    } else {
+      this.#extractor.write(`export default new (
+  /**
+   * @extends {${removeNewLines(templateOverrideClass)}}
+   */
+  class Template extends ${templateBaseClass} {}
+);
+`);
+    }
+    this.#writeComments(program);
+  }
+  #writeCommentPragmas(program) {
+    const firstComments = program.static.length ? program.static[0].comments : program.body.length ? program.body[0].comments : program.comments;
+    if (firstComments) {
+      for (const comment of firstComments) {
+        if (this.#testAtIndex(REG_COMMENT_PRAGMA, comment.start)) {
+          WROTE_COMMENT.add(comment);
+          this.#extractor.copy(comment).write("\n");
+        }
+      }
+    }
+  }
+  #writeComments(node) {
+    if (node.comments) {
+      for (const comment of node.comments) {
+        if (!WROTE_COMMENT.has(comment)) {
+          if (this.#code.charAt(comment.start + 1) === "/") {
+            this.#extractor.write("//").copy(comment.value).write("\n");
+          } else {
+            this.#extractor.write("/*").copy(comment.value).write("*/");
+          }
+        }
+      }
+    }
+  }
+  #writeReturn(returned, localBindings) {
+    if (!returned && !localBindings) {
+      this.#extractor.write(`return ${varShared("voidReturn")};
+`);
+      return;
+    }
+    this.#extractor.write(`return new (class MarkoReturn<Return = void> {
+`);
+    if (localBindings) {
+      this.#extractor.write(`[Marko._.scope] = `);
+      this.#writeObjectKeys(localBindings);
+      this.#extractor.write(`;
+`);
+    }
+    this.#extractor.write(`declare return: Return;
+constructor(_?: Return) {}
+})(
+`);
+    this.#extractor.copy(returned);
+    this.#extractor.write(");\n");
+  }
+  #writeChildren(parent, children) {
+    var _a, _b;
+    const last = children.length - 1;
+    let returnTag;
+    let i = 0;
+    while (i <= last) {
+      const child = children[i++];
+      switch (child.type) {
+        case 1 /* Tag */:
+          switch (child.nameText) {
+            case "return":
+              returnTag = child;
+              break;
+            case "if": {
+              const alternates = IF_TAG_ALTERNATES.get(child);
+              let renderId = this.#getRenderId(child);
+              if (!renderId && alternates) {
+                for (const { node } of alternates) {
+                  if (renderId = this.#getRenderId(node))
+                    break;
+                }
+              }
+              if (renderId) {
+                this.#extractor.write(
+                  `${varShared("assertRendered")}(${varShared(
+                    "rendered"
+                  )}, ${renderId}, (() => {
+`
+                );
+              }
+              this.#writeComments(child);
+              this.#extractor.write("if (").copy(
+                ((_a = child.args) == null ? void 0 : _a.value) || this.#getAttrValue(child, ATTR_UNAMED2) || "undefined"
+              ).write(") {\n");
+              if (child.body) {
+                const localBindings = getHoistSources(child);
+                this.#writeChildren(child, child.body);
+                if (localBindings) {
+                  this.#extractor.write("return {\nscope:");
+                  this.#writeObjectKeys(localBindings);
+                  this.#extractor.write("\n};\n");
+                }
+              }
+              let needsAlternate = true;
+              if (alternates) {
+                for (const { node, condition } of alternates) {
+                  this.#writeComments(node);
+                  if (condition) {
+                    this.#extractor.write("\n} else if (\n").copy(condition).write("\n) {\n");
+                  } else if (node.nameText === "else") {
+                    needsAlternate = false;
+                    this.#extractor.write("\n} else {\n");
+                  } else {
+                    this.#extractor.write("\n} else if (undefined) {\n");
+                  }
+                  if (node.body) {
+                    const localBindings = getHoistSources(node);
+                    this.#writeChildren(node, node.body);
+                    if (localBindings) {
+                      this.#extractor.write("return {\nscope:");
+                      this.#writeObjectKeys(localBindings);
+                      this.#extractor.write("\n};\n");
+                    }
+                  }
+                }
+              }
+              if (needsAlternate && renderId) {
+                this.#extractor.write("\n} else {\nreturn undefined;\n}\n");
+              } else {
+                this.#extractor.write("\n}\n");
+              }
+              if (renderId) {
+                this.#extractor.write("\n})())\n");
+              }
+              break;
+            }
+            case "for": {
+              const renderId = this.#getRenderId(child);
+              if (renderId) {
+                this.#extractor.write(
+                  `${varShared("assertRendered")}(${varShared(
+                    "rendered"
+                  )}, ${renderId}, `
+                );
+              }
+              this.#extractor.write(`${varShared("forTag")}({
+`);
+              this.#writeAttrs(child);
+              this.#extractor.write(`["renderBody"/*`).copy(child.name).write(`*/]: (`);
+              this.#writeComments(child);
+              this.#extractor.copy(child.typeParams).write("(\n");
+              if (child.params) {
+                this.#copyWithMutationsReplaced(child.params.value);
+              }
+              this.#extractor.write("\n) => {\n");
+              const body = this.#processBody(child);
+              if (body == null ? void 0 : body.renderBody) {
+                this.#writeChildren(child, body.renderBody);
+              }
+              this.#writeReturn(
+                void 0,
+                (body == null ? void 0 : body.renderBody) ? getHoistSources(child) : void 0
+              );
+              this.#extractor.write("})");
+              if (renderId) {
+                this.#extractor.write("\n}));\n");
+              } else {
+                this.#extractor.write("\n});\n");
+              }
+              break;
+            }
+            case "while": {
+              this.#writeComments(child);
+              this.#extractor.write("while (\n").copy(((_b = child.args) == null ? void 0 : _b.value) || "undefined").write("\n) {\n");
+              const body = this.#processBody(child);
+              if (body == null ? void 0 : body.renderBody) {
+                this.#writeChildren(child, body.renderBody);
+              }
+              this.#extractor.write("\n}\n");
+              break;
+            }
+            default:
+              this.#writeTag(child);
+              break;
+          }
+          break;
+        case 22 /* Placeholder */:
+          this.#writePlaceholder(child);
+          break;
+        case 23 /* Scriptlet */:
+          this.#writeScriptlet(child);
+          break;
+      }
+    }
+    const mutatedVars = getMutatedVars(parent);
+    if (returnTag || mutatedVars) {
+      this.#extractor.write(`const ${varLocal("return")} = {
+`);
+      if (returnTag) {
+        this.#extractor.write(`return: ${varShared("returnTag")}(`);
+        this.#writeTagInputObject(returnTag);
+        this.#extractor.write(")");
+        if (mutatedVars) {
+          this.#extractor.write(",\n");
+        }
+      }
+      if (mutatedVars) {
+        this.#extractor.write(`mutate: ${varShared("mutable")}([
+`);
+        for (const binding of mutatedVars) {
+          this.#extractor.write(
+            `${// TODO use a different format to avoid const annotation.
+            this.#scriptLang === "js" /* js */ ? "/** @type {const} */" : ""}[${JSON.stringify(binding.name) + (binding.sourceName && binding.sourceName !== binding.name ? `, ${JSON.stringify(binding.sourceName)}` : "")}, ${varShared("rendered")}.returns[${this.#getRenderId(
+              binding.node
+            )}]${binding.objectPath || ""}]${SEP_COMMA_NEW_LINE}`
+          );
+        }
+        this.#extractor.write(
+          `]${this.#scriptLang === "ts" /* ts */ ? " as const" : ""})`
+        );
+      }
+      this.#extractor.write("\n};\n");
+      if (mutatedVars) {
+        this.#extractor.write(`${varShared("noop")}({
+`);
+        for (const binding of mutatedVars) {
+          this.#extractor.write(binding.name + SEP_COMMA_NEW_LINE);
+        }
+        this.#extractor.write("});\n");
+      }
+    }
+    return returnTag !== void 0;
+  }
+  #writeTag(tag) {
+    const tagName = tag.nameText;
+    const renderId = this.#getRenderId(tag);
+    if (renderId) {
+      this.#extractor.write(
+        `${varShared("assertRendered")}(${varShared("rendered")}, ${renderId}, `
+      );
+    }
+    if (tagName) {
+      const def = this.#lookup.getTag(tagName);
+      if (def) {
+        const importPath = resolveTagImport(this.#filename, def);
+        const renderer = (importPath == null ? void 0 : importPath.endsWith(".marko")) ? `renderTemplate(import("${importPath}"))` : def.html ? `renderNativeTag("${def.name}")` : "missingTag";
+        if (!def.html && isValidIdentifier(tagName)) {
+          this.#extractor.write(
+            `${varShared("renderPreferLocal")}(
+// @ts-expect-error We expect the compiler to error because we are checking if the tag is defined.
+(${varShared("error")}, `
+          ).copy(tag.name).write(`),
+${varShared(renderer)})`);
+        } else {
+          this.#extractor.write(varShared(renderer));
+        }
+      } else if (isValidIdentifier(tagName)) {
+        this.#extractor.write(`${varShared("renderDynamicTag")}(
+`).copy(tag.name).write("\n)");
+      } else {
+        this.#extractor.write(`${varShared("missingTag")}`);
+      }
+    } else {
+      this.#extractor.write(`${varShared("renderDynamicTag")}(`);
+      this.#writeDynamicTagName(tag);
+      this.#extractor.write(")");
+    }
+    if (tag.typeArgs) {
+      this.#extractor.write(`<0>()`).copy(tag.typeArgs).write("()(");
+    } else {
+      this.#extractor.write("()()(");
+    }
+    this.#writeTagInputObject(tag);
+    if (renderId) {
+      this.#extractor.write(`)`);
+    }
+    this.#extractor.write(");\n");
+    if (renderId && tag.var) {
+      this.#extractor.write(`const `);
+      this.#copyWithMutationsReplaced(tag.var.value);
+      this.#extractor.write(
+        ` = ${varShared("rendered")}.returns[${renderId}].${ATTR_UNAMED2};
+`
+      );
+    }
+  }
+  #writeDynamicTagName(tag) {
+    const dynamicTagNameExpression = this.#getDynamicTagExpression(tag);
+    if (dynamicTagNameExpression) {
+      this.#extractor.copy(dynamicTagNameExpression);
+    } else {
+      this.#extractor.write(`${varShared("interpolated")}\``).copy(tag.name).write("`");
+    }
+  }
+  #writeTagNameComment(tag) {
+    this.#extractor.write("/*").copy(this.#getDynamicTagExpression(tag) || tag.name).write("*/");
+  }
+  #writePlaceholder(placeholder) {
+    this.#writeComments(placeholder);
+    this.#extractor.write("(").copy(placeholder.value).write(");\n");
+  }
+  #writeScriptlet(scriptlet) {
+    this.#writeComments(scriptlet);
+    this.#extractor.copy(scriptlet.value).write(";\n");
+  }
+  #writeAttrs(tag) {
+    var _a, _b, _c, _d, _e, _f;
+    let hasAttrs = false;
+    if (tag.shorthandId) {
+      hasAttrs = true;
+      this.#extractor.write(`id: ${varShared("interpolated")}\``).copy({
+        start: tag.shorthandId.start + 1,
+        end: tag.shorthandId.end
+      }).write("`" + SEP_COMMA_NEW_LINE);
+    }
+    if (tag.shorthandClassNames) {
+      let sep = SEP_EMPTY;
+      hasAttrs = true;
+      this.#extractor.write(`class: ${varShared("interpolated")}\``);
+      for (const shorthandClassName of tag.shorthandClassNames) {
+        this.#extractor.write(sep).copy({
+          start: shorthandClassName.start + 1,
+          end: shorthandClassName.end
+        });
+        sep = SEP_SPACE;
+      }
+      this.#extractor.write("`" + SEP_COMMA_NEW_LINE);
+    }
+    let attrWhitespaceStart = Math.max(
+      tag.name.end,
+      ((_a = tag.shorthandId) == null ? void 0 : _a.end) ?? -1,
+      ((_c = (_b = tag.shorthandClassNames) == null ? void 0 : _b[tag.shorthandClassNames.length - 1]) == null ? void 0 : _c.end) ?? -1,
+      ((_d = tag.var) == null ? void 0 : _d.end) ?? -1,
+      ((_e = tag.args) == null ? void 0 : _e.end) ?? -1,
+      ((_f = tag.params) == null ? void 0 : _f.end) ?? -1
+    );
+    if (tag.attrs) {
+      hasAttrs = true;
+      for (const attr of tag.attrs) {
+        this.#copyWhitespaceWithin(attrWhitespaceStart, attr.start);
+        attrWhitespaceStart = attr.end;
+        switch (attr.type) {
+          case 15 /* AttrSpread */:
+            this.#extractor.write(`...(
+`);
+            this.#copyWithMutationsReplaced(attr.value);
+            this.#extractor.write(`
+)`);
+            break;
+          case 10 /* AttrNamed */: {
+            const isDefault = isEmptyRange(attr.name);
+            const name = isDefault ? ATTR_UNAMED2 : attr.name;
+            const value = attr.value;
+            const defaultMapPosition = isDefault ? attr.name : void 0;
+            if (value) {
+              switch (value.type) {
+                case 14 /* AttrMethod */:
+                  this.#extractor.write('"').copy(defaultMapPosition).copy(name).write('"').copy(value.typeParams);
+                  this.#copyWithMutationsReplaced(value.params);
+                  this.#copyWithMutationsReplaced(value.body);
+                  break;
+                case 13 /* AttrValue */:
+                  this.#extractor.write('"').copy(defaultMapPosition).copy(name).write('": (\n');
+                  if (value.bound) {
+                    const memberExpressionStart = getBoundAttrMemberExpressionStartOffset(value);
+                    if (memberExpressionStart === void 0) {
+                      const valueLiteral = this.#read(value.value);
+                      this.#extractor.copy(value.value).write(`
+)${SEP_COMMA_NEW_LINE}"`).copy(defaultMapPosition).copy(name).write(
+                        `Change"(_${valueLiteral}) {
+${isMutatedVar(tag.parent, valueLiteral) ? `${varLocal("return")}.mutate.` : ""}`
+                      ).copy(value.value).write(`= _${valueLiteral};
+}`);
+                    } else if (this.#code[memberExpressionStart] === "[") {
+                      const memberObjectRange = {
+                        start: value.value.start,
+                        end: memberExpressionStart + 1
+                      };
+                      const memberPropertyRange = {
+                        start: memberObjectRange.end,
+                        end: value.value.end - 1
+                      };
+                      const memberPropertyCloseRange = {
+                        start: memberPropertyRange.end,
+                        end: value.value.end
+                      };
+                      this.#extractor.copy(memberObjectRange).copy(memberPropertyRange).copy(memberPropertyCloseRange).write(`
+)${SEP_COMMA_NEW_LINE}"`).copy(defaultMapPosition).copy(name).write('Change": (\n').copy(memberObjectRange).write("\n`${\n").copy(memberPropertyRange).write("\n}Change`\n").copy(memberPropertyCloseRange).write("\n)");
+                    } else {
+                      this.#extractor.copy(value.value).write(`
+)${SEP_COMMA_NEW_LINE}"`).copy(defaultMapPosition).copy(name).write('Change"').write(": ").copy(value.value).write(`Change`);
+                    }
+                  } else {
+                    this.#copyWithMutationsReplaced(value.value);
+                    this.#extractor.write("\n)");
+                  }
+                  break;
+              }
+            } else if (attr.args) {
+              const stringLiteralFirstArgMatch = this.#execAtIndex(
+                REG_ATTR_ARG_LITERAL,
+                attr.args.value.start
+              );
+              this.#extractor.write('"').copy(name).write('": ');
+              if (stringLiteralFirstArgMatch) {
+                const hasPartialArgs = stringLiteralFirstArgMatch[3] === ",";
+                const stringLiteralValue = stringLiteralFirstArgMatch[2];
+                const stringLiteralStart = stringLiteralFirstArgMatch.index;
+                const isValidProperty = REG_OBJECT_PROPERTY.test(
+                  stringLiteralFirstArgMatch[2]
+                );
+                if (isValidProperty) {
+                  const propertNameStart = stringLiteralStart + 1;
+                  this.#extractor.write("component.").copy({
+                    start: propertNameStart,
+                    end: propertNameStart + stringLiteralValue.length
+                  });
+                } else {
+                  this.#extractor.write(`component[`).copy({
+                    start: stringLiteralStart,
+                    end: stringLiteralStart + stringLiteralValue.length + 2
+                  }).write("]");
+                }
+                if (hasPartialArgs) {
+                  this.#extractor.write(`.bind(component, `).copy({
+                    start: stringLiteralStart + stringLiteralFirstArgMatch[0].length,
+                    end: attr.args.value.end
+                  }).write(")");
+                }
+              } else {
+                this.#extractor.write(`${varShared("bind")}(component, 
+`).copy(attr.args.value).write("\n)");
+              }
+            } else {
+              this.#extractor.write('"').copy(defaultMapPosition).copy(name).write('": true');
+            }
+            break;
+          }
+        }
+        this.#extractor.write(SEP_COMMA_NEW_LINE);
+      }
+    }
+    this.#copyWhitespaceWithin(
+      attrWhitespaceStart,
+      tag.open.end - (tag.concise ? this.#code[tag.open.end] === ";" ? 1 : 0 : tag.selfClosed ? 2 : 1)
+    );
+    return hasAttrs;
+  }
+  #writeAttrTags({ staticAttrTags, dynamicAttrTagParents }, inMerge) {
+    let wasMerge = false;
+    if (dynamicAttrTagParents) {
+      if (staticAttrTags) {
+        this.#extractor.write(`...${varShared("mergeAttrTags")}({
+`);
+        inMerge = wasMerge = true;
+      } else if (dynamicAttrTagParents.length > 1) {
+        this.#extractor.write(`...${varShared("mergeAttrTags")}(
+`);
+        inMerge = wasMerge = true;
+      } else {
+        this.#extractor.write(`...`);
+      }
+    }
+    if (staticAttrTags) {
+      this.#writeStaticAttrTags(staticAttrTags, inMerge);
+      if (dynamicAttrTagParents)
+        this.#extractor.write(`}${SEP_COMMA_NEW_LINE}`);
+    }
+    if (dynamicAttrTagParents) {
+      this.#writeDynamicAttrTagParents(dynamicAttrTagParents);
+      if (wasMerge)
+        this.#extractor.write(")");
+    }
+  }
+  #writeStaticAttrTags(staticAttrTags, wasMerge) {
+    if (!wasMerge)
+      this.#extractor.write("...{");
+    this.#extractor.write(
+      `[${varShared("never")}](){
+const attrTags = ${varShared(
+        "attrTagNames"
+      )}(this);
+`
+    );
+    for (const nameText in staticAttrTags) {
+      for (const tag of staticAttrTags[nameText]) {
+        this.#extractor.write(`attrTags["`);
+        this.#extractor.copy(tag.name);
+        this.#extractor.write('"];\n');
+      }
+    }
+    this.#extractor.write("\n}");
+    if (!wasMerge)
+      this.#extractor.write("}");
+    this.#extractor.write(SEP_COMMA_NEW_LINE);
+    for (const nameText in staticAttrTags) {
+      const attrTag = staticAttrTags[nameText];
+      const attrTagDef = this.#lookup.getTag(nameText);
+      const isRepeated = attrTag.length > 1 ? true : attrTagDef == null ? void 0 : attrTagDef.isRepeated;
+      const [firstAttrTag] = attrTag;
+      const name = (attrTagDef == null ? void 0 : attrTagDef.targetProperty) || nameText.slice(nameText.lastIndexOf(":") + 1);
+      this.#extractor.write(`["${name}"`);
+      this.#writeTagNameComment(firstAttrTag);
+      this.#extractor.write("]: ");
+      if (isRepeated) {
+        this.#extractor.write("[\n");
+      }
+      for (const childNode of attrTag) {
+        this.#writeTagInputObject(childNode);
+        this.#extractor.write(SEP_COMMA_NEW_LINE);
+      }
+      if (isRepeated) {
+        this.#extractor.write(`]${SEP_COMMA_NEW_LINE}`);
+      }
+    }
+  }
+  #writeDynamicAttrTagParents(dynamicAttrTagParents) {
+    var _a, _b, _c;
+    for (const tag of dynamicAttrTagParents) {
+      switch (tag.nameText) {
+        case "if": {
+          const alternates = IF_TAG_ALTERNATES.get(tag);
+          this.#writeComments(tag);
+          this.#extractor.write("((\n").copy(
+            ((_a = tag.args) == null ? void 0 : _a.value) || this.#getAttrValue(tag, ATTR_UNAMED2) || "undefined"
+          ).write("\n) ? ");
+          this.#extractor.write("{\n");
+          const body = this.#processBody(tag);
+          if (body)
+            this.#writeAttrTags(body, true);
+          this.#extractor.write("\n} ");
+          let needsAlternate = true;
+          if (alternates) {
+            for (const { node, condition } of alternates) {
+              this.#writeComments(node);
+              if (condition) {
+                this.#extractor.write(": (\n").copy(condition).write("\n) ? ");
+              } else if (node.nameText === "else") {
+                needsAlternate = false;
+                this.#extractor.write(": ");
+              } else {
+                this.#extractor.write(": undefined ? ");
+              }
+              const body2 = this.#processBody(tag);
+              if (body2) {
+                this.#extractor.write("{\n");
+                this.#writeAttrTags(body2, true);
+                this.#extractor.write("}");
+              } else {
+                this.#extractor.write("{}");
+              }
+            }
+          }
+          if (needsAlternate) {
+            this.#extractor.write(" : {}");
+          }
+          this.#extractor.write(")");
+          break;
+        }
+        case "for": {
+          this.#extractor.write(`${varShared("forAttrTag")}({
+`);
+          if (!this.#writeAttrs(tag))
+            this.#writeTagNameComment(tag);
+          this.#extractor.write("}, \n");
+          this.#writeComments(tag);
+          this.#extractor.copy(tag.typeParams).write("(\n").copy((_b = tag.params) == null ? void 0 : _b.value).write("\n) => ({\n");
+          const body = this.#processBody(tag);
+          if (body)
+            this.#writeAttrTags(body, true);
+          this.#extractor.write("}))");
+          break;
+        }
+        case "while": {
+          this.#writeComments(tag);
+          this.#extractor.write(`${varShared("mergeAttrTags")}((
+`).copy(((_c = tag.args) == null ? void 0 : _c.value) || "undefined").write("\n) ? [{\n");
+          const body = this.#processBody(tag);
+          this.#writeAttrTags(body, true);
+          this.#extractor.write("}] : [])");
+          break;
+        }
+      }
+      this.#extractor.write(SEP_COMMA_NEW_LINE);
+    }
+  }
+  #writeTagInputObject(tag) {
+    if (!tag.params)
+      this.#writeComments(tag);
+    let hasInput = false;
+    this.#extractor.write("{\n");
+    if (tag.args) {
+      hasInput = true;
+      this.#extractor.write("[").copy({
+        start: tag.args.start,
+        end: tag.args.start + 1
+      }).write('"value"').copy({
+        start: tag.args.end - 1,
+        end: tag.args.end
+      }).write(`]: ${varShared("tuple")}(`).copy(tag.args.value).write(")").write(",\n");
+    }
+    if (this.#writeAttrs(tag)) {
+      hasInput = true;
+    }
+    const body = this.#processBody(tag);
+    let hasRenderBody = false;
+    if (body) {
+      hasInput = true;
+      this.#writeAttrTags(body, false);
+      hasRenderBody = body.renderBody !== void 0;
+    } else if (tag.close) {
+      hasRenderBody = true;
+    }
+    if (tag.params || hasRenderBody) {
+      this.#extractor.write('["renderBody"');
+      this.#writeTagNameComment(tag);
+      this.#extractor.write("]: ");
+      if (tag.params) {
+        this.#extractor.write("(");
+        this.#writeComments(tag);
+        this.#extractor.copy(tag.typeParams).write("(\n");
+        this.#copyWithMutationsReplaced(tag.params.value);
+        this.#extractor.write("\n) => {\n");
+      } else {
+        this.#extractor.write(`(() => {
+`);
+      }
+      const localBindings = getHoistSources(tag);
+      const didReturn = (body == null ? void 0 : body.renderBody) && this.#writeChildren(tag, body.renderBody);
+      if (!tag.params) {
+        this.#extractor.write(`return () => {
+`);
+      }
+      this.#writeReturn(
+        didReturn ? `${varLocal("return")}.return` : void 0,
+        localBindings
+      );
+      if (tag.params) {
+        this.#extractor.write("})");
+      } else {
+        this.#extractor.write("}\n})()");
+      }
+    }
+    if (!hasInput) {
+      this.#writeTagNameComment(tag);
+    }
+    this.#extractor.write("\n}");
+  }
+  #writeObjectKeys(keys) {
+    this.#extractor.write("{");
+    for (const key of keys) {
+      this.#extractor.write(key + SEP_COMMA_SPACE);
+    }
+    this.#extractor.write("}");
+  }
+  #copyWithMutationsReplaced(range) {
+    const mutations = this.#mutationOffsets;
+    if (!mutations)
+      return this.#extractor.copy(range);
+    const len = mutations.length;
+    let curOffset = range.start;
+    let minIndex = 0;
+    do {
+      let maxIndex = len;
+      while (minIndex < maxIndex) {
+        const midIndex = minIndex + maxIndex >>> 1;
+        if (mutations[midIndex] >= curOffset) {
+          maxIndex = midIndex;
+        } else {
+          minIndex = midIndex + 1;
+        }
+      }
+      const nextOffset = maxIndex === len ? range.end : mutations[maxIndex];
+      if (nextOffset >= range.end) {
+        this.#extractor.copy({
+          start: curOffset,
+          end: range.end
+        });
+        return;
+      }
+      this.#extractor.copy({ start: curOffset, end: nextOffset });
+      this.#extractor.write(`${varLocal("return")}.mutate.`);
+      curOffset = nextOffset;
+      minIndex = maxIndex + 1;
+    } while (true);
+  }
+  #copyWhitespaceWithin(start, end) {
+    const code = this.#code;
+    const max = Math.min(end, code.length);
+    let lastPos = start;
+    let pos = start;
+    while (pos < max) {
+      if (!isWhitespaceCode(code.charCodeAt(pos))) {
+        lastPos = pos + 1;
+        if (pos > lastPos) {
+          this.#extractor.copy({ start: lastPos, end: pos });
+        }
+        return;
+      }
+      pos++;
+    }
+    if (pos > lastPos) {
+      this.#extractor.copy({ start: lastPos, end: pos });
+    }
+  }
+  #processBody(parent) {
+    var _a;
+    const { body } = parent;
+    if (!body)
+      return;
+    const last = body.length - 1;
+    let renderBody;
+    let staticAttrTags;
+    let dynamicAttrTagParents;
+    let i = 0;
+    while (i <= last) {
+      const child = body[i++];
+      switch (child.type) {
+        case 16 /* AttrTag */: {
+          const attrName = child.nameText;
+          if (staticAttrTags) {
+            const attr = staticAttrTags[attrName];
+            if (attr) {
+              attr.push(child);
+            } else {
+              staticAttrTags[attrName] = [child];
+            }
+          } else {
+            staticAttrTags = { [attrName]: [child] };
+          }
+          break;
+        }
+        case 1 /* Tag */: {
+          let hasDynamicAttrTags = false;
+          switch (child.nameText) {
+            case "for":
+            case "while":
+              hasDynamicAttrTags ||= child.hasAttrTags;
+              break;
+            case "if": {
+              let alternates;
+              hasDynamicAttrTags ||= child.hasAttrTags;
+              loop:
+                while (i <= last) {
+                  const nextChild = body[i++];
+                  switch (nextChild.type) {
+                    case 17 /* Text */:
+                      if (this.#isEmptyText(nextChild)) {
+                        continue loop;
+                      } else {
+                        break;
+                      }
+                    case 1 /* Tag */:
+                      switch (nextChild.nameText) {
+                        case "else-if": {
+                          const alternate = {
+                            condition: ((_a = nextChild.args) == null ? void 0 : _a.value) || this.#getAttrValue(nextChild, ATTR_UNAMED2),
+                            node: nextChild
+                          };
+                          hasDynamicAttrTags ||= nextChild.hasAttrTags;
+                          if (alternates) {
+                            alternates.push(alternate);
+                          } else {
+                            alternates = [alternate];
+                          }
+                          continue loop;
+                        }
+                        case "else": {
+                          const alternate = {
+                            condition: this.#getAttrValue(nextChild, "if"),
+                            node: nextChild
+                          };
+                          hasDynamicAttrTags ||= nextChild.hasAttrTags;
+                          if (alternates) {
+                            alternates.push(alternate);
+                          } else {
+                            alternates = [alternate];
+                          }
+                          if (alternate.condition) {
+                            continue loop;
+                          } else {
+                            break loop;
+                          }
+                        }
+                      }
+                      break;
+                  }
+                  i--;
+                  break;
+                }
+              IF_TAG_ALTERNATES.set(child, alternates);
+            }
+          }
+          if (hasDynamicAttrTags) {
+            if (dynamicAttrTagParents) {
+              dynamicAttrTagParents.push(child);
+            } else {
+              dynamicAttrTagParents = [child];
+            }
+          } else if (renderBody) {
+            renderBody.push(child);
+          } else {
+            renderBody = [child];
+          }
+          break;
+        }
+        case 17 /* Text */: {
+          if (!this.#isEmptyText(child)) {
+            if (renderBody) {
+              renderBody.push(child);
+            } else {
+              renderBody = [child];
+            }
+          }
+          break;
+        }
+        default:
+          if (renderBody) {
+            renderBody.push(child);
+          } else {
+            renderBody = [child];
+          }
+          break;
+      }
+    }
+    if (renderBody || staticAttrTags || dynamicAttrTagParents) {
+      return { renderBody, staticAttrTags, dynamicAttrTagParents };
+    }
+  }
+  #getAttrValue(tag, name) {
+    if (tag.attrs) {
+      for (const attr of tag.attrs) {
+        if (isValueAttribute(attr) && (this.#read(attr.name) || ATTR_UNAMED2) === name) {
+          return attr.value.value;
+        }
+      }
+    }
+  }
+  #isEmptyText(text) {
+    let pos = text.start;
+    while (pos < text.end) {
+      if (!isWhitespaceCode(this.#code.charCodeAt(pos))) {
+        return false;
+      }
+      pos++;
+    }
+    return true;
+  }
+  #getInputType(program) {
+    return this.#scriptLang === "ts" /* ts */ ? this.#getTSInputType(program) : this.#ts && this.#getJSDocInputType(program);
+  }
+  #getTSInputType(program) {
+    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 }));
+          return {
+            typeParameters: (_a = inputType == null ? void 0 : inputType.typeParameters) == null ? void 0 : _a.params.map((param) => {
+              return {
+                name: param.name,
+                constraint: param.constraint ? this.#read(param.constraint) : void 0,
+                default: param.default ? this.#read(param.default) : void 0
+              };
+            })
+          };
+        }
+      }
+    }
+  }
+  #getJSDocInputType(program) {
+    return this.#getJSDocInputTypeFromNodes(program.static) || this.#getJSDocInputTypeFromNodes(program.body) || this.#getJSDocInputTypeFromNode(program);
+  }
+  #getJSDocInputTypeFromNodes(nodes) {
+    for (const node of nodes) {
+      const code = this.#read(node);
+      code;
+      const info = this.#getJSDocInputTypeFromNode(node);
+      if (info)
+        return info;
+    }
+  }
+  #getJSDocInputTypeFromNode(node) {
+    const comments = node.comments;
+    if (comments) {
+      for (const comment of comments) {
+        if (this.#code.charAt(comment.start + 1) === "*") {
+          const type = getJSDocInputType(this.#read(comment), this.#ts);
+          if (type) {
+            WROTE_COMMENT.add(comment);
+            this.#extractor.write("/*").copy(comment.value).write("*/");
+            return type;
+          }
+        }
+      }
+    }
+  }
+  #getDynamicTagExpression(tag) {
+    if (tag.name.expressions.length === 1 && isEmptyRange(tag.name.quasis[0]) && isEmptyRange(tag.name.quasis[1])) {
+      return tag.name.expressions[0].value;
+    }
+  }
+  #getRenderId(tag) {
+    let renderId = this.#renderIds.get(tag);
+    if (renderId === void 0 && tag.var || hasHoists(tag)) {
+      renderId = this.#renderId++;
+      this.#renderIds.set(tag, renderId);
+    }
+    return renderId;
+  }
+  #testAtIndex(reg, index) {
+    reg.lastIndex = index;
+    return reg.test(this.#code);
+  }
+  #execAtIndex(reg, index) {
+    reg.lastIndex = index;
+    return reg.exec(this.#code);
+  }
+};
+function varLocal(name) {
+  return VAR_LOCAL_PREFIX + name;
+}
+function varShared(name) {
+  return VAR_SHARED_PREFIX + name;
+}
+function getReturnTag(parent) {
+  if (parent.body) {
+    for (const child of parent.body) {
+      if (child.type === 1 /* Tag */ && child.nameText === "return") {
+        return child;
+      }
+    }
+  }
+}
+function isValueAttribute(attr) {
+  var _a;
+  return attr.type === 10 /* AttrNamed */ && ((_a = attr.value) == null ? void 0 : _a.type) === 13 /* AttrValue */;
+}
+function resolveTagImport(from, def) {
+  const filename = resolveTagFile(def);
+  if (filename) {
+    return from ? relativeImportPath(from, filename) : filename;
+  }
+}
+function resolveTagFile(def) {
+  return def && (def.types || def.template || def.renderer);
+}
+function isWhitespaceCode(code) {
+  return code <= 32;
+}
+function stripExt(filename) {
+  return filename.replace(REG_EXT, "");
+}
+function removeNewLines(str) {
+  return str.replace(REG_NEW_LINE, " ");
+}
+function isEmptyRange(range) {
+  return range.start === range.end;
+}
+export {
+  NodeType,
+  ScriptLang,
+  UNFINISHED,
+  extractScript,
+  extractStyle,
+  getLines,
+  getLocation,
+  getPosition,
+  parse
+};