@stacksjs/stx 0.2.95 → 0.2.97

package/dist/precompiler.js

@@ -1,91 +1,670 @@
-// @bun
-import{pe as S}from"./chunk-kgym7ch9.js";import{GA as _,HA as U,IA as W,JA as X,KA as $,MA as z,NA as G,OA as w,ZA as A,lB as D}from"./chunk-x0770gt9.js";import{pB as I}from"./chunk-xv34zbp4.js";class k{parser;constructor(){this.parser=new D}compile(q,B={}){let{filename:F="template.stx",mode:j="ssr",optimize:H=!0,sourceMaps:J=!0,module:K="esm",functionName:R="render",dev:L=!1}=B,O=this.parser.parse(q,F),Q=this.createContext({sourceFile:F,mode:j,optimize:H,dev:L,sourceMaps:J}),T=this.generateRenderFunction(O,Q),Y={code:this.wrapModule(T,R,K,Q),analysis:{usedVariables:Q.usedVariables,usedDirectives:Q.usedDirectives,usedComponents:Q.usedComponents,isDynamic:Q.usedVariables.size>0||Q.usedDirectives.size>0,hasSlots:Q.hasSlots}};if(J&&Q.sourceMapGenerator)Y.map=Q.sourceMapGenerator.toJSON();return Y}async compileFile(q,B={}){let j=await(await import("fs/promises")).readFile(q,"utf-8");return this.compile(j,{...B,filename:q})}createContext(q){return{code:"",indentLevel:0,sourceMapGenerator:q.sourceMaps?new S("output.js",""):void 0,currentLine:1,currentColumn:0,sourceFile:q.sourceFile,mode:q.mode,optimize:q.optimize,dev:q.dev,usedVariables:new Set,usedDirectives:new Set,usedComponents:new Set,hasSlots:!1,varCounter:0}}generateRenderFunction(q,B){this.analyzeAST(q,B);let F=this.generateNode(q,B),j="";if(j+=`function render(__ctx) {
-`,j+=`  const __html = [];
-`,j+=`  const __escape = (s) => String(s).replace(/[&<>"']/g, c => ({"&":"&amp;","<":"&lt;",">":"&gt;","\\"":"&quot;","'":"&#x27;"})[c]);
-`,j+=`  const __push = (s) => __html.push(s);
-`,B.usedVariables.size>0){let H=Array.from(B.usedVariables).join(", ");j+=`  const { ${H} } = __ctx;
-`}return j+=`
-`,j+=F,j+=`
-`,j+=`  return __html.join('');
-`,j+="}",j}analyzeAST(q,B){A(q,{enter(F){if(U(F))Z(F.expression).forEach((H)=>B.usedVariables.add(H));else if(W(F)){if(B.usedDirectives.add(F.name),F.name==="slot")B.hasSlots=!0;if(F.params)Z(F.params).forEach((H)=>B.usedVariables.add(H))}else if(X(F))B.usedComponents.add(F.name)}})}generateNode(q,B){if(_(q))return this.generateText(q.value,B);else if(U(q))return this.generateExpression(q,B);else if(W(q))return this.generateDirective(q,B);else if($(q))return this.generateElement(q,B);else if(X(q))return this.generateComponent(q,B);else if(z(q)){if(B.dev&&q.style==="html")return this.generateText(`<!-- ${q.value} -->`,B);return""}else if(G(q))return"";else if(w(q))return this.generateStyle(q,B);else if(q.type==="Document")return q.children.map((F)=>this.generateNode(F,B)).join("");return""}generateText(q,B){if(!q)return"";return`  __push(${JSON.stringify(q)});
-`}generateExpression(q,B){let F=q.expression.trim();if(q.escaped)return`  __push(__escape(${F}));
-`;else return`  __push(${F});
-`}generateDirective(q,B){let{name:F,params:j,body:H}=q;switch(F){case"if":return this.generateIf(j,H,B);case"unless":return this.generateUnless(j,H,B);case"foreach":return this.generateForeach(j,H,B);case"for":return this.generateFor(j,H,B);case"while":return this.generateWhile(j,H,B);case"isset":return this.generateIsset(j,H,B);case"empty":return this.generateEmpty(j,H,B);case"auth":return this.generateAuth(H,B);case"guest":return this.generateGuest(H,B);case"env":return this.generateEnv(j,H,B);case"switch":return this.generateSwitch(j,H,B);case"slot":return this.generateSlot(j,H,B);case"section":return this.generateSection(j,H,B);case"push":return this.generatePush(j,H,B);case"once":return this.generateOnce(H,B);case"js":case"ts":return this.generateScript(H,B);default:if(B.dev)return`  __push('@${F}${j?`(${j})`:""}');
-`;return""}}generateIf(q,B,F){if(!q||!B)return"";let j=`  if (${q}) {
-`;F.indentLevel++;let H=this.splitConditionalBody(B);j+=H.ifBody.map((J)=>this.generateNode(J,F)).join("");for(let J of H.elseifs)j+=`  }
-else if (${J.condition}) {
-`,j+=J.body.map((K)=>this.generateNode(K,F)).join("");if(H.elseBody.length>0)j+=`  }
+import {
+  isCommentNode,
+  isComponentNode,
+  isDirectiveNode,
+  isElementNode,
+  isExpressionNode,
+  isScriptNode,
+  isStyleNode,
+  isTextNode,
+  TemplateParser,
+  walkAST
+} from "./ast.js";
+import { SourceMapGenerator } from "./source-maps.js";
+
+export class TemplateCompiler {
+  parser;
+  constructor() {
+    this.parser = new TemplateParser;
+  }
+  compile(template, options = {}) {
+    const {
+      filename = "template.stx",
+      mode = "ssr",
+      optimize = !0,
+      sourceMaps = !0,
+      module = "esm",
+      functionName = "render",
+      dev = !1
+    } = options, ast = this.parser.parse(template, filename), ctx = this.createContext({
+      sourceFile: filename,
+      mode,
+      optimize,
+      dev,
+      sourceMaps
+    }), functionCode = this.generateRenderFunction(ast, ctx), result = {
+      code: this.wrapModule(functionCode, functionName, module, ctx),
+      analysis: {
+        usedVariables: ctx.usedVariables,
+        usedDirectives: ctx.usedDirectives,
+        usedComponents: ctx.usedComponents,
+        isDynamic: ctx.usedVariables.size > 0 || ctx.usedDirectives.size > 0,
+        hasSlots: ctx.hasSlots
+      }
+    };
+    if (sourceMaps && ctx.sourceMapGenerator)
+      result.map = ctx.sourceMapGenerator.toJSON();
+    return result;
+  }
+  async compileFile(filePath, options = {}) {
+    const template = await (await import("node:fs/promises")).readFile(filePath, "utf-8");
+    return this.compile(template, { ...options, filename: filePath });
+  }
+  createContext(options) {
+    return {
+      code: "",
+      indentLevel: 0,
+      sourceMapGenerator: options.sourceMaps ? new SourceMapGenerator("output.js", "") : void 0,
+      currentLine: 1,
+      currentColumn: 0,
+      sourceFile: options.sourceFile,
+      mode: options.mode,
+      optimize: options.optimize,
+      dev: options.dev,
+      usedVariables: new Set,
+      usedDirectives: new Set,
+      usedComponents: new Set,
+      hasSlots: !1,
+      varCounter: 0
+    };
+  }
+  generateRenderFunction(ast, ctx) {
+    this.analyzeAST(ast, ctx);
+    const bodyCode = this.generateNode(ast, ctx);
+    let fn = "";
+    fn += `function render(__ctx) {
+`;
+    fn += `  const __html = [];
+`;
+    fn += `  const __escape = (s) => String(s).replace(/[&<>"']/g, c => ({"&":"&amp;","<":"&lt;",">":"&gt;","\\"":"&quot;","'":"&#x27;"})[c]);
+`;
+    fn += `  const __push = (s) => __html.push(s);
+`;
+    if (ctx.usedVariables.size > 0) {
+      const vars = Array.from(ctx.usedVariables).join(", ");
+      fn += `  const { ${vars} } = __ctx;
+`;
+    }
+    fn += `
+`;
+    fn += bodyCode;
+    fn += `
+`;
+    fn += `  return __html.join('');
+`;
+    fn += "}";
+    return fn;
+  }
+  analyzeAST(ast, ctx) {
+    walkAST(ast, {
+      enter(node) {
+        if (isExpressionNode(node))
+          extractVariables(node.expression).forEach((v) => ctx.usedVariables.add(v));
+        else if (isDirectiveNode(node)) {
+          ctx.usedDirectives.add(node.name);
+          if (node.name === "slot")
+            ctx.hasSlots = !0;
+          if (node.params)
+            extractVariables(node.params).forEach((v) => ctx.usedVariables.add(v));
+        } else if (isComponentNode(node))
+          ctx.usedComponents.add(node.name);
+      }
+    });
+  }
+  generateNode(node, ctx) {
+    if (isTextNode(node))
+      return this.generateText(node.value, ctx);
+    else if (isExpressionNode(node))
+      return this.generateExpression(node, ctx);
+    else if (isDirectiveNode(node))
+      return this.generateDirective(node, ctx);
+    else if (isElementNode(node))
+      return this.generateElement(node, ctx);
+    else if (isComponentNode(node))
+      return this.generateComponent(node, ctx);
+    else if (isCommentNode(node)) {
+      if (ctx.dev && node.style === "html")
+        return this.generateText(`<!-- ${node.value} -->`, ctx);
+      return "";
+    } else if (isScriptNode(node))
+      return "";
+    else if (isStyleNode(node))
+      return this.generateStyle(node, ctx);
+    else if (node.type === "Document")
+      return node.children.map((child) => this.generateNode(child, ctx)).join("");
+    return "";
+  }
+  generateText(text, _ctx) {
+    if (!text)
+      return "";
+    return `  __push(${JSON.stringify(text)});
+`;
+  }
+  generateExpression(node, _ctx) {
+    const expr = node.expression.trim();
+    if (node.escaped)
+      return `  __push(__escape(${expr}));
+`;
+    else
+      return `  __push(${expr});
+`;
+  }
+  generateDirective(node, ctx) {
+    const { name, params, body } = node;
+    switch (name) {
+      case "if":
+        return this.generateIf(params, body, ctx);
+      case "unless":
+        return this.generateUnless(params, body, ctx);
+      case "foreach":
+        return this.generateForeach(params, body, ctx);
+      case "for":
+        return this.generateFor(params, body, ctx);
+      case "while":
+        return this.generateWhile(params, body, ctx);
+      case "isset":
+        return this.generateIsset(params, body, ctx);
+      case "empty":
+        return this.generateEmpty(params, body, ctx);
+      case "auth":
+        return this.generateAuth(body, ctx);
+      case "guest":
+        return this.generateGuest(body, ctx);
+      case "env":
+        return this.generateEnv(params, body, ctx);
+      case "switch":
+        return this.generateSwitch(params, body, ctx);
+      case "slot":
+        return this.generateSlot(params, body, ctx);
+      case "section":
+        return this.generateSection(params, body, ctx);
+      case "push":
+        return this.generatePush(params, body, ctx);
+      case "once":
+        return this.generateOnce(body, ctx);
+      case "js":
+      case "ts":
+        return this.generateScript(body, ctx);
+      default:
+        if (ctx.dev)
+          return `  __push('@${name}${params ? `(${params})` : ""}');
+`;
+        return "";
+    }
+  }
+  generateIf(condition, body, ctx) {
+    if (!condition || !body)
+      return "";
+    let code = `  if (${condition}) {
+`;
+    ctx.indentLevel++;
+    const parts = this.splitConditionalBody(body);
+    code += parts.ifBody.map((child) => this.generateNode(child, ctx)).join("");
+    for (const elseif of parts.elseifs) {
+      code += `  }
+else if (${elseif.condition}) {
+`;
+      code += elseif.body.map((child) => this.generateNode(child, ctx)).join("");
+    }
+    if (parts.elseBody.length > 0) {
+      code += `  }
 else {
-`,j+=H.elseBody.map((J)=>this.generateNode(J,F)).join("");return F.indentLevel--,j+=`  }
-`,j}generateUnless(q,B,F){if(!q||!B)return"";let j=`  if (!(${q})) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateForeach(q,B,F){if(!q||!B)return"";let j=q.match(/^\s*(\S+)\s+as\s+(\S+)(?:\s*=>\s*(\S+))?\s*$/),H=q.match(/^\s*\(?([\w$]+)(?:,\s*([\w$]+))?\)?\s+in\s+(\S+)\s*$/),J,K,R=null;if(j)J=j[1],K=j[3]||j[2],R=j[3]?j[2]:null;else if(H)J=H[3],K=H[1],R=H[2]||null;else return"";F.usedVariables.add(J.split(".")[0]);let L=`__loop${F.varCounter++}`,O=`  const ${L} = ${J} || [];
-`;if(O+=`  for (let __i = 0; __i < ${L}.length; __i++) {
-`,O+=`    const ${K} = ${L}[__i];
-`,R)O+=`    const ${R} = __i;
-`;return O+=B.map((Q)=>this.generateNode(Q,F)).join(""),O+=`  }
-`,O}generateFor(q,B,F){if(!q||!B)return"";let j=`  for (${q}) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateWhile(q,B,F){if(!q||!B)return"";let j=`  while (${q}) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateIsset(q,B,F){if(!q||!B)return"";let j=`  if (${q} !== undefined && ${q} !== null) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateEmpty(q,B,F){if(!q||!B)return"";let j=`  if (!${q} || (Array.isArray(${q}) && ${q}.length === 0)) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateAuth(q,B){if(!q)return"";B.usedVariables.add("$auth");let F=`  if (__ctx.$auth?.user) {
-`;return F+=q.map((j)=>this.generateNode(j,B)).join(""),F+=`  }
-`,F}generateGuest(q,B){if(!q)return"";B.usedVariables.add("$auth");let F=`  if (!__ctx.$auth?.user) {
-`;return F+=q.map((j)=>this.generateNode(j,B)).join(""),F+=`  }
-`,F}generateEnv(q,B,F){if(!q||!B)return"";F.usedVariables.add("$env");let j=`  if (__ctx.$env === ${q}) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateSwitch(q,B,F){if(!q||!B)return"";let j=`  switch (${q}) {
-`;return j+=B.map((H)=>this.generateNode(H,F)).join(""),j+=`  }
-`,j}generateSlot(q,B,F){let j=q?.replace(/['"]/g,"")||"default";F.hasSlots=!0;let H=`  if (__ctx.$slots?.['${j}']) {
-`;if(H+=`    __push(__ctx.$slots['${j}']());
-`,H+="  }",B&&B.length>0)H+=` else {
-`,H+=B.map((J)=>this.generateNode(J,F)).join(""),H+="  }";return H+=`
-`,H}generateSection(q,B,F){if(!q||!B)return"";let j=q.replace(/['"]/g,""),H=`__section_${j.replace(/\W/g,"_")}`,J=`  const ${H} = () => {
-`;return J+=`    const __sectionHtml = [];
-`,J+=`    const __sectionPush = (s) => __sectionHtml.push(s);
-`,J+=B.map((K)=>{return this.generateNode(K,F).replace(/__push/g,"__sectionPush")}).join(""),J+=`    return __sectionHtml.join('');
-`,J+=`  };
-`,J+=`  __ctx.$sections = __ctx.$sections || {};
-`,J+=`  __ctx.$sections['${j}'] = ${H};
-`,J}generatePush(q,B,F){if(!q||!B)return"";let j=q.replace(/['"]/g,""),H=`  __ctx.$stacks = __ctx.$stacks || {};
-`;return H+=`  __ctx.$stacks['${j}'] = __ctx.$stacks['${j}'] || [];
-`,H+=`  __ctx.$stacks['${j}'].push(() => {
-`,H+=`    const __stackHtml = [];
-`,H+=`    const __stackPush = (s) => __stackHtml.push(s);
-`,H+=B.map((J)=>{return this.generateNode(J,F).replace(/__push/g,"__stackPush")}).join(""),H+=`    return __stackHtml.join('');
-`,H+=`  });
-`,H}generateOnce(q,B){if(!q)return"";let F=`__once_${B.varCounter++}`,j=`  if (!__ctx.$once?.has('${F}')) {
-`;return j+=`    __ctx.$once = __ctx.$once || new Set();
-`,j+=`    __ctx.$once.add('${F}');
-`,j+=q.map((H)=>this.generateNode(H,B)).join(""),j+=`  }
-`,j}generateScript(q,B){if(!q)return"";return""}generateStyle(q,B){if(!q.content)return"";let F=q.content.trim();if(q.scoped)return`  __push('<style data-scoped>${F}</style>');
-`;return`  __push('<style>${F}</style>');
-`}generateElement(q,B){let F="";F+=`  __push('<${q.tag}');
-`;for(let j of q.attributes)F+=this.generateAttribute(j,B);if(q.void)F+=`  __push('>');
-`;else if(q.selfClosing&&q.children.length===0)F+=`  __push(' />');
-`;else{F+=`  __push('>');
-`;for(let j of q.children)F+=this.generateNode(j,B);F+=`  __push('</${q.tag}>');
-`}return F}generateAttribute(q,B){let{name:F,value:j}=q;if(j===null)return`  __push(' ${F}');
-`;else if(typeof j==="string")if(j.includes("{{")||j.includes("{!!")){let H=this.parseAttributeValue(j,B);return`  __push(' ${F}="' + ${H} + '"');
-`}else return`  __push(' ${F}="${j}"');
-`;else if(U(j)){let H=j.expression.trim();if(j.escaped)return`  __push(' ${F}="' + __escape(${H}) + '"');
-`;else return`  __push(' ${F}="' + ${H} + '"');
-`}return""}parseAttributeValue(q,B){let F=[],j=0,H=/\{\{(.+?)\}\}|\{!!(.+?)!!\}/g,J=H.exec(q);while(J!==null){if(J.index>j)F.push(JSON.stringify(q.slice(j,J.index)));if(J[1]){let K=J[1].trim();B.usedVariables.add(K.split(/[.[(]/)[0]),F.push(`__escape(${K})`)}else if(J[2]){let K=J[2].trim();B.usedVariables.add(K.split(/[.[(]/)[0]),F.push(`String(${K})`)}j=J.index+J[0].length,J=H.exec(q)}if(j<q.length)F.push(JSON.stringify(q.slice(j)));return F.join(" + ")}generateComponent(q,B){let{name:F,attributes:j,children:H}=q;B.usedComponents.add(F);let J="{",K=[];for(let L of j)if(L.value===null)K.push(`${L.name}: true`);else if(typeof L.value==="string")if(L.name.startsWith(":")){let O=L.name.slice(1);K.push(`${O}: ${L.value}`)}else K.push(`${L.name}: ${JSON.stringify(L.value)}`);else if(U(L.value))K.push(`${L.name}: ${L.value.expression}`);J+=K.join(", "),J+="}";let R="{}";if(H.length>0)R=`{ default: () => { const __slotHtml = []; const __push = (s) => __slotHtml.push(s); ${H.map((O)=>this.generateNode(O,B)).join("").replace(/^\s+/gm,"")} return __slotHtml.join(''); } }`;return`  __push(await __ctx.$components['${F}'](${J}, ${R}));
-`}splitConditionalBody(q){let B={ifBody:[],elseifs:[],elseBody:[]},F="if",j=null;for(let H of q){if(W(H)){if(H.name==="elseif"){if(j)B.elseifs.push(j);j={condition:H.params||"true",body:[]},F="elseif";continue}else if(H.name==="else"){if(j)B.elseifs.push(j),j=null;F="else";continue}}switch(F){case"if":B.ifBody.push(H);break;case"elseif":if(j)j.body.push(H);break;case"else":B.elseBody.push(H);break}}if(j)B.elseifs.push(j);return B}wrapModule(q,B,F,j){switch(F){case"esm":return`${q}
+`;
+      code += parts.elseBody.map((child) => this.generateNode(child, ctx)).join("");
+    }
+    ctx.indentLevel--;
+    code += `  }
+`;
+    return code;
+  }
+  generateUnless(condition, body, ctx) {
+    if (!condition || !body)
+      return "";
+    let code = `  if (!(${condition})) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateForeach(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    const asMatch = params.match(/^\s*(\S+)\s+as\s+(\S+)(?:\s*=>\s*(\S+))?\s*$/), inMatch = params.match(/^\s*\(?([\w$]+)(?:,\s*([\w$]+))?\)?\s+in\s+(\S+)\s*$/);
+    let items, item, index = null;
+    if (asMatch) {
+      items = asMatch[1];
+      item = asMatch[3] || asMatch[2];
+      index = asMatch[3] ? asMatch[2] : null;
+    } else if (inMatch) {
+      items = inMatch[3];
+      item = inMatch[1];
+      index = inMatch[2] || null;
+    } else
+      return "";
+    ctx.usedVariables.add(items.split(".")[0]);
+    const loopVar = `__loop${ctx.varCounter++}`;
+    let code = `  const ${loopVar} = ${items} || [];
+`;
+    code += `  for (let __i = 0; __i < ${loopVar}.length; __i++) {
+`;
+    code += `    const ${item} = ${loopVar}[__i];
+`;
+    if (index)
+      code += `    const ${index} = __i;
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateFor(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    let code = `  for (${params}) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateWhile(condition, body, ctx) {
+    if (!condition || !body)
+      return "";
+    let code = `  while (${condition}) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateIsset(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    let code = `  if (${params} !== undefined && ${params} !== null) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateEmpty(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    let code = `  if (!${params} || (Array.isArray(${params}) && ${params}.length === 0)) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateAuth(body, ctx) {
+    if (!body)
+      return "";
+    ctx.usedVariables.add("$auth");
+    let code = `  if (__ctx.$auth?.user) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateGuest(body, ctx) {
+    if (!body)
+      return "";
+    ctx.usedVariables.add("$auth");
+    let code = `  if (!__ctx.$auth?.user) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateEnv(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    ctx.usedVariables.add("$env");
+    let code = `  if (__ctx.$env === ${params}) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateSwitch(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    let code = `  switch (${params}) {
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateSlot(params, body, ctx) {
+    const slotName = params?.replace(/['"]/g, "") || "default";
+    ctx.hasSlots = !0;
+    let code = `  if (__ctx.$slots?.['${slotName}']) {
+`;
+    code += `    __push(__ctx.$slots['${slotName}']());
+`;
+    code += "  }";
+    if (body && body.length > 0) {
+      code += ` else {
+`;
+      code += body.map((child) => this.generateNode(child, ctx)).join("");
+      code += "  }";
+    }
+    code += `
+`;
+    return code;
+  }
+  generateSection(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    const sectionName = params.replace(/['"]/g, ""), sectionVar = `__section_${sectionName.replace(/\W/g, "_")}`;
+    let code = `  const ${sectionVar} = () => {
+`;
+    code += `    const __sectionHtml = [];
+`;
+    code += `    const __sectionPush = (s) => __sectionHtml.push(s);
+`;
+    code += body.map((child) => {
+      return this.generateNode(child, ctx).replace(/__push/g, "__sectionPush");
+    }).join("");
+    code += `    return __sectionHtml.join('');
+`;
+    code += `  };
+`;
+    code += `  __ctx.$sections = __ctx.$sections || {};
+`;
+    code += `  __ctx.$sections['${sectionName}'] = ${sectionVar};
+`;
+    return code;
+  }
+  generatePush(params, body, ctx) {
+    if (!params || !body)
+      return "";
+    const stackName = params.replace(/['"]/g, "");
+    let code = `  __ctx.$stacks = __ctx.$stacks || {};
+`;
+    code += `  __ctx.$stacks['${stackName}'] = __ctx.$stacks['${stackName}'] || [];
+`;
+    code += `  __ctx.$stacks['${stackName}'].push(() => {
+`;
+    code += `    const __stackHtml = [];
+`;
+    code += `    const __stackPush = (s) => __stackHtml.push(s);
+`;
+    code += body.map((child) => {
+      return this.generateNode(child, ctx).replace(/__push/g, "__stackPush");
+    }).join("");
+    code += `    return __stackHtml.join('');
+`;
+    code += `  });
+`;
+    return code;
+  }
+  generateOnce(body, ctx) {
+    if (!body)
+      return "";
+    const onceId = `__once_${ctx.varCounter++}`;
+    let code = `  if (!__ctx.$once?.has('${onceId}')) {
+`;
+    code += `    __ctx.$once = __ctx.$once || new Set();
+`;
+    code += `    __ctx.$once.add('${onceId}');
+`;
+    code += body.map((child) => this.generateNode(child, ctx)).join("");
+    code += `  }
+`;
+    return code;
+  }
+  generateScript(body, _ctx) {
+    if (!body)
+      return "";
+    return "";
+  }
+  generateStyle(node, _ctx) {
+    if (!node.content)
+      return "";
+    const content = node.content.trim();
+    if (node.scoped)
+      return `  __push('<style data-scoped>${content}</style>');
+`;
+    return `  __push('<style>${content}</style>');
+`;
+  }
+  generateElement(node, ctx) {
+    let code = "";
+    code += `  __push('<${node.tag}');
+`;
+    for (const attr of node.attributes)
+      code += this.generateAttribute(attr, ctx);
+    if (node.void)
+      code += `  __push('>');
+`;
+    else if (node.selfClosing && node.children.length === 0)
+      code += `  __push(' />');
+`;
+    else {
+      code += `  __push('>');
+`;
+      for (const child of node.children)
+        code += this.generateNode(child, ctx);
+      code += `  __push('</${node.tag}>');
+`;
+    }
+    return code;
+  }
+  generateAttribute(attr, ctx) {
+    const { name, value } = attr;
+    if (value === null)
+      return `  __push(' ${name}');
+`;
+    else if (typeof value === "string")
+      if (value.includes("{{") || value.includes("{!!")) {
+        const parts = this.parseAttributeValue(value, ctx);
+        return `  __push(' ${name}="' + ${parts} + '"');
+`;
+      } else
+        return `  __push(' ${name}="${value}"');
+`;
+    else if (isExpressionNode(value)) {
+      const expr = value.expression.trim();
+      if (value.escaped)
+        return `  __push(' ${name}="' + __escape(${expr}) + '"');
+`;
+      else
+        return `  __push(' ${name}="' + ${expr} + '"');
+`;
+    }
+    return "";
+  }
+  parseAttributeValue(value, ctx) {
+    const parts = [];
+    let lastIndex = 0;
+    const regex = /\{\{(.+?)\}\}|\{!!(.+?)!!\}/g;
+    let match = regex.exec(value);
+    while (match !== null) {
+      if (match.index > lastIndex)
+        parts.push(JSON.stringify(value.slice(lastIndex, match.index)));
+      if (match[1]) {
+        const expr = match[1].trim();
+        ctx.usedVariables.add(expr.split(/[.[(]/)[0]);
+        parts.push(`__escape(${expr})`);
+      } else if (match[2]) {
+        const expr = match[2].trim();
+        ctx.usedVariables.add(expr.split(/[.[(]/)[0]);
+        parts.push(`String(${expr})`);
+      }
+      lastIndex = match.index + match[0].length;
+      match = regex.exec(value);
+    }
+    if (lastIndex < value.length)
+      parts.push(JSON.stringify(value.slice(lastIndex)));
+    return parts.join(" + ");
+  }
+  generateComponent(node, ctx) {
+    const { name, attributes, children } = node;
+    ctx.usedComponents.add(name);
+    let propsCode = "{";
+    const propParts = [];
+    for (const attr of attributes)
+      if (attr.value === null)
+        propParts.push(`${attr.name}: true`);
+      else if (typeof attr.value === "string")
+        if (attr.name.startsWith(":")) {
+          const propName = attr.name.slice(1);
+          propParts.push(`${propName}: ${attr.value}`);
+        } else
+          propParts.push(`${attr.name}: ${JSON.stringify(attr.value)}`);
+      else if (isExpressionNode(attr.value))
+        propParts.push(`${attr.name}: ${attr.value.expression}`);
+    propsCode += propParts.join(", ");
+    propsCode += "}";
+    let slotsCode = "{}";
+    if (children.length > 0)
+      slotsCode = `{ default: () => { const __slotHtml = []; const __push = (s) => __slotHtml.push(s); ${children.map((child) => this.generateNode(child, ctx)).join("").replace(/^\s+/gm, "")} return __slotHtml.join(''); } }`;
+    return `  __push(await __ctx.$components['${name}'](${propsCode}, ${slotsCode}));
+`;
+  }
+  splitConditionalBody(body) {
+    const result = {
+      ifBody: [],
+      elseifs: [],
+      elseBody: []
+    };
+    let current = "if", currentElseif = null;
+    for (const node of body) {
+      if (isDirectiveNode(node)) {
+        if (node.name === "elseif") {
+          if (currentElseif)
+            result.elseifs.push(currentElseif);
+          currentElseif = { condition: node.params || "true", body: [] };
+          current = "elseif";
+          continue;
+        } else if (node.name === "else") {
+          if (currentElseif) {
+            result.elseifs.push(currentElseif);
+            currentElseif = null;
+          }
+          current = "else";
+          continue;
+        }
+      }
+      switch (current) {
+        case "if":
+          result.ifBody.push(node);
+          break;
+        case "elseif":
+          if (currentElseif)
+            currentElseif.body.push(node);
+          break;
+        case "else":
+          result.elseBody.push(node);
+          break;
+      }
+    }
+    if (currentElseif)
+      result.elseifs.push(currentElseif);
+    return result;
+  }
+  wrapModule(functionCode, functionName, format, _ctx) {
+    switch (format) {
+      case "esm":
+        return `${functionCode}
 
 export { render };
 export default render;
-`;case"cjs":return`${q}
+`;
+      case "cjs":
+        return `${functionCode}
 
 module.exports = render;
 module.exports.render = render;
-`;case"iife":return`var ${B} = (function() {
-${q}
+`;
+      case "iife":
+        return `var ${functionName} = (function() {
+${functionCode}
 
 return render;
 })();
-`;default:return q}}}function Z(q){let B=[],F=q.match(/\b[a-z_$]\w*\b/gi)||[],j=new Set(["true","false","null","undefined","NaN","Infinity","if","else","for","while","do","switch","case","break","continue","return","function","const","let","var","class","new","this","typeof","instanceof","in","of","delete","void","try","catch","finally","throw","async","await","yield","import","export","default","from","as","Math","Date","Array","Object","String","Number","Boolean","RegExp","JSON","console","window","document","global","process"]);for(let H of F)if(!j.has(H)&&!B.includes(H))B.push(H);return B}var M=new k;export{M as compiler,k as TemplateCompiler};
+`;
+      default:
+        return functionCode;
+    }
+  }
+}
+function extractVariables(expression) {
+  const variables = [], matches = expression.match(/\b[a-z_$]\w*\b/gi) || [], keywords = new Set([
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "NaN",
+    "Infinity",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "return",
+    "function",
+    "const",
+    "let",
+    "var",
+    "class",
+    "new",
+    "this",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "delete",
+    "void",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "async",
+    "await",
+    "yield",
+    "import",
+    "export",
+    "default",
+    "from",
+    "as",
+    "Math",
+    "Date",
+    "Array",
+    "Object",
+    "String",
+    "Number",
+    "Boolean",
+    "RegExp",
+    "JSON",
+    "console",
+    "window",
+    "document",
+    "global",
+    "process"
+  ]);
+  for (const match of matches)
+    if (!keywords.has(match) && !variables.includes(match))
+      variables.push(match);
+  return variables;
+}
+function _addMapping(ctx, generated, original) {
+  if (ctx.sourceMapGenerator)
+    ctx.sourceMapGenerator.addMapping({
+      generated,
+      original,
+      source: ctx.sourceFile
+    });
+}
+export const compiler = new TemplateCompiler;