coffeehaml 0.7.0 → 0.7.1

package/dist/src/emitter.js

@@ -0,0 +1,791 @@
+// 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) {
+        return this.output += ' '.repeat(this.indent * 2) + s;
+      }
+    }
+
+    emitLine(s = '') {
+      if (s) {
+        this.output += ' '.repeat(this.indent * 2) + s;
+      }
+      this.output += '\n';
+      return this.outputLine++;
+    }
+
+    mapSource(loc) {
+      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();
+      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 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 ─────────────────────────────
+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 null; })()`;
+    }
+    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 ─────────────────────────────────────────
+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 ───────────────────────────────────────────────
+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) {
+      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
+    });
+    return emitChildToJs(el, state);
+  }
+  if (node instanceof ControlFlow) {
+    return emitControlFlowToJs(node, state);
+  }
+  if (node instanceof Filter) {
+    return emitFilterToJs(node, state);
+  }
+  return 'null';
+};
+
+// ─── Control Flow ──────────────────────────────────────────
+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) {
+        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 (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 ────────────
+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 ───────────────────────────────────────────────
+escapeString = function(s) {
+  return JSON.stringify(s);
+};
+
+mapSourceLocation = function(loc, state) {
+  if (loc) {
+    return state.mapSource(loc.start);
+  }
+};