coffeehaml 0.6.0 → 0.7.1

package/dist/emitter.js

@@ -1,756 +1,791 @@
-import { Element, ImplicitDiv, Text, Output, ControlFlow, Comment, Filter, Doctype, Expression, } from './ast.js';
-import { compileExpression, compileStatement } from './expressions.js';
-import { SourceMapGenerator } from 'source-map';
-// ─── Void elements (self-closing, no children) ─────────────
-const VOID_ELEMENTS = new Set([
-    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-    'link', 'meta', 'param', 'source', 'track', 'wbr',
-]);
-// ─── Emit State ────────────────────────────────────────────
-class EmitState {
-    constructor(options = {}) {
-        this.indent = 0;
-        this.output = '';
-        this.needsFragment = false;
-        this.needsImport = false;
-        this.sourceMapGenerator = null;
-        this.outputLine = 0;
-        this.warnings = [];
-        this.hoisted = []; // statement JS hoisted before return
-        this.directEmit = false; // emit statements inline (wrap='none')
-        this.options = options;
-        if (options.sourceMap && options.filename) {
-            this.sourceMapGenerator = new SourceMapGenerator({ file: options.filename });
-        }
+// Generated by CoffeeScript 2.7.0
+// emitter.coffee — AST → JSX/JS code generation
+var EmitState, VOID_ELEMENTS, attrNameToJs, buildAttributes, compileComponentBody, emitArrowOutput, emitArrowOutputToJs, emitChildToJs, emitComment, emitConditional, emitControlFlow, emitControlFlowToJs, emitDoctype, emitElement, emitElseBranch, emitFilter, emitFilterToJs, emitImplicitDiv, emitLoop, emitNode, emitNodes, emitOutput, emitStatement, emitText, escapeString, mapSourceLocation, splitJsStatements, tagToJs;
+
+import {
+  Document,
+  Element,
+  ImplicitDiv,
+  Text,
+  Output,
+  ControlFlow,
+  Comment,
+  Filter,
+  Doctype,
+  Node,
+  Expression
+} from './ast.js';
+
+import {
+  compileExpression,
+  compileStatement
+} from './expressions.js';
+
+import {
+  CompileWarning
+} from './types.js';
+
+import {
+  SourceMapGenerator
+} from 'source-map';
+
+VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+
+EmitState = (function() {
+  // ─── Emit State ────────────────────────────────────────────
+  class EmitState {
+    constructor(options1 = {}) {
+      this.options = options1;
+      if (this.options.sourceMap && this.options.filename) {
+        this.sourceMapGenerator = new SourceMapGenerator({
+          file: this.options.filename
+        });
+      }
     }
+
     emit(s) {
-        if (s) {
-            this.output += ' '.repeat(this.indent * 2) + s;
-        }
+      if (s) {
+        return this.output += ' '.repeat(this.indent * 2) + s;
+      }
     }
+
     emitLine(s = '') {
-        if (s) {
-            this.output += ' '.repeat(this.indent * 2) + s;
-        }
-        this.output += '\n';
-        this.outputLine++;
+      if (s) {
+        this.output += ' '.repeat(this.indent * 2) + s;
+      }
+      this.output += '\n';
+      return this.outputLine++;
     }
+
     mapSource(loc) {
-        if (!this.sourceMapGenerator || !loc)
-            return;
-        const outputCol = this.indent * 2;
-        this.sourceMapGenerator.addMapping({
-            generated: { line: this.outputLine + 1, column: outputCol },
-            original: { line: loc.line + 1, column: loc.column },
-            source: this.options.filename || 'source.coffeehaml',
-        });
-    }
+      var outputCol;
+      if (!(this.sourceMapGenerator && loc)) {
+        return;
+      }
+      outputCol = this.indent * 2;
+      return this.sourceMapGenerator.addMapping({
+        generated: {
+          line: this.outputLine + 1,
+          column: outputCol
+        },
+        original: {
+          line: loc.line + 1,
+          column: loc.column
+        },
+        source: this.options.filename || 'source.coffeehaml'
+      });
+    }
+
     indentBlock(fn) {
-        this.indent++;
-        fn();
-        this.indent--;
-    }
-}
+      this.indent++;
+      fn();
+      return this.indent--;
+    }
+
+  };
+
+  EmitState.prototype.indent = 0;
+
+  EmitState.prototype.output = '';
+
+  EmitState.prototype.needsFragment = false;
+
+  EmitState.prototype.needsImport = false;
+
+  EmitState.prototype.options = null;
+
+  EmitState.prototype.sourceMapGenerator = null;
+
+  EmitState.prototype.outputLine = 0;
+
+  EmitState.prototype.warnings = [];
+
+  EmitState.prototype.hoisted = [];
+
+  EmitState.prototype.directEmit = false;
+
+  return EmitState;
+
+}).call(this);
+
 // ─── Public API ────────────────────────────────────────────
-export function emit(ast, options = {}) {
-    const state = new EmitState(options);
-    // Emit import (always needed)
-    state.emitLine(`import { jsx, jsxs, Fragment } from "${options.jsxRuntime || 'react/jsx-runtime'}";`);
-    // Emit prologue lines (verbatim JS before any HAML)
-    if (ast.prologue && ast.prologue.length > 0) {
-        for (const line of ast.prologue) {
-            state.emitLine(line);
-        }
-    }
-    state.emitLine();
-    // Component / HOC wrapping
-    const wrap = options.wrap;
-    if (wrap && wrap !== 'none') {
-        const name = options.componentName || 'Component';
-        const hocs = wrap === 'component' ? [] : wrap === 'observer' ? ['observer'] : wrap;
-        const bodyExpr = compileComponentBody(ast, state);
-        const inner = `function ${name}(props) { return ${bodyExpr}; }`;
-        const wrapped = hocs.reduceRight((acc, hoc) => `${hoc}(${acc})`, inner);
-        state.emitLine(`export default ${wrapped}`);
-    }
-    else {
-        state.directEmit = true;
-        emitNodes(ast.children, state, true);
-    }
-    const result = { code: state.output, warnings: state.warnings };
-    if (state.sourceMapGenerator) {
-        result.sourceMap = state.sourceMapGenerator.toString();
-    }
-    return result;
-}
-// ─── Node Emitters ─────────────────────────────────────────
+export var emit = function(ast, options = {}) {
+  var bodyExpr, hocs, inner, j, len, line, name, ref, result, state, wrap, wrapped;
+  state = new EmitState(options);
+  state.emitLine(`import { jsx, jsxs, Fragment } from \"${options.jsxRuntime || 'react/jsx-runtime'}\";`);
+  // Emit prologue lines
+  if (ast.prologue && ast.prologue.length > 0) {
+    ref = ast.prologue;
+    for (j = 0, len = ref.length; j < len; j++) {
+      line = ref[j];
+      state.emitLine(line);
+    }
+  }
+  state.emitLine();
+  wrap = options.wrap;
+  if (wrap && wrap !== 'none') {
+    name = options.componentName || 'Component';
+    hocs = (function() {
+      switch (wrap) {
+        case 'component':
+          return [];
+        case 'observer':
+          return ['observer'];
+        default:
+          return wrap;
+      }
+    })();
+    bodyExpr = compileComponentBody(ast, state);
+    inner = `function ${name}(props) { return ${bodyExpr}; }`;
+    wrapped = hocs.reduceRight((function(acc, hoc) {
+      return `${hoc}(${acc})`;
+    }), inner);
+    state.emitLine(`export default ${wrapped}`);
+  } else {
+    state.directEmit = true;
+    emitNodes(ast.children, state, true);
+  }
+  result = {
+    code: state.output,
+    warnings: state.warnings
+  };
+  if (state.sourceMapGenerator) {
+    result.sourceMap = state.sourceMapGenerator.toString();
+  }
+  return result;
+};
+
 // ─── Component Body Compilation ─────────────────────────────
