coffeehaml 0.7.7 → 0.10.0

package/README.md

@@ -152,6 +152,9 @@ console.log(result.code);
 | `- code` | Arbitrary CoffeeScript statements; continuation via indented lines |
 | `- for x in xs` | Loop → `.map()` |
 | `- else`, `- else if` | Chain conditionals |
+| `---` … `---` | Fenced CoffeeScript block — render-time statements (multiline `-`) |
+| `===` … `===` | Fenced yield block — CoffeeScript whose final value renders (escaped) |
+| `~~~` … `~~~` | Fenced preamble block — module-scope code (imports, helpers, setup) |
 | `-# comment` | Haml comment (stripped) |
 | `/ comment` | HTML comment |
 | `.wrapper` | Implicit div |
@@ -173,7 +176,7 @@ Full grammar: [`docs/grammar.md`](docs/grammar.md)
 
 ## Status
 
-**v0.7.0 — production beta.** The compiler pipeline (Lexer → Parser → Emitter)
+**v0.10.0 — production beta.** The compiler pipeline (Lexer → Parser → Emitter)
 is complete. The [Prettier plugin](src/prettier/) provides 16 deactivatable
 formatting options including attribute style preservation, statement merging,
 blank line handling, and CoffeeScript code formatting.
@@ -194,6 +197,9 @@ blank line handling, and CoffeeScript code formatting.
 | Haml/HTML comments | ✅ |
 | `:filter` blocks | ✅ |
 | Prologue passthrough (`import`, `@decorator`) | ✅ |
+| `---` render-time CoffeeScript block | ✅ |
+| `===` yield block (fenced output) | ✅ |
+| `~~~` module-scope preamble block | ✅ |
 | Component / HOC wrapping (`wrap: 'observer'`) | ✅ |
 | Vite plugin with HMR | ✅ |
 | CLI `--wrap` flag | ✅ |

package/dist/ast.js

@@ -6,7 +6,7 @@ import {
 } from './types.js';
 
 // ─── Node Kinds ────────────────────────────────────────────
-export var NodeKind = ['Document', 'Element', 'ImplicitDiv', 'Text', 'Output', 'ControlFlow', 'Comment', 'Filter', 'Doctype'];
+export var NodeKind = ['Document', 'Element', 'ImplicitDiv', 'Text', 'Output', 'ControlFlow', 'Comment', 'Filter', 'CoffeeBlock', 'CoffeeYield', 'CoffeePreamble', 'Doctype'];
 
 export var ControlFlowKind = ['if', 'unless', 'for', 'while', 'else', 'statement'];
 
@@ -319,6 +319,71 @@ export var Filter = (function() {
 
 }).call(this);
 
