coffeehaml 0.6.0 → 0.7.1

package/dist/lexer.js

@@ -1,366 +1,562 @@
+// 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, parseModifiersAndAttrs, preMergeBracketLines, tokenizeLine;
+
+import {
+  SourceLocation
+} from './types.js';
+
 // ─── Token Types ───────────────────────────────────────────
-export var TokenType;
-(function (TokenType) {
-    TokenType["TAG"] = "TAG";
-    TokenType["CLASS"] = "CLASS";
-    TokenType["ID"] = "ID";
-    TokenType["ATTRS_PAREN"] = "ATTRS_PAREN";
-    TokenType["ATTRS_BRACE"] = "ATTRS_BRACE";
-    TokenType["OUTPUT"] = "OUTPUT";
-    TokenType["OUTPUT_UNESC"] = "OUTPUT_UNESC";
-    TokenType["CONTROL"] = "CONTROL";
-    TokenType["COMMENT"] = "COMMENT";
-    TokenType["HTML_COMMENT"] = "HTML_COMMENT";
-    TokenType["FILTER"] = "FILTER";
-    TokenType["DOCTYPE"] = "DOCTYPE";
-    TokenType["TEXT"] = "TEXT";
-    TokenType["PROLOGUE"] = "PROLOGUE";
-    TokenType["INDENT"] = "INDENT";
-    TokenType["DEDENT"] = "DEDENT";
-    TokenType["NEWLINE"] = "NEWLINE";
-    TokenType["SELF_CLOSE"] = "SELF_CLOSE";
-})(TokenType || (TokenType = {}));
-// ─── Lexer ─────────────────────────────────────────────────
-export function tokenize(source, filename) {
-    const tokens = [];
-    const lines = source.split('\n');
-    const indentStack = [0]; // level 0 is always on the stack
-    let offset = 0;
-    let lineIndex = 0;
-    let inPrologue = true; // true until first HAML construct encountered
-    for (const rawLine of lines) {
-        const line = rawLine.replace(/\r$/, '');
-        const lineLength = rawLine.length + 1; // +1 for \n (used only for offset)
-        // Skip empty lines (but preserve their space for offset tracking)
-        if (line.trim() === '') {
-            offset += lineLength;
-            lineIndex++;
-            continue;
+export var TokenType = {
+  TAG: 'TAG',
+  CLASS: 'CLASS',
+  ID: 'ID',
+  ATTRS_PAREN: 'ATTRS_PAREN',
+  ATTRS_BRACE: 'ATTRS_BRACE',
+  OUTPUT: 'OUTPUT',
+  OUTPUT_UNESC: 'OUTPUT_UNESC',
+  CONTROL: 'CONTROL',
+  COMMENT: 'COMMENT',
+  HTML_COMMENT: 'HTML_COMMENT',
+  FILTER: 'FILTER',
+  DOCTYPE: 'DOCTYPE',
+  TEXT: 'TEXT',
+  PROLOGUE: 'PROLOGUE',
+  INDENT: 'INDENT',
+  DEDENT: 'DEDENT',
+  NEWLINE: 'NEWLINE',
+  SELF_CLOSE: 'SELF_CLOSE'
+};
+
+// ─── Token (plain object convention) ───────────────────────
+// { type, value, location, indent? }
+
+// ─── Main entry ────────────────────────────────────────────
+
+// ─── Pre-processing: merge lines with unclosed attribute brackets ──
+preMergeBracketLines = function(lines) {
+  var i, line, merged, rest, result;
+  result = [];
+  i = 0;
+  while (i < lines.length) {
+    line = lines[i];
+    rest = line.replace(/^\s+/, '');
+    // Check if this is a HAML tag/implicit-div line with unclosed {
+    if (/^[%.#]/.test(rest) && rest.includes('{') && !rest.includes('}')) {
+      merged = line;
+      i++;
+      while (i < lines.length) {
+        merged += '\n' + lines[i];
+        i++;
+        if (lines[i - 1].includes('}')) {
+          break;
         }
-        const indent = countIndent(line);
-        const content = line.slice(indent);
-        // Skip blank lines
-        if (content === '') {
-            offset += lineLength;
-            lineIndex++;
-            continue;
+      }
+      result.push(merged);
+    } else if (/^[%.#]/.test(rest) && rest.includes('(') && !rest.includes(')')) {
+      merged = line;
+      i++;
+      while (i < lines.length) {
+        merged += '\n' + lines[i];
+        i++;
+        if (lines[i - 1].includes(')')) {
+          break;
         }
-        // ── Prologue detection: non-indented JS lines before first HAML construct ──
-        if (inPrologue && indent === 0 && !isHamlConstruct(content)) {
-            tokens.push({
-                type: TokenType.PROLOGUE,
-                value: content,
-                location: {
-                    start: { line: lineIndex, column: indent },
-                    end: { line: lineIndex, column: indent + content.length },
-                    offset: offset + indent,
-                    length: lineLength - indent,
-                    file: filename,
-                },
-            });
-            offset += lineLength;
-            lineIndex++;
-            continue;
-        }
-        inPrologue = false; // first HAML construct or indented line locks us out of prologue
-        // Handle indentation changes
-        const currentIndent = indentStack[indentStack.length - 1];
-        if (indent > currentIndent) {
-            indentStack.push(indent);
-            tokens.push(indentToken(indent, offset, indent, filename, lineIndex));
-        }
-        else if (indent < currentIndent) {
-            while (indentStack.length > 1 && indent < indentStack[indentStack.length - 1]) {
-                indentStack.pop();
-                tokens.push(dedentToken(offset, filename, lineIndex));
-            }
-            if (indent !== indentStack[indentStack.length - 1]) {
-                // Misaligned indent — still emit what we can
-                indentStack.push(indent);
-                tokens.push(indentToken(indent, offset, indent, filename, lineIndex));
-            }
+      }
+      result.push(merged);
+    } else {
+      result.push(line);
+      i++;
+    }
+  }
+  return result;
+};
+
+export var tokenize = function(source, filename = null) {
+  var content, currentIndent, inPrologue, indent, indentStack, j, len, 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];
+    line = rawLine.replace(/\r$/, '');
+    lineLength = rawLine.length + 1;
+    // Skip empty lines
+    if (line.trim() === '') {
+      offset += lineLength;
+      lineIndex++;
+      continue;
+    }
+    indent = countIndent(line);
+    content = line.slice(indent);
+    if (content === '') {
+      offset += lineLength;
+      lineIndex++;
+      continue;
+    }
+    // Prologue detection: non-indented JS before first HAML construct
+    if (inPrologue && indent === 0 && !isHamlConstruct(content)) {
+      tokens.push({
+        type: TokenType.PROLOGUE,
+        value: content,
+        location: {
+          start: {
+            line: lineIndex,
+            column: indent
+          },
+          end: {
+            line: lineIndex,
+            column: indent + content.length
+          },
+          offset: offset + indent,
+          length: lineLength - indent,
+          file: filename
         }
-        // Parse the line content
-        const lineStartOffset = offset + indent;
-        const lineTokens = tokenizeLine(content, lineStartOffset, lineLength - indent, filename, lineIndex);
-        tokens.push(...lineTokens);
-        offset += lineLength;
-        lineIndex++;
+      });
+      offset += lineLength;
+      lineIndex++;
+      continue;
     }
-    // Emit remaining DEDENT tokens at EOF
-    while (indentStack.length > 1) {
+    inPrologue = false;
+    // Handle indentation changes
+    currentIndent = indentStack[indentStack.length - 1];
+    if (indent > currentIndent) {
+      indentStack.push(indent);
+      tokens.push(indentToken(indent, offset, indent, filename, lineIndex));
+    } else if (indent < currentIndent) {
+      while (indentStack.length > 1 && indent < indentStack[indentStack.length - 1]) {
         indentStack.pop();
         tokens.push(dedentToken(offset, filename, lineIndex));
+      }
+      if (indent !== indentStack[indentStack.length - 1]) {
+        indentStack.push(indent);
+        tokens.push(indentToken(indent, offset, indent, filename, lineIndex));
+      }
     }
-    return tokens;
-}
+    // Parse line content
+    lineStartOffset = offset + indent;
+    lineTokens = tokenizeLine(content, lineStartOffset, lineLength - indent, filename, lineIndex);
+    tokens.push(...lineTokens);
+    offset += lineLength;
+    lineIndex++;
+  }
+  // Emit remaining DEDENT tokens at EOF
+  while (indentStack.length > 1) {
+    indentStack.pop();
+    tokens.push(dedentToken(offset, filename, lineIndex));
+  }
+  return tokens;
+};
+
 // ─── Line Tokenization ─────────────────────────────────────
-function tokenizeLine(content, lineStartOffset, _lineLength, filename, lineIndex) {
-    const tokens = [];
-    let pos = 0;
-    function loc(start, end) {
-        return {
-            start: { line: lineIndex ?? 0, column: lineStartOffset + start },
-            end: { line: lineIndex ?? 0, column: lineStartOffset + end },
-            offset: lineStartOffset + start,
-            length: end - start,
-            file: filename,
-        };
+tokenizeLine = function(content, lineStartOffset, _lineLength, filename = null, lineIndex = 0) {
+  var end, expr, filterContent, filterName, firstChar, loc, modResult, pos, remaining, spaceIdx, tagName, tokens, trimmedOffset, val;
+  tokens = [];
+  pos = 0;
+  loc = function(start, end) {
+    return {
+      start: {
+        line: lineIndex != null ? lineIndex : 0,
+        column: lineStartOffset + start
+      },
+      end: {
+        line: lineIndex != null ? lineIndex : 0,
+        column: lineStartOffset + end
+      },
+      offset: lineStartOffset + start,
+      length: end - start,
+      file: filename
+    };
+  };
+  firstChar = content[0];
+  // %tag
+  if (firstChar === '%') {
+    end = 1;
+    while (end < content.length && /[\w-]/.test(content[end])) {
+      end++;
     }
-    const firstChar = content[0];
-    // ── %tag ──
-    if (firstChar === '%') {
-        let end = 1;
-        // Read tag name: letters, digits, hyphens, underscores
-        while (end < content.length && /[\w-]/.test(content[end])) {
-            end++;
-        }
-        const tagName = content.slice(1, end);
-        tokens.push({ type: TokenType.TAG, value: tagName, location: loc(0, end) });
-        pos = end;
-        // Check for self-closing /
-        if (content[pos] === '/') {
-            tokens.push({ type: TokenType.SELF_CLOSE, value: '/', location: loc(pos, pos + 1) });
-            pos++;
-        }
-        // Parse modifiers and attributes on the rest of the line
-        const modResult = parseModifiersAndAttrs(content, pos, lineStartOffset, filename, lineIndex);
-        tokens.push(...modResult.tokens);
-        pos = modResult.pos;
-        // Parse inline output or text after tag and attributes
-        const remaining = content.slice(pos).trimStart();
-        const trimmedOffset = content.length - remaining.length;
-        if (remaining) {
-            if (remaining.startsWith('= ') || remaining === '=') {
-                tokens.push({ type: TokenType.OUTPUT, value: remaining.slice(1).trimStart(), location: loc(trimmedOffset + 1, content.length) });
-            }
-            else if (remaining.startsWith('!= ')) {
-                tokens.push({ type: TokenType.OUTPUT_UNESC, value: remaining.slice(2).trimStart(), location: loc(trimmedOffset + 2, content.length) });
-            }
-            else if (!remaining.startsWith('{') && !remaining.startsWith('(')) {
-                tokens.push({
-                    type: TokenType.TEXT,
-                    value: remaining,
-                    location: loc(trimmedOffset, content.length),
-                });
-            }
-        }
-        return tokens;
+    tagName = content.slice(1, end);
+    tokens.push({
+      type: TokenType.TAG,
+      value: tagName,
+      location: loc(0, end)
+    });
+    pos = end;
+    // Self-closing /
+    if (content[pos] === '/') {
+      tokens.push({
+        type: TokenType.SELF_CLOSE,
+        value: '/',
+        location: loc(pos, pos + 1)
+      });
+      pos++;
     }
-    // ── .class / #id (implicit div) ──
-    // Only match if the modifier is immediately followed by a valid identifier char.
-    // This prevents `# Hello` (Markdown heading) or `. something` from being
-    // mistakenly parsed as modifiers inside filter blocks.
-    if ((firstChar === '.' || firstChar === '#') && /^[.#][\w-]/.test(content)) {
-        const modResult = parseModifiersAndAttrs(content, 0, lineStartOffset, filename, lineIndex);
-        tokens.push(...modResult.tokens);
-        let pos = modResult.pos;
-        // Parse inline output or text after modifiers (same as %tag path)
-        const remaining = content.slice(pos).trimStart();
-        const trimmedOffset = content.length - remaining.length;
-        if (remaining) {
-            if (remaining.startsWith('= ') || remaining === '=') {
-                tokens.push({ type: TokenType.OUTPUT, value: remaining.slice(1).trimStart(), location: loc(trimmedOffset + 1, content.length) });
-            }
-            else if (remaining.startsWith('!= ')) {
-                tokens.push({ type: TokenType.OUTPUT_UNESC, value: remaining.slice(2).trimStart(), location: loc(trimmedOffset + 2, content.length) });
-            }
-            else if (!remaining.startsWith('{') && !remaining.startsWith('(')) {
-                tokens.push({
-                    type: TokenType.TEXT,
-                    value: remaining,
-                    location: loc(trimmedOffset, content.length),
-                });
-            }
-        }
-        return tokens;
+    modResult = parseModifiersAndAttrs(content, pos, lineStartOffset, filename, lineIndex);
+    tokens.push(...modResult.tokens);
+    pos = modResult.pos;
+    // Self-closing / after attributes (must check BEFORE remaining text)
+    if (content[pos] === '/') {
+      tokens.push({
+        type: TokenType.SELF_CLOSE,
+        value: '/',
+        location: loc(pos, pos + 1)
+      });
+      pos++;
     }
-    // ── = expression ──
-    if (firstChar === '=' && content[1] !== '=') {
-        const expr = content.slice(1).trimStart();
-        return [{ type: TokenType.OUTPUT, value: expr, location: loc(1, content.length) }];
+    remaining = content.slice(pos).trimStart();
+    trimmedOffset = content.length - remaining.length;
+    if (remaining) {
+      if (remaining.startsWith('= ') || remaining === '=') {
+        tokens.push({
+          type: TokenType.OUTPUT,
+          value: remaining.slice(1).trimStart(),
+          location: loc(trimmedOffset + 1, content.length)
+        });
+      } else if (remaining.startsWith('!= ')) {
+        tokens.push({
+          type: TokenType.OUTPUT_UNESC,
+          value: remaining.slice(2).trimStart(),
+          location: loc(trimmedOffset + 2, content.length)
+        });
+      } else if (!(remaining.startsWith('{') || remaining.startsWith('('))) {
+        tokens.push({
+          type: TokenType.TEXT,
+          value: remaining,
+          location: loc(trimmedOffset, content.length)
+        });
+      }
     }
-    // ── != expression ──
-    if (firstChar === '!' && content[1] === '=') {
-        const expr = content.slice(2).trimStart();
-        return [{ type: TokenType.OUTPUT_UNESC, value: expr, location: loc(2, content.length) }];
+    return tokens;
+  }
+  // .class / #id (implicit div) — only if followed by valid identifier
+  if ((firstChar === '.' || firstChar === '#') && /^[.#][\w-]/.test(content)) {
+    modResult = parseModifiersAndAttrs(content, 0, lineStartOffset, filename, lineIndex);
+    tokens.push(...modResult.tokens);
+    pos = modResult.pos;
+    // Self-closing / after attributes (must check BEFORE remaining text)
+    if (content[pos] === '/') {
+      tokens.push({
+        type: TokenType.SELF_CLOSE,
+        value: '/',
+        location: loc(pos, pos + 1)
+      });
+      pos++;
+    }
+    remaining = content.slice(pos).trimStart();
+    trimmedOffset = content.length - remaining.length;
+    if (remaining) {
+      if (remaining.startsWith('= ') || remaining === '=') {
+        tokens.push({
+          type: TokenType.OUTPUT,
+          value: remaining.slice(1).trimStart(),
+          location: loc(trimmedOffset + 1, content.length)
+        });
+      } else if (remaining.startsWith('!= ')) {
+        tokens.push({
+          type: TokenType.OUTPUT_UNESC,
+          value: remaining.slice(2).trimStart(),
+          location: loc(trimmedOffset + 2, content.length)
+        });
+      } else if (!(remaining.startsWith('{') || remaining.startsWith('('))) {
+        tokens.push({
+          type: TokenType.TEXT,
+          value: remaining,
+          location: loc(trimmedOffset, content.length)
+        });
+      }
     }
-    // ── - control / comment ──
-    if (firstChar === '-') {
-        if (content[1] === '#') {
-            // Haml comment
-            return [{ type: TokenType.COMMENT, value: content.slice(2).trimStart(), location: loc(2, content.length) }];
+    return tokens;
+  }
+  // = expression
+  if (firstChar === '=' && content[1] !== '=') {
+    expr = content.slice(1).trimStart();
+    return [
+      {
+        type: TokenType.OUTPUT,
+        value: expr,
+        location: loc(1,
+      content.length)
+      }
+    ];
+  }
+  // != expression
+  if (firstChar === '!' && content[1] === '=') {
+    expr = content.slice(2).trimStart();
+    return [
+      {
+        type: TokenType.OUTPUT_UNESC,
+        value: expr,
+        location: loc(2,
+      content.length)
+      }
+    ];
+  }
+  // - control / comment
+  if (firstChar === '-') {
+    if (content[1] === '#') {
+      return [
+        {
+          type: TokenType.COMMENT,
+          value: content.slice(2).trimStart(),
+          location: loc(2,
+        content.length)
         }
-        // Control flow or code
-        const expr = content.slice(1).trimStart();
-        return [{ type: TokenType.CONTROL, value: expr, location: loc(1, content.length) }];
+      ];
+    }
+    expr = content.slice(1).trimStart();
+    return [
+      {
+        type: TokenType.CONTROL,
+        value: expr,
+        location: loc(1,
+      content.length)
+      }
+    ];
+  }
+  // / HTML comment
+  if (firstChar === '/') {
+    return [
+      {
+        type: TokenType.HTML_COMMENT,
+        value: content.slice(1).trimStart(),
+        location: loc(1,
+      content.length)
+      }
+    ];
+  }
+  // :filter
+  if (firstChar === ':') {
+    spaceIdx = content.search(/\s/);
+    filterName = spaceIdx === -1 ? content.slice(1) : content.slice(1, spaceIdx);
+    filterContent = spaceIdx === -1 ? '' : content.slice(spaceIdx + 1);
+    return [
+      {
+        type: TokenType.FILTER,
+        value: `${filterName}\n${filterContent}`,
+        location: loc(0,
+      content.length)
+      }
+    ];
+  }
+  // !!! doctype
+  if (content.startsWith('!!!')) {
+    val = content.slice(3).trimStart();
+    return [
+      {
+        type: TokenType.DOCTYPE,
+        value: val || 'html',
+        location: loc(0,
+      content.length)
+      }
+    ];
+  }
+  return [
+    {
+      // Plain text
+      type: TokenType.TEXT,
+      value: content,
+      location: loc(0,
+    content.length)
     }
-    // ── / HTML comment ──
-    if (firstChar === '/') {
-        return [{ type: TokenType.HTML_COMMENT, value: content.slice(1).trimStart(), location: loc(1, content.length) }];
+  ];
+};
+
+// ─── Modifiers and Attributes ──────────────────────────────
+parseModifiersAndAttrs = function(content, startPos, lineStartOffset, filename = null, lineIndex = 0) {
+  var block, ch, className, end, idName, loc, pos, tokens;
+  tokens = [];
+  pos = startPos;
+  loc = function(start, end) {
+    return {
+      start: {
+        line: lineIndex != null ? lineIndex : 0,
+        column: lineStartOffset + start
+      },
+      end: {
+        line: lineIndex != null ? lineIndex : 0,
+        column: lineStartOffset + end
+      },
+      offset: lineStartOffset + start,
+      length: end - start,
+      file: filename
+    };
+  };
+  while (pos < content.length) {
+    ch = content[pos];
+    if (ch === ' ' || ch === '\t') {
+      pos++;
+      continue;
     }
-    // ── :filter ──
-    if (firstChar === ':') {
-        const spaceIdx = content.search(/\s/);
-        const filterName = spaceIdx === -1 ? content.slice(1) : content.slice(1, spaceIdx);
-        const filterContent = spaceIdx === -1 ? '' : content.slice(spaceIdx + 1);
-        return [{ type: TokenType.FILTER, value: `${filterName}\n${filterContent}`, location: loc(0, content.length) }];
+    // .class
+    if (ch === '.') {
+      end = pos + 1;
+      while (end < content.length && /[\w-]/.test(content[end])) {
+        end++;
+      }
+      className = content.slice(pos + 1, end);
+      tokens.push({
+        type: TokenType.CLASS,
+        value: className,
+        location: loc(pos, end)
+      });
+      pos = end;
+      continue;
     }
-    // ── !!! doctype ──
-    if (content.startsWith('!!!')) {
-        const val = content.slice(3).trimStart();
-        return [{ type: TokenType.DOCTYPE, value: val || 'html', location: loc(0, content.length) }];
+    // #id
+    if (ch === '#') {
+      end = pos + 1;
+      while (end < content.length && /[\w-]/.test(content[end])) {
+        end++;
+      }
+      idName = content.slice(pos + 1, end);
+      tokens.push({
+        type: TokenType.ID,
+        value: idName,
+        location: loc(pos, end)
+      });
+      pos = end;
+      continue;
     }
-    // ── Plain text ──
-    return [{ type: TokenType.TEXT, value: content, location: loc(0, content.length) }];
-}
-// ─── Modifiers and Attributes Parser ───────────────────────
-function parseModifiersAndAttrs(content, startPos, lineStartOffset, filename, lineIndex) {
-    const tokens = [];
-    let pos = startPos;
-    function loc(start, end) {
-        return {
-            start: { line: lineIndex ?? 0, column: lineStartOffset + start },
-            end: { line: lineIndex ?? 0, column: lineStartOffset + end },
-            offset: lineStartOffset + start,
-            length: end - start,
-            file: filename,
-        };
+    // {attribute block}
+    if (ch === '{') {
+      block = extractBracketed(content, pos, '{', '}');
+      if (block !== null) {
+        tokens.push({
+          type: TokenType.ATTRS_BRACE,
+          value: block,
+          location: loc(pos, pos + block.length + 2)
+        });
+        pos += block.length + 2;
+      } else {
+        tokens.push({
+          type: TokenType.ATTRS_BRACE,
+          value: content.slice(pos + 1),
+          location: loc(pos, content.length)
+        });
+        pos = content.length;
+      }
+      continue;
     }
-    while (pos < content.length) {
-        const ch = content[pos];
-        // Whitespace
-        if (ch === ' ' || ch === '\t') {
-            pos++;
-            continue;
-        }
-        // .class
-        if (ch === '.') {
-            let end = pos + 1;
-            while (end < content.length && /[\w-]/.test(content[end])) {
-                end++;
-            }
-            const className = content.slice(pos + 1, end);
-            tokens.push({ type: TokenType.CLASS, value: className, location: loc(pos, end) });
-            pos = end;
-            continue;
-        }
-        // #id
-        if (ch === '#') {
-            let end = pos + 1;
-            while (end < content.length && /[\w-]/.test(content[end])) {
-                end++;
-            }
-            const idName = content.slice(pos + 1, end);
-            tokens.push({ type: TokenType.ID, value: idName, location: loc(pos, end) });
-            pos = end;
-            continue;
-        }
-        // {attribute block}
-        if (ch === '{') {
-            const block = extractBracketed(content, pos, '{', '}');
-            if (block !== null) {
-                tokens.push({ type: TokenType.ATTRS_BRACE, value: block, location: loc(pos, pos + block.length + 2) });
-                pos += block.length + 2;
-            }
-            else {
-                // Unterminated — consume rest
-                tokens.push({ type: TokenType.ATTRS_BRACE, value: content.slice(pos + 1), location: loc(pos, content.length) });
-                pos = content.length;
-            }
-            continue;
-        }
-        // (attribute block)
-        if (ch === '(') {
-            const block = extractBracketed(content, pos, '(', ')');
-            if (block !== null) {
-                tokens.push({ type: TokenType.ATTRS_PAREN, value: block, location: loc(pos, pos + block.length + 2) });
-                pos += block.length + 2;
-            }
-            else {
-                tokens.push({ type: TokenType.ATTRS_PAREN, value: content.slice(pos + 1), location: loc(pos, content.length) });
-                pos = content.length;
-            }
-            continue;
-        }
-        // Anything else → stop, it's inline text
-        break;
+    // (attribute block)
+    if (ch === '(') {
+      block = extractBracketed(content, pos, '(', ')');
+      if (block !== null) {
+        tokens.push({
+          type: TokenType.ATTRS_PAREN,
+          value: block,
+          location: loc(pos, pos + block.length + 2)
+        });
+        pos += block.length + 2;
+      } else {
+        tokens.push({
+          type: TokenType.ATTRS_PAREN,
+          value: content.slice(pos + 1),
+          location: loc(pos, content.length)
+        });
+        pos = content.length;
+      }
+      continue;
     }
-    return { tokens, pos };
-}
+    // Anything else → stop
+    break;
+  }
+  return {tokens, pos};
+};
+
 // ─── Helpers ───────────────────────────────────────────────
-/** Returns true if a line of content starts a HAML construct (not plain text). */
-function isHamlConstruct(content) {
-    const fc = content[0];
-    return fc === '%' || fc === '.' || fc === '#' || fc === '=' ||
-        fc === '-' || fc === '/' || fc === ':' ||
-        (fc === '!' && content[1] === '=') ||
-        content.startsWith('!!!');
-}
-function countIndent(line) {
-    let count = 0;
-    for (const ch of line) {
-        if (ch === ' ')
-            count++;
-        else if (ch === '\t')
-            count += 2; // tab = 2 spaces
-        else
-            break;
+isHamlConstruct = function(content) {
+  var fc;
+  fc = content[0];
+  return (fc === '%' || fc === '.' || fc === '#' || fc === '=' || fc === '-' || fc === '/' || fc === ':') || (fc === '!' && content[1] === '=') || content.startsWith('!!!');
+};
+
+countIndent = function(line) {
+  var ch, count, j, len;
+  count = 0;
+  for (j = 0, len = line.length; j < len; j++) {
+    ch = line[j];
+    if (ch === ' ') {
+      count++;
+    } else if (ch === '\t') {
+      count += 2;
+    } else {
+      break;
     }
-    return count;
-}
-function indentToken(_indent, offset, level, filename, line) {
-    return {
-        type: TokenType.INDENT,
-        value: '',
-        indent: level,
-        location: {
-            start: { line: line ?? 0, column: 0 },
-            end: { line: line ?? 0, column: 0 },
-            offset,
-            length: 0,
-            file: filename,
-        },
-    };
-}
-function dedentToken(offset, filename, line) {
-    return {
-        type: TokenType.DEDENT,
-        value: '',
-        indent: undefined,
-        location: {
-            start: { line: line ?? 0, column: 0 },
-            end: { line: line ?? 0, column: 0 },
-            offset,
-            length: 0,
-            file: filename,
-        },
-    };
-}
-/** Extract content between balanced open/close brackets. Returns inner content or null. */
-function extractBracketed(content, start, open, close) {
-    let depth = 0;
-    let pos = start;
-    while (pos < content.length) {
-        if (content[pos] === open)
-            depth++;
-        else if (content[pos] === close) {
-            depth--;
-            if (depth === 0)
-                return content.slice(start + 1, pos);
-        }
-        // Handle string literals — skip over them
-        if (content[pos] === '"' || content[pos] === "'") {
-            const q = content[pos];
-            pos++;
-            while (pos < content.length && content[pos] !== q) {
-                if (content[pos] === '\\')
-                    pos++; // skip escape
-                pos++;
-            }
+  }
+  return count;
+};
+
+indentToken = function(_indent, offset, level, filename = null, line = 0) {
+  return {
+    type: TokenType.INDENT,
+    value: '',
+    indent: level,
+    location: {
+      start: {
+        line: line != null ? line : 0,
+        column: 0
+      },
+      end: {
+        line: line != null ? line : 0,
+        column: 0
+      },
+      offset,
+      length: 0,
+      file: filename
+    }
+  };
+};
+
+dedentToken = function(offset, filename = null, line = 0) {
+  return {
+    type: TokenType.DEDENT,
+    value: '',
+    indent: void 0,
+    location: {
+      start: {
+        line: line != null ? line : 0,
+        column: 0
+      },
+      end: {
+        line: line != null ? line : 0,
+        column: 0
+      },
+      offset,
+      length: 0,
+      file: filename
+    }
+  };
+};
+
+extractBracketed = function(content, start, open, close) {
+  var depth, pos, q, ref;
+  depth = 0;
+  pos = start;
+  while (pos < content.length) {
+    if (content[pos] === open) {
+      depth++;
+    } else if (content[pos] === close) {
+      depth--;
+      if (depth === 0) {
+        return content.slice(start + 1, pos);
+      }
+    }
+    // Skip string literals
+    if ((ref = content[pos]) === '"' || ref === "'") {
+      q = content[pos];
+      pos++;
+      while (pos < content.length && content[pos] !== q) {
+        if (content[pos] === '\\') {
+          pos++;
         }
         pos++;
+      }
     }
-    return null; // unbalanced
-}
-//# sourceMappingURL=lexer.js.map
+    pos++;
+  }
+  return null;
+};