coffeehaml 0.6.0 → 0.7.1

package/dist/parser.js

@@ -1,474 +1,575 @@
-import { TokenType } from './lexer.js';
-import { Document, Element, ImplicitDiv, Text, Output, ControlFlow, Comment, Filter, Doctype, Expression, } from './ast.js';
-import { CompileError } from './types.js';
-// ─── Parser State ──────────────────────────────────────────
-class ParserState {
-    constructor(tokens, filename) {
-        this.errors = [];
-        this.tokens = tokens;
-        this.pos = 0;
-        this.filename = filename;
+// Generated by CoffeeScript 2.7.0
+// parser.coffee — recursive descent parser
+// Converts token stream into AST
+var ParserState, findColon, isElse, parseAttributeBlock, parseBlock, parseComment, parseControlFlow, parseControlKind, parseDoctype, parseElement, parseFilter, parseHtmlComment, parseImplicitDiv, parseNode, parseOutput, parseText, splitAttributePairs, stripControlKeyword;
+
+import {
+  TokenType
+} from './lexer.js';
+
+import {
+  Document,
+  Element,
+  ImplicitDiv,
+  Text,
+  Output,
+  ControlFlow,
+  Comment,
+  Filter,
+  Doctype,
+  Expression,
+  Attribute,
+  SpreadAttribute
+} from './ast.js';
+
+import {
+  CompileError
+} from './types.js';
+
+ParserState = (function() {
+  // ─── Parser State ──────────────────────────────────────────
+  class ParserState {
+    constructor(tokens1, filename1 = null) {
+      this.tokens = tokens1;
+      this.filename = filename1;
+      this.pos = 0;
+      this.errors = [];
     }
-    get current() {
-        return this.pos < this.tokens.length ? this.tokens[this.pos] : null;
+
+    current() {
+      if (this.pos < this.tokens.length) {
+        return this.tokens[this.pos];
+      } else {
+        return null;
+      }
     }
-    get peek() {
-        return this.pos + 1 < this.tokens.length ? this.tokens[this.pos + 1] : null;
+
+    peek() {
+      if (this.pos + 1 < this.tokens.length) {
+        return this.tokens[this.pos + 1];
+      } else {
+        return null;
+      }
     }
+
     advance() {
-        const token = this.current;
-        this.pos++;
-        return token;
+      var token;
+      token = this.current();
+      this.pos++;
+      return token;
     }
-    /** Record an error and attempt recovery by skipping to the next safe boundary. */
+
     error(message, code = 'PARSE_ERROR') {
-        this.errors.push(new CompileError(message, 'parser', code, this.current?.location));
+      var ref;
+      return this.errors.push(new CompileError(message, 'parser', code, (ref = this.current()) != null ? ref.location : void 0));
     }
-    /** Expect a token type. On mismatch, records error and recovers (never throws). */
+
     expect(type) {
-        const token = this.current;
-        if (!token || token.type !== type) {
-            this.error(`Expected ${type} but got ${token?.type ?? 'EOF'}`, 'UNEXPECTED_TOKEN');
-            // Recovery: skip to next structural token
-            this.recover();
-            return null;
-        }
-        return this.advance();
+      var ref, token;
+      token = this.current();
+      if (!token || token.type !== type) {
+        this.error(`Expected ${type} but got ${(ref = token != null ? token.type : void 0) != null ? ref : 'EOF'}`, 'UNEXPECTED_TOKEN');
+        this.recover();
+        return null;
+      }
+      return this.advance();
     }
-    /** Skip tokens until a structural boundary (INDENT/DEDENT/block-level token). */
+
     recover() {
-        while (this.current) {
-            const 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) {
-                return;
-            }
-            this.advance();
+      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) {
+          return;
         }
+        this.advance();
+      }
     }
+
     skip(type) {
-        if (this.current?.type === type) {
-            this.advance();
-            return true;
-        }
-        return false;
+      var ref;
+      if (((ref = this.current()) != null ? ref.type : void 0) === type) {
+        this.advance();
+        return true;
+      }
+      return false;
     }
+
     isAt(type) {
-        return this.current?.type === type;
+      var ref;
+      return ((ref = this.current()) != null ? ref.type : void 0) === type;
     }
-}
+
+  };
+
+  ParserState.prototype.tokens = [];
+
+  ParserState.prototype.pos = 0;
+
+  ParserState.prototype.filename = null;
+
+  ParserState.prototype.errors = [];
+
+  return ParserState;
+
+}).call(this);
+
 // ─── Public API ────────────────────────────────────────────
-export function parse(tokens, filename) {
-    const state = new ParserState(tokens, filename);
-    // Collect prologue (raw JS lines before the first HAML construct)
-    const prologue = [];
-    while (state.current?.type === TokenType.PROLOGUE) {
-        prologue.push(state.advance().value);
-    }
-    const children = parseBlock(state);
-    return { document: new Document(children, prologue), errors: state.errors };
-}
+export var parse = function(tokens, filename = null) {
+  var children, prologue, ref, state;
+  state = new ParserState(tokens, filename);
+  prologue = [];
+  while (((ref = state.current()) != null ? ref.type : void 0) === TokenType.PROLOGUE) {
+    prologue.push(state.advance().value);
+  }
+  children = parseBlock(state);
+  return {
+    document: new Document(children, prologue),
+    errors: state.errors
+  };
+};
+
 // ─── Block Parsing ─────────────────────────────────────────
-/** Parse nodes until DEDENT or EOF. */
-function parseBlock(state) {
-    const nodes = [];
-    while (state.current && state.current.type !== TokenType.DEDENT) {
-        const node = parseNode(state);
-        if (node)
-            nodes.push(node);
+parseBlock = function(state) {
+  var node, nodes;
+  nodes = [];
+  while (state.current() && state.current().type !== TokenType.DEDENT) {
+    node = parseNode(state);
+    if (node) {
+      nodes.push(node);
     }
-    return nodes;
-}
+  }
+  return nodes;
+};
+
 // ─── Node Dispatcher ───────────────────────────────────────
-function parseNode(state) {
-    const token = state.current;
-    if (!token)
-        return null;
-    switch (token.type) {
-        case TokenType.TAG:
-            return parseElement(state);
-        case TokenType.CLASS:
-        case TokenType.ID:
-            return parseImplicitDiv(state);
-        case TokenType.OUTPUT:
-        case TokenType.OUTPUT_UNESC:
-            return parseOutput(state);
-        case TokenType.CONTROL:
-            return parseControlFlow(state);
-        case TokenType.COMMENT:
-            return parseComment(state);
-        case TokenType.HTML_COMMENT:
-            return parseHtmlComment(state);
-        case TokenType.FILTER:
-            return parseFilter(state);
-        case TokenType.DOCTYPE:
-            return parseDoctype(state);
-        case TokenType.TEXT:
-            return parseText(state);
-        case TokenType.INDENT:
-            state.advance(); // skip, handled by parseBlock
-            return null;
-        case TokenType.DEDENT:
-            return null; // handled by parseBlock loop
-        case TokenType.NEWLINE:
-            state.advance();
-            return null;
-        default:
-            state.advance();
-            return null;
-    }
-}
+parseNode = function(state) {
+  var token;
+  token = state.current();
+  if (!token) {
+    return null;
+  }
+  switch (token.type) {
+    case TokenType.TAG:
+      return parseElement(state);
+    case TokenType.CLASS:
+      return parseImplicitDiv(state);
+    case TokenType.ID:
+      return parseImplicitDiv(state);
+    case TokenType.OUTPUT:
+      return parseOutput(state);
+    case TokenType.OUTPUT_UNESC:
+      return parseOutput(state);
+    case TokenType.CONTROL:
+      return parseControlFlow(state);
+    case TokenType.COMMENT:
+      return parseComment(state);
+    case TokenType.HTML_COMMENT:
+      return parseHtmlComment(state);
+    case TokenType.FILTER:
+      return parseFilter(state);
+    case TokenType.DOCTYPE:
+      return parseDoctype(state);
+    case TokenType.TEXT:
+      return parseText(state);
+    case TokenType.INDENT:
+      state.advance();
+      return null;
+    case TokenType.DEDENT:
+      return null;
+    case TokenType.NEWLINE:
+      state.advance();
+      return null;
+    default:
+      state.advance();
+      return null;
+  }
+};
+
 // ─── Element ───────────────────────────────────────────────
-function parseElement(state) {
-    const tagToken = state.expect(TokenType.TAG);
-    if (!tagToken)
-        return new Element('div', { location: state.current?.location });
-    const tag = tagToken.value;
-    const isComponent = /^[A-Z]/.test(tag);
-    let classes = [];
-    let id = null;
-    let attributes = [];
-    let isSelfClosing = false;
-    // Parse modifiers and attributes
-    while (state.current &&
-        (state.current.type === TokenType.CLASS ||
-            state.current.type === TokenType.ID ||
-            state.current.type === TokenType.ATTRS_BRACE ||
-            state.current.type === TokenType.ATTRS_PAREN ||
-            state.current.type === TokenType.SELF_CLOSE)) {
-        const tok = state.current;
-        if (tok.type === TokenType.CLASS) {
-            state.advance();
-            classes.push(tok.value);
-        }
-        else if (tok.type === TokenType.ID) {
-            state.advance();
-            id = tok.value; // last #id wins
-        }
-        else if (tok.type === TokenType.ATTRS_BRACE) {
-            state.advance();
-            attributes.push(...parseAttributeBlock(tok.value, '{}', tagToken.location));
-        }
-        else if (tok.type === TokenType.ATTRS_PAREN) {
-            state.advance();
-            attributes.push(...parseAttributeBlock(tok.value, '()', tagToken.location));
-        }
-        else if (tok.type === TokenType.SELF_CLOSE) {
-            state.advance();
-            isSelfClosing = true;
-        }
-    }
-    // Parse inline text or output if present
-    let children = [];
-    if (state.current && !isSelfClosing) {
-        if (state.current.type === TokenType.OUTPUT) {
-            const tok = state.advance();
-            children.push(new Output(new Expression(tok.value), 'escaped', tok.location));
-        }
-        else if (state.current.type === TokenType.OUTPUT_UNESC) {
-            const tok = state.advance();
-            children.push(new Output(new Expression(tok.value), 'unescaped', tok.location));
-        }
-        else if (state.current.type === TokenType.TEXT) {
-            const textToken = state.advance();
-            children.push(new Text(textToken.value, textToken.location));
-        }
-    }
-    // Parse child block if INDENT follows
-    if (state.current?.type === TokenType.INDENT && !isSelfClosing) {
-        state.advance(); // consume INDENT
-        children = children.concat(parseBlock(state));
-        state.expect(TokenType.DEDENT);
-    }
-    return new Element(tag, { classes, id, attributes, children, isComponent, isSelfClosing, location: tagToken.location });
-}
-// ─── ImplicitDiv ───────────────────────────────────────────
-function parseImplicitDiv(state) {
-    let classes = [];
-    let id = null;
-    let attributes = [];
-    const firstToken = state.current; // for location
-    while (state.current &&
-        (state.current.type === TokenType.CLASS ||
-            state.current.type === TokenType.ID ||
-            state.current.type === TokenType.ATTRS_BRACE ||
-            state.current.type === TokenType.ATTRS_PAREN)) {
-        const tok = state.current;
-        if (tok.type === TokenType.CLASS) {
-            state.advance();
-            classes.push(tok.value);
-        }
-        else if (tok.type === TokenType.ID) {
-            state.advance();
-            id = tok.value;
-        }
-        else if (tok.type === TokenType.ATTRS_BRACE) {
-            state.advance();
-            attributes.push(...parseAttributeBlock(tok.value, '{}', firstToken.location));
-        }
-        else if (tok.type === TokenType.ATTRS_PAREN) {
-            state.advance();
-            attributes.push(...parseAttributeBlock(tok.value, '()', firstToken.location));
-        }
+parseElement = function(state) {
+  var attrStyle, attributes, children, classes, id, isComponent, isSelfClosing, ref, ref1, ref2, tag, tagToken, textToken, tok;
+  tagToken = state.expect(TokenType.TAG);
+  if (!tagToken) {
+    return new Element('div', {
+      location: (ref = state.current()) != null ? ref.location : void 0
+    });
+  }
+  tag = tagToken.value;
+  isComponent = /^[A-Z]/.test(tag);
+  classes = [];
+  id = null;
+  attributes = [];
+  isSelfClosing = false;
+  attrStyle = null;
+  while (state.current() && ((ref1 = state.current().type) === TokenType.CLASS || ref1 === TokenType.ID || ref1 === TokenType.ATTRS_BRACE || ref1 === TokenType.ATTRS_PAREN || ref1 === TokenType.SELF_CLOSE)) {
+    tok = state.current();
+    switch (tok.type) {
+      case TokenType.CLASS:
+        state.advance();
+        classes.push(tok.value);
+        break;
+      case TokenType.ID:
+        state.advance();
+        id = tok.value;
+        break;
+      case TokenType.ATTRS_BRACE:
+        state.advance();
+        attributes.push(...parseAttributeBlock(tok.value, '{}', tagToken.location));
+        attrStyle = 'braces';
+        break;
+      case TokenType.ATTRS_PAREN:
+        state.advance();
+        attributes.push(...parseAttributeBlock(tok.value, '()', tagToken.location));
+        attrStyle = 'parens';
+        break;
+      case TokenType.SELF_CLOSE:
+        state.advance();
+        isSelfClosing = true;
     }
-    // Parse inline text
-    let children = [];
-    if (state.current && state.current.type === TokenType.TEXT) {
-        const textToken = state.advance();
+  }
+  // Parse inline text or output
+  children = [];
+  if (state.current() && !isSelfClosing) {
+    switch (state.current().type) {
+      case TokenType.OUTPUT:
+        tok = state.advance();
+        children.push(new Output(new Expression(tok.value), 'escaped', tok.location));
+        break;
+      case TokenType.OUTPUT_UNESC:
+        tok = state.advance();
+        children.push(new Output(new Expression(tok.value), 'unescaped', tok.location));
+        break;
+      case TokenType.TEXT:
+        textToken = state.advance();
         children.push(new Text(textToken.value, textToken.location));
     }
-    // Parse child block
-    if (state.current?.type === TokenType.INDENT) {
+  }
+  // Parse child block if INDENT follows
+  if (((ref2 = state.current()) != null ? ref2.type : void 0) === TokenType.INDENT && !isSelfClosing) {
+    state.advance();
+    children = children.concat(parseBlock(state));
+    state.expect(TokenType.DEDENT);
+  }
+  return new Element(tag, {
+    classes,
+    id,
+    attributes,
+    children,
+    isComponent,
+    isSelfClosing,
+    attrStyle,
+    location: tagToken.location
+  });
+};
+
+// ─── ImplicitDiv ───────────────────────────────────────────
+parseImplicitDiv = function(state) {
+  var attrStyle, attributes, children, classes, firstToken, id, ref, ref1, ref2, textToken, tok;
+  classes = [];
+  id = null;
+  attributes = [];
+  attrStyle = null;
+  firstToken = state.current();
+  while (state.current() && ((ref = state.current().type) === TokenType.CLASS || ref === TokenType.ID || ref === TokenType.ATTRS_BRACE || ref === TokenType.ATTRS_PAREN)) {
+    tok = state.current();
+    switch (tok.type) {
+      case TokenType.CLASS:
         state.advance();
-        children = children.concat(parseBlock(state));
-        state.expect(TokenType.DEDENT);
+        classes.push(tok.value);
+        break;
+      case TokenType.ID:
+        state.advance();
+        id = tok.value;
+        break;
+      case TokenType.ATTRS_BRACE:
+        state.advance();
+        attributes.push(...parseAttributeBlock(tok.value, '{}', firstToken.location));
+        attrStyle = 'braces';
+        break;
+      case TokenType.ATTRS_PAREN:
+        state.advance();
+        attributes.push(...parseAttributeBlock(tok.value, '()', firstToken.location));
+        attrStyle = 'parens';
     }
-    return new ImplicitDiv({ classes, id, attributes, children, location: firstToken.location });
-}
+  }
+  // Parse inline text
+  children = [];
+  if (((ref1 = state.current()) != null ? ref1.type : void 0) === TokenType.TEXT) {
+    textToken = state.advance();
+    children.push(new Text(textToken.value, textToken.location));
+  }
+  // Parse child block
+  if (((ref2 = state.current()) != null ? ref2.type : void 0) === TokenType.INDENT) {
+    state.advance();
+    children = children.concat(parseBlock(state));
+    state.expect(TokenType.DEDENT);
+  }
+  return new ImplicitDiv({
+    classes,
+    id,
+    attributes,
+    children,
+    attrStyle,
+    location: firstToken.location
+  });
+};
+
 // ─── Output ────────────────────────────────────────────────
-function parseOutput(state) {
-    const token = state.current;
-    const outputKind = token.type === TokenType.OUTPUT ? 'escaped' : 'unescaped';
+parseOutput = function(state) {
+  var children, expr, outputKind, ref, token;
+  token = state.current();
+  outputKind = token.type === TokenType.OUTPUT ? 'escaped' : 'unescaped';
+  state.advance();
+  expr = new Expression(token.value);
+  children = [];
+  if (((ref = state.current()) != null ? ref.type : void 0) === TokenType.INDENT) {
     state.advance();
-    const expr = new Expression(token.value, undefined);
-    // Parse continuation children if INDENT follows
-    let children = [];
-    if (state.current?.type === TokenType.INDENT) {
-        state.advance();
-        children = parseBlock(state);
-        state.expect(TokenType.DEDENT);
-    }
-    return new Output(expr, outputKind, token.location, children);
-}
+    children = parseBlock(state);
+    state.expect(TokenType.DEDENT);
+  }
+  return new Output(expr, outputKind, token.location, children);
+};
+
 // ─── Control Flow ──────────────────────────────────────────
-function parseControlFlow(state) {
-    const token = state.expect(TokenType.CONTROL);
-    if (!token)
-        return new ControlFlow('statement', new Expression(''), [], null, state.current?.location);
-    let source = token.value;
-    // Normalize "else if" → "if" so it chains naturally in ternary
-    if (/^\s*else\s+if\b/.test(source)) {
-        source = source.replace(/^\s*else\s+/, '');
+parseControlFlow = function(state) {
+  var children, controlKind, expr, exprSource, next, nextSource, ref, ref1, ref2, source, token;
+  token = state.expect(TokenType.CONTROL);
+  if (!token) {
+    return new ControlFlow('statement', new Expression(''), [], null, (ref = state.current()) != null ? ref.location : void 0);
+  }
+  source = token.value;
+  // Normalize "else if" → "if"
+  if (/^\s*else\s+if\b/.test(source)) {
+    source = source.replace(/^\s*else\s+/, '');
+  }
+  controlKind = parseControlKind(source);
+  exprSource = stripControlKeyword(source, controlKind);
+  expr = new Expression(exprSource);
+  children = [];
+  if (((ref1 = state.current()) != null ? ref1.type : void 0) === TokenType.INDENT) {
+    state.advance();
+    children = parseBlock(state);
+    state.expect(TokenType.DEDENT);
+  }
+  // Check for chained else / else if
+  next = null;
+  if (((ref2 = state.current()) != null ? ref2.type : void 0) === TokenType.CONTROL) {
+    nextSource = state.current().value.trimStart();
+    if (isElse(nextSource)) {
+      next = parseControlFlow(state);
     }
-    // Parse the control kind from the expression
-    const controlKind = parseControlKind(source);
-    // Strip the keyword from the expression — store only the condition/iterable
-    const exprSource = stripControlKeyword(source, controlKind);
-    const expr = new Expression(exprSource, undefined);
-    // Parse body if INDENT follows
-    let children = [];
-    if (state.current?.type === TokenType.INDENT) {
+  }
+  return new ControlFlow(controlKind, expr, children, next, token.location);
+};
+
+parseControlKind = function(source) {
+  var keyword;
+  keyword = source.trimStart().split(/\s+/)[0];
+  switch (keyword) {
+    case 'if':
+      return 'if';
+    case 'unless':
+      return 'unless';
+    case 'for':
+      return 'for';
+    case 'while':
+      return 'while';
+    case 'else':
+      return 'else';
+    default:
+      return 'statement';
+  }
+};
+
+stripControlKeyword = function(source, kind) {
+  var keyword, re, trimmed;
+  trimmed = source.trimStart();
+  if (kind === 'statement') {
+    return trimmed;
+  }
+  keyword = kind === 'else' ? 'else' : kind;
+  re = new RegExp(`^\\s*${keyword}\\b\\s*`);
+  return trimmed.replace(re, '');
+};
+
+isElse = function(source) {
+  return /^\s*else\b/.test(source);
+};
+
+// ─── Comments ──────────────────────────────────────────────
+parseComment = function(state) {
+  var token;
+  token = state.expect(TokenType.COMMENT);
+  if (!token) {
+    return new Comment('haml', '');
+  }
+  return new Comment('haml', token.value, token.location);
+};
+
+parseHtmlComment = function(state) {
+  var token;
+  token = state.expect(TokenType.HTML_COMMENT);
+  if (!token) {
+    return new Comment('html', '');
+  }
+  return new Comment('html', token.value, token.location);
+};
+
+// ─── Filter ────────────────────────────────────────────────
+parseFilter = function(state) {
+  var content, filterName, lines, parts, tok, token;
+  token = state.expect(TokenType.FILTER);
+  if (!token) {
+    return new Filter('', '');
+  }
+  parts = token.value.split('\n');
+  filterName = parts[0];
+  content = parts.slice(1).join('\n');
+  // Consume indented body
+  if (state.isAt(TokenType.INDENT)) {
+    state.advance();
+    lines = [];
+    while (state.current() && !state.isAt(TokenType.DEDENT)) {
+      tok = state.current();
+      if (tok.type === TokenType.TEXT) {
+        lines.push(tok.value);
         state.advance();
-        children = parseBlock(state);
-        state.expect(TokenType.DEDENT);
-    }
-    // Check for chained else / else if
-    let next = null;
-    if (state.current?.type === TokenType.CONTROL) {
-        const nextSource = state.current.value.trimStart();
-        if (isElse(nextSource)) {
-            next = parseControlFlow(state);
-        }
-    }
-    return new ControlFlow(controlKind, expr, children, next, token.location);
-}
-function parseControlKind(source) {
-    const trimmed = source.trimStart();
-    const keyword = trimmed.split(/\s+/)[0];
-    switch (keyword) {
-        case 'if': return 'if';
-        case 'unless': return 'unless';
-        case 'for': return 'for';
-        case 'while': return 'while';
-        case 'else': return 'else';
-        default: return 'statement';
+      } else if (tok.type === TokenType.NEWLINE) {
+        state.advance();
+      } else {
+        break;
+      }
     }
-}
-function stripControlKeyword(source, kind) {
-    const trimmed = source.trimStart();
-    if (kind === 'statement') {
-        return trimmed; // no keyword to strip — entire source is the statement
+    if (state.isAt(TokenType.DEDENT)) {
+      state.advance();
     }
-    // Remove the keyword and any whitespace after it
-    const keyword = kind === 'else' ? 'else' : kind;
-    const re = new RegExp("^\\s*" + keyword + "\\b\\s*");
-    return trimmed.replace(re, '');
-}
-function isElse(source) {
-    return /^\s*else\b/.test(source);
-}
-// ─── Comments ──────────────────────────────────────────────
-function parseComment(state) {
-    const token = state.expect(TokenType.COMMENT);
-    if (!token)
-        return new Comment('haml', '');
-    return new Comment('haml', token.value, token.location);
-}
-function parseHtmlComment(state) {
-    const token = state.expect(TokenType.HTML_COMMENT);
-    if (!token)
-        return new Comment('html', '');
-    return new Comment('html', token.value, token.location);
-}
-// ─── Filter ────────────────────────────────────────────────
-function parseFilter(state) {
-    const token = state.expect(TokenType.FILTER);
-    if (!token)
-        return new Filter('', '');
-    const parts = token.value.split('\n');
-    const filterName = parts[0];
-    let content = parts.slice(1).join('\n');
-    // Consume indented children as filter body (Haml convention).
-    // After `:markdown`, all indented content belongs to the filter.
-    if (state.isAt(TokenType.INDENT)) {
-        state.advance(); // skip INDENT
-        const lines = [];
-        while (state.current && !state.isAt(TokenType.DEDENT)) {
-            const tok = state.current;
-            if (tok.type === TokenType.TEXT) {
-                lines.push(tok.value);
-                state.advance();
-            }
-            else if (tok.type === TokenType.NEWLINE) {
-                state.advance();
-            }
-            else {
-                // Unexpected token in filter body — break to avoid infinite loop
-                break;
-            }
-        }
-        // Consume DEDENT
-        if (state.isAt(TokenType.DEDENT)) {
-            state.advance();
-        }
-        if (lines.length > 0) {
-            content = (content ? content + '\n' : '') + lines.join('\n');
-        }
+    if (lines.length > 0) {
+      content = content ? content + '\n' + lines.join('\n') : lines.join('\n');
     }
-    return new Filter(filterName, content, token.location);
-}
+  }
+  return new Filter(filterName, content, token.location);
+};
+
 // ─── Doctype ───────────────────────────────────────────────
-function parseDoctype(state) {
-    const token = state.expect(TokenType.DOCTYPE);
-    if (!token)
-        return new Doctype('html');
-    return new Doctype(token.value || 'html', token.location);
-}
+parseDoctype = function(state) {
+  var token;
+  token = state.expect(TokenType.DOCTYPE);
+  if (!token) {
+    return new Doctype('html');
+  }
+  return new Doctype(token.value || 'html', token.location);
+};
+
 // ─── Text ──────────────────────────────────────────────────
-function parseText(state) {
-    const token = state.expect(TokenType.TEXT);
-    if (!token)
-        return new Text('');
-    return new Text(token.value, token.location);
-}
+parseText = function(state) {
+  var token;
+  token = state.expect(TokenType.TEXT);
+  if (!token) {
+    return new Text('');
+  }
+  return new Text(token.value, token.location);
+};
+
 // ─── Attribute Block Parser ────────────────────────────────
-/** Parse a CoffeeScript object literal into attributes.
- *  Uses a simple key-value parser that handles:
- *    {key: value, key2: value2}
- *    {shorthand}
- *    {key: "string", 'quoted-key': val, nested: {a: 1}}
- */
-function parseAttributeBlock(source, _style, _location) {
-    const attrs = [];
-    if (!source.trim())
-        return attrs;
-    // Simple attribute parser: split on commas outside of brackets/strings
-    const pairs = splitAttributePairs(source);
-    for (const pair of pairs) {
-        const trimmed = pair.trim();
-        if (!trimmed)
-            continue;
-        // Spread attribute: props... (CoffeeScript form) or ...props (JSX form)
-        if (trimmed.endsWith('...')) {
-            const expr = trimmed.slice(0, -3).trim();
-            if (expr) {
-                attrs.push({ spread: true, expression: new Expression(expr) });
-            }
-            continue;
-        }
-        if (trimmed.startsWith('...')) {
-            const expr = trimmed.slice(3).trim();
-            if (expr) {
-                attrs.push({ spread: true, expression: new Expression(expr) });
-            }
-            continue;
-        }
-        const colonIdx = findColon(trimmed);
-        if (colonIdx === -1) {
-            // Shorthand: {foo} → foo={foo}
-            attrs.push({
-                name: trimmed,
-                value: new Expression(trimmed),
-                shorthand: true,
-            });
-        }
-        else {
-            const name = trimmed.slice(0, colonIdx).trim();
-            const value = trimmed.slice(colonIdx + 1).trim();
-            // Strip quotes from key if present
-            const cleanName = name.replace(/^['"]|['"]$/g, '');
-            attrs.push({
-                name: cleanName,
-                value: new Expression(value),
-                shorthand: false,
-            });
-        }
-    }
+parseAttributeBlock = function(source, _style, _location = null) {
+  var attrs, cleanName, colonIdx, expr, j, len, name, pair, pairs, trimmed, value;
+  attrs = [];
+  if (!source.trim()) {
     return attrs;
-}
-/** Split attribute string on commas, respecting nested brackets and string literals. */
-function splitAttributePairs(source) {
-    const result = [];
-    let depth = 0;
-    let start = 0;
-    for (let i = 0; i < source.length; i++) {
-        const ch = source[i];
-        if (ch === '{' || ch === '[' || ch === '(')
-            depth++;
-        else if (ch === '}' || ch === ']' || ch === ')')
-            depth--;
-        else if ((ch === '"' || ch === "'") && depth === 0) {
-            // Skip over string literals
-            const q = ch;
-            i++;
-            while (i < source.length && source[i] !== q) {
-                if (source[i] === '\\')
-                    i++;
-                i++;
-            }
-        }
-        else if (ch === ',' && depth === 0) {
-            result.push(source.slice(start, i));
-            start = i + 1;
-        }
+  }
+  pairs = splitAttributePairs(source);
+  for (j = 0, len = pairs.length; j < len; j++) {
+    pair = pairs[j];
+    trimmed = pair.trim();
+    if (!trimmed) {
+      continue;
+    }
+    // Spread: props... or ...props
+    if (trimmed.endsWith('...')) {
+      expr = trimmed.slice(0, -3).trim();
+      if (expr) {
+        attrs.push(new SpreadAttribute(new Expression(expr)));
+      }
+      continue;
     }
-    result.push(source.slice(start));
-    return result;
-}
-/** Find the first colon that is not inside brackets or strings. */
-function findColon(source) {
-    let depth = 0;
-    for (let i = 0; i < source.length; i++) {
-        const ch = source[i];
-        if (ch === '{' || ch === '[' || ch === '(')
-            depth++;
-        else if (ch === '}' || ch === ']' || ch === ')')
-            depth--;
-        else if ((ch === '"' || ch === "'") && depth === 0) {
-            const q = ch;
-            i++;
-            while (i < source.length && source[i] !== q) {
-                if (source[i] === '\\')
-                    i++;
-                i++;
-            }
+    if (trimmed.startsWith('...')) {
+      expr = trimmed.slice(3).trim();
+      if (expr) {
+        attrs.push(new SpreadAttribute(new Expression(expr)));
+      }
+      continue;
+    }
+    colonIdx = findColon(trimmed);
+    if (colonIdx === -1) {
+      // Shorthand: {foo} → foo={foo}
+      attrs.push(new Attribute(trimmed, new Expression(trimmed), true));
+    } else {
+      name = trimmed.slice(0, colonIdx).trim();
+      value = trimmed.slice(colonIdx + 1).trim();
+      cleanName = name.replace(/^['"]|['"]$/g, '');
+      attrs.push(new Attribute(cleanName, new Expression(value), false));
+    }
+  }
+  return attrs;
+};
+
+splitAttributePairs = function(source) {
+  var ch, depth, i, q, result, start;
+  result = [];
+  depth = 0;
+  start = 0;
+  i = 0;
+  while (i < source.length) {
+    ch = source[i];
+    if (ch === '{' || ch === '[' || ch === '(') {
+      depth++;
+    } else if (ch === '}' || ch === ']' || ch === ')') {
+      depth--;
+    } else if ((ch === '"' || ch === "'") && depth === 0) {
+      q = ch;
+      i++;
+      while (i < source.length && source[i] !== q) {
+        if (source[i] === '\\') {
+          i++;
         }
-        else if (ch === ':' && depth === 0) {
-            return i;
+        i++;
+      }
+    } else if (ch === ',' && depth === 0) {
+      result.push(source.slice(start, i));
+      start = i + 1;
+    }
+    i++;
+  }
+  result.push(source.slice(start));
+  return result;
+};
+
+findColon = function(source) {
+  var ch, depth, i, q;
+  depth = 0;
+  i = 0;
+  while (i < source.length) {
+    ch = source[i];
+    if (ch === '{' || ch === '[' || ch === '(') {
+      depth++;
+    } else if (ch === '}' || ch === ']' || ch === ')') {
+      depth--;
+    } else if ((ch === '"' || ch === "'") && depth === 0) {
+      q = ch;
+      i++;
+      while (i < source.length && source[i] !== q) {
+        if (source[i] === '\\') {
+          i++;
         }
+        i++;
+      }
+    } else if (ch === ':' && depth === 0) {
+      return i;
     }
-    return -1;
-}
-//# sourceMappingURL=parser.js.map
+    i++;
+  }
+  return -1;
+};
+
+// ParseResult shape: { document: Document, errors: CompileError[] }