-/** Emit all root children as a single JSX expression for component return. */
-function compileComponentBody(ast, state) {
-    // Emit to a temporary buffer to capture statement-level output
-    const tmpState = new EmitState(state.options);
-    tmpState.indent = state.indent;
-    // emitNodes handles control flow consuming subsequent siblings
-    emitNodes(ast.children, tmpState, true);
-    // Transfer warnings and hoisted statements from temp state
-    state.warnings.push(...tmpState.warnings);
-    const body = tmpState.output.trim();
-    // Hoisted statements (from - blocks) go before the return
-    const hoistedJs = tmpState.hoisted.length > 0
-        ? tmpState.hoisted.join('; ') + '; '
-        : '';
-    if (!body) {
-        if (hoistedJs)
-            return `(() => { ${hoistedJs}return null; })()`;
-        return 'null';
-    }
-    // Split into JS statements respecting brackets and strings
-    const stmts = splitJsStatements(body);
-    const jsx = stmts.length === 0 ? 'null'
-        : stmts.length === 1 ? stmts[0]
-            : `jsxs(Fragment, { children: [${stmts.join(', ')}] })`;
+compileComponentBody = function(ast, state) {
+  var body, hoistedJs, jsx, stmts, tmpState;
+  tmpState = new EmitState(state.options);
+  tmpState.indent = state.indent;
+  emitNodes(ast.children, tmpState, true);
+  state.warnings.push(...tmpState.warnings);
+  body = tmpState.output.trim();
+  hoistedJs = tmpState.hoisted.length > 0 ? tmpState.hoisted.join('; ') + '; ' : '';
+  if (!body) {
     if (hoistedJs) {
-        return `(() => { ${hoistedJs}return ${jsx}; })()`;
+      return `(()-> { ${hoistedJs}return null; })()`;
     }
-    return jsx;
-}
-/** Split JS body into top-level statements, respecting string literals
- *  and bracket depth. Only splits on `;` at depth 0 followed by newline. */
-function splitJsStatements(body) {
-    const stmts = [];
-    let depth = 0; // {} [] ()
-    let inString = null;
-    let start = 0;
-    for (let i = 0; i < body.length; i++) {
-        const ch = body[i];
-        if (inString) {
-            if (ch === '\\') {
-                i++;
-                continue;
-            }
-            if (ch === inString) {
-                inString = null;
-            }
-            continue;
-        }
-        if (ch === "'" || ch === '"' || ch === '`') {
-            inString = ch;
-            continue;
-        }
-        if (ch === '{' || ch === '[' || ch === '(') {
-            depth++;
-            continue;
-        }
-        if (ch === '}' || ch === ']' || ch === ')') {
-            depth--;
-            continue;
-        }
-        if (ch === ';' && depth === 0 && body[i + 1] === '\n') {
-            let stmt = body.slice(start, i).trim();
-            if (stmt)
-                stmts.push(stmt);
-            start = i + 2; // skip ;\n
-            i++; // skip \n
-        }
-    }
-    // Trailing content after last ;
-    const last = body.slice(start).trim();
-    if (last) {
-        stmts.push(last.endsWith(';') ? last.slice(0, -1).trim() : last);
-    }
-    return stmts;
-}
+    return 'null';
+  }
+  stmts = splitJsStatements(body);
+  jsx = stmts.length === 0 ? 'null' : stmts.length === 1 ? stmts[0] : `jsxs(Fragment, { children: [${stmts.join(', ')}] })`;
+  if (hoistedJs) {
+    return `(()-> { ${hoistedJs}return ${jsx}; })()`;
+  }
+  return jsx;
+};
+
+splitJsStatements = function(body) {
+  var ch, depth, i, inString, last, start, stmt, stmts;
+  stmts = [];
+  depth = 0;
+  inString = null;
+  start = 0;
+  i = 0;
+  while (i < body.length) {
+    ch = body[i];
+    if (inString) {
+      if (ch === '\\') {
+        i++;
+        continue;
+      }
+      if (ch === inString) {
+        inString = null;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === '`') {
+      inString = ch;
+      i++;
+      continue;
+    }
+    if (ch === '{' || ch === '[' || ch === '(') {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === '}' || ch === ']' || ch === ')') {
+      depth--;
+      i++;
+      continue;
+    }
+    if (ch === ';' && depth === 0 && body[i + 1] === '\n') {
+      stmt = body.slice(start, i).trim();
+      if (stmt) {
+        stmts.push(stmt);
+      }
+      start = i + 2;
+      i++;
+    }
+    i++;
+  }
+  last = body.slice(start).trim();
+  if (last) {
+    stmts.push(last.endsWith(';') ? last.slice(0, -1).trim() : last);
+  }
+  return stmts;
+};
+
 // ─── Node Emitters ─────────────────────────────────────────
-function emitNodes(nodes, state, isRoot = false) {
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        if (node instanceof ControlFlow) {
-            // Control flow wraps subsequent siblings
-            const remaining = nodes.slice(i + 1);
-            emitControlFlow(node, remaining, state, isRoot);
-            return; // control flow consumes remaining nodes
-        }
-        emitNode(node, state, isRoot);
-    }
-}
-function emitNode(node, state, isRoot) {
-    if (node instanceof Element)
-        emitElement(node, state);
-    else if (node instanceof ImplicitDiv)
-        emitImplicitDiv(node, state);
-    else if (node instanceof Text)
-        emitText(node, state);
-    else if (node instanceof Output)
-        emitOutput(node, state);
-    else if (node instanceof ControlFlow)
-        emitControlFlow(node, [], state, isRoot);
-    else if (node instanceof Comment)
-        emitComment(node, state);
-    else if (node instanceof Filter)
-        emitFilter(node, state);
-    else if (node instanceof Doctype)
-        emitDoctype(node, state);
-}
+emitNodes = function(nodes, state, isRoot = false) {
+  var i, node, remaining;
+  i = 0;
+  while (i < nodes.length) {
+    node = nodes[i];
+    if (node instanceof ControlFlow) {
+      remaining = nodes.slice(i + 1);
+      emitControlFlow(node, remaining, state, isRoot);
+      return;
+    } else {
+      emitNode(node, state, isRoot);
+    }
+    i++;
+  }
+};
+
+emitNode = function(node, state, isRoot) {
+  if (node instanceof Element) {
+    return emitElement(node, state);
+  } else if (node instanceof ImplicitDiv) {
+    return emitImplicitDiv(node, state);
+  } else if (node instanceof Text) {
+    return emitText(node, state);
+  } else if (node instanceof Output) {
+    return emitOutput(node, state);
+  } else if (node instanceof ControlFlow) {
+    return emitControlFlow(node, [], state, isRoot);
+  } else if (node instanceof Comment) {
+    return emitComment(node, state);
+  } else if (node instanceof Filter) {
+    return emitFilter(node, state);
+  } else if (node instanceof Doctype) {
+    return emitDoctype(node, state);
+  }
+};
+
 // ─── Element ───────────────────────────────────────────────