+export var CoffeeBlock = (function() {
+  // ─── CoffeeBlock ───────────────────────────────────────────
+  // A fenced raw CoffeeScript block (--- ... ---). Its content is a
+  // multi-line CoffeeScript program compiled to render-time statements — the
+  // multiline counterpart to `-`. It runs on every render and produces no
+  // output.
+  class CoffeeBlock extends Node {
+    constructor(content, location = null) {
+      super(location);
+      this.content = content;
+    }
+
+  };
+
+  CoffeeBlock.prototype.kind = 'CoffeeBlock';
+
+  CoffeeBlock.prototype.content = '';
+
+  return CoffeeBlock;
+
+}).call(this);
+
+export var CoffeePreamble = (function() {
+  // ─── CoffeePreamble ────────────────────────────────────────
+  // A fenced CoffeeScript preamble block (~~~ ... ~~~). The body is a
+  // multi-line CoffeeScript program compiled to statements hoisted to module
+  // scope — imports, helpers, and once-only setup. It runs once at import and
+  // produces no output.
+  class CoffeePreamble extends Node {
+    constructor(content, location = null) {
+      super(location);
+      this.content = content;
+    }
+
+  };
+
+  CoffeePreamble.prototype.kind = 'CoffeePreamble';
+
+  CoffeePreamble.prototype.content = '';
+
+  return CoffeePreamble;
+
+}).call(this);
+
+export var CoffeeYield = (function() {
+  // ─── CoffeeYield ───────────────────────────────────────────
+  // A fenced CoffeeScript yield block (=== ... ===). The body is a
+  // multi-line CoffeeScript program whose final value is yielded as
+  // content at that position (the multiline counterpart to `=`).
+  class CoffeeYield extends Node {
+    constructor(content, location = null) {
+      super(location);
+      this.content = content;
+    }
+
+  };
+
+  CoffeeYield.prototype.kind = 'CoffeeYield';
+
+  CoffeeYield.prototype.content = '';
+
+  return CoffeeYield;
+
+}).call(this);
+
 export var Doctype = (function() {
   // ─── Doctype ───────────────────────────────────────────────
   class Doctype extends Node {

package/dist/emitter.js

@@ -1,6 +1,6 @@
 // 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;
+var EmitState, VOID_ELEMENTS, attrNameToJs, buildAttributes, collectCoffeePreamble, compileComponentBody, emitArrowOutput, emitArrowOutputToJs, emitChildToJs, emitCoffeeBlock, emitCoffeeYield, emitComment, emitConditional, emitControlFlow, emitControlFlowToJs, emitDoctype, emitElement, emitElseBranch, emitFilter, emitFilterToJs, emitImplicitDiv, emitLoop, emitNode, emitNodes, emitOutput, emitStatement, emitText, escapeString, mapSourceLocation, splitJsStatements, tagToJs;
 
 import {
   Document,
@@ -11,6 +11,9 @@ import {
   ControlFlow,
   Comment,
   Filter,
+  CoffeeBlock,
+  CoffeeYield,
+  CoffeePreamble,
   Doctype,
   Node,
   Expression
@@ -18,7 +21,8 @@ import {
 
 import {
   compileExpression,
-  compileStatement
+  compileStatement,
+  compileYield
 } from './expressions.js';
 
 import {
@@ -36,6 +40,11 @@ EmitState = (function() {
   class EmitState {
     constructor(options1 = {}) {
       this.options = options1;
+      // `hoisted` and `warnings` must be instance-level (not prototype-level):
+      // CoffeeScript emits class-body arrays as shared prototype properties, so
+      // every EmitState would otherwise mutate the same accumulator across calls.
+      this.hoisted = [];
+      this.warnings = [];
       if (this.options.sourceMap && this.options.filename) {
         this.sourceMapGenerator = new SourceMapGenerator({
           file: this.options.filename
@@ -110,7 +119,7 @@ EmitState = (function() {
 
 // ─── Public API ────────────────────────────────────────────
 export var emit = function(ast, options = {}) {
-  var bodyExpr, hocs, inner, j, len, line, name, ref, result, state, wrap, wrapped;
+  var bodyExpr, hocs, inner, j, k, len, len1, line, name, p, preambles, ref, result, state, wrap, wrapped;
   state = new EmitState(options);
   state.emitLine(`import { jsx, jsxs, Fragment } from \"${options.jsxRuntime || 'react/jsx-runtime'}\";`);
   // Emit prologue lines
@@ -122,6 +131,18 @@ export var emit = function(ast, options = {}) {
     }
   }
   state.emitLine();
+  // Emit fenced `~~~ ... ~~~` blocks at module scope. Imports, helpers and
+  // setup code must live outside any component wrapper (and cannot rerun per
+  // render), so they are collected here and emitted before the body. This is
+  // the once-at-import region; `---` is the render-time counterpart.
+  preambles = collectCoffeePreamble(ast.children, []);
+  if (preambles.length > 0) {
+    for (k = 0, len1 = preambles.length; k < len1; k++) {
+      p = preambles[k];
+      state.emitLine(compileStatement(p.content, p.location));
+    }
+    state.emitLine();
+  }
   wrap = options.wrap;
   if (wrap && wrap !== 'none') {
     name = options.componentName || 'Component';
@@ -231,6 +252,34 @@ splitJsStatements = function(body) {
 };
 
 // ─── Node Emitters ─────────────────────────────────────────
+
+// Recursively collect fenced `~~~ ... ~~~` preamble blocks, removing them
+// from the render tree in place (they contribute no markup). Their statements
+// are hoisted to module scope — imports, helpers, and once-only setup.
+collectCoffeePreamble = function(nodes, acc) {
+  var i, node, ref;
+  if (!(nodes != null ? nodes.length : void 0)) {
+    return acc;
+  }
+  i = 0;
+  while (i < nodes.length) {
+    node = nodes[i];
+    if (node instanceof CoffeePreamble) {
+      acc.push(node);
+      nodes.splice(i, 1);
+      continue;
+    }
+    if (((ref = node.children) != null ? ref.length : void 0) > 0) {
+      collectCoffeePreamble(node.children, acc);
+    }
+    if (node.next != null) {
+      collectCoffeePreamble([node.next], acc);
+    }
+    i++;
+  }
+  return acc;
+};
+
 emitNodes = function(nodes, state, isRoot = false) {
   var i, node, remaining;
   i = 0;
@@ -248,6 +297,15 @@ emitNodes = function(nodes, state, isRoot = false) {
 };
 
 emitNode = function(node, state, isRoot) {
+  if (node instanceof CoffeeBlock) {
+    return emitCoffeeBlock(node, state);
+  }
+  if (node instanceof CoffeePreamble) { // hoisted to module scope above
+    return;
+  }
+  if (node instanceof CoffeeYield) {
+    return emitCoffeeYield(node, state);
+  }
   if (node instanceof Element) {
     return emitElement(node, state);
   } else if (node instanceof ImplicitDiv) {
@@ -396,7 +454,7 @@ emitImplicitDiv = function(div, state) {
 
 // ─── Child Emission ────────────────────────────────────────
 emitChildToJs = function(node, state) {
-  var allAttrs, attrResult, attrs, attrsJs, c, childParts, childrenAttr, el, exprSource, fn, hasChildren, keyArg, tagJs, textContinuations;
+  var allAttrs, attrResult, attrs, attrsJs, c, childParts, childrenAttr, el, exprSource, fn, hasChildren, js, keyArg, tagJs, textContinuations;
   if (node instanceof Text) {
     return escapeString(node.value);
   }
@@ -456,6 +514,13 @@ emitChildToJs = function(node, state) {
   if (node instanceof Filter) {
     return emitFilterToJs(node, state);
   }
+  if (node instanceof CoffeeBlock) {
+    js = compileStatement(node.content, node.location);
+    return `/* - ${js} */ null`;
+  }
+  if (node instanceof CoffeeYield) {
+    return compileYield(node.content, node.location);
+  }
   return 'null';
 };
 
@@ -496,6 +561,20 @@ emitStatement = function(cf, remaining, state) {
   }
 };
 
+// Fenced `--- ... ---` block: the multiline counterpart to `-`. Compiles the
+// body to statements that run at render time, producing no output. In a
+// wrapped component they hoist alongside `-` statements (same IIFE path); in
+// unwrapped mode they emit in place.
+emitCoffeeBlock = function(node, state) {
+  var js;
+  js = compileStatement(node.content, node.location);
+  if (state.directEmit) {
+    return state.emitLine(js + ';');
+  } else {
+    return state.hoisted.push(js);
+  }
+};
+
 emitLoop = function(cf, remaining, state) {
   var cond, expr, forMatch, iterable, vars;
   if (cf.controlKind === 'for') {
@@ -683,6 +762,12 @@ emitOutput = function(out, state) {
   return state.emitLine(result + ';');
 };
 
+emitCoffeeYield = function(node, state) {
+  var js;
+  js = compileYield(node.content, node.location);
+  return state.emitLine(`jsx(Fragment, { children: ${js} });`);
+};
+
 emitArrowOutput = function(exprSource, elementChildren, out, state) {
   var arrowArgs, arrowFn, arrowMatch, body, callTarget, compiledTarget, result, stripped;
   stripped = exprSource.replace(/\s*->\s*$/, '').trim();

package/dist/expressions.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
   // expressions.coffee — CoffeeScript expression compilation bridge
-var _coffeeScriptAvailable, _coffeeScriptUnavailableReason, _require, checkCoffeeScript, collapseWs, loadCoffeeScript, objectTarget, splitTopLevelStatements, stripCoffeeWrapper, stripToConst,
+var _coffeeScriptAvailable, _coffeeScriptUnavailableReason, _require, checkCoffeeScript, collapseWs, isSingleExpression, loadCoffeeScript, objectTarget, splitTopLevelStatements, stripCoffeeWrapper, stripToConst,
   indexOf = [].indexOf;
 
 import {
@@ -179,6 +179,55 @@ export var compileStatement = function(source, location = null) {
   return source;
 };
 
+// ─── Compile yield block to JS expression ──────────────────
+// Compiles a fenced `=== ... ===` body to a single JS expression whose
+// value is the body's final result (the multiline counterpart to `=`).
+// A single expression compiles cleanly; multiple statements are wrapped
+// in an IIFE so CoffeeScript's implicit return becomes the yielded value.
+export var compileYield = function(source, location = null) {
+  var CoffeeScript, e, indented, js, msg, wrapped;
+  if (source.trim() === '') {
+    return '';
+  }
+  try {
+    CoffeeScript = loadCoffeeScript();
+    if (!(CoffeeScript && typeof CoffeeScript.compile === 'function')) {
+      return source;
+    }
+    if (isSingleExpression(source)) {
+      return compileExpression(new Expression(source), location);
+    }
+    indented = source.replace(/^/gm, '  ');
+    wrapped = `(->\n${indented}\n)()`;
+    js = CoffeeScript.compile(wrapped, {
+      bare: true,
+      inlineMap: false
+    });
+    return collapseWs(js.trim()).replace(/;\s*$/, '');
+  } catch (error) {
+    e = error;
+    msg = e instanceof Error ? e.message : String(e);
+    if (location) {
+      throw new CompileError(`CoffeeScript yield error: ${msg}`, 'emitter', 'YIELD_ERROR', location, `Check block: ${source.slice(0, 80)}`);
+    }
+  }
+  return source;
+};
+
+isSingleExpression = function(source) {
+  var CoffeeScript, ref, ref1, root;
+  try {
+    CoffeeScript = loadCoffeeScript();
+    if (CoffeeScript && typeof CoffeeScript.nodes === 'function') {
+      root = CoffeeScript.nodes(source);
+      return (root != null ? (ref = root.body) != null ? (ref1 = ref.expressions) != null ? ref1.length : void 0 : void 0 : void 0) === 1;
+    }
+  } catch (error) {
+    false;
+  }
+  return false;
+};
+
 // ─── Convert var → const/let ───────────────────────────────
 
 // Extract the bound variable name from one entry of an object
@@ -194,7 +243,7 @@ objectTarget = function(pair) {
 };
 
 stripToConst = function(js) {
-  var allConsumed, assignments, body, consumed, inner, j, len, m, n, name, names, s, stmts, varIdx, varNames;
+  var allConsumed, body, constReplacements, consumed, idx, inner, j, len, m, n, name, names, s, stmts, varIdx, varNames;
   stmts = splitTopLevelStatements(js);
   if (stmts.length === 0) {
     return js.replace(/;\s*$/, '');
@@ -220,10 +269,10 @@ stripToConst = function(js) {
     }
     return results;
   })();
-  assignments = [];
+  constReplacements = {};
   consumed = [];
-  for (j = 0, len = body.length; j < len; j++) {
-    s = body[j];
+  for (idx = j = 0, len = body.length; j < len; idx = ++j) {
+    s = body[idx];
     m = s.match(/^\[([^\]]*)\]\s*=/);
     if (m != null) {
       // Array destructuring: [a, b] = expr
@@ -240,7 +289,7 @@ stripToConst = function(js) {
         return results;
       })();
       consumed = consumed.concat(names);
-      assignments.push('const ' + s);
+      constReplacements[idx] = 'const ' + s;
       continue;
     }
     m = s.match(/^\(\s*\{([^}]*)\}\s*=.*\)$/);
@@ -260,7 +309,7 @@ stripToConst = function(js) {
         return results;
       })();
       consumed = consumed.concat(names);
-      assignments.push('const ' + inner);
+      constReplacements[idx] = 'const ' + inner;
       continue;
     }
     name = varNames.find(function(n) {
@@ -268,14 +317,24 @@ stripToConst = function(js) {
     });
     if (name != null) {
       consumed.push(name);
-      assignments.push('const ' + s);
+      constReplacements[idx] = 'const ' + s;
     }
   }
   allConsumed = varNames.every(function(n) {
     return indexOf.call(consumed, n) >= 0;
   });
-  if (assignments.length > 0 && allConsumed) {
-    return assignments.join('; ');
+  if (allConsumed && Object.keys(constReplacements).length > 0) {
+    return ((function() {
+      var k, len1, ref, results;
+      results = [];
+      for (idx = k = 0, len1 = body.length; k < len1; idx = ++k) {
+        s = body[idx];
+        // Preserve non-assignment statements (imports, calls, declarations)
+        // in their original order, converting only bound assignments to const.
+        results.push((ref = constReplacements[idx]) != null ? ref : s);
+      }
+      return results;
+    })()).join('; ');
   }
   return ((function() {
     var k, len1, results;

package/dist/lexer.js

@@ -1,7 +1,7 @@
 // Generated by CoffeeScript 2.7.0
 // lexer.coffee — CoffeeHaml tokenizer
 // Converts raw .chaml source into a token stream with INDENT/DEDENT
-var countIndent, dedentToken, extractBracketed, indentToken, isHamlConstruct, looksLikeBareAttributes, parseModifiersAndAttrs, preMergeBracketLines, tokenizeLine;
+var countIndent, dedentLines, dedentToken, extractBracketed, indentToken, isHamlConstruct, looksLikeBareAttributes, parseModifiersAndAttrs, preMergeBracketLines, stripIndent, tokenizeLine;
 
 import {
   SourceLocation
@@ -21,6 +21,9 @@ export var TokenType = {
   COMMENT: 'COMMENT',
   HTML_COMMENT: 'HTML_COMMENT',
   FILTER: 'FILTER',
+  COFFEE_BLOCK: 'COFFEE_BLOCK',
+  COFFEE_YIELD: 'COFFEE_YIELD',
+  COFFEE_PREAMBLE: 'COFFEE_PREAMBLE',
   DOCTYPE: 'DOCTYPE',
   TEXT: 'TEXT',
   PROLOGUE: 'PROLOGUE',
@@ -75,21 +78,23 @@ preMergeBracketLines = function(lines) {
 };
 
 export var tokenize = function(source, filename = null) {
-  var content, currentIndent, inPrologue, indent, indentStack, j, len, line, lineIndex, lineLength, lineStartOffset, lineTokens, lines, offset, rawLine, tokens;
+  var body, bodyLine, content, currentIndent, fence, fenceIndent, fenceStartLine, fenceStartOffset, i, inPrologue, indent, indentStack, line, lineIndex, lineLength, lineStartOffset, lineTokens, lines, offset, rawLine, tokens;
   tokens = [];
   lines = preMergeBracketLines(source.split('\n'));
   indentStack = [0];
   offset = 0;
   lineIndex = 0;
   inPrologue = true;
-  for (j = 0, len = lines.length; j < len; j++) {
-    rawLine = lines[j];
+  i = 0;
+  while (i < lines.length) {
+    rawLine = lines[i];
     line = rawLine.replace(/\r$/, '');
     lineLength = rawLine.length + 1;
     // Skip empty lines
     if (line.trim() === '') {
       offset += lineLength;
       lineIndex++;
+      i++;
       continue;
     }
     indent = countIndent(line);
@@ -97,6 +102,85 @@ export var tokenize = function(source, filename = null) {
     if (content === '') {
       offset += lineLength;
       lineIndex++;
+      i++;
+      continue;
+    }
+    // ─── Multiline CoffeeScript fences: --- / === / ~~~ ───
+    // A line consisting solely of `---`, `===` or `~~~` opens a raw
+    // CoffeeScript area that escapes HAML indentation. `---` compiles the
+    // body to render-time statements (COFFEE_BLOCK — the multiline
+    // counterpart to `-`); `===` yields the body's final value as content
+    // (COFFEE_YIELD — the multiline counterpart to `=`); `~~~` compiles the
+    // body to code hoisted to module scope, running once at import
+    // (COFFEE_PREAMBLE). The body runs until the matching closing fence line;
+    // it is dedented to column 0 and tokenized as a single token (no
+    // INDENT/DEDENT inside).
+    fence = content.trim();
+    if (fence === '---' || fence === '===' || fence === '~~~') {
+      inPrologue = false;
+      fenceIndent = indent;
+      fenceStartLine = lineIndex;
+      fenceStartOffset = offset + indent;
+      // Handle indentation change (same as a normal line)
+      currentIndent = indentStack[indentStack.length - 1];
+      if (fenceIndent > currentIndent) {
+        indentStack.push(fenceIndent);
+        tokens.push(indentToken(fenceIndent, fenceStartOffset, fenceIndent, filename, fenceStartLine));
+      } else if (fenceIndent < currentIndent) {
+        while (indentStack.length > 1 && fenceIndent < indentStack[indentStack.length - 1]) {
+          indentStack.pop();
+          tokens.push(dedentToken(fenceStartOffset, filename, fenceStartLine));
+        }
+        if (fenceIndent !== indentStack[indentStack.length - 1]) {
+          indentStack.push(fenceIndent);
+          tokens.push(indentToken(fenceIndent, fenceStartOffset, fenceIndent, filename, fenceStartLine));
+        }
+      }
+      // Consume opening fence
+      offset += lineLength;
+      lineIndex++;
+      i++;
+      // Collect body until closing fence
+      body = [];
+      while (i < lines.length) {
+        bodyLine = lines[i].replace(/\r$/, '');
+        if (bodyLine.trim() === fence) {
+          offset += lines[i].length + 1;
+          lineIndex++;
+          i++;
+          break;
+        }
+        body.push(bodyLine);
+        offset += lines[i].length + 1;
+        lineIndex++;
+        i++;
+      }
+      tokens.push({
+        type: (function() {
+          switch (fence) {
+            case '===':
+              return TokenType.COFFEE_YIELD;
+            case '~~~':
+              return TokenType.COFFEE_PREAMBLE;
+            default:
+              return TokenType.COFFEE_BLOCK;
+          }
+        })(),
+        value: (dedentLines(body)).join('\n'),
+        location: {
+          start: {
+            line: fenceStartLine,
+            column: fenceIndent
+          },
+          end: {
+            line: lineIndex,
+            column: 0
+          },
+          offset: fenceStartOffset,
+          length: offset - fenceStartOffset,
+          file: filename
+        }
+      });
       continue;
     }
     // Prologue detection: non-indented JS before first HAML construct
@@ -120,6 +204,7 @@ export var tokenize = function(source, filename = null) {
       });
       offset += lineLength;
       lineIndex++;
+      i++;
       continue;
     }
     inPrologue = false;
@@ -144,6 +229,7 @@ export var tokenize = function(source, filename = null) {
     tokens.push(...lineTokens);
     offset += lineLength;
     lineIndex++;
+    i++;
   }
   // Emit remaining DEDENT tokens at EOF
   while (indentStack.length > 1) {
@@ -535,6 +621,52 @@ countIndent = function(line) {
   return count;
 };
 
+// Strip up to `amount` visual columns of leading whitespace (space=1, tab=2).
+stripIndent = function(line, amount) {
+  var ch, i, seen;
+  seen = 0;
+  i = 0;
+  while (i < line.length && seen < amount) {
+    ch = line[i];
+    if (ch === ' ') {
+      seen += 1;
+    } else if (ch === '\t') {
+      seen += 2;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return line.slice(i);
+};
+
+// Normalize a fenced block's body to column 0 by removing the minimum
+// indentation found across its non-empty lines.
+dedentLines = function(lines) {
+  var amount, ind, j, k, l, len, len1, min, results;
+  min = null;
+  for (j = 0, len = lines.length; j < len; j++) {
+    l = lines[j];
+    if (l.trim() === '') {
+      continue;
+    }
+    ind = countIndent(l);
+    if (min === null || ind < min) {
+      min = ind;
+    }
+  }
+  amount = min === null ? 0 : min;
+  if (amount === 0) {
+    return lines;
+  }
+  results = [];
+  for (k = 0, len1 = lines.length; k < len1; k++) {
+    l = lines[k];
+    results.push(stripIndent(l, amount));
+  }
+  return results;
+};
+
 indentToken = function(_indent, offset, level, filename = null, line = 0) {
   return {
     type: TokenType.INDENT,

package/dist/parser.js

@@ -1,7 +1,7 @@
 // Generated by CoffeeScript 2.7.0
 // parser.coffee — recursive descent parser
 // Converts token stream into AST
-var ParserState, cleanAttrName, findColon, findEquals, isElse, parseAttributeBlock, parseBareAttributes, parseBlock, parseComment, parseControlFlow, parseControlKind, parseDoctype, parseElement, parseFilter, parseHtmlComment, parseImplicitDiv, parseNode, parseOutput, parseText, splitAttributePairs, splitBareAttributePairs, stripControlKeyword;
+var ParserState, cleanAttrName, findColon, findEquals, isElse, parseAttributeBlock, parseBareAttributes, parseBlock, parseCoffeeBlock, parseCoffeePreamble, parseCoffeeYield, parseComment, parseControlFlow, parseControlKind, parseDoctype, parseElement, parseFilter, parseHtmlComment, parseImplicitDiv, parseNode, parseOutput, parseText, splitAttributePairs, splitBareAttributePairs, stripControlKeyword;
 
 import {
   TokenType
@@ -16,6 +16,9 @@ import {
   ControlFlow,
   Comment,
   Filter,
+  CoffeeBlock,
+  CoffeeYield,
+  CoffeePreamble,
   Doctype,
   Expression,
   Attribute,
@@ -79,7 +82,7 @@ ParserState = (function() {
       var t;
       while (this.current()) {
         t = this.current().type;
-        if (t === TokenType.TAG || t === TokenType.CLASS || t === TokenType.ID || t === TokenType.OUTPUT || t === TokenType.OUTPUT_UNESC || t === TokenType.CONTROL || t === TokenType.FILTER || t === TokenType.COMMENT || t === TokenType.HTML_COMMENT || t === TokenType.DOCTYPE || t === TokenType.INDENT || t === TokenType.DEDENT) {
+        if (t === TokenType.TAG || t === TokenType.CLASS || t === TokenType.ID || t === TokenType.OUTPUT || t === TokenType.OUTPUT_UNESC || t === TokenType.CONTROL || t === TokenType.FILTER || t === TokenType.COFFEE_BLOCK || t === TokenType.COFFEE_YIELD || t === TokenType.COFFEE_PREAMBLE || t === TokenType.COMMENT || t === TokenType.HTML_COMMENT || t === TokenType.DOCTYPE || t === TokenType.INDENT || t === TokenType.DEDENT) {
           return;
         }
         this.advance();
@@ -168,6 +171,12 @@ parseNode = function(state) {
       return parseHtmlComment(state);
     case TokenType.FILTER:
       return parseFilter(state);
+    case TokenType.COFFEE_BLOCK:
+      return parseCoffeeBlock(state);
+    case TokenType.COFFEE_YIELD:
+      return parseCoffeeYield(state);
+    case TokenType.COFFEE_PREAMBLE:
+      return parseCoffeePreamble(state);
     case TokenType.DOCTYPE:
       return parseDoctype(state);
     case TokenType.TEXT:
@@ -461,6 +470,34 @@ parseFilter = function(state) {
   return new Filter(filterName, content, token.location);
 };
 
+// ─── CoffeeBlock ───────────────────────────────────────────
+parseCoffeeBlock = function(state) {
+  var token;
+  token = state.expect(TokenType.COFFEE_BLOCK);
+  if (!token) {
+    return new CoffeeBlock('');
+  }
+  return new CoffeeBlock(token.value, token.location);
+};
+
+parseCoffeeYield = function(state) {
+  var token;
+  token = state.expect(TokenType.COFFEE_YIELD);
+  if (!token) {
+    return new CoffeeYield('');
+  }
+  return new CoffeeYield(token.value, token.location);
+};
+
+parseCoffeePreamble = function(state) {
+  var token;
+  token = state.expect(TokenType.COFFEE_PREAMBLE);
+  if (!token) {
+    return new CoffeePreamble('');
+  }
+  return new CoffeePreamble(token.value, token.location);
+};
+
 // ─── Doctype ───────────────────────────────────────────────
 parseDoctype = function(state) {
   var token;

package/dist/prettier/options.js

@@ -81,7 +81,7 @@ export var options = {
   attributeMultilineThreshold: {
     category: CAT.ATTRIBUTES,
     type: 'int',
-    description: 'Break attributes across lines when count >= this. 0 = always multiline.'
+    description: 'Force attributes across lines when count >= this. 0 = never force (fold only when exceeding printWidth).'
   },
   attributeSort: {
     category: CAT.ATTRIBUTES,
@@ -218,7 +218,7 @@ export var defaultOptions = {
   inlineThreshold: -1,
   voidElementStyle: 'explicit',
   attributeStyle: 'preserve',
-  attributeMultilineThreshold: 1,
+  attributeMultilineThreshold: 0,
   attributeSort: 'none',
   quoteStyle: 'preserve',
   coffeeScriptFormat: true,

package/dist/prettier/printer.js

@@ -1,7 +1,7 @@
 // Generated by CoffeeScript 2.7.0
 // printer.coffee — AST → Prettier Doc IR
 // Core formatting engine for CoffeeHaml Prettier plugin
-var MergedStatements, VOID_ELEMENTS, _prettier, _require, analyzeBlankLines, defaultOpts, detectStyle, formatAttributes, formatTag, group, hardline, indent, isSingleInlineChild, isVoidElement, join, joinChildrenWithBlanks, mergeAllStatements, opts, printComment, printControlFlow, printDoc, printDoctype, printElement, printFilter, printFlow, printImplicitDiv, printMergedFlow, printNode, printOutput, reflowCommentText;
+var MergedStatements, VOID_ELEMENTS, _prettier, _require, analyzeBlankLines, defaultOpts, detectStyle, formatAttributes, formatTag, group, hardline, indent, isSingleInlineChild, isVoidElement, join, joinChildrenWithBlanks, line, mergeAllStatements, opts, printCoffeeBlock, printCoffeePreamble, printCoffeeYield, printComment, printControlFlow, printDoc, printDoctype, printElement, printFence, printFilter, printFlow, printImplicitDiv, printMergedFlow, printNode, printOutput, reflowCommentText;
 
 import {
   Document,
@@ -12,6 +12,9 @@ import {
   ControlFlow,
   Comment,
   Filter,
+  CoffeeBlock,
+  CoffeeYield,
+  CoffeePreamble,
   Doctype,
   Node,
   Expression,
@@ -32,7 +35,7 @@ _require = createRequire(import.meta.url);
 
 _prettier = _require('prettier');
 
-({group, indent, hardline, join} = _prettier.doc.builders);
+({group, indent, hardline, line, join} = _prettier.doc.builders);
 
 // ─── Format Options ────────────────────────────────────────
 // CoffeeHamlFormatOptions shape (runtime):
@@ -49,7 +52,7 @@ defaultOpts = {
   inlineThreshold: -1,
   voidElementStyle: 'self-closing',
   attributeStyle: 'preserve',
-  attributeMultilineThreshold: 1,
+  attributeMultilineThreshold: 0,
   attributeSort: 'none',
   quoteStyle: 'preserve',
   coffeeScriptFormat: true,
@@ -225,6 +228,15 @@ printNode = function(path, o, printFn) {
   if (node instanceof Filter) {
     return printFilter(path, o, printFn);
   }
+  if (node instanceof CoffeeBlock) {
+    return printCoffeeBlock(path, o, printFn);
+  }
+  if (node instanceof CoffeeYield) {
+    return printCoffeeYield(path, o, printFn);
+  }
+  if (node instanceof CoffeePreamble) {
+    return printCoffeePreamble(path, o, printFn);
+  }
   if (node instanceof Doctype) {
     return printDoctype(path, o);
   }
@@ -259,7 +271,7 @@ printDoc = function(path, o, printFn) {
 
 // ─── Element ───────────────────────────────────────────────
 printElement = function(path, o, printFn) {
-  var attrStyle, attrs, childDoc, childDocs, children, classes, header, id, isVoid, joined, node, ref, ref1, ref2, ref3, selfClose, tag;
+  var attrStyle, attrs, childDoc, childDocs, children, classes, header, id, isVoid, joined, node, ref, ref1, ref2, ref3, selfClose, sep, tag;
   node = path.node;
   tag = formatTag(node.tag, o);
   // Classes and ID
@@ -282,16 +294,18 @@ printElement = function(path, o, printFn) {
   } else if (node.isSelfClosing) {
     selfClose = '/';
   }
-  header = `%${tag}${classes}${id}${attrs}${selfClose}`;
+  header = [`%${tag}${classes}${id}`, attrs, selfClose];
   // Children
   children = (ref = node.children) != null ? ref : [];
   if (children.length === 0) {
     return header;
   }
   // Inline child
-  if (isSingleInlineChild(children) && o.controlFlowInline !== false) {
+  if (isSingleInlineChild(children)) {
     childDoc = (ref1 = (ref2 = path.map(printFn, 'children')) != null ? ref2[0] : void 0) != null ? ref1 : '';
-    return `${header} ${childDoc}`;
+    // Output (= expr) carries its own separator; Text needs a space
+    sep = children[0] instanceof Output ? '' : ' ';
+    return [header, sep, childDoc];
   }
   childDocs = (ref3 = path.map(printFn, 'children')) != null ? ref3 : [];
   joined = joinChildrenWithBlanks(children, childDocs, o);
@@ -300,7 +314,7 @@ printElement = function(path, o, printFn) {
 
 // ─── ImplicitDiv ───────────────────────────────────────────
 printImplicitDiv = function(path, o, printFn) {
-  var attrStyle, attrs, childDoc, childDocs, children, classes, header, id, joined, node, ref, ref1, ref2, ref3;
+  var attrStyle, attrs, childDoc, childDocs, children, classes, header, id, joined, node, ref, ref1, ref2, ref3, sep;
   node = path.node;
   classes = node.classes.map(function(c) {
     return `.${c}`;
@@ -308,14 +322,15 @@ printImplicitDiv = function(path, o, printFn) {
   id = node.id ? `#${node.id}` : '';
   attrStyle = detectStyle(node, o);
   attrs = formatAttributes(node, attrStyle, o);
-  header = `${classes}${id}${attrs}`;
+  header = [`${classes}${id}`, attrs];
   children = (ref = node.children) != null ? ref : [];
   if (children.length === 0) {
     return header;
   }
   if (isSingleInlineChild(children)) {
     childDoc = (ref1 = (ref2 = path.map(printFn, 'children')) != null ? ref2[0] : void 0) != null ? ref1 : '';
-    return `${header} ${childDoc}`;
+    sep = children[0] instanceof Output ? '' : ' ';
+    return [header, sep, childDoc];
   }
   childDocs = (ref3 = path.map(printFn, 'children')) != null ? ref3 : [];
   joined = joinChildrenWithBlanks(children, childDocs, o);
@@ -473,6 +488,38 @@ printFilter = function(path, o, _printFn) {
   }
 };
 
+// ─── CoffeeBlock ───────────────────────────────────────────
+
+// Build a fenced block doc using `hardline` so Prettier can re-indent the
+// dedented body to the correct nesting level (raw `\n` strings would not).
+printFence = function(fence, content) {
+  var k, len, parts, ref;
+  if (content) {
+    parts = [fence];
+    ref = content.split('\n');
+    for (k = 0, len = ref.length; k < len; k++) {
+      line = ref[k];
+      parts.push(hardline, line);
+    }
+    parts.push(hardline, fence);
+    return parts;
+  } else {
+    return [fence, hardline, fence];
+  }
+};
+
+printCoffeeBlock = function(path, o, _printFn) {
+  return printFence('---', path.node.content);
+};
+
+printCoffeeYield = function(path, o, _printFn) {
+  return printFence('===', path.node.content);
+};
+
+printCoffeePreamble = function(path, o, _printFn) {
+  return printFence('~~~', path.node.content);
+};
+
 // ─── Doctype ───────────────────────────────────────────────
 printDoctype = function(path, o) {
   var node;
@@ -501,12 +548,14 @@ detectStyle = function(node, o) {
 };
 
 formatAttributes = function(node, style, o) {
-  var attr, attrs, bareParts, expr, k, len, name, parts, ref, ref1, ref2, val;
+  var attr, attrs, bareParts, close, expr, forceBreak, k, len, name, open, parts, ref, ref1, ref2, sep, val;
   attrs = (ref = node.attributes) != null ? ref : [];
   if (!(attrs.length > 0)) {
     return '';
   }
-  // Bare style: HTML-style key="val" key2={expr} — space-separated
+  // Bare style: HTML-style key="val" key2={expr} — space-separated.
+  // Never folded: an indented continuation line would parse as a child
+  // element, silently changing the tree. Bare attributes stay inline.
   if (style === 'bare') {
     bareParts = (function() {
       var k, len, ref1, ref2, results;
@@ -528,38 +577,44 @@ formatAttributes = function(node, style, o) {
       return results;
     })();
     return ` ${bareParts.join(' ')}`;
-  } else {
-    parts = [];
-    for (k = 0, len = attrs.length; k < len; k++) {
-      attr = attrs[k];
-      if (attr.spread) {
-        expr = (ref1 = attr.expression.source) != null ? ref1 : '';
-        if (o.coffeeScriptFormat) {
-          expr = formatCoffeeScript(expr, o);
-        }
-        parts.push(style === 'parens' ? `...${expr}` : `{${expr}...}`);
-        continue;
-      }
-      name = attr.name;
-      val = (ref2 = attr.value.source) != null ? ref2 : '';
+  }
+  parts = [];
+  for (k = 0, len = attrs.length; k < len; k++) {
+    attr = attrs[k];
+    if (attr.spread) {
+      expr = (ref1 = attr.expression.source) != null ? ref1 : '';
       if (o.coffeeScriptFormat) {
-        val = formatCoffeeScript(val, o);
-      }
-      if (attr.shorthand) {
-        parts.push(name);
-      } else {
-        parts.push(`${name}: ${val}`);
+        expr = formatCoffeeScript(expr, o);
       }
+      parts.push(style === 'parens' ? `...${expr}` : `{${expr}...}`);
+      continue;
     }
-    switch (style) {
-      case 'braces':
-        return `{ ${parts.join(', ')} }`;
-      case 'parens':
-        return `( ${parts.join(', ')} )`;
-      default:
-        return parts.join(', ');
+    name = attr.name;
+    val = (ref2 = attr.value.source) != null ? ref2 : '';
+    if (o.coffeeScriptFormat) {
+      val = formatCoffeeScript(val, o);
     }
+    if (attr.shorthand) {
+      parts.push(name);
+    } else {
+      parts.push(`${name}: ${val}`);
+    }
+  }
+  // Count-based forcing: a positive threshold breaks even when the
+  // attributes would otherwise fit within printWidth.
+  forceBreak = o.attributeMultilineThreshold > 0 && attrs.length >= o.attributeMultilineThreshold;
+  sep = forceBreak ? hardline : line;
+  if (style === 'braces') {
+    open = '{';
+    close = '}';
+  } else if (style === 'parens') {
+    open = '(';
+    close = ')';
+  } else {
+    // Unknown style — inline fallback, no folding.
+    return parts.join(', ');
   }
+  return group([open, indent([sep, join([',', sep], parts)]), sep, close]);
 };
 
 // ─── CoffeeScript Embed (for Prettier embed) ───────────────

package/docs/grammar.md

@@ -292,6 +292,103 @@ depending on configuration.
 
 ---
 
+## CoffeeScript Blocks (`---`)
+
+```
+CoffeeBlock    := '---' Newline
+                  CoffeeBody
+                  '---' Newline
+
+CoffeeBody     := Raw CoffeeScript lines, dedented to column 0.
+```
+
+The `---` fence is the multiline counterpart to `-` (statement). The body
+between the two `---` lines is taken verbatim (dedented by its minimum
+indentation) and compiled to executable JavaScript via the CoffeeScript
+bridge. The resulting statements run at **render time**, produce no markup,
+and behave exactly like a block of `-` lines.
+
+```haml
+---
+total = price * quantity
+tax = total * 0.08
+---
+%p= total + tax
+```
+
+Semantics:
+
+- **Escapes indentation**: body lines are dedented to column 0, so a block
+  nested under an element still writes CoffeeScript flush-left.
+- **Render-time**: the compiled statements run on every render, before the
+  JSX at their position. In a wrapped component they are hoisted into the
+  render expression alongside `-` statements; with `wrap: 'none'` they emit
+  in place.
+- **No markup**: the block contributes nothing to the render tree.
+
+Note: `---` is a CoffeeHaml fence marker, not an element. For a horizontal
+rule use `%hr` — mapping `---` to `<hr>` is a Markdown/YAML convention, not
+Haml.
+
+---
+
+## Yield Blocks (`===`)
+
+```
+CoffeeYield     := '===' Newline
+                   CoffeeBody
+                   '===' Newline
+```
+
+The `===` fence is the multiline counterpart to `=` (output): its body is
+CoffeeScript, dedented to column 0 exactly like a `---` block, but instead
+of running as statements its **final value is yielded as content**
+at that position in the render tree (escaped, matching `=`).
+
+```haml
+%p
+  ===
+  name = computeName()
+  "Hello, #{name}"
+  ===
+```
+
+A single-expression body compiles directly; a multi-statement body is
+wrapped in an IIFE so the last expression is the yielded value.
+
+---
+
+## Preamble Blocks (`~~~`)
+
+```
+CoffeePreamble  := '~~~' Newline
+                   CoffeeBody
+                   '~~~' Newline
+```
+
+The `~~~` fence holds module-scope code. Its body is CoffeeScript, dedented
+to column 0, and compiled to statements hoisted to **module scope** — outside
+any component wrapper. This is where imports, helper functions and one-time
+setup code live (the once-at-import region).
+
+```haml
+~~~
+import { useState } from 'react'
+formatPrice = (n) -> "$#{n.toFixed 2}"
+~~~
+%p= formatPrice total
+```
+
+Semantics:
+
+- **Module scope**: the compiled statements run once at module load, before
+  any JSX. `import`/`export` stay valid (they are not wrapped in a function).
+- **No markup**: the block contributes nothing to the render tree.
+- **Runs once**: unlike `---` (render-time), the body does not rerun per
+  render — ideal for imports, constants and pure helpers.
+
+---
+
 ## Raw Text / Passthrough
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coffeehaml",
-  "version": "0.7.7",
+  "version": "0.10.0",
   "description": "Haml structure. CoffeeScript semantics. React runtime. Zero runtime. Vite-native.",
   "type": "module",
   "license": "MIT",
@@ -62,7 +62,7 @@
   "scripts": {
     "build": "coffee -c -o dist/ src/*.coffee && coffee -c -o dist/prettier/ src/prettier/*.coffee",
     "dev": "coffee -c -w -o dist/ src/*.coffee & coffee -c -w -o dist/prettier/ src/prettier/*.coffee",
-    "test": "node test/run-compiler-tests.mjs && node test/prettier/run-integration-tests.mjs && node test/prettier/run-coffeescript-tests.mjs && node test/prettier/run-statement-merge-tests.mjs",
+    "test": "node test/run-compiler-tests.mjs && node test/run-coffee-block-tests.mjs && node test/prettier/run-integration-tests.mjs && node test/prettier/run-coffeescript-tests.mjs && node test/prettier/run-statement-merge-tests.mjs",
     "prepublishOnly": "npm run build",
     "fmt": "prettier --write --plugin=. **/*.chaml"
   },

package/syntaxes/CoffeeHaml.tmLanguage

@@ -15,6 +15,18 @@
 			<key>include</key>
 			<string>#prologue</string>
 		</dict>
+		<dict>
+			<key>include</key>
+			<string>#coffee-block</string>
+		</dict>
+		<dict>
+			<key>include</key>
+			<string>#coffee-yield</string>
+		</dict>
+		<dict>
+			<key>include</key>
+			<string>#coffee-preamble</string>
+		</dict>
 		<dict>
 			<key>include</key>
 			<string>#comment-haml</string>
@@ -183,6 +195,40 @@
 			<key>name</key>
 			<string>meta.attribute.shorthand.coffeehaml</string>
 		</dict>
+		<key>coffee-block</key>
+		<dict>
+			<key>begin</key>
+			<string>^([ \t]*)(---)[ \t]*$</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.coffee-block.coffeehaml</string>
+				</dict>
+			</dict>
+			<key>contentName</key>
+			<string>source.coffee.embedded.haml</string>
+			<key>end</key>
+			<string>^([ \t]*)(---)[ \t]*$</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.coffee-block.coffeehaml</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>meta.coffee-block.coffeehaml</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>source.coffee</string>
+				</dict>
+			</array>
+		</dict>
 		<key>coffee-boolean</key>
 		<dict>
 			<key>match</key>
@@ -566,6 +612,74 @@
 			<key>name</key>
 			<string>variable.other.coffeehaml</string>
 		</dict>
+		<key>coffee-yield</key>
+		<dict>
+			<key>begin</key>
+			<string>^([ \t]*)(===)[ \t]*$</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.coffee-yield.coffeehaml</string>
+				</dict>
+			</dict>
+			<key>contentName</key>
+			<string>source.coffee.embedded.haml</string>
+			<key>end</key>
+			<string>^([ \t]*)(===)[ \t]*$</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.coffee-yield.coffeehaml</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>meta.coffee-yield.coffeehaml</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>source.coffee</string>
+				</dict>
+			</array>
+		</dict>
+		<key>coffee-preamble</key>
+		<dict>
+			<key>begin</key>
+			<string>^([ \t]*)(~~~)[ \t]*$</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.coffee-preamble.coffeehaml</string>
+				</dict>
+			</dict>
+			<key>contentName</key>
+			<string>source.coffee.embedded.haml</string>
+			<key>end</key>
+			<string>^([ \t]*)(~~~)[ \t]*$</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.coffee-preamble.coffeehaml</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>meta.coffee-preamble.coffeehaml</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>source.coffee</string>
+				</dict>
+			</array>
+		</dict>
 		<key>coffeescript-expression</key>
 		<dict>
 			<key>patterns</key>
@@ -971,4 +1085,4 @@
 	<key>uuid</key>
 	<string>1EEA33FD-AEAC-4C44-9EB6-D4D0D9E5C9CB</string>
 </dict>
-</plist>
+</plist>

package/syntaxes/coffeehaml.tmLanguage.json

@@ -11,6 +11,15 @@
     {
       "include": "#prologue"
     },
+    {
+      "include": "#coffee-block"
+    },
+    {
+      "include": "#coffee-yield"
+    },
+    {
+      "include": "#coffee-preamble"
+    },
     {
       "include": "#comment-haml"
     },
@@ -300,6 +309,69 @@
       ],
       "contentName": "source.coffee.embedded.haml"
     },
+    "coffee-block": {
+      "name": "meta.coffee-block.coffeehaml",
+      "begin": "^([ \\t]*)(---)[ \\t]*$",
+      "beginCaptures": {
+        "2": {
+          "name": "punctuation.definition.coffee-block.coffeehaml"
+        }
+      },
+      "end": "^([ \\t]*)(---)[ \\t]*$",
+      "endCaptures": {
+        "2": {
+          "name": "punctuation.definition.coffee-block.coffeehaml"
+        }
+      },
+      "patterns": [
+        {
+          "include": "source.coffee"
+        }
+      ],
+      "contentName": "source.coffee.embedded.haml"
+    },
+    "coffee-yield": {
+      "name": "meta.coffee-yield.coffeehaml",
+      "begin": "^([ \\t]*)(===)[ \\t]*$",
+      "beginCaptures": {
+        "2": {
+          "name": "punctuation.definition.coffee-yield.coffeehaml"
+        }
+      },
+      "end": "^([ \\t]*)(===)[ \\t]*$",
+      "endCaptures": {
+        "2": {
+          "name": "punctuation.definition.coffee-yield.coffeehaml"
+        }
+      },
+      "patterns": [
+        {
+          "include": "source.coffee"
+        }
+      ],
+      "contentName": "source.coffee.embedded.haml"
+    },
+    "coffee-preamble": {
+      "name": "meta.coffee-preamble.coffeehaml",
+      "begin": "^([ \\t]*)(~~~)[ \\t]*$",
+      "beginCaptures": {
+        "2": {
+          "name": "punctuation.definition.coffee-preamble.coffeehaml"
+        }
+      },
+      "end": "^([ \\t]*)(~~~)[ \\t]*$",
+      "endCaptures": {
+        "2": {
+          "name": "punctuation.definition.coffee-preamble.coffeehaml"
+        }
+      },
+      "patterns": [
+        {
+          "include": "source.coffee"
+        }
+      ],
+      "contentName": "source.coffee.embedded.haml"
+    },
     "output": {
       "name": "meta.output.coffeehaml",
       "begin": "^(\\s*)(!=|=)(?!=)(\\s*)",