binja 0.1.0

package/dist/index.js

@@ -0,0 +1,2499 @@
+// @bun
+// src/lexer/tokens.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2["TEXT"] = "TEXT";
+  TokenType2["EOF"] = "EOF";
+  TokenType2["VARIABLE_START"] = "VARIABLE_START";
+  TokenType2["VARIABLE_END"] = "VARIABLE_END";
+  TokenType2["BLOCK_START"] = "BLOCK_START";
+  TokenType2["BLOCK_END"] = "BLOCK_END";
+  TokenType2["COMMENT_START"] = "COMMENT_START";
+  TokenType2["COMMENT_END"] = "COMMENT_END";
+  TokenType2["NAME"] = "NAME";
+  TokenType2["STRING"] = "STRING";
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["DOT"] = "DOT";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["PIPE"] = "PIPE";
+  TokenType2["LPAREN"] = "LPAREN";
+  TokenType2["RPAREN"] = "RPAREN";
+  TokenType2["LBRACKET"] = "LBRACKET";
+  TokenType2["RBRACKET"] = "RBRACKET";
+  TokenType2["LBRACE"] = "LBRACE";
+  TokenType2["RBRACE"] = "RBRACE";
+  TokenType2["EQ"] = "EQ";
+  TokenType2["NE"] = "NE";
+  TokenType2["LT"] = "LT";
+  TokenType2["GT"] = "GT";
+  TokenType2["LE"] = "LE";
+  TokenType2["GE"] = "GE";
+  TokenType2["ADD"] = "ADD";
+  TokenType2["SUB"] = "SUB";
+  TokenType2["MUL"] = "MUL";
+  TokenType2["DIV"] = "DIV";
+  TokenType2["MOD"] = "MOD";
+  TokenType2["AND"] = "AND";
+  TokenType2["OR"] = "OR";
+  TokenType2["NOT"] = "NOT";
+  TokenType2["ASSIGN"] = "ASSIGN";
+  TokenType2["TILDE"] = "TILDE";
+})(TokenType ||= {});
+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();
+      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();
+  }
+  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/runtime/context.ts
+class Context {
+  scopes = [];
+  parent = null;
+  _forloopStack = [];
+  _lastCycleValue = null;
+  constructor(data = {}, parent = null) {
+    this.parent = parent;
+    this.scopes.push(new Map(Object.entries(data)));
+  }
+  get(name) {
+    if (name === "forloop" || name === "loop") {
+      return this._forloopStack[this._forloopStack.length - 1] || null;
+    }
+    for (let i = this.scopes.length - 1;i >= 0; i--) {
+      if (this.scopes[i].has(name)) {
+        return this.scopes[i].get(name);
+      }
+    }
+    if (this.parent) {
+      return this.parent.get(name);
+    }
+    return;
+  }
+  set(name, value) {
+    this.scopes[this.scopes.length - 1].set(name, value);
+  }
+  has(name) {
+    for (let i = this.scopes.length - 1;i >= 0; i--) {
+      if (this.scopes[i].has(name))
+        return true;
+    }
+    return this.parent ? this.parent.has(name) : false;
+  }
+  push(data = {}) {
+    this.scopes.push(new Map(Object.entries(data)));
+  }
+  pop() {
+    if (this.scopes.length > 1) {
+      this.scopes.pop();
+    }
+  }
+  derived(data = {}) {
+    return new Context(data, this);
+  }
+  pushForLoop(items, index) {
+    const length = items.length;
+    const depth = this._forloopStack.length + 1;
+    const forloop = {
+      counter: index + 1,
+      counter0: index,
+      revcounter: length - index,
+      revcounter0: length - index - 1,
+      first: index === 0,
+      last: index === length - 1,
+      length,
+      index: index + 1,
+      index0: index,
+      revindex: length - index,
+      revindex0: length - index - 1,
+      depth,
+      depth0: depth - 1,
+      previtem: index > 0 ? items[index - 1] : undefined,
+      nextitem: index < length - 1 ? items[index + 1] : undefined,
+      cycle: (...args) => args[index % args.length],
+      changed: (value) => {
+        const changed = value !== this._lastCycleValue;
+        this._lastCycleValue = value;
+        return changed;
+      }
+    };
+    if (this._forloopStack.length > 0) {
+      forloop.parentloop = this._forloopStack[this._forloopStack.length - 1];
+    }
+    this._forloopStack.push(forloop);
+    return forloop;
+  }
+  popForLoop() {
+    this._forloopStack.pop();
+  }
+  updateForLoop(index, items) {
+    const forloop = this._forloopStack[this._forloopStack.length - 1];
+    if (!forloop)
+      return;
+    const length = items.length;
+    forloop.counter = index + 1;
+    forloop.counter0 = index;
+    forloop.revcounter = length - index;
+    forloop.revcounter0 = length - index - 1;
+    forloop.first = index === 0;
+    forloop.last = index === length - 1;
+    forloop.index = index + 1;
+    forloop.index0 = index;
+    forloop.revindex = length - index;
+    forloop.revindex0 = length - index - 1;
+    forloop.previtem = index > 0 ? items[index - 1] : undefined;
+    forloop.nextitem = index < length - 1 ? items[index + 1] : undefined;
+  }
+  toObject() {
+    const result = {};
+    if (this.parent) {
+      Object.assign(result, this.parent.toObject());
+    }
+    for (const scope of this.scopes) {
+      for (const [key, value] of scope) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+}
+
+// src/filters/index.ts
+var upper = (value) => String(value).toUpperCase();
+var lower = (value) => String(value).toLowerCase();
+var capitalize = (value) => {
+  const str = String(value);
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+var capfirst = (value) => {
+  const str = String(value);
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var title = (value) => String(value).replace(/\b\w/g, (c) => c.toUpperCase());
+var trim = (value) => String(value).trim();
+var striptags = (value) => String(value).replace(/<[^>]*>/g, "");
+var escape = (value) => {
+  if (value?.__safe__)
+    return value;
+  const escaped = String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+  const safeString = new String(escaped);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var safe = (value) => {
+  const safeString = new String(value);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var escapejs = (value) => JSON.stringify(String(value)).slice(1, -1);
+var linebreaks = (value) => {
+  const str = String(value);
+  const paragraphs = str.split(/\n\n+/);
+  const html = paragraphs.map((p) => `<p>${p.replace(/\n/g, "<br>")}</p>`).join(`
+`);
+  const safeString = new String(html);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var linebreaksbr = (value) => {
+  const html = String(value).replace(/\n/g, "<br>");
+  const safeString = new String(html);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var truncatechars = (value, length = 30) => {
+  const str = String(value);
+  if (str.length <= length)
+    return str;
+  return str.slice(0, length - 3) + "...";
+};
+var truncatewords = (value, count = 15) => {
+  const words = String(value).split(/\s+/);
+  if (words.length <= count)
+    return value;
+  return words.slice(0, count).join(" ") + "...";
+};
+var wordcount = (value) => String(value).split(/\s+/).filter(Boolean).length;
+var center = (value, width = 80) => {
+  const str = String(value);
+  const padding = Math.max(0, width - str.length);
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return " ".repeat(left) + str + " ".repeat(right);
+};
+var ljust = (value, width = 80) => String(value).padEnd(width);
+var rjust = (value, width = 80) => String(value).padStart(width);
+var cut = (value, arg = "") => String(value).split(arg).join("");
+var slugify = (value) => String(value).toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+var abs = (value) => Math.abs(Number(value));
+var round = (value, precision = 0) => Number(Number(value).toFixed(precision));
+var int = (value) => parseInt(String(value), 10) || 0;
+var float = (value) => parseFloat(String(value)) || 0;
+var floatformat = (value, decimals = -1) => {
+  const num = parseFloat(String(value));
+  if (isNaN(num))
+    return "";
+  if (decimals === -1) {
+    const formatted = num.toFixed(1);
+    return formatted.endsWith(".0") ? Math.round(num).toString() : formatted;
+  }
+  return num.toFixed(Math.abs(decimals));
+};
+var add = (value, arg) => {
+  const numValue = Number(value);
+  const numArg = Number(arg);
+  if (!isNaN(numValue) && !isNaN(numArg)) {
+    return numValue + numArg;
+  }
+  return String(value) + String(arg);
+};
+var divisibleby = (value, arg) => Number(value) % Number(arg) === 0;
+var filesizeformat = (value) => {
+  const bytes = Number(value);
+  const units = ["bytes", "KB", "MB", "GB", "TB", "PB"];
+  let i = 0;
+  let size = bytes;
+  while (size >= 1024 && i < units.length - 1) {
+    size /= 1024;
+    i++;
+  }
+  return `${size.toFixed(1)} ${units[i]}`;
+};
+var length = (value) => {
+  if (value == null)
+    return 0;
+  if (typeof value === "string" || Array.isArray(value))
+    return value.length;
+  if (typeof value === "object")
+    return Object.keys(value).length;
+  return 0;
+};
+var length_is = (value, len) => length(value) === Number(len);
+var first = (value) => {
+  if (Array.isArray(value))
+    return value[0];
+  if (typeof value === "string")
+    return value[0];
+  return value;
+};
+var last = (value) => {
+  if (Array.isArray(value))
+    return value[value.length - 1];
+  if (typeof value === "string")
+    return value[value.length - 1];
+  return value;
+};
+var join = (value, separator = "") => {
+  if (Array.isArray(value))
+    return value.join(separator);
+  return String(value);
+};
+var slice = (value, arg) => {
+  if (!value)
+    return value;
+  const [startStr, endStr] = String(arg).split(":");
+  const start = startStr ? parseInt(startStr, 10) : 0;
+  const end = endStr ? parseInt(endStr, 10) : undefined;
+  if (Array.isArray(value) || typeof value === "string") {
+    return value.slice(start, end);
+  }
+  return value;
+};
+var reverse = (value) => {
+  if (Array.isArray(value))
+    return [...value].reverse();
+  if (typeof value === "string")
+    return value.split("").reverse().join("");
+  return value;
+};
+var sort = (value, reverse2 = false) => {
+  if (!Array.isArray(value))
+    return value;
+  const sorted = [...value].sort();
+  return reverse2 ? sorted.reverse() : sorted;
+};
+var unique = (value) => {
+  if (Array.isArray(value))
+    return [...new Set(value)];
+  return value;
+};
+var make_list = (value) => {
+  if (Array.isArray(value))
+    return value;
+  return String(value).split("");
+};
+var dictsort = (value, key) => {
+  if (!Array.isArray(value))
+    return value;
+  return [...value].sort((a, b) => {
+    const aVal = key ? a[key] : a;
+    const bVal = key ? b[key] : b;
+    return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+  });
+};
+var dictsortreversed = (value, key) => {
+  const sorted = dictsort(value, key);
+  return Array.isArray(sorted) ? sorted.reverse() : sorted;
+};
+var columns = (value, cols) => {
+  if (!Array.isArray(value))
+    return [[value]];
+  const result = [];
+  const numCols = Number(cols) || 2;
+  for (let i = 0;i < value.length; i += numCols) {
+    result.push(value.slice(i, i + numCols));
+  }
+  return result;
+};
+var date = (value, format = "N j, Y") => {
+  const d = value instanceof Date ? value : new Date(value);
+  if (isNaN(d.getTime()))
+    return "";
+  const formatMap = {
+    d: () => String(d.getDate()).padStart(2, "0"),
+    j: () => String(d.getDate()),
+    D: () => ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][d.getDay()],
+    l: () => ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][d.getDay()],
+    m: () => String(d.getMonth() + 1).padStart(2, "0"),
+    n: () => String(d.getMonth() + 1),
+    M: () => ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][d.getMonth()],
+    F: () => [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ][d.getMonth()],
+    N: () => [
+      "Jan.",
+      "Feb.",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "Aug.",
+      "Sept.",
+      "Oct.",
+      "Nov.",
+      "Dec."
+    ][d.getMonth()],
+    y: () => String(d.getFullYear()).slice(-2),
+    Y: () => String(d.getFullYear()),
+    H: () => String(d.getHours()).padStart(2, "0"),
+    G: () => String(d.getHours()),
+    i: () => String(d.getMinutes()).padStart(2, "0"),
+    s: () => String(d.getSeconds()).padStart(2, "0"),
+    a: () => d.getHours() < 12 ? "a.m." : "p.m.",
+    A: () => d.getHours() < 12 ? "AM" : "PM",
+    g: () => String(d.getHours() % 12 || 12),
+    h: () => String(d.getHours() % 12 || 12).padStart(2, "0")
+  };
+  return format.replace(/[a-zA-Z]/g, (char) => formatMap[char]?.() ?? char);
+};
+var time = (value, format = "H:i") => date(value, format);
+var timesince = (value, now = new Date) => {
+  const d = value instanceof Date ? value : new Date(value);
+  const diff = (new Date(now).getTime() - d.getTime()) / 1000;
+  const intervals = [
+    [31536000, "year", "years"],
+    [2592000, "month", "months"],
+    [604800, "week", "weeks"],
+    [86400, "day", "days"],
+    [3600, "hour", "hours"],
+    [60, "minute", "minutes"]
+  ];
+  for (const [seconds, singular, plural] of intervals) {
+    const count = Math.floor(diff / seconds);
+    if (count >= 1) {
+      return `${count} ${count === 1 ? singular : plural}`;
+    }
+  }
+  return "just now";
+};
+var timeuntil = (value, now = new Date) => {
+  const d = value instanceof Date ? value : new Date(value);
+  const diff = (d.getTime() - new Date(now).getTime()) / 1000;
+  const intervals = [
+    [31536000, "year", "years"],
+    [2592000, "month", "months"],
+    [604800, "week", "weeks"],
+    [86400, "day", "days"],
+    [3600, "hour", "hours"],
+    [60, "minute", "minutes"]
+  ];
+  for (const [seconds, singular, plural] of intervals) {
+    const count = Math.floor(diff / seconds);
+    if (count >= 1) {
+      return `${count} ${count === 1 ? singular : plural}`;
+    }
+  }
+  return "now";
+};
+var defaultFilter = (value, defaultValue = "") => {
+  if (value === undefined || value === null || value === "" || value === false) {
+    return defaultValue;
+  }
+  return value;
+};
+var default_if_none = (value, defaultValue = "") => value === null || value === undefined ? defaultValue : value;
+var yesno = (value, arg = "yes,no,maybe") => {
+  const [yes, no, maybe] = arg.split(",");
+  if (value === true)
+    return yes;
+  if (value === false)
+    return no;
+  return maybe ?? no;
+};
+var pluralize = (value, arg = "s") => {
+  const [singular, plural] = arg.includes(",") ? arg.split(",") : ["", arg];
+  const count = Number(value);
+  return count === 1 ? singular : plural;
+};
+var urlencode = (value) => encodeURIComponent(String(value));
+var urlize = (value) => {
+  const urlRegex = /(https?:\/\/[^\s]+)/g;
+  const html = String(value).replace(urlRegex, '<a href="$1">$1</a>');
+  const safeString = new String(html);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var json = (value, indent) => {
+  try {
+    const jsonStr = JSON.stringify(value, null, indent);
+    const safeString = new String(jsonStr);
+    safeString.__safe__ = true;
+    return safeString;
+  } catch {
+    return "";
+  }
+};
+var random = (value) => {
+  if (Array.isArray(value)) {
+    return value[Math.floor(Math.random() * value.length)];
+  }
+  return value;
+};
+var batch = (value, size, fillWith = null) => {
+  if (!Array.isArray(value))
+    return [[value]];
+  const result = [];
+  const numSize = Number(size) || 1;
+  for (let i = 0;i < value.length; i += numSize) {
+    const batch2 = value.slice(i, i + numSize);
+    while (fillWith !== null && batch2.length < numSize) {
+      batch2.push(fillWith);
+    }
+    result.push(batch2);
+  }
+  return result;
+};
+var groupby = (value, attribute) => {
+  if (!Array.isArray(value))
+    return [];
+  const groups = new Map;
+  for (const item of value) {
+    const key = attribute ? item[attribute] : item;
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push(item);
+  }
+  return Array.from(groups.entries()).map(([grouper, list]) => ({
+    grouper,
+    list
+  }));
+};
+var builtinFilters = {
+  upper,
+  lower,
+  capitalize,
+  capfirst,
+  title,
+  trim,
+  striptags,
+  escape,
+  e: escape,
+  safe,
+  escapejs,
+  linebreaks,
+  linebreaksbr,
+  truncatechars,
+  truncatewords,
+  wordcount,
+  center,
+  ljust,
+  rjust,
+  cut,
+  slugify,
+  abs,
+  round,
+  int,
+  float,
+  floatformat,
+  add,
+  divisibleby,
+  filesizeformat,
+  length,
+  length_is,
+  first,
+  last,
+  join,
+  slice,
+  reverse,
+  sort,
+  unique,
+  make_list,
+  dictsort,
+  dictsortreversed,
+  columns,
+  date,
+  time,
+  timesince,
+  timeuntil,
+  default: defaultFilter,
+  d: defaultFilter,
+  default_if_none,
+  yesno,
+  pluralize,
+  urlencode,
+  urlize,
+  json,
+  tojson: json,
+  random,
+  batch,
+  groupby
+};
+
+// src/tests/index.ts
+var divisibleby2 = (value, num) => {
+  const n = Number(value);
+  const d = Number(num);
+  if (d === 0)
+    return false;
+  return n % d === 0;
+};
+var even = (value) => {
+  const n = Number(value);
+  return Number.isInteger(n) && n % 2 === 0;
+};
+var odd = (value) => {
+  const n = Number(value);
+  return Number.isInteger(n) && n % 2 !== 0;
+};
+var number = (value) => {
+  return typeof value === "number" && !isNaN(value);
+};
+var integer = (value) => {
+  return Number.isInteger(value);
+};
+var float2 = (value) => {
+  return typeof value === "number" && !Number.isInteger(value) && !isNaN(value);
+};
+var gt = (value, other) => Number(value) > Number(other);
+var ge = (value, other) => Number(value) >= Number(other);
+var lt = (value, other) => Number(value) < Number(other);
+var le = (value, other) => Number(value) <= Number(other);
+var greaterthan = gt;
+var lessthan = lt;
+var defined = (value) => {
+  return value !== undefined2;
+};
+var undefined2 = (value) => {
+  return value === undefined2;
+};
+var none = (value) => {
+  return value === null;
+};
+var boolean = (value) => {
+  return typeof value === "boolean";
+};
+var string = (value) => {
+  return typeof value === "string";
+};
+var mapping = (value) => {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+};
+var iterable = (value) => {
+  if (value == null)
+    return false;
+  return typeof value === "string" || Array.isArray(value) || typeof value[Symbol.iterator] === "function";
+};
+var sequence = (value) => {
+  return Array.isArray(value) || typeof value === "string";
+};
+var callable = (value) => {
+  return typeof value === "function";
+};
+var lower2 = (value) => {
+  if (typeof value !== "string")
+    return false;
+  return value === value.toLowerCase() && value !== value.toUpperCase();
+};
+var upper2 = (value) => {
+  if (typeof value !== "string")
+    return false;
+  return value === value.toUpperCase() && value !== value.toLowerCase();
+};
+var empty = (value) => {
+  if (value == null)
+    return true;
+  if (typeof value === "string" || Array.isArray(value))
+    return value.length === 0;
+  if (typeof value === "object")
+    return Object.keys(value).length === 0;
+  return false;
+};
+var in_ = (value, container) => {
+  if (Array.isArray(container))
+    return container.includes(value);
+  if (typeof container === "string")
+    return container.includes(String(value));
+  if (typeof container === "object" && container !== null)
+    return value in container;
+  return false;
+};
+var eq = (value, other) => value === other;
+var ne = (value, other) => value !== other;
+var sameas = (value, other) => value === other;
+var equalto = eq;
+var truthy = (value) => {
+  if (value == null)
+    return false;
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value !== 0;
+  if (typeof value === "string")
+    return value.length > 0;
+  if (Array.isArray(value))
+    return value.length > 0;
+  if (typeof value === "object")
+    return Object.keys(value).length > 0;
+  return true;
+};
+var falsy = (value) => !truthy(value);
+var true_ = (value) => value === true;
+var false_ = (value) => value === false;
+var builtinTests = {
+  divisibleby: divisibleby2,
+  even,
+  odd,
+  number,
+  integer,
+  float: float2,
+  gt,
+  ge,
+  lt,
+  le,
+  greaterthan,
+  lessthan,
+  defined,
+  undefined: undefined2,
+  none,
+  boolean,
+  string,
+  mapping,
+  iterable,
+  sequence,
+  callable,
+  lower: lower2,
+  upper: upper2,
+  empty,
+  in: in_,
+  eq,
+  ne,
+  sameas,
+  equalto,
+  truthy,
+  falsy,
+  true: true_,
+  false: false_
+};
+
+// src/runtime/index.ts
+class Runtime {
+  options;
+  filters;
+  tests;
+  blocks = new Map;
+  parentTemplate = null;
+  constructor(options = {}) {
+    this.options = {
+      autoescape: options.autoescape ?? true,
+      filters: options.filters ?? {},
+      tests: options.tests ?? {},
+      globals: options.globals ?? {},
+      urlResolver: options.urlResolver ?? ((name) => `#${name}`),
+      staticResolver: options.staticResolver ?? ((path) => `/static/${path}`),
+      templateLoader: options.templateLoader ?? (async () => {
+        throw new Error("Template loader not configured");
+      })
+    };
+    this.filters = { ...builtinFilters, ...this.options.filters };
+    this.tests = { ...builtinTests, ...this.options.tests };
+  }
+  async render(ast, context = {}) {
+    const ctx = new Context({ ...this.options.globals, ...context });
+    this.blocks.clear();
+    this.parentTemplate = null;
+    await this.collectBlocks(ast, ctx);
+    if (this.parentTemplate) {
+      return this.renderTemplate(this.parentTemplate, ctx);
+    }
+    return this.renderTemplate(ast, ctx);
+  }
+  async collectBlocks(ast, ctx) {
+    for (const node of ast.body) {
+      if (node.type === "Extends") {
+        const templateName = await this.evaluate(node.template, ctx);
+        this.parentTemplate = await this.options.templateLoader(String(templateName));
+        await this.collectBlocks(this.parentTemplate, ctx);
+      } else if (node.type === "Block") {
+        this.blocks.set(node.name, node);
+      }
+    }
+  }
+  async renderTemplate(ast, ctx) {
+    const parts = [];
+    for (const node of ast.body) {
+      const result = await this.renderNode(node, ctx);
+      if (result !== null)
+        parts.push(result);
+    }
+    return parts.join("");
+  }
+  async renderNode(node, ctx) {
+    switch (node.type) {
+      case "Text":
+        return node.value;
+      case "Output":
+        return this.renderOutput(node, ctx);
+      case "If":
+        return this.renderIf(node, ctx);
+      case "For":
+        return this.renderFor(node, ctx);
+      case "Block":
+        return this.renderBlock(node, ctx);
+      case "Extends":
+        return null;
+      case "Include":
+        return this.renderInclude(node, ctx);
+      case "Set":
+        return this.renderSet(node, ctx);
+      case "With":
+        return this.renderWith(node, ctx);
+      case "Load":
+        return null;
+      case "Url":
+        return this.renderUrl(node, ctx);
+      case "Static":
+        return this.renderStatic(node, ctx);
+      default:
+        return null;
+    }
+  }
+  async renderOutput(node, ctx) {
+    const value = await this.evaluate(node.expression, ctx);
+    return this.stringify(value);
+  }
+  async renderIf(node, ctx) {
+    if (this.isTruthy(await this.evaluate(node.test, ctx))) {
+      return this.renderNodes(node.body, ctx);
+    }
+    for (const elif of node.elifs) {
+      if (this.isTruthy(await this.evaluate(elif.test, ctx))) {
+        return this.renderNodes(elif.body, ctx);
+      }
+    }
+    if (node.else_.length > 0) {
+      return this.renderNodes(node.else_, ctx);
+    }
+    return "";
+  }
+  async renderFor(node, ctx) {
+    const iterable2 = await this.evaluate(node.iter, ctx);
+    const items = this.toIterable(iterable2);
+    if (items.length === 0) {
+      return this.renderNodes(node.else_, ctx);
+    }
+    const parts = [];
+    ctx.push();
+    for (let i = 0;i < items.length; i++) {
+      const item = items[i];
+      if (Array.isArray(node.target)) {
+        let values;
+        if (Array.isArray(item)) {
+          values = item;
+        } else if (item && typeof item === "object" && (("0" in item) || ("key" in item))) {
+          values = [item[0] ?? item.key, item[1] ?? item.value];
+        } else {
+          values = [item, item];
+        }
+        node.target.forEach((name, idx) => {
+          ctx.set(name, values[idx]);
+        });
+      } else {
+        ctx.set(node.target, item);
+      }
+      ctx.pushForLoop(items, i);
+      const result = await this.renderNodes(node.body, ctx);
+      parts.push(result);
+      ctx.popForLoop();
+    }
+    ctx.pop();
+    return parts.join("");
+  }
+  async renderBlock(node, ctx) {
+    const blockToRender = this.blocks.get(node.name) || node;
+    ctx.push();
+    ctx.set("block", {
+      super: async () => {
+        return this.renderNodes(node.body, ctx);
+      }
+    });
+    const result = await this.renderNodes(blockToRender.body, ctx);
+    ctx.pop();
+    return result;
+  }
+  async renderInclude(node, ctx) {
+    try {
+      const templateName = await this.evaluate(node.template, ctx);
+      const template = await this.options.templateLoader(String(templateName));
+      let includeCtx;
+      if (node.only) {
+        includeCtx = new Context(node.context ? await this.evaluateObject(node.context, ctx) : {});
+      } else {
+        const additional = node.context ? await this.evaluateObject(node.context, ctx) : {};
+        includeCtx = ctx.derived(additional);
+      }
+      return this.renderTemplate(template, includeCtx);
+    } catch (error) {
+      if (node.ignoreMissing)
+        return "";
+      throw error;
+    }
+  }
+  async renderSet(node, ctx) {
+    const value = await this.evaluate(node.value, ctx);
+    ctx.set(node.target, value);
+    return "";
+  }
+  async renderWith(node, ctx) {
+    ctx.push();
+    for (const { target, value } of node.assignments) {
+      ctx.set(target, await this.evaluate(value, ctx));
+    }
+    const result = await this.renderNodes(node.body, ctx);
+    ctx.pop();
+    return result;
+  }
+  async renderUrl(node, ctx) {
+    const name = await this.evaluate(node.name, ctx);
+    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
+    const kwargs = await this.evaluateObject(node.kwargs, ctx);
+    const url = this.options.urlResolver(String(name), args, kwargs);
+    if (node.asVar) {
+      ctx.set(node.asVar, url);
+      return "";
+    }
+    return url;
+  }
+  async renderStatic(node, ctx) {
+    const path = await this.evaluate(node.path, ctx);
+    const url = this.options.staticResolver(String(path));
+    if (node.asVar) {
+      ctx.set(node.asVar, url);
+      return "";
+    }
+    return url;
+  }
+  async renderNodes(nodes2, ctx) {
+    const parts = [];
+    for (const node of nodes2) {
+      const result = await this.renderNode(node, ctx);
+      if (result !== null)
+        parts.push(result);
+    }
+    return parts.join("");
+  }
+  async evaluate(node, ctx) {
+    switch (node.type) {
+      case "Literal":
+        return node.value;
+      case "Name":
+        return ctx.get(node.name);
+      case "GetAttr":
+        return this.evaluateGetAttr(node, ctx);
+      case "GetItem":
+        return this.evaluateGetItem(node, ctx);
+      case "FilterExpr":
+        return this.evaluateFilter(node, ctx);
+      case "BinaryOp":
+        return this.evaluateBinaryOp(node, ctx);
+      case "UnaryOp":
+        return this.evaluateUnaryOp(node, ctx);
+      case "Compare":
+        return this.evaluateCompare(node, ctx);
+      case "Conditional":
+        return this.evaluateConditional(node, ctx);
+      case "Array":
+        return Promise.all(node.elements.map((el) => this.evaluate(el, ctx)));
+      case "Object":
+        return this.evaluateObjectLiteral(node, ctx);
+      case "FunctionCall":
+        return this.evaluateFunctionCall(node, ctx);
+      case "TestExpr":
+        return this.evaluateTest(node, ctx);
+      default:
+        return;
+    }
+  }
+  async evaluateTest(node, ctx) {
+    if (node.test === "defined" || node.test === "undefined") {
+      let isDefined = false;
+      if (node.node.type === "Name") {
+        isDefined = ctx.has(node.node.name);
+      } else {
+        const value2 = await this.evaluate(node.node, ctx);
+        isDefined = value2 !== undefined;
+      }
+      const result2 = node.test === "defined" ? isDefined : !isDefined;
+      return node.negated ? !result2 : result2;
+    }
+    const value = await this.evaluate(node.node, ctx);
+    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
+    const test = this.tests[node.test];
+    if (!test) {
+      throw new Error(`Unknown test: ${node.test}`);
+    }
+    const result = test(value, ...args);
+    return node.negated ? !result : result;
+  }
+  async evaluateGetAttr(node, ctx) {
+    const obj = await this.evaluate(node.object, ctx);
+    if (obj == null)
+      return;
+    const numIndex = parseInt(node.attribute, 10);
+    if (!isNaN(numIndex) && Array.isArray(obj)) {
+      return obj[numIndex];
+    }
+    if (typeof obj === "object" && node.attribute in obj) {
+      const value = obj[node.attribute];
+      if (typeof value === "function") {
+        return value.call(obj);
+      }
+      return value;
+    }
+    if (typeof obj[node.attribute] === "function") {
+      return obj[node.attribute].bind(obj);
+    }
+    return;
+  }
+  async evaluateGetItem(node, ctx) {
+    const obj = await this.evaluate(node.object, ctx);
+    const index = await this.evaluate(node.index, ctx);
+    if (obj == null)
+      return;
+    return obj[index];
+  }
+  async evaluateFilter(node, ctx) {
+    const value = await this.evaluate(node.node, ctx);
+    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
+    const kwargs = await this.evaluateObject(node.kwargs, ctx);
+    const filter = this.filters[node.filter];
+    if (!filter) {
+      throw new Error(`Unknown filter: ${node.filter}`);
+    }
+    return filter(value, ...args, ...Object.values(kwargs));
+  }
+  async evaluateBinaryOp(node, ctx) {
+    const left = await this.evaluate(node.left, ctx);
+    if (node.operator === "and") {
+      return this.isTruthy(left) ? await this.evaluate(node.right, ctx) : left;
+    }
+    if (node.operator === "or") {
+      return this.isTruthy(left) ? left : await this.evaluate(node.right, ctx);
+    }
+    const right = await this.evaluate(node.right, ctx);
+    switch (node.operator) {
+      case "+":
+        return typeof left === "string" || typeof right === "string" ? String(left) + String(right) : Number(left) + Number(right);
+      case "-":
+        return Number(left) - Number(right);
+      case "*":
+        return Number(left) * Number(right);
+      case "/":
+        const divisor = Number(right);
+        if (divisor === 0)
+          return 0;
+        return Number(left) / divisor;
+      case "%":
+        return Number(left) % Number(right);
+      case "~":
+        return String(left) + String(right);
+      default:
+        return;
+    }
+  }
+  async evaluateUnaryOp(node, ctx) {
+    const operand = await this.evaluate(node.operand, ctx);
+    switch (node.operator) {
+      case "not":
+        return !this.isTruthy(operand);
+      case "-":
+        return -Number(operand);
+      case "+":
+        return +Number(operand);
+      default:
+        return operand;
+    }
+  }
+  async evaluateCompare(node, ctx) {
+    let left = await this.evaluate(node.left, ctx);
+    for (const { operator, right: rightNode } of node.ops) {
+      const right = await this.evaluate(rightNode, ctx);
+      let result;
+      switch (operator) {
+        case "==":
+          result = left === right;
+          break;
+        case "!=":
+          result = left !== right;
+          break;
+        case "<":
+          result = left < right;
+          break;
+        case ">":
+          result = left > right;
+          break;
+        case "<=":
+          result = left <= right;
+          break;
+        case ">=":
+          result = left >= right;
+          break;
+        case "in":
+          result = this.isIn(left, right);
+          break;
+        case "not in":
+          result = !this.isIn(left, right);
+          break;
+        case "is":
+          result = left === right;
+          break;
+        case "is not":
+          result = left !== right;
+          break;
+        default:
+          result = false;
+      }
+      if (!result)
+        return false;
+      left = right;
+    }
+    return true;
+  }
+  async evaluateConditional(node, ctx) {
+    const test = await this.evaluate(node.test, ctx);
+    return this.isTruthy(test) ? await this.evaluate(node.trueExpr, ctx) : await this.evaluate(node.falseExpr, ctx);
+  }
+  async evaluateObjectLiteral(node, ctx) {
+    const result = {};
+    for (const { key, value } of node.pairs) {
+      const k = await this.evaluate(key, ctx);
+      result[String(k)] = await this.evaluate(value, ctx);
+    }
+    return result;
+  }
+  async evaluateFunctionCall(node, ctx) {
+    const callee = await this.evaluate(node.callee, ctx);
+    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
+    const kwargs = await this.evaluateObject(node.kwargs, ctx);
+    if (typeof callee === "function") {
+      return callee(...args, kwargs);
+    }
+    return;
+  }
+  async evaluateObject(obj, ctx) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = await this.evaluate(value, ctx);
+    }
+    return result;
+  }
+  stringify(value) {
+    if (value == null)
+      return "";
+    if (typeof value === "boolean")
+      return value ? "True" : "False";
+    const str = String(value);
+    if (value.__safe__)
+      return str;
+    if (this.options.autoescape) {
+      return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+    }
+    return str;
+  }
+  isTruthy(value) {
+    if (value == null)
+      return false;
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value !== 0;
+    if (typeof value === "string")
+      return value.length > 0;
+    if (Array.isArray(value))
+      return value.length > 0;
+    if (typeof value === "object")
+      return Object.keys(value).length > 0;
+    return true;
+  }
+  isIn(needle, haystack) {
+    if (Array.isArray(haystack))
+      return haystack.includes(needle);
+    if (typeof haystack === "string")
+      return haystack.includes(String(needle));
+    if (typeof haystack === "object" && haystack !== null)
+      return needle in haystack;
+    return false;
+  }
+  toIterable(value) {
+    if (Array.isArray(value))
+      return value;
+    if (value == null)
+      return [];
+    if (typeof value === "string")
+      return value.split("");
+    if (typeof value === "object") {
+      if (typeof value[Symbol.iterator] === "function") {
+        return Array.from(value);
+      }
+      return Object.entries(value).map(([k, v]) => ({ key: k, value: v, 0: k, 1: v }));
+    }
+    return [value];
+  }
+  addFilter(name, fn) {
+    this.filters[name] = fn;
+  }
+  addTest(name, fn) {
+    this.tests[name] = fn;
+  }
+  addGlobal(name, value) {
+    this.options.globals[name] = value;
+  }
+}
+
+// src/index.ts
+import * as fs from "fs";
+import * as path from "path";
+
+class Environment {
+  options;
+  runtime;
+  templateCache = new Map;
+  routes = new Map;
+  constructor(options = {}) {
+    this.options = {
+      templates: options.templates ?? "./templates",
+      autoescape: options.autoescape ?? true,
+      filters: options.filters ?? {},
+      globals: options.globals ?? {},
+      urlResolver: options.urlResolver ?? this.defaultUrlResolver.bind(this),
+      staticResolver: options.staticResolver ?? this.defaultStaticResolver.bind(this),
+      cache: options.cache ?? true,
+      extensions: options.extensions ?? [".html", ".jinja", ".jinja2", ""]
+    };
+    this.runtime = new Runtime({
+      autoescape: this.options.autoescape,
+      filters: this.options.filters,
+      globals: this.options.globals,
+      urlResolver: this.options.urlResolver,
+      staticResolver: this.options.staticResolver,
+      templateLoader: this.loadTemplate.bind(this)
+    });
+  }
+  async render(templateName, context = {}) {
+    const ast = await this.loadTemplate(templateName);
+    return this.runtime.render(ast, context);
+  }
+  async renderString(source, context = {}) {
+    const ast = this.compile(source);
+    return this.runtime.render(ast, context);
+  }
+  compile(source) {
+    const lexer = new Lexer(source);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(tokens);
+    return parser.parse();
+  }
+  async loadTemplate(templateName) {
+    if (this.options.cache && this.templateCache.has(templateName)) {
+      return this.templateCache.get(templateName);
+    }
+    const templatePath = await this.resolveTemplatePath(templateName);
+    if (!templatePath) {
+      throw new Error(`Template not found: ${templateName}`);
+    }
+    const source = await fs.promises.readFile(templatePath, "utf-8");
+    const ast = this.compile(source);
+    if (this.options.cache) {
+      this.templateCache.set(templateName, ast);
+    }
+    return ast;
+  }
+  clearCache() {
+    this.templateCache.clear();
+  }
+  addFilter(name, fn) {
+    this.runtime.addFilter(name, fn);
+  }
+  addGlobal(name, value) {
+    this.runtime.addGlobal(name, value);
+  }
+  addUrl(name, pattern) {
+    this.routes.set(name, pattern);
+  }
+  addUrls(routes) {
+    for (const [name, pattern] of Object.entries(routes)) {
+      this.routes.set(name, pattern);
+    }
+  }
+  async resolveTemplatePath(templateName) {
+    const basePath = path.resolve(this.options.templates, templateName);
+    for (const ext of this.options.extensions) {
+      const fullPath = basePath + ext;
+      try {
+        await fs.promises.access(fullPath, fs.constants.R_OK);
+        return fullPath;
+      } catch {}
+    }
+    return null;
+  }
+  defaultUrlResolver(name, args, kwargs) {
+    const pattern = this.routes.get(name);
+    if (!pattern) {
+      console.warn(`URL pattern not found: ${name}`);
+      return `#${name}`;
+    }
+    let url = pattern;
+    for (const [key, value] of Object.entries(kwargs)) {
+      url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+      url = url.replace(`<${key}>`, encodeURIComponent(String(value)));
+      url = url.replace(`(?P<${key}>[^/]+)`, encodeURIComponent(String(value)));
+    }
+    let argIndex = 0;
+    url = url.replace(/<[^>]+>|:[a-zA-Z_]+|\(\?P<[^>]+>\[[^\]]+\]\)/g, () => {
+      if (argIndex < args.length) {
+        return encodeURIComponent(String(args[argIndex++]));
+      }
+      return "";
+    });
+    return url;
+  }
+  defaultStaticResolver(filePath) {
+    return `/static/${filePath}`;
+  }
+}
+async function render(source, context = {}, options = {}) {
+  const env = new Environment(options);
+  return env.renderString(source, context);
+}
+function Template(source, options = {}) {
+  const env = new Environment(options);
+  const ast = env.compile(source);
+  return {
+    async render(context = {}) {
+      const runtime = new Runtime({
+        autoescape: options.autoescape ?? true,
+        filters: options.filters ?? {},
+        globals: options.globals ?? {},
+        urlResolver: options.urlResolver,
+        staticResolver: options.staticResolver,
+        templateLoader: async () => ast
+      });
+      return runtime.render(ast, context);
+    }
+  };
+}
+export {
+  render,
+  builtinFilters,
+  TokenType,
+  Template,
+  Runtime,
+  Parser,
+  Lexer,
+  Environment,
+  Context
+};