binja 0.1.1 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,2316 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/lexer/tokens.ts
+var KEYWORDS = {
+  and: "AND" /* AND */,
+  or: "OR" /* OR */,
+  not: "NOT" /* NOT */,
+  true: "NAME" /* NAME */,
+  false: "NAME" /* NAME */,
+  True: "NAME" /* NAME */,
+  False: "NAME" /* NAME */,
+  None: "NAME" /* NAME */,
+  none: "NAME" /* NAME */,
+  is: "NAME" /* NAME */,
+  in: "NAME" /* NAME */
+};
+
+// src/lexer/index.ts
+class Lexer {
+  state;
+  variableStart;
+  variableEnd;
+  blockStart;
+  blockEnd;
+  commentStart;
+  commentEnd;
+  constructor(source, options = {}) {
+    this.state = {
+      source,
+      pos: 0,
+      line: 1,
+      column: 1,
+      tokens: []
+    };
+    this.variableStart = options.variableStart ?? "{{";
+    this.variableEnd = options.variableEnd ?? "}}";
+    this.blockStart = options.blockStart ?? "{%";
+    this.blockEnd = options.blockEnd ?? "%}";
+    this.commentStart = options.commentStart ?? "{#";
+    this.commentEnd = options.commentEnd ?? "#}";
+  }
+  tokenize() {
+    while (!this.isAtEnd()) {
+      this.scanToken();
+    }
+    this.addToken("EOF" /* EOF */, "");
+    return this.state.tokens;
+  }
+  scanToken() {
+    if (this.match(this.variableStart)) {
+      this.addToken("VARIABLE_START" /* VARIABLE_START */, this.variableStart);
+      this.scanExpression(this.variableEnd, "VARIABLE_END" /* VARIABLE_END */);
+      return;
+    }
+    if (this.match(this.blockStart)) {
+      const wsControl = this.peek() === "-";
+      if (wsControl)
+        this.advance();
+      const savedPos = this.state.pos;
+      this.skipWhitespace();
+      if (this.checkWord("raw") || this.checkWord("verbatim")) {
+        const tagName = this.checkWord("raw") ? "raw" : "verbatim";
+        this.scanRawBlock(tagName, wsControl);
+        return;
+      }
+      this.state.pos = savedPos;
+      this.addToken("BLOCK_START" /* BLOCK_START */, this.blockStart + (wsControl ? "-" : ""));
+      this.scanExpression(this.blockEnd, "BLOCK_END" /* BLOCK_END */);
+      return;
+    }
+    if (this.match(this.commentStart)) {
+      this.scanComment();
+      return;
+    }
+    this.scanText();
+  }
+  checkWord(word) {
+    const start = this.state.pos;
+    for (let i = 0;i < word.length; i++) {
+      if (this.state.source[start + i]?.toLowerCase() !== word[i]) {
+        return false;
+      }
+    }
+    const nextChar = this.state.source[start + word.length];
+    return !nextChar || !this.isAlphaNumeric(nextChar);
+  }
+  scanRawBlock(tagName, wsControl) {
+    const startLine = this.state.line;
+    const startColumn = this.state.column;
+    for (let i = 0;i < tagName.length; i++) {
+      this.advance();
+    }
+    this.skipWhitespace();
+    if (this.peek() === "-")
+      this.advance();
+    if (!this.match(this.blockEnd)) {
+      throw new Error(`Expected ${this.blockEnd} after ${tagName} at line ${this.state.line}`);
+    }
+    const endTag = `end${tagName}`;
+    const contentStart = this.state.pos;
+    while (!this.isAtEnd()) {
+      if (this.check(this.blockStart)) {
+        const savedPos = this.state.pos;
+        const savedLine = this.state.line;
+        const savedColumn = this.state.column;
+        this.match(this.blockStart);
+        if (this.peek() === "-")
+          this.advance();
+        this.skipWhitespace();
+        if (this.checkWord(endTag)) {
+          const content = this.state.source.slice(contentStart, savedPos);
+          if (content.length > 0) {
+            this.state.tokens.push({
+              type: "TEXT" /* TEXT */,
+              value: content,
+              line: startLine,
+              column: startColumn
+            });
+          }
+          for (let i = 0;i < endTag.length; i++) {
+            this.advance();
+          }
+          this.skipWhitespace();
+          if (this.peek() === "-")
+            this.advance();
+          if (!this.match(this.blockEnd)) {
+            throw new Error(`Expected ${this.blockEnd} after ${endTag} at line ${this.state.line}`);
+          }
+          return;
+        }
+        this.state.pos = savedPos;
+        this.state.line = savedLine;
+        this.state.column = savedColumn;
+      }
+      if (this.peek() === `
+`) {
+        this.state.line++;
+        this.state.column = 0;
+      }
+      this.advance();
+    }
+    throw new Error(`Unclosed ${tagName} block starting at line ${startLine}`);
+  }
+  scanText() {
+    const start = this.state.pos;
+    const startLine = this.state.line;
+    const startColumn = this.state.column;
+    while (!this.isAtEnd()) {
+      if (this.check(this.variableStart) || this.check(this.blockStart) || this.check(this.commentStart)) {
+        break;
+      }
+      if (this.peek() === `
+`) {
+        this.state.line++;
+        this.state.column = 0;
+      }
+      this.advance();
+    }
+    if (this.state.pos > start) {
+      const text = this.state.source.slice(start, this.state.pos);
+      this.state.tokens.push({
+        type: "TEXT" /* TEXT */,
+        value: text,
+        line: startLine,
+        column: startColumn
+      });
+    }
+  }
+  scanExpression(endDelimiter, endTokenType) {
+    this.skipWhitespace();
+    while (!this.isAtEnd()) {
+      this.skipWhitespace();
+      if (this.peek() === "-" && this.check(endDelimiter, 1)) {
+        this.advance();
+      }
+      if (this.match(endDelimiter)) {
+        this.addToken(endTokenType, endDelimiter);
+        return;
+      }
+      this.scanExpressionToken();
+    }
+    throw new Error(`Unclosed template tag at line ${this.state.line}`);
+  }
+  scanExpressionToken() {
+    this.skipWhitespace();
+    if (this.isAtEnd())
+      return;
+    const c = this.peek();
+    if (c === '"' || c === "'") {
+      this.scanString(c);
+      return;
+    }
+    if (this.isDigit(c)) {
+      this.scanNumber();
+      return;
+    }
+    if (this.isAlpha(c) || c === "_") {
+      this.scanIdentifier();
+      return;
+    }
+    this.scanOperator();
+  }
+  scanString(quote) {
+    this.advance();
+    const start = this.state.pos;
+    while (!this.isAtEnd() && this.peek() !== quote) {
+      if (this.peek() === "\\" && this.peekNext() === quote) {
+        this.advance();
+      }
+      if (this.peek() === `
+`) {
+        this.state.line++;
+        this.state.column = 0;
+      }
+      this.advance();
+    }
+    if (this.isAtEnd()) {
+      throw new Error(`Unterminated string at line ${this.state.line}`);
+    }
+    const value = this.state.source.slice(start, this.state.pos);
+    this.advance();
+    this.addToken("STRING" /* STRING */, value);
+  }
+  scanNumber() {
+    const start = this.state.pos;
+    while (this.isDigit(this.peek())) {
+      this.advance();
+    }
+    if (this.peek() === "." && this.isDigit(this.peekNext())) {
+      this.advance();
+      while (this.isDigit(this.peek())) {
+        this.advance();
+      }
+    }
+    const value = this.state.source.slice(start, this.state.pos);
+    this.addToken("NUMBER" /* NUMBER */, value);
+  }
+  scanIdentifier() {
+    const start = this.state.pos;
+    while (this.isAlphaNumeric(this.peek()) || this.peek() === "_") {
+      this.advance();
+    }
+    const value = this.state.source.slice(start, this.state.pos);
+    const type = KEYWORDS[value] ?? "NAME" /* NAME */;
+    this.addToken(type, value);
+  }
+  scanOperator() {
+    const c = this.advance();
+    switch (c) {
+      case ".":
+        this.addToken("DOT" /* DOT */, c);
+        break;
+      case ",":
+        this.addToken("COMMA" /* COMMA */, c);
+        break;
+      case ":":
+        this.addToken("COLON" /* COLON */, c);
+        break;
+      case "|":
+        this.addToken("PIPE" /* PIPE */, c);
+        break;
+      case "(":
+        this.addToken("LPAREN" /* LPAREN */, c);
+        break;
+      case ")":
+        this.addToken("RPAREN" /* RPAREN */, c);
+        break;
+      case "[":
+        this.addToken("LBRACKET" /* LBRACKET */, c);
+        break;
+      case "]":
+        this.addToken("RBRACKET" /* RBRACKET */, c);
+        break;
+      case "{":
+        this.addToken("LBRACE" /* LBRACE */, c);
+        break;
+      case "}":
+        this.addToken("RBRACE" /* RBRACE */, c);
+        break;
+      case "+":
+        this.addToken("ADD" /* ADD */, c);
+        break;
+      case "-":
+        this.addToken("SUB" /* SUB */, c);
+        break;
+      case "*":
+        this.addToken("MUL" /* MUL */, c);
+        break;
+      case "/":
+        this.addToken("DIV" /* DIV */, c);
+        break;
+      case "%":
+        this.addToken("MOD" /* MOD */, c);
+        break;
+      case "~":
+        this.addToken("TILDE" /* TILDE */, c);
+        break;
+      case "=":
+        if (this.match("=")) {
+          this.addToken("EQ" /* EQ */, "==");
+        } else {
+          this.addToken("ASSIGN" /* ASSIGN */, "=");
+        }
+        break;
+      case "!":
+        if (this.match("=")) {
+          this.addToken("NE" /* NE */, "!=");
+        } else {
+          throw new Error(`Unexpected character '!' at line ${this.state.line}`);
+        }
+        break;
+      case "<":
+        if (this.match("=")) {
+          this.addToken("LE" /* LE */, "<=");
+        } else {
+          this.addToken("LT" /* LT */, "<");
+        }
+        break;
+      case ">":
+        if (this.match("=")) {
+          this.addToken("GE" /* GE */, ">=");
+        } else {
+          this.addToken("GT" /* GT */, ">");
+        }
+        break;
+      default:
+        if (!this.isWhitespace(c)) {
+          throw new Error(`Unexpected character '${c}' at line ${this.state.line}`);
+        }
+    }
+  }
+  scanComment() {
+    while (!this.isAtEnd() && !this.check(this.commentEnd)) {
+      if (this.peek() === `
+`) {
+        this.state.line++;
+        this.state.column = 0;
+      }
+      this.advance();
+    }
+    if (!this.isAtEnd()) {
+      this.match(this.commentEnd);
+    }
+  }
+  isAtEnd() {
+    return this.state.pos >= this.state.source.length;
+  }
+  peek() {
+    if (this.isAtEnd())
+      return "\x00";
+    return this.state.source[this.state.pos];
+  }
+  peekNext() {
+    if (this.state.pos + 1 >= this.state.source.length)
+      return "\x00";
+    return this.state.source[this.state.pos + 1];
+  }
+  advance() {
+    const c = this.state.source[this.state.pos];
+    this.state.pos++;
+    this.state.column++;
+    return c;
+  }
+  match(expected, offset = 0) {
+    const start = this.state.pos + offset;
+    if (start + expected.length > this.state.source.length)
+      return false;
+    if (this.state.source.slice(start, start + expected.length) === expected) {
+      if (offset === 0) {
+        this.state.pos += expected.length;
+        this.state.column += expected.length;
+      }
+      return true;
+    }
+    return false;
+  }
+  check(expected, offset = 0) {
+    const start = this.state.pos + offset;
+    if (start + expected.length > this.state.source.length)
+      return false;
+    return this.state.source.slice(start, start + expected.length) === expected;
+  }
+  skipWhitespace() {
+    while (!this.isAtEnd() && this.isWhitespace(this.peek())) {
+      if (this.peek() === `
+`) {
+        this.state.line++;
+        this.state.column = 0;
+      }
+      this.advance();
+    }
+  }
+  isWhitespace(c) {
+    return c === " " || c === "\t" || c === `
+` || c === "\r";
+  }
+  isDigit(c) {
+    return c >= "0" && c <= "9";
+  }
+  isAlpha(c) {
+    return c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+  }
+  isAlphaNumeric(c) {
+    return this.isAlpha(c) || this.isDigit(c);
+  }
+  addToken(type, value) {
+    this.state.tokens.push({
+      type,
+      value,
+      line: this.state.line,
+      column: this.state.column - value.length
+    });
+  }
+}
+
+// src/parser/index.ts
+class Parser {
+  tokens;
+  current = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    const body = [];
+    while (!this.isAtEnd()) {
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    return {
+      type: "Template",
+      body,
+      line: 1,
+      column: 1
+    };
+  }
+  parseStatement() {
+    const token = this.peek();
+    switch (token.type) {
+      case "TEXT" /* TEXT */:
+        return this.parseText();
+      case "VARIABLE_START" /* VARIABLE_START */:
+        return this.parseOutput();
+      case "BLOCK_START" /* BLOCK_START */:
+        return this.parseBlock();
+      case "EOF" /* EOF */:
+        return null;
+      default:
+        this.advance();
+        return null;
+    }
+  }
+  parseText() {
+    const token = this.advance();
+    return {
+      type: "Text",
+      value: token.value,
+      line: token.line,
+      column: token.column
+    };
+  }
+  parseOutput() {
+    const start = this.advance();
+    const expression = this.parseExpression();
+    this.expect("VARIABLE_END" /* VARIABLE_END */);
+    return {
+      type: "Output",
+      expression,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseBlock() {
+    const start = this.advance();
+    const tagName = this.expect("NAME" /* NAME */);
+    switch (tagName.value) {
+      case "if":
+        return this.parseIf(start);
+      case "for":
+        return this.parseFor(start);
+      case "block":
+        return this.parseBlockTag(start);
+      case "extends":
+        return this.parseExtends(start);
+      case "include":
+        return this.parseInclude(start);
+      case "set":
+        return this.parseSet(start);
+      case "with":
+        return this.parseWith(start);
+      case "load":
+        return this.parseLoad(start);
+      case "url":
+        return this.parseUrl(start);
+      case "static":
+        return this.parseStatic(start);
+      case "comment":
+        return this.parseComment(start);
+      case "spaceless":
+      case "autoescape":
+      case "verbatim":
+        return this.parseSimpleBlock(start, tagName.value);
+      default:
+        this.skipToBlockEnd();
+        return null;
+    }
+  }
+  parseIf(start) {
+    const test = this.parseExpression();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    const body = [];
+    const elifs = [];
+    let else_ = [];
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("elif") || this.checkBlockTag("else") || this.checkBlockTag("endif")) {
+        break;
+      }
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    while (this.checkBlockTag("elif")) {
+      this.advance();
+      this.advance();
+      const elifTest = this.parseExpression();
+      this.expect("BLOCK_END" /* BLOCK_END */);
+      const elifBody = [];
+      while (!this.isAtEnd()) {
+        if (this.checkBlockTag("elif") || this.checkBlockTag("else") || this.checkBlockTag("endif")) {
+          break;
+        }
+        const node = this.parseStatement();
+        if (node)
+          elifBody.push(node);
+      }
+      elifs.push({ test: elifTest, body: elifBody });
+    }
+    if (this.checkBlockTag("else")) {
+      this.advance();
+      this.advance();
+      this.expect("BLOCK_END" /* BLOCK_END */);
+      while (!this.isAtEnd()) {
+        if (this.checkBlockTag("endif"))
+          break;
+        const node = this.parseStatement();
+        if (node)
+          else_.push(node);
+      }
+    }
+    this.expectBlockTag("endif");
+    return {
+      type: "If",
+      test,
+      body,
+      elifs,
+      else_,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseFor(start) {
+    let target;
+    const firstName = this.expect("NAME" /* NAME */).value;
+    if (this.check("COMMA" /* COMMA */)) {
+      const targets = [firstName];
+      while (this.match("COMMA" /* COMMA */)) {
+        targets.push(this.expect("NAME" /* NAME */).value);
+      }
+      target = targets;
+    } else {
+      target = firstName;
+    }
+    const inToken = this.expect("NAME" /* NAME */);
+    if (inToken.value !== "in") {
+      throw this.error(`Expected 'in' in for loop, got '${inToken.value}'`);
+    }
+    const iter = this.parseExpression();
+    const recursive = this.check("NAME" /* NAME */) && this.peek().value === "recursive";
+    if (recursive)
+      this.advance();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    const body = [];
+    let else_ = [];
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("empty") || this.checkBlockTag("else") || this.checkBlockTag("endfor")) {
+        break;
+      }
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    if (this.checkBlockTag("empty") || this.checkBlockTag("else")) {
+      this.advance();
+      this.advance();
+      this.expect("BLOCK_END" /* BLOCK_END */);
+      while (!this.isAtEnd()) {
+        if (this.checkBlockTag("endfor"))
+          break;
+        const node = this.parseStatement();
+        if (node)
+          else_.push(node);
+      }
+    }
+    this.expectBlockTag("endfor");
+    return {
+      type: "For",
+      target,
+      iter,
+      body,
+      else_,
+      recursive,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseBlockTag(start) {
+    const name = this.expect("NAME" /* NAME */).value;
+    const scoped = this.check("NAME" /* NAME */) && this.peek().value === "scoped";
+    if (scoped)
+      this.advance();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    const body = [];
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("endblock"))
+        break;
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    this.advance();
+    this.advance();
+    if (this.check("NAME" /* NAME */))
+      this.advance();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Block",
+      name,
+      body,
+      scoped,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseExtends(start) {
+    const template = this.parseExpression();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Extends",
+      template,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseInclude(start) {
+    const template = this.parseExpression();
+    let context = null;
+    let only = false;
+    let ignoreMissing = false;
+    while (this.check("NAME" /* NAME */)) {
+      const modifier = this.peek().value;
+      if (modifier === "ignore" && this.peekNext()?.value === "missing") {
+        this.advance();
+        this.advance();
+        ignoreMissing = true;
+      } else if (modifier === "with") {
+        this.advance();
+        context = this.parseKeywordArgs();
+      } else if (modifier === "only") {
+        this.advance();
+        only = true;
+      } else if (modifier === "without") {
+        this.advance();
+        if (this.check("NAME" /* NAME */) && this.peek().value === "context") {
+          this.advance();
+          only = true;
+        }
+      } else {
+        break;
+      }
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Include",
+      template,
+      context,
+      only,
+      ignoreMissing,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseSet(start) {
+    const target = this.expect("NAME" /* NAME */).value;
+    this.expect("ASSIGN" /* ASSIGN */);
+    const value = this.parseExpression();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Set",
+      target,
+      value,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseWith(start) {
+    const assignments = [];
+    do {
+      const target = this.expect("NAME" /* NAME */).value;
+      this.expect("ASSIGN" /* ASSIGN */);
+      const value = this.parseExpression();
+      assignments.push({ target, value });
+    } while (this.match("COMMA" /* COMMA */) || this.check("NAME" /* NAME */) && this.peekNext()?.type === "ASSIGN" /* ASSIGN */);
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    const body = [];
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("endwith"))
+        break;
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    this.expectBlockTag("endwith");
+    return {
+      type: "With",
+      assignments,
+      body,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseLoad(start) {
+    const names = [];
+    while (this.check("NAME" /* NAME */)) {
+      names.push(this.advance().value);
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Load",
+      names,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseUrl(start) {
+    const name = this.parseExpression();
+    const args = [];
+    const kwargs = {};
+    let asVar = null;
+    while (!this.check("BLOCK_END" /* BLOCK_END */)) {
+      if (this.check("NAME" /* NAME */) && this.peek().value === "as") {
+        this.advance();
+        asVar = this.expect("NAME" /* NAME */).value;
+        break;
+      }
+      if (this.check("NAME" /* NAME */) && this.peekNext()?.type === "ASSIGN" /* ASSIGN */) {
+        const key = this.advance().value;
+        this.advance();
+        kwargs[key] = this.parseExpression();
+      } else {
+        args.push(this.parseExpression());
+      }
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Url",
+      name,
+      args,
+      kwargs,
+      asVar,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseStatic(start) {
+    const path = this.parseExpression();
+    let asVar = null;
+    if (this.check("NAME" /* NAME */) && this.peek().value === "as") {
+      this.advance();
+      asVar = this.expect("NAME" /* NAME */).value;
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Static",
+      path,
+      asVar,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseComment(start) {
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("endcomment"))
+        break;
+      this.advance();
+    }
+    this.expectBlockTag("endcomment");
+    return null;
+  }
+  parseSimpleBlock(start, tagName) {
+    this.skipToBlockEnd();
+    const endTag = `end${tagName}`;
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag(endTag))
+        break;
+      this.advance();
+    }
+    if (this.checkBlockTag(endTag)) {
+      this.advance();
+      this.advance();
+      this.expect("BLOCK_END" /* BLOCK_END */);
+    }
+    return null;
+  }
+  parseExpression() {
+    return this.parseConditional();
+  }
+  parseConditional() {
+    let expr = this.parseOr();
+    if (this.check("NAME" /* NAME */) && this.peek().value === "if") {
+      this.advance();
+      const test = this.parseOr();
+      this.expectName("else");
+      const falseExpr = this.parseConditional();
+      expr = {
+        type: "Conditional",
+        test,
+        trueExpr: expr,
+        falseExpr,
+        line: expr.line,
+        column: expr.column
+      };
+    }
+    return expr;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.check("OR" /* OR */) || this.check("NAME" /* NAME */) && this.peek().value === "or") {
+      this.advance();
+      const right = this.parseAnd();
+      left = {
+        type: "BinaryOp",
+        operator: "or",
+        left,
+        right,
+        line: left.line,
+        column: left.column
+      };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.check("AND" /* AND */) || this.check("NAME" /* NAME */) && this.peek().value === "and") {
+      this.advance();
+      const right = this.parseNot();
+      left = {
+        type: "BinaryOp",
+        operator: "and",
+        left,
+        right,
+        line: left.line,
+        column: left.column
+      };
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.check("NOT" /* NOT */) || this.check("NAME" /* NAME */) && this.peek().value === "not") {
+      const op = this.advance();
+      const operand = this.parseNot();
+      return {
+        type: "UnaryOp",
+        operator: "not",
+        operand,
+        line: op.line,
+        column: op.column
+      };
+    }
+    return this.parseCompare();
+  }
+  parseCompare() {
+    let left = this.parseAddSub();
+    const ops = [];
+    while (true) {
+      let operator = null;
+      if (this.match("EQ" /* EQ */))
+        operator = "==";
+      else if (this.match("NE" /* NE */))
+        operator = "!=";
+      else if (this.match("LT" /* LT */))
+        operator = "<";
+      else if (this.match("GT" /* GT */))
+        operator = ">";
+      else if (this.match("LE" /* LE */))
+        operator = "<=";
+      else if (this.match("GE" /* GE */))
+        operator = ">=";
+      else if (this.check("NAME" /* NAME */)) {
+        const name = this.peek().value;
+        if (name === "in") {
+          this.advance();
+          operator = "in";
+        } else if (name === "not" && this.peekNext()?.value === "in") {
+          this.advance();
+          this.advance();
+          operator = "not in";
+        } else if (name === "is") {
+          this.advance();
+          const negated = this.check("NOT" /* NOT */);
+          if (negated) {
+            this.advance();
+          }
+          const testToken = this.expect("NAME" /* NAME */);
+          const testName = testToken.value;
+          const args = [];
+          if (this.match("LPAREN" /* LPAREN */)) {
+            while (!this.check("RPAREN" /* RPAREN */)) {
+              args.push(this.parseExpression());
+              if (!this.check("RPAREN" /* RPAREN */)) {
+                this.expect("COMMA" /* COMMA */);
+              }
+            }
+            this.expect("RPAREN" /* RPAREN */);
+          }
+          left = {
+            type: "TestExpr",
+            node: left,
+            test: testName,
+            args,
+            negated,
+            line: left.line,
+            column: left.column
+          };
+          continue;
+        }
+      }
+      if (!operator)
+        break;
+      const right = this.parseAddSub();
+      ops.push({ operator, right });
+    }
+    if (ops.length === 0)
+      return left;
+    return {
+      type: "Compare",
+      left,
+      ops,
+      line: left.line,
+      column: left.column
+    };
+  }
+  parseAddSub() {
+    let left = this.parseMulDiv();
+    while (this.check("ADD" /* ADD */) || this.check("SUB" /* SUB */) || this.check("TILDE" /* TILDE */)) {
+      const op = this.advance();
+      const right = this.parseMulDiv();
+      left = {
+        type: "BinaryOp",
+        operator: op.value,
+        left,
+        right,
+        line: left.line,
+        column: left.column
+      };
+    }
+    return left;
+  }
+  parseMulDiv() {
+    let left = this.parseUnary();
+    while (this.check("MUL" /* MUL */) || this.check("DIV" /* DIV */) || this.check("MOD" /* MOD */)) {
+      const op = this.advance();
+      const right = this.parseUnary();
+      left = {
+        type: "BinaryOp",
+        operator: op.value,
+        left,
+        right,
+        line: left.line,
+        column: left.column
+      };
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.check("SUB" /* SUB */) || this.check("ADD" /* ADD */)) {
+      const op = this.advance();
+      const operand = this.parseUnary();
+      return {
+        type: "UnaryOp",
+        operator: op.value,
+        operand,
+        line: op.line,
+        column: op.column
+      };
+    }
+    return this.parseFilter();
+  }
+  parseFilter() {
+    let node = this.parsePostfix();
+    while (this.match("PIPE" /* PIPE */)) {
+      const filterName = this.expect("NAME" /* NAME */).value;
+      const args = [];
+      const kwargs = {};
+      if (this.match("COLON" /* COLON */)) {
+        if (this.check("SUB" /* SUB */) || this.check("ADD" /* ADD */)) {
+          const op = this.advance();
+          const operand = this.parsePostfix();
+          args.push({
+            type: "UnaryOp",
+            operator: op.value,
+            operand,
+            line: op.line,
+            column: op.column
+          });
+        } else {
+          args.push(this.parsePostfix());
+        }
+      } else if (this.match("LPAREN" /* LPAREN */)) {
+        while (!this.check("RPAREN" /* RPAREN */)) {
+          if (this.check("NAME" /* NAME */) && this.peekNext()?.type === "ASSIGN" /* ASSIGN */) {
+            const key = this.advance().value;
+            this.advance();
+            kwargs[key] = this.parseExpression();
+          } else {
+            args.push(this.parseExpression());
+          }
+          if (!this.check("RPAREN" /* RPAREN */)) {
+            this.expect("COMMA" /* COMMA */);
+          }
+        }
+        this.expect("RPAREN" /* RPAREN */);
+      }
+      node = {
+        type: "FilterExpr",
+        node,
+        filter: filterName,
+        args,
+        kwargs,
+        line: node.line,
+        column: node.column
+      };
+    }
+    return node;
+  }
+  parsePostfix() {
+    let node = this.parsePrimary();
+    while (true) {
+      if (this.match("DOT" /* DOT */)) {
+        let attr;
+        if (this.check("NUMBER" /* NUMBER */)) {
+          attr = this.advance().value;
+        } else {
+          attr = this.expect("NAME" /* NAME */).value;
+        }
+        node = {
+          type: "GetAttr",
+          object: node,
+          attribute: attr,
+          line: node.line,
+          column: node.column
+        };
+      } else if (this.match("LBRACKET" /* LBRACKET */)) {
+        const index = this.parseExpression();
+        this.expect("RBRACKET" /* RBRACKET */);
+        node = {
+          type: "GetItem",
+          object: node,
+          index,
+          line: node.line,
+          column: node.column
+        };
+      } else if (this.match("LPAREN" /* LPAREN */)) {
+        const args = [];
+        const kwargs = {};
+        while (!this.check("RPAREN" /* RPAREN */)) {
+          if (this.check("NAME" /* NAME */) && this.peekNext()?.type === "ASSIGN" /* ASSIGN */) {
+            const key = this.advance().value;
+            this.advance();
+            kwargs[key] = this.parseExpression();
+          } else {
+            args.push(this.parseExpression());
+          }
+          if (!this.check("RPAREN" /* RPAREN */)) {
+            this.expect("COMMA" /* COMMA */);
+          }
+        }
+        this.expect("RPAREN" /* RPAREN */);
+        node = {
+          type: "FunctionCall",
+          callee: node,
+          args,
+          kwargs,
+          line: node.line,
+          column: node.column
+        };
+      } else {
+        break;
+      }
+    }
+    return node;
+  }
+  parsePrimary() {
+    const token = this.peek();
+    if (this.match("STRING" /* STRING */)) {
+      return {
+        type: "Literal",
+        value: token.value,
+        line: token.line,
+        column: token.column
+      };
+    }
+    if (this.match("NUMBER" /* NUMBER */)) {
+      const value = token.value.includes(".") ? parseFloat(token.value) : parseInt(token.value, 10);
+      return {
+        type: "Literal",
+        value,
+        line: token.line,
+        column: token.column
+      };
+    }
+    if (this.check("NAME" /* NAME */)) {
+      const name = this.advance().value;
+      if (name === "true" || name === "True") {
+        return { type: "Literal", value: true, line: token.line, column: token.column };
+      }
+      if (name === "false" || name === "False") {
+        return { type: "Literal", value: false, line: token.line, column: token.column };
+      }
+      if (name === "none" || name === "None" || name === "null") {
+        return { type: "Literal", value: null, line: token.line, column: token.column };
+      }
+      return { type: "Name", name, line: token.line, column: token.column };
+    }
+    if (this.match("LPAREN" /* LPAREN */)) {
+      const expr = this.parseExpression();
+      this.expect("RPAREN" /* RPAREN */);
+      return expr;
+    }
+    if (this.match("LBRACKET" /* LBRACKET */)) {
+      const elements = [];
+      while (!this.check("RBRACKET" /* RBRACKET */)) {
+        elements.push(this.parseExpression());
+        if (!this.check("RBRACKET" /* RBRACKET */)) {
+          this.expect("COMMA" /* COMMA */);
+        }
+      }
+      this.expect("RBRACKET" /* RBRACKET */);
+      return { type: "Array", elements, line: token.line, column: token.column };
+    }
+    if (this.match("LBRACE" /* LBRACE */)) {
+      const pairs = [];
+      while (!this.check("RBRACE" /* RBRACE */)) {
+        const key = this.parseExpression();
+        this.expect("COLON" /* COLON */);
+        const value = this.parseExpression();
+        pairs.push({ key, value });
+        if (!this.check("RBRACE" /* RBRACE */)) {
+          this.expect("COMMA" /* COMMA */);
+        }
+      }
+      this.expect("RBRACE" /* RBRACE */);
+      return { type: "Object", pairs, line: token.line, column: token.column };
+    }
+    throw this.error(`Unexpected token: ${token.type} (${token.value})`);
+  }
+  parseKeywordArgs() {
+    const kwargs = {};
+    while (this.check("NAME" /* NAME */) && this.peekNext()?.type === "ASSIGN" /* ASSIGN */) {
+      const key = this.advance().value;
+      this.advance();
+      kwargs[key] = this.parseExpression();
+    }
+    return kwargs;
+  }
+  checkBlockTag(name) {
+    if (this.peek().type !== "BLOCK_START" /* BLOCK_START */)
+      return false;
+    const saved = this.current;
+    this.advance();
+    const isMatch = this.check("NAME" /* NAME */) && this.peek().value === name;
+    this.current = saved;
+    return isMatch;
+  }
+  expectBlockTag(name) {
+    this.advance();
+    const tag = this.expect("NAME" /* NAME */);
+    if (tag.value !== name) {
+      throw this.error(`Expected '${name}', got '${tag.value}'`);
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+  }
+  expectName(name) {
+    const token = this.expect("NAME" /* NAME */);
+    if (token.value !== name) {
+      throw this.error(`Expected '${name}', got '${token.value}'`);
+    }
+  }
+  skipToBlockEnd() {
+    while (!this.isAtEnd() && !this.check("BLOCK_END" /* BLOCK_END */)) {
+      this.advance();
+    }
+    if (this.check("BLOCK_END" /* BLOCK_END */)) {
+      this.advance();
+    }
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF" /* EOF */;
+  }
+  peek() {
+    return this.tokens[this.current];
+  }
+  peekNext() {
+    if (this.current + 1 >= this.tokens.length)
+      return null;
+    return this.tokens[this.current + 1];
+  }
+  advance() {
+    if (!this.isAtEnd())
+      this.current++;
+    return this.tokens[this.current - 1];
+  }
+  check(type) {
+    if (this.isAtEnd())
+      return false;
+    return this.peek().type === type;
+  }
+  match(type) {
+    if (this.check(type)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  expect(type) {
+    if (this.check(type))
+      return this.advance();
+    const token = this.peek();
+    throw this.error(`Expected ${type}, got ${token.type} (${token.value})`);
+  }
+  error(message) {
+    const token = this.peek();
+    return new Error(`Parse error at line ${token.line}, column ${token.column}: ${message}`);
+  }
+}
+
+// src/compiler/index.ts
+function compileToString(ast, options = {}) {
+  const compiler = new Compiler(options);
+  return compiler.compile(ast);
+}
+class Compiler {
+  options;
+  indent = 0;
+  varCounter = 0;
+  loopStack = [];
+  localVars = [];
+  constructor(options = {}) {
+    this.options = {
+      functionName: options.functionName ?? "render",
+      inlineHelpers: options.inlineHelpers ?? true,
+      minify: options.minify ?? false,
+      autoescape: options.autoescape ?? true
+    };
+  }
+  pushScope() {
+    this.localVars.push(new Set);
+  }
+  popScope() {
+    this.localVars.pop();
+  }
+  addLocalVar(name) {
+    if (this.localVars.length > 0) {
+      this.localVars[this.localVars.length - 1].add(name);
+    }
+  }
+  isLocalVar(name) {
+    for (let i = this.localVars.length - 1;i >= 0; i--) {
+      if (this.localVars[i].has(name))
+        return true;
+    }
+    return false;
+  }
+  compile(ast) {
+    const body = this.compileNodes(ast.body);
+    const nl = this.options.minify ? "" : `
+`;
+    return `function ${this.options.functionName}(__ctx) {${nl}` + `  let __out = '';${nl}` + body + `  return __out;${nl}` + `}`;
+  }
+  compileNodes(nodes2) {
+    return nodes2.map((node) => this.compileNode(node)).join("");
+  }
+  compileNode(node) {
+    switch (node.type) {
+      case "Text":
+        return this.compileText(node);
+      case "Output":
+        return this.compileOutput(node);
+      case "If":
+        return this.compileIf(node);
+      case "For":
+        return this.compileFor(node);
+      case "Set":
+        return this.compileSet(node);
+      case "With":
+        return this.compileWith(node);
+      case "Comment":
+        return "";
+      case "Extends":
+      case "Block":
+      case "Include":
+        throw new Error(`AOT compilation does not support '${node.type}' - use Environment.render() for templates with inheritance`);
+      case "Url":
+      case "Static":
+        throw new Error(`AOT compilation does not support '${node.type}' tag - use Environment.render() with urlResolver/staticResolver`);
+      default:
+        throw new Error(`Unknown node type in AOT compiler: ${node.type}`);
+    }
+  }
+  compileText(node) {
+    const escaped = JSON.stringify(node.value);
+    return `  __out += ${escaped};${this.nl()}`;
+  }
+  compileOutput(node) {
+    const expr = this.compileExpr(node.expression);
+    if (this.options.autoescape && !this.isMarkedSafe(node.expression)) {
+      return `  __out += escape(${expr});${this.nl()}`;
+    }
+    return `  __out += (${expr}) ?? '';${this.nl()}`;
+  }
+  compileIf(node) {
+    let code = "";
+    const test = this.compileExpr(node.test);
+    code += `  if (isTruthy(${test})) {${this.nl()}`;
+    code += this.compileNodes(node.body);
+    code += `  }`;
+    for (const elif of node.elifs) {
+      const elifTest = this.compileExpr(elif.test);
+      code += ` else if (isTruthy(${elifTest})) {${this.nl()}`;
+      code += this.compileNodes(elif.body);
+      code += `  }`;
+    }
+    if (node.else_.length > 0) {
+      code += ` else {${this.nl()}`;
+      code += this.compileNodes(node.else_);
+      code += `  }`;
+    }
+    code += this.nl();
+    return code;
+  }
+  compileFor(node) {
+    const iterVar = this.genVar("iter");
+    const indexVar = this.genVar("i");
+    const lenVar = this.genVar("len");
+    const loopVar = this.genVar("loop");
+    const itemVar = Array.isArray(node.target) ? node.target[0] : node.target;
+    const valueVar = Array.isArray(node.target) && node.target[1] ? node.target[1] : null;
+    const parentLoopVar = this.loopStack.length > 0 ? this.loopStack[this.loopStack.length - 1] : null;
+    const iter = this.compileExpr(node.iter);
+    let code = "";
+    code += `  const ${iterVar} = toArray(${iter});${this.nl()}`;
+    code += `  const ${lenVar} = ${iterVar}.length;${this.nl()}`;
+    if (node.else_.length > 0) {
+      code += `  if (${lenVar} === 0) {${this.nl()}`;
+      code += this.compileNodes(node.else_);
+      code += `  } else {${this.nl()}`;
+    }
+    code += `  for (let ${indexVar} = 0; ${indexVar} < ${lenVar}; ${indexVar}++) {${this.nl()}`;
+    if (valueVar) {
+      code += `    const ${itemVar} = ${iterVar}[${indexVar}][0];${this.nl()}`;
+      code += `    const ${valueVar} = ${iterVar}[${indexVar}][1];${this.nl()}`;
+    } else {
+      code += `    const ${itemVar} = ${iterVar}[${indexVar}];${this.nl()}`;
+    }
+    code += `    const ${loopVar} = {${this.nl()}`;
+    code += `      counter: ${indexVar} + 1,${this.nl()}`;
+    code += `      counter0: ${indexVar},${this.nl()}`;
+    code += `      revcounter: ${lenVar} - ${indexVar},${this.nl()}`;
+    code += `      revcounter0: ${lenVar} - ${indexVar} - 1,${this.nl()}`;
+    code += `      first: ${indexVar} === 0,${this.nl()}`;
+    code += `      last: ${indexVar} === ${lenVar} - 1,${this.nl()}`;
+    code += `      length: ${lenVar},${this.nl()}`;
+    code += `      index: ${indexVar} + 1,${this.nl()}`;
+    code += `      index0: ${indexVar},${this.nl()}`;
+    if (parentLoopVar) {
+      code += `      parentloop: ${parentLoopVar},${this.nl()}`;
+      code += `      parent: ${parentLoopVar}${this.nl()}`;
+    } else {
+      code += `      parentloop: null,${this.nl()}`;
+      code += `      parent: null${this.nl()}`;
+    }
+    code += `    };${this.nl()}`;
+    code += `    const forloop = ${loopVar};${this.nl()}`;
+    code += `    const loop = ${loopVar};${this.nl()}`;
+    this.loopStack.push(loopVar);
+    const bodyCode = this.compileNodes(node.body);
+    code += bodyCode.replace(new RegExp(`__ctx\\.${itemVar}`, "g"), itemVar);
+    this.loopStack.pop();
+    code += `  }${this.nl()}`;
+    if (node.else_.length > 0) {
+      code += `  }${this.nl()}`;
+    }
+    return code;
+  }
+  compileSet(node) {
+    const value = this.compileExpr(node.value);
+    return `  const ${node.target} = ${value};${this.nl()}`;
+  }
+  compileWith(node) {
+    let code = `  {${this.nl()}`;
+    this.pushScope();
+    for (const { target, value } of node.assignments) {
+      const valueExpr = this.compileExpr(value);
+      code += `    const ${target} = ${valueExpr};${this.nl()}`;
+      this.addLocalVar(target);
+    }
+    code += this.compileNodes(node.body);
+    code += `  }${this.nl()}`;
+    this.popScope();
+    return code;
+  }
+  compileExpr(node) {
+    switch (node.type) {
+      case "Name":
+        return this.compileName(node);
+      case "Literal":
+        return this.compileLiteral(node);
+      case "Array":
+        return this.compileArray(node);
+      case "Object":
+        return this.compileObject(node);
+      case "BinaryOp":
+        return this.compileBinaryOp(node);
+      case "UnaryOp":
+        return this.compileUnaryOp(node);
+      case "Compare":
+        return this.compileCompare(node);
+      case "GetAttr":
+        return this.compileGetAttr(node);
+      case "GetItem":
+        return this.compileGetItem(node);
+      case "FilterExpr":
+        return this.compileFilter(node);
+      case "TestExpr":
+        return this.compileTest(node);
+      case "Conditional":
+        return this.compileConditional(node);
+      default:
+        return "undefined";
+    }
+  }
+  compileName(node) {
+    if (node.name === "true" || node.name === "True")
+      return "true";
+    if (node.name === "false" || node.name === "False")
+      return "false";
+    if (node.name === "none" || node.name === "None" || node.name === "null")
+      return "null";
+    if (node.name === "forloop" || node.name === "loop")
+      return node.name;
+    if (this.isLocalVar(node.name)) {
+      return node.name;
+    }
+    return `__ctx.${node.name}`;
+  }
+  compileLiteral(node) {
+    if (typeof node.value === "string") {
+      return JSON.stringify(node.value);
+    }
+    return String(node.value);
+  }
+  compileArray(node) {
+    const elements = node.elements.map((el) => this.compileExpr(el)).join(", ");
+    return `[${elements}]`;
+  }
+  compileObject(node) {
+    const pairs = node.pairs.map(({ key, value }) => {
+      const k = this.compileExpr(key);
+      const v = this.compileExpr(value);
+      return `[${k}]: ${v}`;
+    }).join(", ");
+    return `{${pairs}}`;
+  }
+  compileBinaryOp(node) {
+    const left = this.compileExpr(node.left);
+    const right = this.compileExpr(node.right);
+    switch (node.operator) {
+      case "and":
+        return `(${left} && ${right})`;
+      case "or":
+        return `(${left} || ${right})`;
+      case "~":
+        return `(String(${left}) + String(${right}))`;
+      case "in":
+        return `(Array.isArray(${right}) ? ${right}.includes(${left}) : String(${right}).includes(String(${left})))`;
+      case "not in":
+        return `!(Array.isArray(${right}) ? ${right}.includes(${left}) : String(${right}).includes(String(${left})))`;
+      default:
+        return `(${left} ${node.operator} ${right})`;
+    }
+  }
+  compileUnaryOp(node) {
+    const operand = this.compileExpr(node.operand);
+    switch (node.operator) {
+      case "not":
+        return `!isTruthy(${operand})`;
+      case "-":
+        return `-(${operand})`;
+      case "+":
+        return `+(${operand})`;
+      default:
+        return operand;
+    }
+  }
+  compileCompare(node) {
+    let result = this.compileExpr(node.left);
+    for (const { operator, right } of node.ops) {
+      const rightExpr = this.compileExpr(right);
+      switch (operator) {
+        case "==":
+        case "===":
+          result = `(${result} === ${rightExpr})`;
+          break;
+        case "!=":
+        case "!==":
+          result = `(${result} !== ${rightExpr})`;
+          break;
+        default:
+          result = `(${result} ${operator} ${rightExpr})`;
+      }
+    }
+    return result;
+  }
+  compileGetAttr(node) {
+    const obj = this.compileExpr(node.object);
+    return `${obj}?.${node.attribute}`;
+  }
+  compileGetItem(node) {
+    const obj = this.compileExpr(node.object);
+    const index = this.compileExpr(node.index);
+    return `${obj}?.[${index}]`;
+  }
+  compileFilter(node) {
+    const value = this.compileExpr(node.node);
+    const args = node.args.map((arg) => this.compileExpr(arg));
+    switch (node.filter) {
+      case "upper":
+        return `String(${value}).toUpperCase()`;
+      case "lower":
+        return `String(${value}).toLowerCase()`;
+      case "title":
+        return `String(${value}).replace(/\\b\\w/g, c => c.toUpperCase())`;
+      case "trim":
+        return `String(${value}).trim()`;
+      case "length":
+        return `(${value}?.length ?? Object.keys(${value} ?? {}).length)`;
+      case "first":
+        return `(${value})?.[0]`;
+      case "last":
+        return `(${value})?.[(${value})?.length - 1]`;
+      case "default":
+        return `((${value}) ?? ${args[0] ?? '""'})`;
+      case "safe":
+        return `{ __safe: true, value: String(${value}) }`;
+      case "escape":
+      case "e":
+        return `escape(${value})`;
+      case "join":
+        return `(${value} ?? []).join(${args[0] ?? '""'})`;
+      case "abs":
+        return `Math.abs(${value})`;
+      case "round":
+        return args.length ? `Number(${value}).toFixed(${args[0]})` : `Math.round(${value})`;
+      case "int":
+        return `parseInt(${value}, 10)`;
+      case "float":
+        return `parseFloat(${value})`;
+      case "floatformat":
+        return `Number(${value}).toFixed(${args[0] ?? 1})`;
+      case "filesizeformat":
+        return `applyFilter('filesizeformat', ${value})`;
+      default:
+        const argsStr = args.length ? ", " + args.join(", ") : "";
+        return `applyFilter('${node.filter}', ${value}${argsStr})`;
+    }
+  }
+  compileTest(node) {
+    const value = this.compileExpr(node.node);
+    const args = node.args.map((arg) => this.compileExpr(arg));
+    const negation = node.negated ? "!" : "";
+    switch (node.test) {
+      case "defined":
+        return `${negation}(${value} !== undefined)`;
+      case "undefined":
+        return `${negation}(${value} === undefined)`;
+      case "none":
+        return `${negation}(${value} === null)`;
+      case "even":
+        return `${negation}(${value} % 2 === 0)`;
+      case "odd":
+        return `${negation}(${value} % 2 !== 0)`;
+      case "divisibleby":
+        return `${negation}(${value} % ${args[0]} === 0)`;
+      case "empty":
+        return `${negation}((${value} == null) || (${value}.length === 0) || (Object.keys(${value}).length === 0))`;
+      case "iterable":
+        return `${negation}(Array.isArray(${value}) || typeof ${value} === 'string')`;
+      case "number":
+        return `${negation}(typeof ${value} === 'number' && !isNaN(${value}))`;
+      case "string":
+        return `${negation}(typeof ${value} === 'string')`;
+      default:
+        const argsStr = args.length ? ", " + args.join(", ") : "";
+        return `${negation}applyTest('${node.test}', ${value}${argsStr})`;
+    }
+  }
+  compileConditional(node) {
+    const test = this.compileExpr(node.test);
+    const trueExpr = this.compileExpr(node.trueExpr);
+    const falseExpr = this.compileExpr(node.falseExpr);
+    return `(isTruthy(${test}) ? ${trueExpr} : ${falseExpr})`;
+  }
+  isMarkedSafe(node) {
+    if (node.type === "FilterExpr") {
+      const filter = node;
+      return filter.filter === "safe";
+    }
+    return false;
+  }
+  genVar(prefix) {
+    return `__${prefix}${this.varCounter++}`;
+  }
+  nl() {
+    return this.options.minify ? "" : `
+`;
+  }
+}
+
+// src/compiler/flattener.ts
+function flattenTemplate(ast, options) {
+  const flattener = new TemplateFlattener(options);
+  return flattener.flatten(ast);
+}
+function canFlatten(ast) {
+  const checker = new StaticChecker;
+  return checker.check(ast);
+}
+
+class TemplateFlattener {
+  loader;
+  maxDepth;
+  blocks = new Map;
+  depth = 0;
+  constructor(options) {
+    this.loader = options.loader;
+    this.maxDepth = options.maxDepth ?? 10;
+  }
+  flatten(ast) {
+    this.blocks.clear();
+    this.depth = 0;
+    return this.processTemplate(ast);
+  }
+  processTemplate(ast, isChild = true) {
+    if (this.depth > this.maxDepth) {
+      throw new Error(`Maximum template inheritance depth (${this.maxDepth}) exceeded`);
+    }
+    this.collectBlocks(ast.body, isChild);
+    const extendsNode = this.findExtends(ast.body);
+    if (extendsNode) {
+      const parentName = this.getStaticTemplateName(extendsNode.template);
+      const parentSource = this.loader.load(parentName);
+      const parentAst = this.loader.parse(parentSource);
+      this.depth++;
+      const flattenedParent = this.processTemplate(parentAst, false);
+      this.depth--;
+      return {
+        type: "Template",
+        body: this.replaceBlocks(flattenedParent.body),
+        line: ast.line,
+        column: ast.column
+      };
+    }
+    return {
+      type: "Template",
+      body: this.processNodes(ast.body),
+      line: ast.line,
+      column: ast.column
+    };
+  }
+  collectBlocks(nodes2, override = true) {
+    for (const node of nodes2) {
+      if (node.type === "Block") {
+        const block = node;
+        if (override || !this.blocks.has(block.name)) {
+          this.blocks.set(block.name, block);
+        }
+      }
+      this.collectBlocksFromNode(node, override);
+    }
+  }
+  collectBlocksFromNode(node, override = true) {
+    switch (node.type) {
+      case "If": {
+        const ifNode = node;
+        this.collectBlocks(ifNode.body, override);
+        for (const elif of ifNode.elifs) {
+          this.collectBlocks(elif.body, override);
+        }
+        this.collectBlocks(ifNode.else_, override);
+        break;
+      }
+      case "For": {
+        const forNode = node;
+        this.collectBlocks(forNode.body, override);
+        this.collectBlocks(forNode.else_, override);
+        break;
+      }
+      case "With": {
+        const withNode = node;
+        this.collectBlocks(withNode.body, override);
+        break;
+      }
+      case "Block": {
+        const blockNode = node;
+        this.collectBlocks(blockNode.body, override);
+        break;
+      }
+    }
+  }
+  findExtends(nodes2) {
+    for (const node of nodes2) {
+      if (node.type === "Extends") {
+        return node;
+      }
+    }
+    return null;
+  }
+  processNodes(nodes2) {
+    const result = [];
+    for (const node of nodes2) {
+      if (node.type === "Extends") {
+        continue;
+      }
+      if (node.type === "Include") {
+        const includeNode = node;
+        const inlined = this.inlineInclude(includeNode);
+        result.push(...inlined);
+        continue;
+      }
+      if (node.type === "Block") {
+        const block = node;
+        const childBlock = this.blocks.get(block.name);
+        if (childBlock && childBlock !== block) {
+          result.push(...this.processNodes(childBlock.body));
+        } else {
+          result.push(...this.processNodes(block.body));
+        }
+        continue;
+      }
+      const processed = this.processNode(node);
+      if (processed) {
+        result.push(processed);
+      }
+    }
+    return result;
+  }
+  processNode(node) {
+    switch (node.type) {
+      case "If": {
+        const ifNode = node;
+        return {
+          ...ifNode,
+          body: this.processNodes(ifNode.body),
+          elifs: ifNode.elifs.map((elif) => ({
+            test: elif.test,
+            body: this.processNodes(elif.body)
+          })),
+          else_: this.processNodes(ifNode.else_)
+        };
+      }
+      case "For": {
+        const forNode = node;
+        return {
+          ...forNode,
+          body: this.processNodes(forNode.body),
+          else_: this.processNodes(forNode.else_)
+        };
+      }
+      case "With": {
+        const withNode = node;
+        return {
+          ...withNode,
+          body: this.processNodes(withNode.body)
+        };
+      }
+      default:
+        return node;
+    }
+  }
+  replaceBlocks(nodes2) {
+    return this.processNodes(nodes2);
+  }
+  inlineInclude(node) {
+    const templateName = this.getStaticTemplateName(node.template);
+    try {
+      const source = this.loader.load(templateName);
+      const ast = this.loader.parse(source);
+      this.depth++;
+      const flattened = this.processTemplate(ast);
+      this.depth--;
+      if (node.context && Object.keys(node.context).length > 0) {
+        const withNode = {
+          type: "With",
+          assignments: Object.entries(node.context).map(([target, value]) => ({
+            target,
+            value
+          })),
+          body: flattened.body,
+          line: node.line,
+          column: node.column
+        };
+        return [withNode];
+      }
+      return flattened.body;
+    } catch (error) {
+      if (node.ignoreMissing) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  getStaticTemplateName(expr) {
+    if (expr.type === "Literal") {
+      const literal = expr;
+      if (typeof literal.value === "string") {
+        return literal.value;
+      }
+    }
+    throw new Error(`AOT compilation requires static template names. ` + `Found dynamic expression at line ${expr.line}. ` + `Use Environment.render() for dynamic template names.`);
+  }
+}
+
+class StaticChecker {
+  check(ast) {
+    return this.checkNodes(ast.body);
+  }
+  checkNodes(nodes2) {
+    for (const node of nodes2) {
+      const result = this.checkNode(node);
+      if (!result.canFlatten) {
+        return result;
+      }
+    }
+    return { canFlatten: true };
+  }
+  checkNode(node) {
+    switch (node.type) {
+      case "Extends": {
+        const extendsNode = node;
+        if (!this.isStaticName(extendsNode.template)) {
+          return {
+            canFlatten: false,
+            reason: `Dynamic extends at line ${node.line} - use static string literal`
+          };
+        }
+        break;
+      }
+      case "Include": {
+        const includeNode = node;
+        if (!this.isStaticName(includeNode.template)) {
+          return {
+            canFlatten: false,
+            reason: `Dynamic include at line ${node.line} - use static string literal`
+          };
+        }
+        break;
+      }
+      case "If": {
+        const ifNode = node;
+        let result = this.checkNodes(ifNode.body);
+        if (!result.canFlatten)
+          return result;
+        for (const elif of ifNode.elifs) {
+          result = this.checkNodes(elif.body);
+          if (!result.canFlatten)
+            return result;
+        }
+        result = this.checkNodes(ifNode.else_);
+        if (!result.canFlatten)
+          return result;
+        break;
+      }
+      case "For": {
+        const forNode = node;
+        let result = this.checkNodes(forNode.body);
+        if (!result.canFlatten)
+          return result;
+        result = this.checkNodes(forNode.else_);
+        if (!result.canFlatten)
+          return result;
+        break;
+      }
+      case "With": {
+        const withNode = node;
+        const result = this.checkNodes(withNode.body);
+        if (!result.canFlatten)
+          return result;
+        break;
+      }
+      case "Block": {
+        const blockNode = node;
+        const result = this.checkNodes(blockNode.body);
+        if (!result.canFlatten)
+          return result;
+        break;
+      }
+    }
+    return { canFlatten: true };
+  }
+  isStaticName(expr) {
+    return expr.type === "Literal" && typeof expr.value === "string";
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.1.1";
+var colors = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+function log(msg) {
+  console.log(msg);
+}
+function success(msg) {
+  console.log(`${colors.green}\u2713${colors.reset} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${colors.yellow}\u26A0${colors.reset} ${msg}`);
+}
+function error(msg) {
+  console.error(`${colors.red}\u2717${colors.reset} ${msg}`);
+}
+function printHelp() {
+  console.log(`
+${colors.cyan}binja${colors.reset} - High-performance template compiler
+
+${colors.yellow}Usage:${colors.reset}
+  binja compile <source> [options]    Compile templates to JavaScript
+  binja check <source>                Check if templates can be AOT compiled
+  binja --help                        Show this help
+  binja --version                     Show version
+
+${colors.yellow}Compile Options:${colors.reset}
+  -o, --output <dir>      Output directory (required)
+  -n, --name <name>       Function name for single file compilation
+  -m, --minify            Minify output
+  -e, --ext <extensions>  File extensions to compile (default: .html,.jinja,.jinja2)
+  -v, --verbose           Verbose output
+  -w, --watch             Watch for changes and recompile
+
+${colors.yellow}Examples:${colors.reset}
+  ${colors.dim}# Compile all templates in a directory${colors.reset}
+  binja compile ./templates -o ./dist/templates
+
+  ${colors.dim}# Compile with minification${colors.reset}
+  binja compile ./views -o ./compiled --minify
+
+  ${colors.dim}# Compile single file with custom function name${colors.reset}
+  binja compile ./templates/home.html -o ./dist --name renderHome
+
+  ${colors.dim}# Watch mode for development${colors.reset}
+  binja compile ./templates -o ./dist --watch
+
+${colors.yellow}Output:${colors.reset}
+  Generated files export a render function:
+
+    ${colors.dim}// dist/templates/home.js${colors.reset}
+    export function render(ctx) { ... }
+
+    ${colors.dim}// Usage${colors.reset}
+    import { render } from './dist/templates/home.js'
+    const html = render({ title: 'Hello' })
+`);
+}
+function parseArgs(args) {
+  const options = {
+    output: "",
+    minify: false,
+    watch: false,
+    extensions: [".html", ".jinja", ".jinja2"],
+    verbose: false
+  };
+  let command = "";
+  let source = "";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "compile" || arg === "check" || arg === "watch") {
+      command = arg;
+      if (arg === "watch") {
+        options.watch = true;
+        command = "compile";
+      }
+    } else if (arg === "-o" || arg === "--output") {
+      options.output = args[++i];
+    } else if (arg === "-n" || arg === "--name") {
+      options.name = args[++i];
+    } else if (arg === "-m" || arg === "--minify") {
+      options.minify = true;
+    } else if (arg === "-w" || arg === "--watch") {
+      options.watch = true;
+    } else if (arg === "-v" || arg === "--verbose") {
+      options.verbose = true;
+    } else if (arg === "-e" || arg === "--ext") {
+      options.extensions = args[++i].split(",").map((e) => e.startsWith(".") ? e : `.${e}`);
+    } else if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    } else if (arg === "--version" || arg === "-V") {
+      console.log(`binja v${VERSION}`);
+      process.exit(0);
+    } else if (!arg.startsWith("-") && !source) {
+      source = arg;
+    }
+  }
+  return { command, source, options };
+}
+function createTemplateLoader(baseDir, extensions) {
+  return {
+    load(name) {
+      const basePath = path.resolve(baseDir, name);
+      for (const ext of [...extensions, ""]) {
+        const fullPath = basePath + ext;
+        if (fs.existsSync(fullPath)) {
+          return fs.readFileSync(fullPath, "utf-8");
+        }
+      }
+      throw new Error(`Template not found: ${name}`);
+    },
+    parse(source) {
+      const lexer = new Lexer(source);
+      const tokens = lexer.tokenize();
+      const parser = new Parser(tokens);
+      return parser.parse();
+    }
+  };
+}
+function generateOutputCode(code, functionName) {
+  return `// Generated by binja - DO NOT EDIT
+// Source: binja compile
+
+const escape = (v) => {
+  if (v == null) return '';
+  if (v?.__safe__ || v?.__safe) return String(v?.value ?? v);
+  return Bun?.escapeHTML?.(String(v)) ?? String(v).replace(/[&<>"']/g, c => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+  })[c]);
+};
+
+const isTruthy = (v) => {
+  if (v == null) return false;
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') return v.length > 0;
+  if (Array.isArray(v)) return v.length > 0;
+  if (typeof v === 'object') { for (const _ in v) return true; return false; }
+  return true;
+};
+
+const toArray = (v) => {
+  if (v == null) return [];
+  if (Array.isArray(v)) return v;
+  if (typeof v === 'string') return v.split('');
+  if (typeof v === 'object') {
+    if (typeof v[Symbol.iterator] === 'function') return [...v];
+    return Object.entries(v);
+  }
+  return [];
+};
+
+const applyFilter = (name, value, ...args) => {
+  throw new Error(\`Filter '\${name}' not available in compiled template. Use inline filters.\`);
+};
+
+const applyTest = (name, value, ...args) => {
+  throw new Error(\`Test '\${name}' not available in compiled template.\`);
+};
+
+${code}
+
+export { ${functionName} as render };
+export default ${functionName};
+`;
+}
+async function compileFile(filePath, outputDir, baseDir, options) {
+  try {
+    const source = fs.readFileSync(filePath, "utf-8");
+    const loader = createTemplateLoader(baseDir, options.extensions);
+    const ast = loader.parse(source);
+    const check = canFlatten(ast);
+    let finalAst = ast;
+    if (!check.canFlatten) {
+      if (options.verbose) {
+        warn(`${path.basename(filePath)}: ${check.reason} - compiling without inheritance resolution`);
+      }
+    } else {
+      finalAst = flattenTemplate(ast, { loader });
+    }
+    const relativePath = path.relative(baseDir, filePath);
+    const functionName = options.name || "render" + relativePath.replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9]/g, "_").replace(/^_+|_+$/g, "").replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+    const code = compileToString(finalAst, {
+      functionName,
+      minify: options.minify
+    });
+    const outputFileName = relativePath.replace(/\.[^.]+$/, ".js");
+    const outputPath = path.join(outputDir, outputFileName);
+    const outputDirPath = path.dirname(outputPath);
+    if (!fs.existsSync(outputDirPath)) {
+      fs.mkdirSync(outputDirPath, { recursive: true });
+    }
+    const outputCode = generateOutputCode(code, functionName);
+    fs.writeFileSync(outputPath, outputCode);
+    return { success: true, outputPath };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+async function compileDirectory(sourceDir, outputDir, options) {
+  let compiled = 0;
+  let failed = 0;
+  const files = [];
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (options.extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  walkDir(sourceDir);
+  for (const fullPath of files) {
+    const result = await compileFile(fullPath, outputDir, sourceDir, options);
+    if (result.success) {
+      compiled++;
+      if (options.verbose) {
+        success(`${path.relative(sourceDir, fullPath)} \u2192 ${path.relative(process.cwd(), result.outputPath)}`);
+      }
+    } else {
+      failed++;
+      error(`${path.relative(sourceDir, fullPath)}: ${result.error}`);
+    }
+  }
+  return { compiled, failed };
+}
+async function checkTemplates(sourceDir, options) {
+  const loader = createTemplateLoader(sourceDir, options.extensions);
+  let total = 0;
+  let canCompile = 0;
+  let cannotCompile = 0;
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (options.extensions.includes(ext)) {
+          total++;
+          try {
+            const source = fs.readFileSync(fullPath, "utf-8");
+            const ast = loader.parse(source);
+            const check = canFlatten(ast);
+            const relativePath = path.relative(sourceDir, fullPath);
+            if (check.canFlatten) {
+              canCompile++;
+              success(`${relativePath}`);
+            } else {
+              cannotCompile++;
+              warn(`${relativePath}: ${check.reason}`);
+            }
+          } catch (err) {
+            cannotCompile++;
+            error(`${path.relative(sourceDir, fullPath)}: ${err.message}`);
+          }
+        }
+      }
+    }
+  }
+  walkDir(sourceDir);
+  log("");
+  log(`Total: ${total} templates`);
+  log(`${colors.green}AOT compatible: ${canCompile}${colors.reset}`);
+  if (cannotCompile > 0) {
+    log(`${colors.yellow}Require runtime: ${cannotCompile}${colors.reset}`);
+  }
+}
+async function watchAndCompile(sourceDir, outputDir, options) {
+  log(`${colors.cyan}Watching${colors.reset} ${sourceDir} for changes...`);
+  log(`${colors.dim}Press Ctrl+C to stop${colors.reset}`);
+  log("");
+  const { compiled, failed } = await compileDirectory(sourceDir, outputDir, { ...options, verbose: true });
+  log("");
+  log(`Compiled ${compiled} templates${failed > 0 ? `, ${failed} failed` : ""}`);
+  log("");
+  const watcher = fs.watch(sourceDir, { recursive: true }, async (eventType, filename) => {
+    if (!filename)
+      return;
+    const ext = path.extname(filename);
+    if (!options.extensions.includes(ext))
+      return;
+    const fullPath = path.join(sourceDir, filename);
+    if (!fs.existsSync(fullPath))
+      return;
+    log(`${colors.dim}[${new Date().toLocaleTimeString()}]${colors.reset} ${filename} changed`);
+    const result = await compileFile(fullPath, outputDir, sourceDir, options);
+    if (result.success) {
+      success(`Compiled ${filename}`);
+    } else {
+      error(`${filename}: ${result.error}`);
+    }
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    log(`
+Stopped watching.`);
+    process.exit(0);
+  });
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    printHelp();
+    process.exit(0);
+  }
+  const { command, source, options } = parseArgs(args);
+  if (!command) {
+    error('No command specified. Use "compile" or "check".');
+    printHelp();
+    process.exit(1);
+  }
+  if (!source) {
+    error("No source path specified.");
+    process.exit(1);
+  }
+  const sourcePath = path.resolve(source);
+  if (!fs.existsSync(sourcePath)) {
+    error(`Source not found: ${source}`);
+    process.exit(1);
+  }
+  const isDirectory = fs.statSync(sourcePath).isDirectory();
+  if (command === "check") {
+    if (isDirectory) {
+      await checkTemplates(sourcePath, options);
+    } else {
+      const loader = createTemplateLoader(path.dirname(sourcePath), options.extensions);
+      const src = fs.readFileSync(sourcePath, "utf-8");
+      const ast = loader.parse(src);
+      const check = canFlatten(ast);
+      if (check.canFlatten) {
+        success(`${source} can be AOT compiled`);
+      } else {
+        warn(`${source}: ${check.reason}`);
+      }
+    }
+  } else if (command === "compile") {
+    if (!options.output) {
+      error("Output directory required. Use -o <dir>");
+      process.exit(1);
+    }
+    const outputDir = path.resolve(options.output);
+    if (options.watch) {
+      if (!isDirectory) {
+        error("Watch mode requires a directory, not a single file.");
+        process.exit(1);
+      }
+      await watchAndCompile(sourcePath, outputDir, options);
+    } else if (isDirectory) {
+      const startTime = Date.now();
+      const { compiled, failed } = await compileDirectory(sourcePath, outputDir, options);
+      const elapsed = Date.now() - startTime;
+      log("");
+      if (failed === 0) {
+        success(`Compiled ${compiled} templates in ${elapsed}ms`);
+      } else {
+        warn(`Compiled ${compiled} templates, ${failed} failed (${elapsed}ms)`);
+      }
+    } else {
+      const result = await compileFile(sourcePath, outputDir, path.dirname(sourcePath), options);
+      if (result.success) {
+        success(`Compiled to ${result.outputPath}`);
+      } else {
+        error(result.error);
+        process.exit(1);
+      }
+    }
+  }
+}
+main().catch((err) => {
+  error(err.message);
+  process.exit(1);
+});