-function emitElement(el, state) {
-    const isVoid = typeof el.tag === 'string' && VOID_ELEMENTS.has(el.tag);
-    const hasChildren = !isVoid && el.children.length > 0;
-    // Tag
-    const tagJs = tagToJs(el);
-    // Attributes
-    const attrResult = buildAttributes(el);
-    const attrs = attrResult.parts;
-    const keyArg = attrResult.keyExpr ? `, ${attrResult.keyExpr}` : '';
-    const attrsJs = attrs.length > 0 ? `{ ${attrs.join(', ')} }` : 'null';
-    // Children — embedded in props per React JSX runtime convention
+emitElement = function(el, state) {
+  var allAttrs, attrResult, attrs, attrsJs, childJs, childParts, childrenAttr, hasChildren, isVoid, keyArg, tagJs;
+  mapSourceLocation(el.location, state);
+  isVoid = typeof el.tag === 'string' && VOID_ELEMENTS.has(el.tag);
+  hasChildren = !isVoid && el.children.length > 0;
+  tagJs = tagToJs(el);
+  attrResult = buildAttributes(el);
+  attrs = attrResult.parts;
+  keyArg = attrResult.keyExpr ? `, ${attrResult.keyExpr}` : '';
+  if (hasChildren) {
+    if (el.children.length === 1) {
+      childJs = emitChildToJs(el.children[0], state);
+      childrenAttr = `children: ${childJs}`;
+      allAttrs = attrs.length > 0 ? `{ ${attrs.join(', ')}, ${childrenAttr} }` : `{ ${childrenAttr} }`;
+      return state.emitLine(`jsx(${tagJs}, ${allAttrs}${keyArg});`);
+    } else {
+      childParts = el.children.map(function(c) {
+        return emitChildToJs(c, state);
+      });
+      childrenAttr = `children: [${childParts.join(', ')}]`;
+      allAttrs = attrs.length > 0 ? `{ ${attrs.join(', ')}, ${childrenAttr} }` : `{ ${childrenAttr} }`;
+      return state.emitLine(`jsxs(${tagJs}, ${allAttrs}${keyArg});`);
+    }
+  } else {
+    attrsJs = attrs.length > 0 ? `{ ${attrs.join(', ')} }` : 'null';
+    return state.emitLine(`jsx(${tagJs}, ${attrsJs}${keyArg});`);
+  }
+};
+
+tagToJs = function(el) {
+  if (el.tag instanceof Expression) {
+    return compileExpression(el.tag, el.location);
+  }
+  if (el.isComponent) {
+    return el.tag;
+  }
+  return `\"${el.tag}\"`;
+};
+
+buildAttributes = function(el) {
+  var attr, classNames, filteredParts, j, joined, k, keyExpr, len, len1, name, p, parts, ref, unique, valJs;
+  parts = [];
+  if (el.id) {
+    parts.push(`id: \"${el.id}\"`);
+  }
+  classNames = el.classes.slice();
+  ref = el.attributes;
+  for (j = 0, len = ref.length; j < len; j++) {
+    attr = ref[j];
+    if (attr.spread) {
+      valJs = compileExpression(attr.expression);
+      parts.push(`...${valJs}`);
+      continue;
+    }
+    valJs = compileExpression(attr.value);
+    name = attrNameToJs(attr.name);
+    if (name === 'className' || name === 'class') {
+      if (attr.shorthand) {
+        classNames.push(`$\{${valJs}}`);
+      } else {
+        classNames.push(valJs.replace(/^['"]|['"]$/g, ''));
+      }
+    } else {
+      parts.push(`${name}: ${valJs}`);
+    }
+  }
+  if (classNames.length > 0) {
+    unique = [...new Set(classNames)];
+    if (unique.length === 1 && !unique[0].includes('${')) {
+      parts.push(`className: \"${unique[0]}\"`);
+    } else {
+      joined = unique.map(function(c) {
+        if (c.includes('${')) {
+          return c;
+        } else {
+          return `\"${c}\"`;
+        }
+      }).join(' + " " + ');
+      parts.push(`className: ${joined}`);
+    }
+  }
+  // Extract key
+  keyExpr = null;
+  filteredParts = [];
+  for (k = 0, len1 = parts.length; k < len1; k++) {
+    p = parts[k];
+    if (p.startsWith('key: ')) {
+      keyExpr = p.slice(5).trim();
+    } else {
+      filteredParts.push(p);
+    }
+  }
+  return {
+    parts: filteredParts,
+    keyExpr: keyExpr
+  };
+};
+
+attrNameToJs = function(name) {
+  if (name === 'class') {
+    return 'className';
+  }
+  if (name === 'for') {
+    return 'htmlFor';
+  }
+  if (name.includes('-')) {
+    return `\"${name}\"`;
+  }
+  return name;
+};
+
+emitImplicitDiv = function(div, state) {
+  var el;
+  mapSourceLocation(div.location, state);
+  el = new Element('div', {
+    classes: div.classes,
+    id: div.id,
+    attributes: div.attributes,
+    children: div.children,
+    isComponent: false,
+    isSelfClosing: false,
+    location: div.location
+  });
+  return emitElement(el, state);
+};
+
+// ─── Child Emission ────────────────────────────────────────
+emitChildToJs = function(node, state) {
+  var allAttrs, attrResult, attrs, attrsJs, c, childParts, childrenAttr, el, exprSource, fn, hasChildren, keyArg, tagJs, textContinuations;
+  if (node instanceof Text) {
+    return escapeString(node.value);
+  }
+  if (node instanceof Output) {
+    // Arrow continuation
+    if (node.children.length > 0 && /->\s*$/.test(node.expression.source.trim())) {
+      return emitArrowOutputToJs(node.expression.source, node.children, state);
+    }
+    textContinuations = (function() {
+      var j, len, ref, results;
+      ref = node.children;
+      results = [];
+      for (j = 0, len = ref.length; j < len; j++) {
+        c = ref[j];
+        if (c instanceof Text) {
+          results.push(c.value);
+        }
+      }
+      return results;
+    })();
+    exprSource = textContinuations.length > 0 ? [node.expression.source, ...textContinuations].join(' ') : node.expression.source;
+    return compileExpression(new Expression(exprSource), node.location);
+  }
+  if (node instanceof Element) {
+    hasChildren = node.children.length > 0;
+    tagJs = tagToJs(node);
+    attrResult = buildAttributes(node);
+    attrs = attrResult.parts;
+    keyArg = attrResult.keyExpr ? `, ${attrResult.keyExpr}` : '';
     if (hasChildren) {
-        if (el.children.length === 1) {
-            const childJs = emitChildToJs(el.children[0], state);
-            const childrenAttr = `children: ${childJs}`;
-            const allAttrs = attrs.length > 0 ? `{ ${attrs.join(', ')}, ${childrenAttr} }` : `{ ${childrenAttr} }`;
-            state.emitLine(`jsx(${tagJs}, ${allAttrs}${keyArg});`);
-        }
-        else {
-            const childParts = el.children.map(c => emitChildToJs(c, state));
-            const childrenAttr = `children: [${childParts.join(', ')}]`;
-            const allAttrs = attrs.length > 0 ? `{ ${attrs.join(', ')}, ${childrenAttr} }` : `{ ${childrenAttr} }`;
-            state.emitLine(`jsxs(${tagJs}, ${allAttrs}${keyArg});`);
-        }
-    }
-    else {
-        state.emitLine(`jsx(${tagJs}, ${attrsJs}${keyArg});`);
-    }
-}
-function tagToJs(el) {
-    if (el.tag instanceof Expression) {
-        return compileExpression(el.tag, el.location);
-    }
-    if (el.isComponent) {
-        return el.tag;
-    }
-    return `"${el.tag}"`;
-}
-function buildAttributes(el) {
-    const parts = [];
-    // id
-    if (el.id) {
-        parts.push(`id: "${el.id}"`);
-    }
-    // class from .class modifiers
-    let classNames = [...el.classes];
-    // Named attributes
-    for (const attr of el.attributes) {
-        // Spread attribute: {...props}
-        if (attr.spread) {
-            const valJs = compileExpression(attr.expression);
-            parts.push(`...${valJs}`);
-            continue;
-        }
-        const valJs = compileExpression(attr.value);
-        const name = attrNameToJs(attr.name);
-        if (name === 'className' || name === 'class') {
-            // Collect class names from className/class attribute
-            if (attr.shorthand) {
-                classNames.push(`\${${valJs}}`);
-            }
-            else {
-                classNames.push(valJs.replace(/^['"]|['"]$/g, ''));
-            }
-        }
-        else if (attr.shorthand) {
-            parts.push(`${name}: ${valJs}`);
-        }
-        else {
-            parts.push(`${name}: ${valJs}`);
-        }
-    }
-    // Emit className
-    if (classNames.length > 0) {
-        const unique = [...new Set(classNames)];
-        if (unique.length === 1 && !unique[0].includes('${')) {
-            parts.push(`className: "${unique[0]}"`);
-        }
-        else {
-            const joined = unique.map(c => c.includes('${') ? c : `"${c}"`).join(' + " " + ');
-            parts.push(`className: ${joined}`);
-        }
-    }
-    // style as object
-    const styleAttr = el.attributes.find(a => !a.spread && attrNameToJs(a.name) === 'style');
-    if (styleAttr && !styleAttr.spread && !styleAttr.shorthand) {
-        // Already handled above — but ensure it's an object expression
-    }
-    // Extract key from parts for React 3rd-arg convention
-    let keyExpr = null;
-    const filteredParts = [];
-    for (const p of parts) {
-        if (p.startsWith('key: ')) {
-            keyExpr = p.slice(5).trim();
-        }
-        else {
-            filteredParts.push(p);
-        }
-    }
-    return { parts: filteredParts, keyExpr };
-}
-function attrNameToJs(name) {
-    // class → className for React
-    if (name === 'class')
-        return 'className';
-    // for → htmlFor for React
-    if (name === 'for')
-        return 'htmlFor';
-    // data-* attributes keep their name
-    if (name.includes('-')) {
-        // Convert to camelCase quoted: 'data-value' → "data-value"
-        return `"${name}"`;
-    }
-    return name;
-}
-function emitImplicitDiv(div, state) {
-    mapSourceLocation(div.location, state);
-    const el = new Element('div', {
-        classes: div.classes,
-        id: div.id,
-        attributes: div.attributes,
-        children: div.children,
-        isComponent: false,
-        isSelfClosing: false,
-        location: div.location,
+      childParts = node.children.map(function(c) {
+        return emitChildToJs(c, state);
+      });
+      childrenAttr = childParts.length === 1 ? `children: ${childParts[0]}` : `children: [${childParts.join(', ')}]`;
+      fn = childParts.length === 1 ? 'jsx' : 'jsxs';
+      allAttrs = attrs.length > 0 ? `{ ${attrs.join(', ')}, ${childrenAttr} }` : `{ ${childrenAttr} }`;
+      return `${fn}(${tagJs}, ${allAttrs}${keyArg})`;
+    }
+    attrsJs = attrs.length > 0 ? `{ ${attrs.join(', ')} }` : 'null';
+    return `jsx(${tagJs}, ${attrsJs}${keyArg})`;
+  }
+  if (node instanceof ImplicitDiv) {
+    el = new Element('div', {
+      classes: node.classes,
+      id: node.id,
+      attributes: node.attributes,
+      children: node.children,
+      isComponent: false,
+      isSelfClosing: false,
+      location: node.location
     });
-    emitElement(el, state);
-}
-// ─── Child Emission ────────────────────────────────────────
-function emitChildToJs(node, state) {
-    if (node instanceof Text) {
-        return escapeString(node.value);
-    }
-    if (node instanceof Output) {
-        // Arrow continuation: = expr -> with indented element children
-        if (node.children.length > 0 && /->\s*$/.test(node.expression.source.trim())) {
-            return emitArrowOutputToJs(node.expression.source, node.children, state);
-        }
-        // TEXT continuation: join text children into expression
-        const textContinuations = node.children
-            .filter(c => c instanceof Text)
-            .map(c => c.value);
-        const exprSource = textContinuations.length > 0
-            ? [node.expression.source, ...textContinuations].join(' ')
-            : node.expression.source;
-        return compileExpression(new Expression(exprSource), node.location);
-    }
-    if (node instanceof Element) {
-        const hasChildren = node.children.length > 0;
-        const tagJs = tagToJs(node);
-        const attrResult = buildAttributes(node);
-        const attrs = attrResult.parts;
-        const keyArg = attrResult.keyExpr ? `, ${attrResult.keyExpr}` : '';
-        if (hasChildren) {
-            const childParts = node.children.map(c => emitChildToJs(c, state));
-            const childrenAttr = childParts.length === 1 ? `children: ${childParts[0]}` : `children: [${childParts.join(', ')}]`;
-            const fn = childParts.length === 1 ? 'jsx' : 'jsxs';
-            const allAttrs = attrs.length > 0 ? `{ ${attrs.join(', ')}, ${childrenAttr} }` : `{ ${childrenAttr} }`;
-            return `${fn}(${tagJs}, ${allAttrs}${keyArg})`;
-        }
-        const attrsJs = attrs.length > 0 ? `{ ${attrs.join(', ')} }` : 'null';
-        return `jsx(${tagJs}, ${attrsJs}${keyArg})`;
-    }
-    if (node instanceof ImplicitDiv) {
-        const el = new Element('div', {
-            classes: node.classes,
-            id: node.id,
-            attributes: node.attributes,
-            children: node.children,
-            isComponent: false,
-            isSelfClosing: false,
-            location: node.location,
-        });
-        return emitChildToJs(el, state);
-    }
-    if (node instanceof ControlFlow) {
-        return emitControlFlowToJs(node, state);
-    }
-    if (node instanceof Filter) {
-        return emitFilterToJs(node, state);
-    }
-    return 'null';
-}
+    return emitChildToJs(el, state);
+  }
+  if (node instanceof ControlFlow) {
+    return emitControlFlowToJs(node, state);
+  }
+  if (node instanceof Filter) {
+    return emitFilterToJs(node, state);
+  }
+  return 'null';
+};
+
 // ─── Control Flow ──────────────────────────────────────────
-function emitControlFlow(cf, remaining, state, _isRoot) {
-    if (cf.controlKind === 'statement') {
-        emitStatement(cf, remaining, state);
-    }
-    else if (cf.isLoop) {
-        emitLoop(cf, remaining, state);
-    }
-    else {
-        emitConditional(cf, remaining, state);
-    }
-}
-/** Emit an arbitrary CoffeeScript statement (- code). */
-function emitStatement(cf, remaining, state) {
-    // Compile as statement, preserving var→const declarations
-    const js = compileStatement(cf.expression.source.trim(), cf.location);
-    // Indented children without a '-' prefix are code continuation lines
-    // (lexed as TEXT) or nested HAML elements
-    const stmts = [js];
-    for (const child of cf.children) {
-        if (child instanceof Text) {
-            stmts.push(compileStatement(child.value, child.location));
-        }
-        else {
-            emitNode(child, state, false);
-        }
-    }
-    if (state.directEmit) {
-        for (const s of stmts)
-            state.emitLine(s + ';');
-    }
-    else {
-        state.hoisted.push(...stmts);
-    }
-    if (remaining.length > 0) {
-        emitNodes(remaining, state);
-    }
-}
-function emitLoop(cf, remaining, state) {
-    // - for item in items → items.map(item => ...)
-    // - for item, i in items → items.map((item, i) => ...)
-    // - while condition → (() => { const __r = []; while (cond) __r.push(...); return __r; })()
-    if (cf.controlKind === 'for') {
-        const expr = cf.expression.source.trim();
-        const forMatch = expr.match(/^(.+?)\s+in\s+(.+)$/);
-        if (forMatch) {
-            const vars = forMatch[1].trim(); // e.g., "item" or "item, index"
-            const iterable = forMatch[2].trim();
-            state.emit(`(${compileExpression(new Expression(iterable), cf.location)}).map((${vars}) => `);
-            // Wrap children in Fragment if multiple
-            if (cf.children.length === 0) {
-                state.output += 'null';
-            }
-            else if (cf.children.length === 1) {
-                const childJs = emitChildToJs(cf.children[0], state);
-                state.output += childJs;
-            }
-            else {
-                state.output += 'jsxs(Fragment, { children: [';
-                if (cf.children.length > 0) {
-                    state.output += cf.children.map(c => emitChildToJs(c, state)).join(', ');
-                }
-                state.output += '] })';
-            }
-            state.output += ')';
-            // Handle remaining nodes (they go after the map)
-            if (remaining.length > 0) {
-                state.output += ',\n';
-                emitNodes(remaining, state);
-            }
-            else {
-                state.output += ';\n';
-            }
-            return;
-        }
-    }
-    if (cf.controlKind === 'while') {
-        const cond = compileExpression(cf.expression, cf.location);
-        state.emitLine(`(() => {`);
-        state.indentBlock(() => {
-            state.emitLine(`const __result = [];`);
-            state.emitLine(`while (${cond}) {`);
-            state.indentBlock(() => {
-                if (cf.children.length === 1 && cf.children[0] instanceof Element) {
-                    state.emit(`__result.push(${emitChildToJs(cf.children[0], state)});\n`);
-                }
-                else {
-                    state.emit(`__result.push(jsxs(Fragment, { children: [${cf.children.map(c => emitChildToJs(c, state)).join(', ')}] }));\n`);
-                }
-            });
-            state.emitLine(`}`);
-            state.emitLine(`return __result;`);
-        });
-        state.emit(`})()`);
-        if (remaining.length > 0) {
-            state.output += ',\n';
-            emitNodes(remaining, state);
-        }
-        else {
-            state.output += ';\n';
-        }
-        return;
-    }
-    // Fallback
-    state.emitLine(`/* TODO: emit loop ${cf.controlKind} */`);
-}
-function emitConditional(cf, remaining, state) {
-    // else is always reached via cf.next chain — the " : " was emitted by parent
-    if (cf.controlKind === 'else') {
-        emitElseBranch(cf, state);
-        return;
-    }
-    // Build ternary chain: cond ? jsx(...) : (elseCond ? jsx(...) : null)
-    const condition = compileExpression(cf.expression, cf.location);
-    if (cf.controlKind === 'unless') {
-        // unless cond → !(cond)
-        state.emit(`!(${condition}) ? `);
-    }
-    else {
-        state.emit(`${condition} ? `);
-    }
-    // Then branch
-    if (cf.children.length === 0) {
-        state.output += 'null';
-    }
-    else if (cf.children.length === 1) {
-        state.output += emitChildToJs(cf.children[0], state);
-    }
-    else {
-        state.output += `jsxs(Fragment, { children: [${cf.children.map(c => emitChildToJs(c, state)).join(', ')}] })`;
-    }
-    // Else / remaining
-    state.output += ' : ';
-    if (cf.next) {
-        emitConditional(cf.next, [], state);
-    }
-    else if (remaining.length > 0) {
-        if (remaining.length === 1) {
-            state.output += emitChildToJs(remaining[0], state);
-        }
-        else {
-            state.output += `jsxs(Fragment, { children: [${remaining.map(c => emitChildToJs(c, state)).join(', ')}] })`;
-        }
-    }
-    else {
-        state.output += 'null';
-    }
-    state.output += ';\n';
-}
-/** Emit the body of an else branch — no condition prefix. */
-function emitElseBranch(cf, state) {
-    if (cf.children.length === 0) {
+emitControlFlow = function(cf, remaining, state, _isRoot) {
+  if (cf.controlKind === 'statement') {
+    return emitStatement(cf, remaining, state);
+  } else if (cf.isLoop()) {
+    return emitLoop(cf, remaining, state);
+  } else {
+    return emitConditional(cf, remaining, state);
+  }
+};
+
+emitStatement = function(cf, remaining, state) {
+  var child, j, js, k, len, len1, ref, s, stmts;
+  js = compileStatement(cf.expression.source.trim(), cf.location);
+  stmts = [js];
+  ref = cf.children;
+  for (j = 0, len = ref.length; j < len; j++) {
+    child = ref[j];
+    if (child instanceof Text) {
+      stmts.push(compileStatement(child.value, child.location));
+    } else {
+      emitNode(child, state, false);
+    }
+  }
+  if (state.directEmit) {
+    for (k = 0, len1 = stmts.length; k < len1; k++) {
+      s = stmts[k];
+      state.emitLine(s + ';');
+    }
+  } else {
+    state.hoisted.push(...stmts);
+  }
+  if (remaining.length > 0) {
+    return emitNodes(remaining, state);
+  }
+};
+
+emitLoop = function(cf, remaining, state) {
+  var cond, expr, forMatch, iterable, vars;
+  if (cf.controlKind === 'for') {
+    expr = cf.expression.source.trim();
+    forMatch = expr.match(/^(.+?)\s+in\s+(.+)$/);
+    if (forMatch) {
+      vars = forMatch[1].trim();
+      iterable = forMatch[2].trim();
+      state.emit(`(${compileExpression(new Expression(iterable), cf.location)}).map((${vars}) => `);
+      if (cf.children.length === 0) {
         state.output += 'null';
-    }
-    else if (cf.children.length === 1) {
+      } else if (cf.children.length === 1) {
         state.output += emitChildToJs(cf.children[0], state);
-    }
-    else {
-        state.output += `jsxs(Fragment, {}, ${cf.children.map(c => emitChildToJs(c, state)).join(', ')})`;
-    }
-}
-function emitControlFlowToJs(cf, state) {
-    // Inline version — used when control flow appears as a child
-    if (cf.isLoop && cf.controlKind === 'for') {
-        const expr = cf.expression.source.trim();
-        const forMatch = expr.match(/^(.+?)\s+in\s+(.+)$/);
-        if (forMatch) {
-            const vars = forMatch[1].trim();
-            const iterable = forMatch[2].trim();
-            const compiledIterable = compileExpression(new Expression(iterable), cf.location);
-            const body = cf.children.length === 1
-                ? emitChildToJs(cf.children[0], state)
-                : `jsxs(Fragment, { children: [${cf.children.map(c => emitChildToJs(c, state)).join(', ')}] })`;
-            return `(${compiledIterable}).map((${vars}) => ${body})`;
-        }
-    }
-    if (cf.controlKind === 'else') {
-        // inline else — just emit the body
-        return cf.children.length === 1
-            ? emitChildToJs(cf.children[0], state)
-            : cf.children.length > 0
-                ? `jsxs(Fragment, {}, ${cf.children.map(c => emitChildToJs(c, state)).join(', ')})`
-                : 'null';
-    }
-    if (cf.isConditional) {
-        const condition = compileExpression(cf.expression, cf.location);
-        const condExpr = cf.controlKind === 'unless' ? `!(${condition})` : condition;
-        const consequent = cf.children.length === 1
-            ? emitChildToJs(cf.children[0], state)
-            : cf.children.length > 0
-                ? `jsxs(Fragment, {}, ${cf.children.map(c => emitChildToJs(c, state)).join(', ')})`
-                : 'null';
-        const alternate = cf.next ? emitControlFlowToJs(cf.next, state) : 'null';
-        return `${condExpr} ? ${consequent} : ${alternate}`;
-    }
-    if (cf.controlKind === 'statement') {
-        // Inline statements can't be used as JSX children — pass through as comment
-        const js = compileExpression(cf.expression, cf.location);
-        return `/* - ${js} */ null`;
-    }
-    return 'null';
-}
+      } else {
+        state.output += `jsxs(Fragment, { children: [${cf.children.map(function(c) {
+          return emitChildToJs(c, state);
+        }).join(', ')}] })`;
+      }
+      state.output += ')';
+      if (remaining.length > 0) {
+        state.output += ',\n';
+        emitNodes(remaining, state);
+      } else {
+        state.output += ';\n';
+      }
+      return;
+    }
+  }
+  if (cf.controlKind === 'while') {
+    cond = compileExpression(cf.expression, cf.location);
+    state.emitLine('(() => {');
+    state.indentBlock(function() {
+      state.emitLine('const __result = [];');
+      state.emitLine(`while (${cond}) {`);
+      state.indentBlock(function() {
+        if (cf.children.length === 1 && cf.children[0] instanceof Element) {
+          return state.emit(`__result.push(${emitChildToJs(cf.children[0], state)});\n`);
+        } else {
+          return state.emit(`__result.push(jsxs(Fragment, { children: [${cf.children.map(function(c) {
+            return emitChildToJs(c, state);
+          }).join(', ')}] }));\n`);
+        }
+      });
+      state.emitLine('}');
+      return state.emitLine('return __result;');
+    });
+    state.emit('})()');
+    if (remaining.length > 0) {
+      state.output += ',\n';
+      emitNodes(remaining, state);
+    } else {
+      state.output += ';\n';
+    }
+    return;
+  }
+  return state.emitLine(`/* TODO: emit loop ${cf.controlKind} */`);
+};
+
+emitConditional = function(cf, remaining, state) {
+  var condition;
+  if (cf.controlKind === 'else') {
+    emitElseBranch(cf, state);
+    return;
+  }
+  condition = compileExpression(cf.expression, cf.location);
+  if (cf.controlKind === 'unless') {
+    state.emit(`!(${condition}) ? `);
+  } else {
+    state.emit(`${condition} ? `);
+  }
+  // Then branch
+  if (cf.children.length === 0) {
+    state.output += 'null';
+  } else if (cf.children.length === 1) {
+    state.output += emitChildToJs(cf.children[0], state);
+  } else {
+    state.output += `jsxs(Fragment, { children: [${cf.children.map(function(c) {
+      return emitChildToJs(c, state);
+    }).join(', ')}] })`;
+  }
+  state.output += ' : ';
+  if (cf.next) {
+    emitConditional(cf.next, [], state);
+  } else if (remaining.length > 0) {
+    if (remaining.length === 1) {
+      state.output += emitChildToJs(remaining[0], state);
+    } else {
+      state.output += `jsxs(Fragment, { children: [${remaining.map(function(c) {
+        return emitChildToJs(c, state);
+      }).join(', ')}] })`;
+    }
+  } else {
+    state.output += 'null';
+  }
+  return state.output += ';\n';
+};
+
+emitElseBranch = function(cf, state) {
+  if (cf.children.length === 0) {
+    return state.output += 'null';
+  } else if (cf.children.length === 1) {
+    return state.output += emitChildToJs(cf.children[0], state);
+  } else {
+    return state.output += `jsxs(Fragment, {}, ${cf.children.map(function(c) {
+      return emitChildToJs(c, state);
+    }).join(', ')})`;
+  }
+};
+
+emitControlFlowToJs = function(cf, state) {
+  var alternate, body, compiledIterable, condExpr, condition, consequent, expr, forMatch, iterable, js, vars;
+  if (cf.isLoop() && cf.controlKind === 'for') {
+    expr = cf.expression.source.trim();
+    forMatch = expr.match(/^(.+?)\s+in\s+(.+)$/);
+    if (forMatch) {
+      vars = forMatch[1].trim();
+      iterable = forMatch[2].trim();
+      compiledIterable = compileExpression(new Expression(iterable), cf.location);
+      body = cf.children.length === 1 ? emitChildToJs(cf.children[0], state) : `jsxs(Fragment, { children: [${cf.children.map(function(c) {
+        return emitChildToJs(c, state);
+      }).join(', ')}] })`;
+      return `(${compiledIterable}).map((${vars}) => ${body})`;
+    }
+  }
+  if (cf.controlKind === 'else') {
+    if (cf.children.length === 1) {
+      return emitChildToJs(cf.children[0], state);
+    } else if (cf.children.length > 0) {
+      return `jsxs(Fragment, {}, ${cf.children.map(function(c) {
+        return emitChildToJs(c, state);
+      }).join(', ')})`;
+    } else {
+      return 'null';
+    }
+  }
+  if (cf.isConditional()) {
+    condition = compileExpression(cf.expression, cf.location);
+    condExpr = cf.controlKind === 'unless' ? `!(${condition})` : condition;
+    consequent = cf.children.length === 1 ? emitChildToJs(cf.children[0], state) : cf.children.length > 0 ? `jsxs(Fragment, {}, ${cf.children.map(function(c) {
+      return emitChildToJs(c, state);
+    }).join(', ')})` : 'null';
+    alternate = cf.next ? emitControlFlowToJs(cf.next, state) : 'null';
+    return `${condExpr} ? ${consequent} : ${alternate}`;
+  }
+  if (cf.controlKind === 'statement') {
+    js = compileExpression(cf.expression, cf.location);
+    return `/* - ${js} */ null`;
+  }
+  return 'null';
+};
+
 // ─── Text / Output / Comment / Filter / Doctype ────────────
-function emitText(text, state) {
-    // Standalone text at module level — emit as string expression
-    state.emitLine(`"${escapeString(text.value)}";`);
-}
-function emitOutput(out, state) {
-    // Separate continuation children into TEXT (code lines to join) and elements
-    const textLines = [];
-    const elementChildren = [];
-    for (const child of out.children) {
-        if (child instanceof Text) {
-            textLines.push(child.value);
-        }
-        else {
-            elementChildren.push(child);
-        }
-    }
-    // Build the full expression source, joining TEXT continuation lines
-    let exprSource = out.expression.source;
-    if (textLines.length > 0) {
-        exprSource = [exprSource, ...textLines].join(' ');
-    }
-    // Arrow continuation: = items.map (item) -> with indented element children
-    // Compiles to target.map((args) => <JSX>) — CoffeeScript arrow becomes JS arrow
-    if (elementChildren.length > 0 && /->\s*$/.test(exprSource.trim())) {
-        emitArrowOutput(exprSource, elementChildren, out, state);
-        return;
-    }
-    const js = compileExpression(new Expression(exprSource), out.location);
-    let result;
-    if (out.outputKind === 'escaped') {
-        result = `jsx(Fragment, { children: ${js} })`;
-    }
-    else {
-        result = `jsx(Fragment, {}, ${js})`;
-    }
-    // Emit nested element children after the expression (siblings, not body)
-    for (const child of elementChildren) {
-        emitNode(child, state, false);
-    }
-    state.emitLine(result + ';');
-}
-/** Handle = expr -> with indented element children — compiles to an arrow function
- *  returning JSX. E.g., = items.map (item) ->  + indented %li → items.map((item) => <li/>) */
-function emitArrowOutput(exprSource, elementChildren, out, state) {
-    // Parse: strip trailing ->, extract call target and arrow args
-    const stripped = exprSource.replace(/\s*->\s*$/, '').trim();
-    // Match pattern: target (args) — everything up to last parenthesized arg list
-    const arrowMatch = stripped.match(/^(.+?)\s*\(([^)]*)\)\s*$/);
-    let callTarget;
-    let arrowArgs;
-    if (arrowMatch) {
-        callTarget = arrowMatch[1].trim(); // e.g., "items.map"
-        arrowArgs = arrowMatch[2].trim(); // e.g., "item" or "item, i"
-    }
-    else {
-        // No parens: = -> with just -> (bare arrow)
-        callTarget = stripped;
-        arrowArgs = '';
-    }
-    // Compile the call target as a CoffeeScript expression
-    const compiledTarget = compileExpression(new Expression(callTarget), out.location);
-    // Compile children as JSX body
-    let body;
-    if (elementChildren.length === 1) {
-        body = emitChildToJs(elementChildren[0], state);
-    }
-    else {
-        body = `jsxs(Fragment, { children: [${elementChildren.map(c => emitChildToJs(c, state)).join(', ')}] })`;
-    }
-    // Build the final expression
-    const arrowFn = arrowArgs
-        ? `(${arrowArgs}) => ${body}`
-        : `() => ${body}`;
-    const result = out.outputKind === 'escaped'
-        ? `jsx(Fragment, { children: ${compiledTarget}(${arrowFn}) })`
-        : `jsx(Fragment, {}, ${compiledTarget}(${arrowFn}))`;
-    state.emitLine(result + ';');
-}
-/** Inline version of emitArrowOutput — returns JS string for use inside emitChildToJs. */
-function emitArrowOutputToJs(exprSource, elementChildren, state) {
-    const stripped = exprSource.replace(/\s*->\s*$/, '').trim();
-    const arrowMatch = stripped.match(/^(.+?)\s*\(([^)]*)\)\s*$/);
-    let callTarget;
-    let arrowArgs;
-    if (arrowMatch) {
-        callTarget = arrowMatch[1].trim();
-        arrowArgs = arrowMatch[2].trim();
-    }
-    else {
-        callTarget = stripped;
-        arrowArgs = '';
-    }
-    const compiledTarget = compileExpression(new Expression(callTarget));
-    let body;
-    if (elementChildren.length === 1) {
-        body = emitChildToJs(elementChildren[0], state);
-    }
-    else {
-        body = `jsxs(Fragment, { children: [${elementChildren.map(c => emitChildToJs(c, state)).join(', ')}] })`;
-    }
-    const arrowFn = arrowArgs
-        ? `(${arrowArgs}) => ${body}`
-        : `() => ${body}`;
-    return `${compiledTarget}(${arrowFn})`;
-}
-function emitComment(comment, state) {
-    if (comment.commentKind === 'html') {
-        state.emitLine(`/* <!-- ${comment.text} --> */`);
-    }
-    // Haml comments (-#) are stripped entirely
-}
-function emitFilter(filter, state) {
-    const { filterName, content } = filter;
-    // 1. Plugin-registered filter handlers take priority
-    const handler = state.options.filters?.[filterName];
-    if (handler) {
-        const html = handler(content, filterName);
-        state.emitLine(`jsx(Fragment, { dangerouslySetInnerHTML: { __html: ${JSON.stringify(html)} } })`);
-        return;
-    }
-    // 2. Built-in passthrough filters
-    switch (filterName) {
-        case 'css':
-            state.warnings.push({
-                message: ':css filter emits raw CSS string — not usable as a <style> tag in React. Use a plugin handler to inject CSS properly.',
-                location: filter.location,
-                phase: 'emitter',
-            });
-            state.emitLine(`"${escapeString(content)}";`);
-            break;
-        case 'javascript':
-            state.warnings.push({
-                message: ':javascript filter emits raw JS at module level — an XSS risk with untrusted input. Ensure content is trusted.',
-                location: filter.location,
-                phase: 'emitter',
-            });
-            state.emitLine(content);
-            break;
-        case 'coffee':
-            state.emitLine(content);
-            break;
-        default:
-            state.warnings.push({
-                message: `:${filterName} filter used but no handler registered. Add one to compilerOptions.filters.`,
-                location: filter.location,
-                phase: 'emitter',
-            });
-            state.emitLine(`"${escapeString(content)}";`);
-    }
-}
-/** Emit a filter as a JS expression (for use as a child within parent elements). */
-function emitFilterToJs(filter, state) {
-    const { filterName, content } = filter;
-    const handler = state.options.filters?.[filterName];
-    if (handler) {
-        const html = handler(content, filterName);
-        return `jsx(Fragment, { dangerouslySetInnerHTML: { __html: ${JSON.stringify(html)} } })`;
-    }
-    // No handler — emit raw text as a string child
-    return escapeString(content);
-}
-function emitDoctype(doctype, state) {
-    // Doctype is typically handled by the HTML renderer, but for React
-    // we emit it as a comment or skip it
-    state.emitLine(`// DOCTYPE ${doctype.value || 'html'}`);
-}
+emitText = function(text, state) {
+  return state.emitLine(`\"${escapeString(text.value)}\";`);
+};
+
+emitOutput = function(out, state) {
+  var child, elementChildren, exprSource, j, js, k, len, len1, ref, result, textLines;
+  textLines = [];
+  elementChildren = [];
+  ref = out.children;
+  for (j = 0, len = ref.length; j < len; j++) {
+    child = ref[j];
+    if (child instanceof Text) {
+      textLines.push(child.value);
+    } else {
+      elementChildren.push(child);
+    }
+  }
+  exprSource = out.expression.source;
+  if (textLines.length > 0) {
+    exprSource = [exprSource, ...textLines].join(' ');
+  }
+  // Arrow continuation
+  if (elementChildren.length > 0 && /->\s*$/.test(exprSource.trim())) {
+    emitArrowOutput(exprSource, elementChildren, out, state);
+    return;
+  }
+  js = compileExpression(new Expression(exprSource), out.location);
+  result = out.outputKind === 'escaped' ? `jsx(Fragment, { children: ${js} })` : `jsx(Fragment, {}, ${js})`;
+  for (k = 0, len1 = elementChildren.length; k < len1; k++) {
+    child = elementChildren[k];
+    emitNode(child, state, false);
+  }
+  return state.emitLine(result + ';');
+};
+
+emitArrowOutput = function(exprSource, elementChildren, out, state) {
+  var arrowArgs, arrowFn, arrowMatch, body, callTarget, compiledTarget, result, stripped;
+  stripped = exprSource.replace(/\s*->\s*$/, '').trim();
+  arrowMatch = stripped.match(/^(.+?)\s*\(([^)]*)\)\s*$/);
+  if (arrowMatch) {
+    callTarget = arrowMatch[1].trim();
+    arrowArgs = arrowMatch[2].trim();
+  } else {
+    callTarget = stripped;
+    arrowArgs = '';
+  }
+  compiledTarget = compileExpression(new Expression(callTarget), out.location);
+  body = elementChildren.length === 1 ? emitChildToJs(elementChildren[0], state) : `jsxs(Fragment, { children: [${elementChildren.map(function(c) {
+    return emitChildToJs(c, state);
+  }).join(', ')}] })`;
+  arrowFn = arrowArgs ? `(${arrowArgs}) => ${body}` : `() => ${body}`;
+  result = out.outputKind === 'escaped' ? `jsx(Fragment, { children: ${compiledTarget}(${arrowFn}) })` : `jsx(Fragment, {}, ${compiledTarget}(${arrowFn}))`;
+  return state.emitLine(result + ';');
+};
+
+emitArrowOutputToJs = function(exprSource, elementChildren, state) {
+  var arrowArgs, arrowFn, arrowMatch, body, callTarget, compiledTarget, stripped;
+  stripped = exprSource.replace(/\s*->\s*$/, '').trim();
+  arrowMatch = stripped.match(/^(.+?)\s*\(([^)]*)\)\s*$/);
+  if (arrowMatch) {
+    callTarget = arrowMatch[1].trim();
+    arrowArgs = arrowMatch[2].trim();
+  } else {
+    callTarget = stripped;
+    arrowArgs = '';
+  }
+  compiledTarget = compileExpression(new Expression(callTarget));
+  body = elementChildren.length === 1 ? emitChildToJs(elementChildren[0], state) : `jsxs(Fragment, { children: [${elementChildren.map(function(c) {
+    return emitChildToJs(c, state);
+  }).join(', ')}] })`;
+  arrowFn = arrowArgs ? `(${arrowArgs}) => ${body}` : `() => ${body}`;
+  return `${compiledTarget}(${arrowFn})`;
+};
+
+emitComment = function(comment, state) {
+  if (comment.commentKind === 'html') {
+    return state.emitLine(`/* <!-- ${comment.text} --> */`);
+  }
+};
+
+emitFilter = function(filter, state) {
+  var content, filterName, handler, html, ref;
+  ({filterName, content} = filter);
+  handler = (ref = state.options.filters) != null ? ref[filterName] : void 0;
+  if (handler) {
+    html = handler(content, filterName);
+    state.emitLine(`jsx(Fragment, { dangerouslySetInnerHTML: { __html: ${JSON.stringify(html)} } })`);
+    return;
+  }
+  switch (filterName) {
+    case 'css':
+      state.warnings.push({
+        message: ':css filter emits raw CSS string — not usable as a <style> tag in React. Use a plugin handler to inject CSS properly.',
+        location: filter.location,
+        phase: 'emitter'
+      });
+      return state.emitLine(`\"${escapeString(content)}\";`);
+    case 'javascript':
+      state.warnings.push({
+        message: ':javascript filter emits raw JS at module level — an XSS risk with untrusted input. Ensure content is trusted.',
+        location: filter.location,
+        phase: 'emitter'
+      });
+      return state.emitLine(content);
+    case 'coffee':
+      return state.emitLine(content);
+    default:
+      state.warnings.push({
+        message: `:${filterName} filter used but no handler registered. Add one to compilerOptions.filters.`,
+        location: filter.location,
+        phase: 'emitter'
+      });
+      return state.emitLine(`\"${escapeString(content)}\";`);
+  }
+};
+
+emitFilterToJs = function(filter, state) {
+  var content, filterName, handler, html, ref;
+  ({filterName, content} = filter);
+  handler = (ref = state.options.filters) != null ? ref[filterName] : void 0;
+  if (handler) {
+    html = handler(content, filterName);
+    return `jsx(Fragment, { dangerouslySetInnerHTML: { __html: ${JSON.stringify(html)} } })`;
+  }
+  return escapeString(content);
+};
+
+emitDoctype = function(doctype, state) {
+  return state.emitLine(`// DOCTYPE ${doctype.value || 'html'}`);
+};
+
 // ─── Helpers ───────────────────────────────────────────────
-function escapeString(s) {
-    return JSON.stringify(s);
-}
-function mapSourceLocation(loc, state) {
-    if (loc) {
-        state.mapSource(loc.start);
-    }
-}
-//# sourceMappingURL=emitter.js.map
+escapeString = function(s) {
+  return JSON.stringify(s);
+};
+
+mapSourceLocation = function(loc, state) {
+  if (loc) {
+    return state.mapSource(loc.start);
+  }
+};