coffeehaml 0.7.6 → 0.8.0

package/README.md

@@ -152,6 +152,8 @@ 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 — module-scope code (imports, helpers, setup) |
+| `===` … `===` | Fenced yield block — CoffeeScript whose final value renders (escaped) |
 | `-# comment` | Haml comment (stripped) |
 | `/ comment` | HTML comment |
 | `.wrapper` | Implicit div |
@@ -173,7 +175,7 @@ Full grammar: [`docs/grammar.md`](docs/grammar.md)
 
 ## Status
 
-**v0.7.0 — production beta.** The compiler pipeline (Lexer → Parser → Emitter)
+**v0.8.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 +196,8 @@ blank line handling, and CoffeeScript code formatting.
 | Haml/HTML comments | ✅ |
 | `:filter` blocks | ✅ |
 | Prologue passthrough (`import`, `@decorator`) | ✅ |
+| `---` module-scope CoffeeScript block | ✅ |
+| `===` yield block (fenced output) | ✅ |
 | 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', 'Doctype'];
 
 export var ControlFlowKind = ['if', 'unless', 'for', 'while', 'else', 'statement'];
 
@@ -319,6 +319,48 @@ 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 executable JS statements
+  // and hoisted to module scope (imports, helpers, setup code).
+  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 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, collectCoffeeBlocks, compileComponentBody, emitArrowOutput, emitArrowOutputToJs, emitChildToJs, 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,8 @@ import {
   ControlFlow,
   Comment,
   Filter,
+  CoffeeBlock,
+  CoffeeYield,
   Doctype,
   Node,
   Expression
@@ -18,7 +20,8 @@ import {
 
 import {
   compileExpression,
-  compileStatement
+  compileStatement,
+  compileYield
 } from './expressions.js';
 
 import {
@@ -110,7 +113,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 b, blocks, bodyExpr, hocs, inner, j, k, len, len1, 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
@@ -122,6 +125,17 @@ export var emit = function(ast, options = {}) {
     }
   }
   state.emitLine();
+  // Emit fenced CoffeeScript blocks (--- ... ---) at module scope.
+  // Imports, helpers and setup code must live outside any component
+  // wrapper, so they are collected here and emitted before the body.
+  blocks = collectCoffeeBlocks(ast.children, []);
+  if (blocks.length > 0) {
+    for (k = 0, len1 = blocks.length; k < len1; k++) {
+      b = blocks[k];
+      state.emitLine(compileStatement(b.content, b.location));
+    }
+    state.emitLine();
+  }
   wrap = options.wrap;
   if (wrap && wrap !== 'none') {
     name = options.componentName || 'Component';
@@ -231,6 +245,33 @@ splitJsStatements = function(body) {
 };
 
 // ─── Node Emitters ─────────────────────────────────────────
+
+// Recursively collect fenced CoffeeScript blocks for module-level hoisting,
+// removing them from the render tree in place (they contribute no markup).
+collectCoffeeBlocks = 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 CoffeeBlock) {
+      acc.push(node);
+      nodes.splice(i, 1);
+      continue;
+    }
+    if (((ref = node.children) != null ? ref.length : void 0) > 0) {
+      collectCoffeeBlocks(node.children, acc);
+    }
+    if (node.next != null) {
+      collectCoffeeBlocks([node.next], acc);
+    }
+    i++;
+  }
+  return acc;
+};
+
 emitNodes = function(nodes, state, isRoot = false) {
   var i, node, remaining;
   i = 0;
@@ -248,6 +289,12 @@ emitNodes = function(nodes, state, isRoot = false) {
 };
 
 emitNode = function(node, state, isRoot) {
+  if (node instanceof CoffeeBlock) { // 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) {
@@ -456,6 +503,9 @@ emitChildToJs = function(node, state) {
   if (node instanceof Filter) {
     return emitFilterToJs(node, state);
   }
+  if (node instanceof CoffeeYield) {
+    return compileYield(node.content, node.location);
+  }
   return 'null';
 };
 
@@ -683,6 +733,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,7 @@
 // Generated by CoffeeScript 2.7.0
-// expressions.coffee — CoffeeScript expression compilation bridge
-var _coffeeScriptAvailable, _coffeeScriptUnavailableReason, _require, checkCoffeeScript, collapseWs, loadCoffeeScript, splitTopLevelStatements, stripCoffeeWrapper, stripToConst;
+  // expressions.coffee — CoffeeScript expression compilation bridge
+var _coffeeScriptAvailable, _coffeeScriptUnavailableReason, _require, checkCoffeeScript, collapseWs, isSingleExpression, loadCoffeeScript, objectTarget, splitTopLevelStatements, stripCoffeeWrapper, stripToConst,
+  indexOf = [].indexOf;
 
 import {
   createRequire
@@ -178,9 +179,71 @@ 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
+// destructuring pattern — shorthand `x` stays `x`, aliased `key: target`
+// yields `target`.
+objectTarget = function(pair) {
+  pair = pair.trim();
+  if (pair.includes(':')) {
+    return pair.split(':')[1].trim();
+  } else {
+    return pair;
+  }
+};
+
 stripToConst = function(js) {
-  var assign, assignments, body, idx, j, len, name, 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*$/, '');
@@ -194,28 +257,96 @@ stripToConst = function(js) {
   varNames = stmts[varIdx].replace(/^\s*var\s+/, '').replace(/;\s*$/, '').split(',').map(function(s) {
     return s.trim();
   }).filter(Boolean);
-  body = stmts.filter(function(s, i) {
-    return i !== varIdx;
-  });
-  assignments = [];
-  for (j = 0, len = varNames.length; j < len; j++) {
-    name = varNames[j];
-    idx = body.findIndex(function(s) {
-      var t;
-      t = s.trim();
-      return t.startsWith(`${name} =`) || t.startsWith(`${name}=`);
+  body = (function() {
+    var j, len, ref, results;
+    ref = stmts.filter(function(s, i) {
+      return i !== varIdx;
+    });
+    results = [];
+    for (j = 0, len = ref.length; j < len; j++) {
+      s = ref[j];
+      results.push(collapseWs(s).replace(/;\s*$/, ''));
+    }
+    return results;
+  })();
+  constReplacements = {};
+  consumed = [];
+  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
+      names = (function() {
+        var k, len1, ref, results;
+        ref = m[1].split(',');
+        results = [];
+        for (k = 0, len1 = ref.length; k < len1; k++) {
+          n = ref[k];
+          if (n.trim()) {
+            results.push(n.trim());
+          }
+        }
+        return results;
+      })();
+      consumed = consumed.concat(names);
+      constReplacements[idx] = 'const ' + s;
+      continue;
+    }
+    m = s.match(/^\(\s*\{([^}]*)\}\s*=.*\)$/);
+    if (m != null) {
+      // Object destructuring: ({x, y} = expr) -> const {x, y} = expr
+      inner = s.replace(/^\s*\(\s*/, '').replace(/\s*\)\s*$/, '');
+      names = (function() {
+        var k, len1, ref, results;
+        ref = m[1].split(',');
+        results = [];
+        for (k = 0, len1 = ref.length; k < len1; k++) {
+          n = ref[k];
+          if (n.trim()) {
+            results.push(objectTarget(n));
+          }
+        }
+        return results;
+      })();
+      consumed = consumed.concat(names);
+      constReplacements[idx] = 'const ' + inner;
+      continue;
+    }
+    name = varNames.find(function(n) {
+      return s.startsWith(`${n} =`) || s.startsWith(`${n}=`);
     });
-    if (idx >= 0) {
-      assign = collapseWs(body[idx]).replace(/;\s*$/, '');
-      assignments.push('const ' + assign);
+    if (name != null) {
+      consumed.push(name);
+      constReplacements[idx] = 'const ' + s;
     }
   }
-  if (assignments.length > 0) {
-    return assignments.join('; ');
+  allConsumed = varNames.every(function(n) {
+    return indexOf.call(consumed, n) >= 0;
+  });
+  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 body.map(function(s) {
-    return collapseWs(s);
-  }).join(' ');
+  return ((function() {
+    var k, len1, results;
+    results = [];
+    for (k = 0, len1 = stmts.length; k < len1; k++) {
+      s = stmts[k];
+      // Fallback: keep the original var declaration so no variable goes
+      // undeclared (e.g. chained assignment `a = b = 1`).
+      results.push(collapseWs(s).replace(/;\s*$/, ''));
+    }
+    return results;
+  })()).join('; ');
 };
 
 // Split compiled JS into top-level statements, respecting string literals

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,8 @@ export var TokenType = {
   COMMENT: 'COMMENT',
   HTML_COMMENT: 'HTML_COMMENT',
   FILTER: 'FILTER',
+  COFFEE_BLOCK: 'COFFEE_BLOCK',
+  COFFEE_YIELD: 'COFFEE_YIELD',
   DOCTYPE: 'DOCTYPE',
   TEXT: 'TEXT',
   PROLOGUE: 'PROLOGUE',
@@ -75,21 +77,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 +101,73 @@ 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 code
+    // hoisted to module scope (COFFEE_BLOCK); `===` yields the body's final
+    // value as content at that position (COFFEE_YIELD). 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 === '===') {
+      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: (fence === '===' ? TokenType.COFFEE_YIELD : 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 +191,7 @@ export var tokenize = function(source, filename = null) {
       });
       offset += lineLength;
       lineIndex++;
+      i++;
       continue;
     }
     inPrologue = false;
@@ -144,6 +216,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 +608,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, parseCoffeeYield, parseComment, parseControlFlow, parseControlKind, parseDoctype, parseElement, parseFilter, parseHtmlComment, parseImplicitDiv, parseNode, parseOutput, parseText, splitAttributePairs, splitBareAttributePairs, stripControlKeyword;
 
 import {
   TokenType
@@ -16,6 +16,8 @@ import {
   ControlFlow,
   Comment,
   Filter,
+  CoffeeBlock,
+  CoffeeYield,
   Doctype,
   Expression,
   Attribute,
@@ -79,7 +81,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.COMMENT || t === TokenType.HTML_COMMENT || t === TokenType.DOCTYPE || t === TokenType.INDENT || t === TokenType.DEDENT) {
           return;
         }
         this.advance();
@@ -168,6 +170,10 @@ 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.DOCTYPE:
       return parseDoctype(state);
     case TokenType.TEXT:
@@ -461,6 +467,25 @@ 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);
+};
+
 // ─── 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,