@huggingface/transformers 3.6.2 → 3.6.3

package/dist/transformers.web.js

@@ -111,15 +111,11 @@ var TOKEN_TYPES = Object.freeze({
   Text: "Text",
   // The text between Jinja statements or expressions
   NumericLiteral: "NumericLiteral",
-  // e.g., 123
-  BooleanLiteral: "BooleanLiteral",
-  // true or false
-  NullLiteral: "NullLiteral",
-  // none
+  // e.g., 123, 1.0
   StringLiteral: "StringLiteral",
   // 'string'
   Identifier: "Identifier",
-  // Variables, functions, etc.
+  // Variables, functions, statements, booleans, etc.
   Equals: "Equals",
   // =
   OpenParen: "OpenParen",
@@ -153,63 +149,15 @@ var TOKEN_TYPES = Object.freeze({
   CallOperator: "CallOperator",
   // ()
   AdditiveBinaryOperator: "AdditiveBinaryOperator",
-  // + -
+  // + - ~
   MultiplicativeBinaryOperator: "MultiplicativeBinaryOperator",
   // * / %
   ComparisonBinaryOperator: "ComparisonBinaryOperator",
   // < > <= >= == !=
   UnaryOperator: "UnaryOperator",
   // ! - +
-  // Keywords
-  Set: "Set",
-  If: "If",
-  For: "For",
-  In: "In",
-  Is: "Is",
-  NotIn: "NotIn",
-  Else: "Else",
-  EndSet: "EndSet",
-  EndIf: "EndIf",
-  ElseIf: "ElseIf",
-  EndFor: "EndFor",
-  And: "And",
-  Or: "Or",
-  Not: "UnaryOperator",
-  Macro: "Macro",
-  EndMacro: "EndMacro",
-  Break: "Break",
-  Continue: "Continue"
-});
-var KEYWORDS = Object.freeze({
-  set: TOKEN_TYPES.Set,
-  for: TOKEN_TYPES.For,
-  in: TOKEN_TYPES.In,
-  is: TOKEN_TYPES.Is,
-  if: TOKEN_TYPES.If,
-  else: TOKEN_TYPES.Else,
-  endset: TOKEN_TYPES.EndSet,
-  endif: TOKEN_TYPES.EndIf,
-  elif: TOKEN_TYPES.ElseIf,
-  endfor: TOKEN_TYPES.EndFor,
-  and: TOKEN_TYPES.And,
-  or: TOKEN_TYPES.Or,
-  not: TOKEN_TYPES.Not,
-  "not in": TOKEN_TYPES.NotIn,
-  macro: TOKEN_TYPES.Macro,
-  endmacro: TOKEN_TYPES.EndMacro,
-  break: TOKEN_TYPES.Break,
-  continue: TOKEN_TYPES.Continue,
-  // Literals
-  true: TOKEN_TYPES.BooleanLiteral,
-  false: TOKEN_TYPES.BooleanLiteral,
-  none: TOKEN_TYPES.NullLiteral,
-  // NOTE: According to the Jinja docs: The special constants true, false, and none are indeed lowercase.
-  // Because that caused confusion in the past, (True used to expand to an undefined variable that was considered false),
-  // all three can now also be written in title case (True, False, and None). However, for consistency, (all Jinja identifiers are lowercase)
-  // you should use the lowercase versions.
-  True: TOKEN_TYPES.BooleanLiteral,
-  False: TOKEN_TYPES.BooleanLiteral,
-  None: TOKEN_TYPES.NullLiteral
+  Comment: "Comment"
+  // {# ... #}
 });
 var Token = class {
   /**
@@ -255,6 +203,7 @@ var ORDERED_MAPPING_TABLE = [
   // Arithmetic operators
   ["+", TOKEN_TYPES.AdditiveBinaryOperator],
   ["-", TOKEN_TYPES.AdditiveBinaryOperator],
+  ["~", TOKEN_TYPES.AdditiveBinaryOperator],
   ["*", TOKEN_TYPES.MultiplicativeBinaryOperator],
   ["/", TOKEN_TYPES.MultiplicativeBinaryOperator],
   ["%", TOKEN_TYPES.MultiplicativeBinaryOperator],
@@ -285,19 +234,19 @@ function preprocess(template, options = {}) {
   if (template.endsWith("\n")) {
     template = template.slice(0, -1);
   }
-  template = template.replace(/{#.*?#}/gs, "{##}");
   if (options.lstrip_blocks) {
-    template = template.replace(/^[ \t]*({[#%])/gm, "$1");
+    template = template.replace(/^[ \t]*({[#%-])/gm, "$1");
   }
   if (options.trim_blocks) {
-    template = template.replace(/([#%]})\n/g, "$1");
+    template = template.replace(/([#%-]})\n/g, "$1");
   }
-  return template.replace(/{##}/g, "").replace(/-%}\s*/g, "%}").replace(/\s*{%-/g, "{%").replace(/-}}\s*/g, "}}").replace(/\s*{{-/g, "{{");
+  return template.replace(/-%}\s*/g, "%}").replace(/\s*{%-/g, "{%").replace(/-}}\s*/g, "}}").replace(/\s*{{-/g, "{{").replace(/-#}\s*/g, "#}").replace(/\s*{#-/g, "{#").replace(/{%\s*(end)?generation\s*%}/gs, "");
 }
 function tokenize(source, options = {}) {
   const tokens = [];
   const src = preprocess(source, options);
   let cursorPosition = 0;
+  let curlyBracketDepth = 0;
   const consumeWhile = (predicate) => {
     let str = "";
     while (predicate(src[cursorPosition])) {
@@ -322,10 +271,10 @@ function tokenize(source, options = {}) {
   main:
     while (cursorPosition < src.length) {
       const lastTokenType = tokens.at(-1)?.type;
-      if (lastTokenType === void 0 || lastTokenType === TOKEN_TYPES.CloseStatement || lastTokenType === TOKEN_TYPES.CloseExpression) {
+      if (lastTokenType === void 0 || lastTokenType === TOKEN_TYPES.CloseStatement || lastTokenType === TOKEN_TYPES.CloseExpression || lastTokenType === TOKEN_TYPES.Comment) {
         let text = "";
         while (cursorPosition < src.length && // Keep going until we hit the next Jinja statement or expression
-        !(src[cursorPosition] === "{" && (src[cursorPosition + 1] === "%" || src[cursorPosition + 1] === "{"))) {
+        !(src[cursorPosition] === "{" && (src[cursorPosition + 1] === "%" || src[cursorPosition + 1] === "{" || src[cursorPosition + 1] === "#"))) {
           text += src[cursorPosition++];
         }
         if (text.length > 0) {
@@ -333,6 +282,19 @@ function tokenize(source, options = {}) {
           continue;
         }
       }
+      if (src[cursorPosition] === "{" && src[cursorPosition + 1] === "#") {
+        cursorPosition += 2;
+        let comment = "";
+        while (src[cursorPosition] !== "#" || src[cursorPosition + 1] !== "}") {
+          if (cursorPosition + 2 >= src.length) {
+            throw new SyntaxError("Missing end of comment tag");
+          }
+          comment += src[cursorPosition++];
+        }
+        tokens.push(new Token(comment, TOKEN_TYPES.Comment));
+        cursorPosition += 2;
+        continue;
+      }
       consumeWhile((char2) => /\s/.test(char2));
       const char = src[cursorPosition];
       if (char === "-" || char === "+") {
@@ -343,8 +305,6 @@ function tokenize(source, options = {}) {
         switch (lastTokenType2) {
           case TOKEN_TYPES.Identifier:
           case TOKEN_TYPES.NumericLiteral:
-          case TOKEN_TYPES.BooleanLiteral:
-          case TOKEN_TYPES.NullLiteral:
           case TOKEN_TYPES.StringLiteral:
           case TOKEN_TYPES.CloseParen:
           case TOKEN_TYPES.CloseSquareBracket:
@@ -359,11 +319,21 @@ function tokenize(source, options = {}) {
           }
         }
       }
-      for (const [char2, token] of ORDERED_MAPPING_TABLE) {
-        const slice2 = src.slice(cursorPosition, cursorPosition + char2.length);
-        if (slice2 === char2) {
-          tokens.push(new Token(char2, token));
-          cursorPosition += char2.length;
+      for (const [seq, type] of ORDERED_MAPPING_TABLE) {
+        if (seq === "}}" && curlyBracketDepth > 0) {
+          continue;
+        }
+        const slice2 = src.slice(cursorPosition, cursorPosition + seq.length);
+        if (slice2 === seq) {
+          tokens.push(new Token(seq, type));
+          if (type === TOKEN_TYPES.OpenExpression) {
+            curlyBracketDepth = 0;
+          } else if (type === TOKEN_TYPES.OpenCurlyBracket) {
+            ++curlyBracketDepth;
+          } else if (type === TOKEN_TYPES.CloseCurlyBracket) {
+            --curlyBracketDepth;
+          }
+          cursorPosition += seq.length;
           continue main;
         }
       }
@@ -375,19 +345,18 @@ function tokenize(source, options = {}) {
         continue;
       }
       if (isInteger(char)) {
-        const num = consumeWhile(isInteger);
+        let num = consumeWhile(isInteger);
+        if (src[cursorPosition] === "." && isInteger(src[cursorPosition + 1])) {
+          ++cursorPosition;
+          const frac = consumeWhile(isInteger);
+          num = `${num}.${frac}`;
+        }
         tokens.push(new Token(num, TOKEN_TYPES.NumericLiteral));
         continue;
       }
       if (isWord(char)) {
         const word = consumeWhile(isWord);
-        const type = Object.hasOwn(KEYWORDS, word) ? KEYWORDS[word] : TOKEN_TYPES.Identifier;
-        if (type === TOKEN_TYPES.In && tokens.at(-1)?.type === TOKEN_TYPES.Not) {
-          tokens.pop();
-          tokens.push(new Token("not in", TOKEN_TYPES.NotIn));
-        } else {
-          tokens.push(new Token(word, type));
-        }
+        tokens.push(new Token(word, TOKEN_TYPES.Identifier));
         continue;
       }
       throw new SyntaxError(`Unexpected character: ${char}`);
@@ -449,6 +418,13 @@ var Macro = class extends Statement {
   }
   type = "Macro";
 };
+var Comment = class extends Statement {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  type = "Comment";
+};
 var Expression = class extends Statement {
   type = "Expression";
 };
@@ -486,18 +462,15 @@ var Literal = class extends Expression {
   }
   type = "Literal";
 };
-var NumericLiteral = class extends Literal {
-  type = "NumericLiteral";
+var IntegerLiteral = class extends Literal {
+  type = "IntegerLiteral";
+};
+var FloatLiteral = class extends Literal {
+  type = "FloatLiteral";
 };
 var StringLiteral = class extends Literal {
   type = "StringLiteral";
 };
-var BooleanLiteral = class extends Literal {
-  type = "BooleanLiteral";
-};
-var NullLiteral = class extends Literal {
-  type = "NullLiteral";
-};
 var ArrayLiteral = class extends Literal {
   type = "ArrayLiteral";
 };
@@ -524,10 +497,18 @@ var FilterExpression = class extends Expression {
   }
   type = "FilterExpression";
 };
+var FilterStatement = class extends Statement {
+  constructor(filter, body) {
+    super();
+    this.filter = filter;
+    this.body = body;
+  }
+  type = "FilterStatement";
+};
 var SelectExpression = class extends Expression {
-  constructor(iterable, test) {
+  constructor(lhs, test) {
     super();
-    this.iterable = iterable;
+    this.lhs = lhs;
     this.test = test;
   }
   type = "SelectExpression";
@@ -566,6 +547,31 @@ var KeywordArgumentExpression = class extends Expression {
   }
   type = "KeywordArgumentExpression";
 };
+var SpreadExpression = class extends Expression {
+  constructor(argument) {
+    super();
+    this.argument = argument;
+  }
+  type = "SpreadExpression";
+};
+var CallStatement = class extends Statement {
+  constructor(call, callerArgs, body) {
+    super();
+    this.call = call;
+    this.callerArgs = callerArgs;
+    this.body = body;
+  }
+  type = "CallStatement";
+};
+var Ternary = class extends Expression {
+  constructor(condition, trueExpr, falseExpr) {
+    super();
+    this.condition = condition;
+    this.trueExpr = trueExpr;
+    this.falseExpr = falseExpr;
+  }
+  type = "Ternary";
+};
 
 // src/parser.ts
 function parse(tokens) {
@@ -578,8 +584,16 @@ function parse(tokens) {
     }
     return prev;
   }
+  function expectIdentifier(name) {
+    if (!isIdentifier(name)) {
+      throw new SyntaxError(`Expected ${name}`);
+    }
+    ++current;
+  }
   function parseAny() {
     switch (tokens[current].type) {
+      case TOKEN_TYPES.Comment:
+        return new Comment(tokens[current++].value);
       case TOKEN_TYPES.Text:
         return parseText();
       case TOKEN_TYPES.OpenStatement:
@@ -590,57 +604,103 @@ function parse(tokens) {
         throw new SyntaxError(`Unexpected token type: ${tokens[current].type}`);
     }
   }
-  function not(...types) {
-    return current + types.length <= tokens.length && types.some((type, i) => type !== tokens[current + i].type);
-  }
   function is(...types) {
     return current + types.length <= tokens.length && types.every((type, i) => type === tokens[current + i].type);
   }
+  function isStatement(...names) {
+    return tokens[current]?.type === TOKEN_TYPES.OpenStatement && tokens[current + 1]?.type === TOKEN_TYPES.Identifier && names.includes(tokens[current + 1]?.value);
+  }
+  function isIdentifier(...names) {
+    return current + names.length <= tokens.length && names.every((name, i) => tokens[current + i].type === "Identifier" && name === tokens[current + i].value);
+  }
   function parseText() {
     return new StringLiteral(expect(TOKEN_TYPES.Text, "Expected text token").value);
   }
   function parseJinjaStatement() {
     expect(TOKEN_TYPES.OpenStatement, "Expected opening statement token");
+    if (tokens[current].type !== TOKEN_TYPES.Identifier) {
+      throw new SyntaxError(`Unknown statement, got ${tokens[current].type}`);
+    }
+    const name = tokens[current].value;
     let result;
-    switch (tokens[current].type) {
-      case TOKEN_TYPES.Set:
+    switch (name) {
+      case "set":
         ++current;
         result = parseSetStatement();
-        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
         break;
-      case TOKEN_TYPES.If:
+      case "if":
         ++current;
         result = parseIfStatement();
         expect(TOKEN_TYPES.OpenStatement, "Expected {% token");
-        expect(TOKEN_TYPES.EndIf, "Expected endif token");
+        expectIdentifier("endif");
         expect(TOKEN_TYPES.CloseStatement, "Expected %} token");
         break;
-      case TOKEN_TYPES.Macro:
+      case "macro":
         ++current;
         result = parseMacroStatement();
         expect(TOKEN_TYPES.OpenStatement, "Expected {% token");
-        expect(TOKEN_TYPES.EndMacro, "Expected endmacro token");
+        expectIdentifier("endmacro");
         expect(TOKEN_TYPES.CloseStatement, "Expected %} token");
         break;
-      case TOKEN_TYPES.For:
+      case "for":
         ++current;
         result = parseForStatement();
         expect(TOKEN_TYPES.OpenStatement, "Expected {% token");
-        expect(TOKEN_TYPES.EndFor, "Expected endfor token");
+        expectIdentifier("endfor");
         expect(TOKEN_TYPES.CloseStatement, "Expected %} token");
         break;
-      case TOKEN_TYPES.Break:
+      case "call": {
+        ++current;
+        let callerArgs = null;
+        if (is(TOKEN_TYPES.OpenParen)) {
+          callerArgs = parseArgs();
+        }
+        const callee = parsePrimaryExpression();
+        if (callee.type !== "Identifier") {
+          throw new SyntaxError(`Expected identifier following call statement`);
+        }
+        const callArgs = parseArgs();
+        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+        const body = [];
+        while (!isStatement("endcall")) {
+          body.push(parseAny());
+        }
+        expect(TOKEN_TYPES.OpenStatement, "Expected '{%'");
+        expectIdentifier("endcall");
+        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+        const callExpr = new CallExpression(callee, callArgs);
+        result = new CallStatement(callExpr, callerArgs, body);
+        break;
+      }
+      case "break":
         ++current;
         expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
         result = new Break();
         break;
-      case TOKEN_TYPES.Continue:
+      case "continue":
         ++current;
         expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
         result = new Continue();
         break;
+      case "filter": {
+        ++current;
+        let filterNode = parsePrimaryExpression();
+        if (filterNode instanceof Identifier && is(TOKEN_TYPES.OpenParen)) {
+          filterNode = parseCallExpression(filterNode);
+        }
+        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+        const filterBody = [];
+        while (!isStatement("endfilter")) {
+          filterBody.push(parseAny());
+        }
+        expect(TOKEN_TYPES.OpenStatement, "Expected '{%'");
+        expectIdentifier("endfilter");
+        expect(TOKEN_TYPES.CloseStatement, "Expected '%}'");
+        result = new FilterStatement(filterNode, filterBody);
+        break;
+      }
       default:
-        throw new SyntaxError(`Unknown statement type: ${tokens[current].type}`);
+        throw new SyntaxError(`Unknown statement type: ${name}`);
     }
     return result;
   }
@@ -651,42 +711,42 @@ function parse(tokens) {
     return result;
   }
   function parseSetStatement() {
-    const left = parseExpression();
+    const left = parseExpressionSequence();
+    let value = null;
+    const body = [];
     if (is(TOKEN_TYPES.Equals)) {
       ++current;
-      const value = parseExpression();
-      return new SetStatement(left, value, []);
+      value = parseExpressionSequence();
     } else {
-      const body = [];
       expect(TOKEN_TYPES.CloseStatement, "Expected %} token");
-      while (!(tokens[current]?.type === TOKEN_TYPES.OpenStatement && tokens[current + 1]?.type === TOKEN_TYPES.EndSet)) {
-        const another = parseAny();
-        body.push(another);
+      while (!isStatement("endset")) {
+        body.push(parseAny());
       }
       expect(TOKEN_TYPES.OpenStatement, "Expected {% token");
-      expect(TOKEN_TYPES.EndSet, "Expected endset token");
-      return new SetStatement(left, null, body);
+      expectIdentifier("endset");
     }
+    expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+    return new SetStatement(left, value, body);
   }
   function parseIfStatement() {
     const test = parseExpression();
     expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
     const body = [];
     const alternate = [];
-    while (!(tokens[current]?.type === TOKEN_TYPES.OpenStatement && (tokens[current + 1]?.type === TOKEN_TYPES.ElseIf || tokens[current + 1]?.type === TOKEN_TYPES.Else || tokens[current + 1]?.type === TOKEN_TYPES.EndIf))) {
+    while (!isStatement("elif", "else", "endif")) {
       body.push(parseAny());
     }
-    if (tokens[current]?.type === TOKEN_TYPES.OpenStatement && tokens[current + 1]?.type !== TOKEN_TYPES.EndIf) {
+    if (isStatement("elif")) {
       ++current;
-      if (is(TOKEN_TYPES.ElseIf)) {
-        expect(TOKEN_TYPES.ElseIf, "Expected elseif token");
-        alternate.push(parseIfStatement());
-      } else {
-        expect(TOKEN_TYPES.Else, "Expected else token");
-        expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
-        while (!(tokens[current]?.type === TOKEN_TYPES.OpenStatement && tokens[current + 1]?.type === TOKEN_TYPES.EndIf)) {
-          alternate.push(parseAny());
-        }
+      ++current;
+      const result = parseIfStatement();
+      alternate.push(result);
+    } else if (isStatement("else")) {
+      ++current;
+      ++current;
+      expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
+      while (!isStatement("endif")) {
+        alternate.push(parseAny());
       }
     }
     return new If(test, body, alternate);
@@ -699,7 +759,7 @@ function parse(tokens) {
     const args = parseArgs();
     expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
     const body = [];
-    while (not(TOKEN_TYPES.OpenStatement, TOKEN_TYPES.EndMacro)) {
+    while (!isStatement("endmacro")) {
       body.push(parseAny());
     }
     return new Macro(name, args, body);
@@ -722,19 +782,22 @@ function parse(tokens) {
     if (!(loopVariable instanceof Identifier || loopVariable instanceof TupleLiteral)) {
       throw new SyntaxError(`Expected identifier/tuple for the loop variable, got ${loopVariable.type} instead`);
     }
-    expect(TOKEN_TYPES.In, "Expected `in` keyword following loop variable");
+    if (!isIdentifier("in")) {
+      throw new SyntaxError("Expected `in` keyword following loop variable");
+    }
+    ++current;
     const iterable = parseExpression();
     expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
     const body = [];
-    while (not(TOKEN_TYPES.OpenStatement, TOKEN_TYPES.EndFor) && not(TOKEN_TYPES.OpenStatement, TOKEN_TYPES.Else)) {
+    while (!isStatement("endfor", "else")) {
       body.push(parseAny());
     }
     const alternative = [];
-    if (is(TOKEN_TYPES.OpenStatement, TOKEN_TYPES.Else)) {
+    if (isStatement("else")) {
       ++current;
       ++current;
       expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
-      while (not(TOKEN_TYPES.OpenStatement, TOKEN_TYPES.EndFor)) {
+      while (!isStatement("endfor")) {
         alternative.push(parseAny());
       }
     }
@@ -745,22 +808,22 @@ function parse(tokens) {
   }
   function parseIfExpression() {
     const a = parseLogicalOrExpression();
-    if (is(TOKEN_TYPES.If)) {
+    if (isIdentifier("if")) {
       ++current;
-      const predicate = parseLogicalOrExpression();
-      if (is(TOKEN_TYPES.Else)) {
+      const test = parseLogicalOrExpression();
+      if (isIdentifier("else")) {
         ++current;
-        const b = parseLogicalOrExpression();
-        return new If(predicate, [a], [b]);
+        const falseExpr = parseIfExpression();
+        return new Ternary(test, a, falseExpr);
       } else {
-        return new SelectExpression(a, predicate);
+        return new SelectExpression(a, test);
       }
     }
     return a;
   }
   function parseLogicalOrExpression() {
     let left = parseLogicalAndExpression();
-    while (is(TOKEN_TYPES.Or)) {
+    while (isIdentifier("or")) {
       const operator = tokens[current];
       ++current;
       const right = parseLogicalAndExpression();
@@ -770,7 +833,7 @@ function parse(tokens) {
   }
   function parseLogicalAndExpression() {
     let left = parseLogicalNegationExpression();
-    while (is(TOKEN_TYPES.And)) {
+    while (isIdentifier("and")) {
       const operator = tokens[current];
       ++current;
       const right = parseLogicalNegationExpression();
@@ -780,7 +843,7 @@ function parse(tokens) {
   }
   function parseLogicalNegationExpression() {
     let right;
-    while (is(TOKEN_TYPES.Not)) {
+    while (isIdentifier("not")) {
       const operator = tokens[current];
       ++current;
       const arg = parseLogicalNegationExpression();
@@ -790,9 +853,18 @@ function parse(tokens) {
   }
   function parseComparisonExpression() {
     let left = parseAdditiveExpression();
-    while (is(TOKEN_TYPES.ComparisonBinaryOperator) || is(TOKEN_TYPES.In) || is(TOKEN_TYPES.NotIn)) {
-      const operator = tokens[current];
-      ++current;
+    while (true) {
+      let operator;
+      if (isIdentifier("not", "in")) {
+        operator = new Token("not in", TOKEN_TYPES.Identifier);
+        current += 2;
+      } else if (isIdentifier("in")) {
+        operator = tokens[current++];
+      } else if (is(TOKEN_TYPES.ComparisonBinaryOperator)) {
+        operator = tokens[current++];
+      } else {
+        break;
+      }
       const right = parseAdditiveExpression();
       left = new BinaryExpression(operator, left, right);
     }
@@ -832,14 +904,21 @@ function parse(tokens) {
   function parseArgumentsList() {
     const args = [];
     while (!is(TOKEN_TYPES.CloseParen)) {
-      let argument = parseExpression();
-      if (is(TOKEN_TYPES.Equals)) {
+      let argument;
+      if (tokens[current].type === TOKEN_TYPES.MultiplicativeBinaryOperator && tokens[current].value === "*") {
         ++current;
-        if (!(argument instanceof Identifier)) {
-          throw new SyntaxError(`Expected identifier for keyword argument`);
+        const expr = parseExpression();
+        argument = new SpreadExpression(expr);
+      } else {
+        argument = parseExpression();
+        if (is(TOKEN_TYPES.Equals)) {
+          ++current;
+          if (!(argument instanceof Identifier)) {
+            throw new SyntaxError(`Expected identifier for keyword argument`);
+          }
+          const value = parseExpression();
+          argument = new KeywordArgumentExpression(argument, value);
         }
-        const value = parseExpression();
-        argument = new KeywordArgumentExpression(argument, value);
       }
       args.push(argument);
       if (is(TOKEN_TYPES.Comma)) {
@@ -880,7 +959,7 @@ function parse(tokens) {
       const operator = tokens[current];
       ++current;
       let property;
-      const computed = operator.type !== TOKEN_TYPES.Dot;
+      const computed = operator.type === TOKEN_TYPES.OpenSquareBracket;
       if (computed) {
         property = parseMemberExpressionArgumentsList();
         expect(TOKEN_TYPES.CloseSquareBracket, "Expected closing square bracket");
@@ -897,8 +976,7 @@ function parse(tokens) {
   function parseMultiplicativeExpression() {
     let left = parseTestExpression();
     while (is(TOKEN_TYPES.MultiplicativeBinaryOperator)) {
-      const operator = tokens[current];
-      ++current;
+      const operator = tokens[current++];
       const right = parseTestExpression();
       left = new BinaryExpression(operator, left, right);
     }
@@ -906,18 +984,13 @@ function parse(tokens) {
   }
   function parseTestExpression() {
     let operand = parseFilterExpression();
-    while (is(TOKEN_TYPES.Is)) {
+    while (isIdentifier("is")) {
       ++current;
-      const negate = is(TOKEN_TYPES.Not);
+      const negate = isIdentifier("not");
       if (negate) {
         ++current;
       }
-      let filter = parsePrimaryExpression();
-      if (filter instanceof BooleanLiteral) {
-        filter = new Identifier(filter.value.toString());
-      } else if (filter instanceof NullLiteral) {
-        filter = new Identifier("none");
-      }
+      const filter = parsePrimaryExpression();
       if (!(filter instanceof Identifier)) {
         throw new SyntaxError(`Expected identifier for the test`);
       }
@@ -941,34 +1014,27 @@ function parse(tokens) {
     return operand;
   }
   function parsePrimaryExpression() {
-    const token = tokens[current];
+    const token = tokens[current++];
     switch (token.type) {
-      case TOKEN_TYPES.NumericLiteral:
-        ++current;
-        return new NumericLiteral(Number(token.value));
-      case TOKEN_TYPES.StringLiteral:
-        ++current;
-        return new StringLiteral(token.value);
-      case TOKEN_TYPES.BooleanLiteral:
-        ++current;
-        return new BooleanLiteral(token.value.toLowerCase() === "true");
-      case TOKEN_TYPES.NullLiteral:
-        ++current;
-        return new NullLiteral(null);
+      case TOKEN_TYPES.NumericLiteral: {
+        const num = token.value;
+        return num.includes(".") ? new FloatLiteral(Number(num)) : new IntegerLiteral(Number(num));
+      }
+      case TOKEN_TYPES.StringLiteral: {
+        let value = token.value;
+        while (is(TOKEN_TYPES.StringLiteral)) {
+          value += tokens[current++].value;
+        }
+        return new StringLiteral(value);
+      }
       case TOKEN_TYPES.Identifier:
-        ++current;
         return new Identifier(token.value);
       case TOKEN_TYPES.OpenParen: {
-        ++current;
         const expression = parseExpressionSequence();
-        if (tokens[current].type !== TOKEN_TYPES.CloseParen) {
-          throw new SyntaxError(`Expected closing parenthesis, got ${tokens[current].type} instead`);
-        }
-        ++current;
+        expect(TOKEN_TYPES.CloseParen, "Expected closing parenthesis, got ${tokens[current].type} instead.");
         return expression;
       }
       case TOKEN_TYPES.OpenSquareBracket: {
-        ++current;
         const values = [];
         while (!is(TOKEN_TYPES.CloseSquareBracket)) {
           values.push(parseExpression());
@@ -980,7 +1046,6 @@ function parse(tokens) {
         return new ArrayLiteral(values);
       }
       case TOKEN_TYPES.OpenCurlyBracket: {
-        ++current;
         const values = /* @__PURE__ */ new Map();
         while (!is(TOKEN_TYPES.CloseCurlyBracket)) {
           const key = parseExpression();
@@ -1034,6 +1099,52 @@ function slice(array, start, stop, step = 1) {
 function titleCase(value) {
   return value.replace(/\b\w/g, (c) => c.toUpperCase());
 }
+function strftime_now(format2) {
+  return strftime(/* @__PURE__ */ new Date(), format2);
+}
+function strftime(date, format2) {
+  const monthFormatterLong = new Intl.DateTimeFormat(void 0, { month: "long" });
+  const monthFormatterShort = new Intl.DateTimeFormat(void 0, { month: "short" });
+  const pad2 = (n) => n < 10 ? "0" + n : n.toString();
+  return format2.replace(/%[YmdbBHM%]/g, (token) => {
+    switch (token) {
+      case "%Y":
+        return date.getFullYear().toString();
+      case "%m":
+        return pad2(date.getMonth() + 1);
+      case "%d":
+        return pad2(date.getDate());
+      case "%b":
+        return monthFormatterShort.format(date);
+      case "%B":
+        return monthFormatterLong.format(date);
+      case "%H":
+        return pad2(date.getHours());
+      case "%M":
+        return pad2(date.getMinutes());
+      case "%%":
+        return "%";
+      default:
+        return token;
+    }
+  });
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replace(str, oldvalue, newvalue, count) {
+  if (count === 0)
+    return str;
+  let remaining = count == null || count < 0 ? Infinity : count;
+  const pattern = oldvalue.length === 0 ? new RegExp("(?=)", "gu") : new RegExp(escapeRegExp(oldvalue), "gu");
+  return str.replaceAll(pattern, (match) => {
+    if (remaining > 0) {
+      --remaining;
+      return newvalue;
+    }
+    return match;
+  });
+}
 
 // src/runtime.ts
 var BreakControl = class extends Error {
@@ -1061,9 +1172,18 @@ var RuntimeValue = class {
   __bool__() {
     return new BooleanValue(!!this.value);
   }
+  toString() {
+    return String(this.value);
+  }
+};
+var IntegerValue = class extends RuntimeValue {
+  type = "IntegerValue";
 };
-var NumericValue = class extends RuntimeValue {
-  type = "NumericValue";
+var FloatValue = class extends RuntimeValue {
+  type = "FloatValue";
+  toString() {
+    return this.value % 1 === 0 ? this.value.toFixed(1) : this.value.toString();
+  }
 };
 var StringValue = class extends RuntimeValue {
   type = "StringValue";
@@ -1092,7 +1212,13 @@ var StringValue = class extends RuntimeValue {
         return new StringValue(titleCase(this.value));
       })
     ],
-    ["length", new NumericValue(this.value.length)],
+    [
+      "capitalize",
+      new FunctionValue(() => {
+        return new StringValue(this.value.charAt(0).toUpperCase() + this.value.slice(1));
+      })
+    ],
+    ["length", new IntegerValue(this.value.length)],
     [
       "rstrip",
       new FunctionValue(() => {
@@ -1111,11 +1237,21 @@ var StringValue = class extends RuntimeValue {
         if (args.length === 0) {
           throw new Error("startswith() requires at least one argument");
         }
-        const prefix = args[0];
-        if (!(prefix instanceof StringValue)) {
-          throw new Error("startswith() argument must be a string");
+        const pattern = args[0];
+        if (pattern instanceof StringValue) {
+          return new BooleanValue(this.value.startsWith(pattern.value));
+        } else if (pattern instanceof ArrayValue) {
+          for (const item of pattern.value) {
+            if (!(item instanceof StringValue)) {
+              throw new Error("startswith() tuple elements must be strings");
+            }
+            if (this.value.startsWith(item.value)) {
+              return new BooleanValue(true);
+            }
+          }
+          return new BooleanValue(false);
         }
-        return new BooleanValue(this.value.startsWith(prefix.value));
+        throw new Error("startswith() argument must be a string or tuple of strings");
       })
     ],
     [
@@ -1124,11 +1260,21 @@ var StringValue = class extends RuntimeValue {
         if (args.length === 0) {
           throw new Error("endswith() requires at least one argument");
         }
-        const suffix = args[0];
-        if (!(suffix instanceof StringValue)) {
-          throw new Error("endswith() argument must be a string");
+        const pattern = args[0];
+        if (pattern instanceof StringValue) {
+          return new BooleanValue(this.value.endsWith(pattern.value));
+        } else if (pattern instanceof ArrayValue) {
+          for (const item of pattern.value) {
+            if (!(item instanceof StringValue)) {
+              throw new Error("endswith() tuple elements must be strings");
+            }
+            if (this.value.endsWith(item.value)) {
+              return new BooleanValue(true);
+            }
+          }
+          return new BooleanValue(false);
         }
-        return new BooleanValue(this.value.endsWith(suffix.value));
+        throw new Error("endswith() argument must be a string or tuple of strings");
       })
     ],
     [
@@ -1140,8 +1286,8 @@ var StringValue = class extends RuntimeValue {
         if (!(sep instanceof StringValue || sep instanceof NullValue)) {
           throw new Error("sep argument must be a string or null");
         }
-        const maxsplit = args[1] ?? new NumericValue(-1);
-        if (!(maxsplit instanceof NumericValue)) {
+        const maxsplit = args[1] ?? new IntegerValue(-1);
+        if (!(maxsplit instanceof IntegerValue)) {
           throw new Error("maxsplit argument must be a number");
         }
         let result = [];
@@ -1165,6 +1311,33 @@ var StringValue = class extends RuntimeValue {
         }
         return new ArrayValue(result.map((part) => new StringValue(part)));
       })
+    ],
+    [
+      "replace",
+      new FunctionValue((args) => {
+        if (args.length < 2) {
+          throw new Error("replace() requires at least two arguments");
+        }
+        const oldValue = args[0];
+        const newValue = args[1];
+        if (!(oldValue instanceof StringValue && newValue instanceof StringValue)) {
+          throw new Error("replace() arguments must be strings");
+        }
+        let count;
+        if (args.length > 2) {
+          if (args[2].type === "KeywordArgumentsValue") {
+            count = args[2].value.get("count") ?? new NullValue();
+          } else {
+            count = args[2];
+          }
+        } else {
+          count = new NullValue();
+        }
+        if (!(count instanceof IntegerValue || count instanceof NullValue)) {
+          throw new Error("replace() count argument must be a number or null");
+        }
+        return new StringValue(replace(this.value, oldValue.value, newValue.value, count.value));
+      })
     ]
   ]);
 };
@@ -1194,22 +1367,28 @@ var ObjectValue = class extends RuntimeValue {
         return this.value.get(key.value) ?? defaultValue ?? new NullValue();
       })
     ],
-    [
-      "items",
-      new FunctionValue(() => {
-        return new ArrayValue(
-          Array.from(this.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value]))
-        );
-      })
-    ]
+    ["items", new FunctionValue(() => this.items())],
+    ["keys", new FunctionValue(() => this.keys())],
+    ["values", new FunctionValue(() => this.values())]
   ]);
+  items() {
+    return new ArrayValue(
+      Array.from(this.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value]))
+    );
+  }
+  keys() {
+    return new ArrayValue(Array.from(this.value.keys()).map((key) => new StringValue(key)));
+  }
+  values() {
+    return new ArrayValue(Array.from(this.value.values()));
+  }
 };
 var KeywordArgumentsValue = class extends ObjectValue {
   type = "KeywordArgumentsValue";
 };
 var ArrayValue = class extends RuntimeValue {
   type = "ArrayValue";
-  builtins = /* @__PURE__ */ new Map([["length", new NumericValue(this.value.length)]]);
+  builtins = /* @__PURE__ */ new Map([["length", new IntegerValue(this.value.length)]]);
   /**
    * NOTE: necessary to override since all JavaScript arrays are considered truthy,
    * while only non-empty Python arrays are consider truthy.
@@ -1264,8 +1443,8 @@ var Environment = class {
     [
       "odd",
       (operand) => {
-        if (operand.type !== "NumericValue") {
-          throw new Error(`Cannot apply test "odd" to type: ${operand.type}`);
+        if (!(operand instanceof IntegerValue)) {
+          throw new Error(`cannot odd on ${operand.type}`);
         }
         return operand.value % 2 !== 0;
       }
@@ -1273,8 +1452,8 @@ var Environment = class {
     [
       "even",
       (operand) => {
-        if (operand.type !== "NumericValue") {
-          throw new Error(`Cannot apply test "even" to type: ${operand.type}`);
+        if (!(operand instanceof IntegerValue)) {
+          throw new Error(`cannot even on ${operand.type}`);
         }
         return operand.value % 2 === 0;
       }
@@ -1283,8 +1462,8 @@ var Environment = class {
     ["true", (operand) => operand.type === "BooleanValue" && operand.value],
     ["none", (operand) => operand.type === "NullValue"],
     ["string", (operand) => operand.type === "StringValue"],
-    ["number", (operand) => operand.type === "NumericValue"],
-    ["integer", (operand) => operand.type === "NumericValue" && Number.isInteger(operand.value)],
+    ["number", (operand) => operand instanceof IntegerValue || operand instanceof FloatValue],
+    ["integer", (operand) => operand instanceof IntegerValue],
     ["iterable", (operand) => operand.type === "ArrayValue" || operand.type === "StringValue"],
     ["mapping", (operand) => operand.type === "ObjectValue"],
     [
@@ -1355,6 +1534,19 @@ var Environment = class {
     }
   }
 };
+function setupGlobals(env) {
+  env.set("false", false);
+  env.set("true", true);
+  env.set("none", null);
+  env.set("raise_exception", (args) => {
+    throw new Error(args);
+  });
+  env.set("range", range);
+  env.set("strftime_now", strftime_now);
+  env.set("True", true);
+  env.set("False", false);
+  env.set("None", null);
+}
 var Interpreter = class {
   global;
   constructor(env) {
@@ -1385,29 +1577,39 @@ var Interpreter = class {
         return new BooleanValue(left.value != right.value);
     }
     if (left instanceof UndefinedValue || right instanceof UndefinedValue) {
-      throw new Error("Cannot perform operation on undefined values");
+      if (right instanceof UndefinedValue && ["in", "not in"].includes(node.operator.value)) {
+        return new BooleanValue(node.operator.value === "not in");
+      }
+      throw new Error(`Cannot perform operation ${node.operator.value} on undefined values`);
     } else if (left instanceof NullValue || right instanceof NullValue) {
       throw new Error("Cannot perform operation on null values");
-    } else if (left instanceof NumericValue && right instanceof NumericValue) {
+    } else if (node.operator.value === "~") {
+      return new StringValue(left.value.toString() + right.value.toString());
+    } else if ((left instanceof IntegerValue || left instanceof FloatValue) && (right instanceof IntegerValue || right instanceof FloatValue)) {
+      const a = left.value, b = right.value;
       switch (node.operator.value) {
         case "+":
-          return new NumericValue(left.value + right.value);
         case "-":
-          return new NumericValue(left.value - right.value);
-        case "*":
-          return new NumericValue(left.value * right.value);
+        case "*": {
+          const res = node.operator.value === "+" ? a + b : node.operator.value === "-" ? a - b : a * b;
+          const isFloat = left instanceof FloatValue || right instanceof FloatValue;
+          return isFloat ? new FloatValue(res) : new IntegerValue(res);
+        }
         case "/":
-          return new NumericValue(left.value / right.value);
-        case "%":
-          return new NumericValue(left.value % right.value);
+          return new FloatValue(a / b);
+        case "%": {
+          const rem = a % b;
+          const isFloat = left instanceof FloatValue || right instanceof FloatValue;
+          return isFloat ? new FloatValue(rem) : new IntegerValue(rem);
+        }
         case "<":
-          return new BooleanValue(left.value < right.value);
+          return new BooleanValue(a < b);
         case ">":
-          return new BooleanValue(left.value > right.value);
+          return new BooleanValue(a > b);
         case ">=":
-          return new BooleanValue(left.value >= right.value);
+          return new BooleanValue(a >= b);
         case "<=":
-          return new BooleanValue(left.value <= right.value);
+          return new BooleanValue(a <= b);
       }
     } else if (left instanceof ArrayValue && right instanceof ArrayValue) {
       switch (node.operator.value) {
@@ -1451,7 +1653,16 @@ var Interpreter = class {
     const positionalArguments = [];
     const keywordArguments = /* @__PURE__ */ new Map();
     for (const argument of args) {
-      if (argument.type === "KeywordArgumentExpression") {
+      if (argument.type === "SpreadExpression") {
+        const spreadNode = argument;
+        const val = this.evaluate(spreadNode.argument, environment);
+        if (!(val instanceof ArrayValue)) {
+          throw new Error(`Cannot unpack non-iterable type: ${val.type}`);
+        }
+        for (const item of val.value) {
+          positionalArguments.push(item);
+        }
+      } else if (argument.type === "KeywordArgumentExpression") {
         const kwarg = argument;
         keywordArguments.set(kwarg.key.value, this.evaluate(kwarg.value, environment));
       } else {
@@ -1463,13 +1674,9 @@ var Interpreter = class {
     }
     return [positionalArguments, keywordArguments];
   }
-  /**
-   * Evaluates expressions following the filter operation type.
-   */
-  evaluateFilterExpression(node, environment) {
-    const operand = this.evaluate(node.operand, environment);
-    if (node.filter.type === "Identifier") {
-      const filter = node.filter;
+  applyFilter(operand, filterNode, environment) {
+    if (filterNode.type === "Identifier") {
+      const filter = filterNode;
       if (filter.value === "tojson") {
         return new StringValue(toJSON(operand));
       }
@@ -1482,7 +1689,7 @@ var Interpreter = class {
           case "last":
             return operand.value[operand.value.length - 1];
           case "length":
-            return new NumericValue(operand.value.length);
+            return new IntegerValue(operand.value.length);
           case "reverse":
             return new ArrayValue(operand.value.reverse());
           case "sort":
@@ -1492,7 +1699,8 @@ var Interpreter = class {
                   throw new Error(`Cannot compare different types: ${a.type} and ${b.type}`);
                 }
                 switch (a.type) {
-                  case "NumericValue":
+                  case "IntegerValue":
+                  case "FloatValue":
                     return a.value - b.value;
                   case "StringValue":
                     return a.value.localeCompare(b.value);
@@ -1505,21 +1713,40 @@ var Interpreter = class {
             return new StringValue(operand.value.map((x) => x.value).join(""));
           case "string":
             return new StringValue(toJSON(operand));
+          case "unique": {
+            const seen = /* @__PURE__ */ new Set();
+            const output = [];
+            for (const item of operand.value) {
+              if (!seen.has(item.value)) {
+                seen.add(item.value);
+                output.push(item);
+              }
+            }
+            return new ArrayValue(output);
+          }
           default:
             throw new Error(`Unknown ArrayValue filter: ${filter.value}`);
         }
       } else if (operand instanceof StringValue) {
         switch (filter.value) {
           case "length":
-            return new NumericValue(operand.value.length);
           case "upper":
-            return new StringValue(operand.value.toUpperCase());
           case "lower":
-            return new StringValue(operand.value.toLowerCase());
           case "title":
-            return new StringValue(titleCase(operand.value));
-          case "capitalize":
-            return new StringValue(operand.value.charAt(0).toUpperCase() + operand.value.slice(1));
+          case "capitalize": {
+            const builtin = operand.builtins.get(filter.value);
+            if (builtin instanceof FunctionValue) {
+              return builtin.value(
+                /* no arguments */
+                [],
+                environment
+              );
+            } else if (builtin instanceof IntegerValue) {
+              return builtin;
+            } else {
+              throw new Error(`Unknown StringValue filter: ${filter.value}`);
+            }
+          }
           case "trim":
             return new StringValue(operand.value.trim());
           case "indent":
@@ -1534,13 +1761,25 @@ var Interpreter = class {
           case "join":
           case "string":
             return operand;
+          case "int": {
+            const val = parseInt(operand.value, 10);
+            return new IntegerValue(isNaN(val) ? 0 : val);
+          }
+          case "float": {
+            const val = parseFloat(operand.value);
+            return new FloatValue(isNaN(val) ? 0 : val);
+          }
           default:
             throw new Error(`Unknown StringValue filter: ${filter.value}`);
         }
-      } else if (operand instanceof NumericValue) {
+      } else if (operand instanceof IntegerValue || operand instanceof FloatValue) {
         switch (filter.value) {
           case "abs":
-            return new NumericValue(Math.abs(operand.value));
+            return operand instanceof IntegerValue ? new IntegerValue(Math.abs(operand.value)) : new FloatValue(Math.abs(operand.value));
+          case "int":
+            return new IntegerValue(Math.floor(operand.value));
+          case "float":
+            return new FloatValue(operand.value);
           default:
             throw new Error(`Unknown NumericValue filter: ${filter.value}`);
         }
@@ -1551,14 +1790,27 @@ var Interpreter = class {
               Array.from(operand.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value]))
             );
           case "length":
-            return new NumericValue(operand.value.size);
+            return new IntegerValue(operand.value.size);
           default:
             throw new Error(`Unknown ObjectValue filter: ${filter.value}`);
         }
+      } else if (operand instanceof BooleanValue) {
+        switch (filter.value) {
+          case "bool":
+            return new BooleanValue(operand.value);
+          case "int":
+            return new IntegerValue(operand.value ? 1 : 0);
+          case "float":
+            return new FloatValue(operand.value ? 1 : 0);
+          case "string":
+            return new StringValue(operand.value ? "true" : "false");
+          default:
+            throw new Error(`Unknown BooleanValue filter: ${filter.value}`);
+        }
       }
       throw new Error(`Cannot apply filter "${filter.value}" to type: ${operand.type}`);
-    } else if (node.filter.type === "CallExpression") {
-      const filter = node.filter;
+    } else if (filterNode.type === "CallExpression") {
+      const filter = filterNode;
       if (filter.callee.type !== "Identifier") {
         throw new Error(`Unknown filter: ${filter.callee.type}`);
       }
@@ -1566,7 +1818,7 @@ var Interpreter = class {
       if (filterName === "tojson") {
         const [, kwargs] = this.evaluateArguments(filter.args, environment);
         const indent = kwargs.get("indent") ?? new NullValue();
-        if (!(indent instanceof NumericValue || indent instanceof NullValue)) {
+        if (!(indent instanceof IntegerValue || indent instanceof NullValue)) {
           throw new Error("If set, indent must be a number");
         }
         return new StringValue(toJSON(operand, indent.value));
@@ -1585,6 +1837,30 @@ var Interpreter = class {
           throw new Error("separator must be a string");
         }
         return new StringValue(value.join(separator.value));
+      } else if (filterName === "int" || filterName === "float") {
+        const [args, kwargs] = this.evaluateArguments(filter.args, environment);
+        const defaultValue = args.at(0) ?? kwargs.get("default") ?? (filterName === "int" ? new IntegerValue(0) : new FloatValue(0));
+        if (operand instanceof StringValue) {
+          const val = filterName === "int" ? parseInt(operand.value, 10) : parseFloat(operand.value);
+          return isNaN(val) ? defaultValue : filterName === "int" ? new IntegerValue(val) : new FloatValue(val);
+        } else if (operand instanceof IntegerValue || operand instanceof FloatValue) {
+          return operand;
+        } else if (operand instanceof BooleanValue) {
+          return filterName === "int" ? new IntegerValue(operand.value ? 1 : 0) : new FloatValue(operand.value ? 1 : 0);
+        } else {
+          throw new Error(`Cannot apply filter "${filterName}" to type: ${operand.type}`);
+        }
+      } else if (filterName === "default") {
+        const [args, kwargs] = this.evaluateArguments(filter.args, environment);
+        const defaultValue = args[0] ?? new StringValue("");
+        const booleanValue = args[1] ?? kwargs.get("boolean") ?? new BooleanValue(false);
+        if (!(booleanValue instanceof BooleanValue)) {
+          throw new Error("`default` filter flag must be a boolean");
+        }
+        if (operand instanceof UndefinedValue || booleanValue.value && !operand.__bool__().value) {
+          return defaultValue;
+        }
+        return operand;
       }
       if (operand instanceof ArrayValue) {
         switch (filterName) {
@@ -1640,8 +1916,8 @@ var Interpreter = class {
         switch (filterName) {
           case "indent": {
             const [args, kwargs] = this.evaluateArguments(filter.args, environment);
-            const width = args.at(0) ?? kwargs.get("width") ?? new NumericValue(4);
-            if (!(width instanceof NumericValue)) {
+            const width = args.at(0) ?? kwargs.get("width") ?? new IntegerValue(4);
+            if (!(width instanceof IntegerValue)) {
               throw new Error("width must be a number");
             }
             const first = args.at(1) ?? kwargs.get("first") ?? new BooleanValue(false);
@@ -1653,13 +1929,28 @@ var Interpreter = class {
             );
             return new StringValue(indented.join("\n"));
           }
+          case "replace": {
+            const replaceFn = operand.builtins.get("replace");
+            if (!(replaceFn instanceof FunctionValue)) {
+              throw new Error("replace filter not available");
+            }
+            const [args, kwargs] = this.evaluateArguments(filter.args, environment);
+            return replaceFn.value([...args, new KeywordArgumentsValue(kwargs)], environment);
+          }
         }
         throw new Error(`Unknown StringValue filter: ${filterName}`);
       } else {
         throw new Error(`Cannot apply filter "${filterName}" to type: ${operand.type}`);
       }
     }
-    throw new Error(`Unknown filter: ${node.filter.type}`);
+    throw new Error(`Unknown filter: ${filterNode.type}`);
+  }
+  /**
+   * Evaluates expressions following the filter operation type.
+   */
+  evaluateFilterExpression(node, environment) {
+    const operand = this.evaluate(node.operand, environment);
+    return this.applyFilter(operand, node.filter, environment);
   }
   /**
    * Evaluates expressions following the test operation type.
@@ -1673,6 +1964,16 @@ var Interpreter = class {
     const result = test(operand);
     return new BooleanValue(node.negate ? !result : result);
   }
+  /**
+   * Evaluates expressions following the select operation type.
+   */
+  evaluateSelectExpression(node, environment) {
+    const predicate = this.evaluate(node.test, environment);
+    if (!predicate.__bool__().value) {
+      return new UndefinedValue();
+    }
+    return this.evaluate(node.lhs, environment);
+  }
   /**
    * Evaluates expressions following the unary operation type.
    */
@@ -1685,6 +1986,10 @@ var Interpreter = class {
         throw new SyntaxError(`Unknown operator: ${node.operator.value}`);
     }
   }
+  evaluateTernaryExpression(node, environment) {
+    const cond = this.evaluate(node.condition, environment);
+    return cond.__bool__().value ? this.evaluate(node.trueExpr, environment) : this.evaluate(node.falseExpr, environment);
+  }
   evalProgram(program, environment) {
     return this.evaluateBlock(program.body, environment);
   }
@@ -1693,7 +1998,7 @@ var Interpreter = class {
     for (const statement of statements) {
       const lastEvaluated = this.evaluate(statement, environment);
       if (lastEvaluated.type !== "NullValue" && lastEvaluated.type !== "UndefinedValue") {
-        result += lastEvaluated.value;
+        result += lastEvaluated.toString();
       }
     }
     return new StringValue(result);
@@ -1719,13 +2024,13 @@ var Interpreter = class {
     const start = this.evaluate(expr.start, environment);
     const stop = this.evaluate(expr.stop, environment);
     const step = this.evaluate(expr.step, environment);
-    if (!(start instanceof NumericValue || start instanceof UndefinedValue)) {
+    if (!(start instanceof IntegerValue || start instanceof UndefinedValue)) {
       throw new Error("Slice start must be numeric or undefined");
     }
-    if (!(stop instanceof NumericValue || stop instanceof UndefinedValue)) {
+    if (!(stop instanceof IntegerValue || stop instanceof UndefinedValue)) {
       throw new Error("Slice stop must be numeric or undefined");
     }
-    if (!(step instanceof NumericValue || step instanceof UndefinedValue)) {
+    if (!(step instanceof IntegerValue || step instanceof UndefinedValue)) {
       throw new Error("Slice step must be numeric or undefined");
     }
     if (object instanceof ArrayValue) {
@@ -1753,7 +2058,7 @@ var Interpreter = class {
       }
       value = object.value.get(property.value) ?? object.builtins.get(property.value);
     } else if (object instanceof ArrayValue || object instanceof StringValue) {
-      if (property instanceof NumericValue) {
+      if (property instanceof IntegerValue) {
         value = object.value.at(property.value);
         if (object instanceof StringValue) {
           value = new StringValue(object.value.at(property.value));
@@ -1776,6 +2081,22 @@ var Interpreter = class {
     if (node.assignee.type === "Identifier") {
       const variableName = node.assignee.value;
       environment.setVariable(variableName, rhs);
+    } else if (node.assignee.type === "TupleLiteral") {
+      const tuple = node.assignee;
+      if (!(rhs instanceof ArrayValue)) {
+        throw new Error(`Cannot unpack non-iterable type in set: ${rhs.type}`);
+      }
+      const arr = rhs.value;
+      if (arr.length !== tuple.value.length) {
+        throw new Error(`Too ${tuple.value.length > arr.length ? "few" : "many"} items to unpack in set`);
+      }
+      for (let i = 0; i < tuple.value.length; ++i) {
+        const elem = tuple.value[i];
+        if (elem.type !== "Identifier") {
+          throw new Error(`Cannot unpack to non-identifier in set: ${elem.type}`);
+        }
+        environment.setVariable(elem.value, arr[i]);
+      }
     } else if (node.assignee.type === "MemberExpression") {
       const member = node.assignee;
       const object = this.evaluate(member.object, environment);
@@ -1800,13 +2121,16 @@ var Interpreter = class {
     let test, iterable;
     if (node.iterable.type === "SelectExpression") {
       const select = node.iterable;
-      iterable = this.evaluate(select.iterable, scope);
+      iterable = this.evaluate(select.lhs, scope);
       test = select.test;
     } else {
       iterable = this.evaluate(node.iterable, scope);
     }
-    if (!(iterable instanceof ArrayValue)) {
-      throw new Error(`Expected iterable type in for loop: got ${iterable.type}`);
+    if (!(iterable instanceof ArrayValue || iterable instanceof ObjectValue)) {
+      throw new Error(`Expected iterable or object type in for loop: got ${iterable.type}`);
+    }
+    if (iterable instanceof ObjectValue) {
+      iterable = iterable.keys();
     }
     const items = [];
     const scopeUpdateFunctions = [];
@@ -1850,13 +2174,13 @@ var Interpreter = class {
     let noIteration = true;
     for (let i = 0; i < items.length; ++i) {
       const loop = /* @__PURE__ */ new Map([
-        ["index", new NumericValue(i + 1)],
-        ["index0", new NumericValue(i)],
-        ["revindex", new NumericValue(items.length - i)],
-        ["revindex0", new NumericValue(items.length - i - 1)],
+        ["index", new IntegerValue(i + 1)],
+        ["index0", new IntegerValue(i)],
+        ["revindex", new IntegerValue(items.length - i)],
+        ["revindex0", new IntegerValue(items.length - i - 1)],
         ["first", new BooleanValue(i === 0)],
         ["last", new BooleanValue(i === items.length - 1)],
-        ["length", new NumericValue(items.length)],
+        ["length", new IntegerValue(items.length)],
         ["previtem", i > 0 ? items[i - 1] : new UndefinedValue()],
         ["nextitem", i < items.length - 1 ? items[i + 1] : new UndefinedValue()]
       ]);
@@ -1919,8 +2243,36 @@ var Interpreter = class {
     );
     return new NullValue();
   }
+  evaluateCallStatement(node, environment) {
+    const callerFn = new FunctionValue((callerArgs, callerEnv) => {
+      const callBlockEnv = new Environment(callerEnv);
+      if (node.callerArgs) {
+        for (let i = 0; i < node.callerArgs.length; ++i) {
+          const param = node.callerArgs[i];
+          if (param.type !== "Identifier") {
+            throw new Error(`Caller parameter must be an identifier, got ${param.type}`);
+          }
+          callBlockEnv.setVariable(param.value, callerArgs[i] ?? new UndefinedValue());
+        }
+      }
+      return this.evaluateBlock(node.body, callBlockEnv);
+    });
+    const [macroArgs, macroKwargs] = this.evaluateArguments(node.call.args, environment);
+    macroArgs.push(new KeywordArgumentsValue(macroKwargs));
+    const fn = this.evaluate(node.call.callee, environment);
+    if (fn.type !== "FunctionValue") {
+      throw new Error(`Cannot call something that is not a function: got ${fn.type}`);
+    }
+    const newEnv = new Environment(environment);
+    newEnv.setVariable("caller", callerFn);
+    return fn.value(macroArgs, newEnv);
+  }
+  evaluateFilterStatement(node, environment) {
+    const rendered = this.evaluateBlock(node.body, environment);
+    return this.applyFilter(rendered, node.filter, environment);
+  }
   evaluate(statement, environment) {
-    if (statement === void 0)
+    if (!statement)
       return new UndefinedValue();
     switch (statement.type) {
       case "Program":
@@ -1933,18 +2285,18 @@ var Interpreter = class {
         return this.evaluateFor(statement, environment);
       case "Macro":
         return this.evaluateMacro(statement, environment);
+      case "CallStatement":
+        return this.evaluateCallStatement(statement, environment);
       case "Break":
         throw new BreakControl();
       case "Continue":
         throw new ContinueControl();
-      case "NumericLiteral":
-        return new NumericValue(Number(statement.value));
+      case "IntegerLiteral":
+        return new IntegerValue(statement.value);
+      case "FloatLiteral":
+        return new FloatValue(statement.value);
       case "StringLiteral":
         return new StringValue(statement.value);
-      case "BooleanLiteral":
-        return new BooleanValue(statement.value);
-      case "NullLiteral":
-        return new NullValue(statement.value);
       case "ArrayLiteral":
         return new ArrayValue(statement.value.map((x) => this.evaluate(x, environment)));
       case "TupleLiteral":
@@ -1972,8 +2324,16 @@ var Interpreter = class {
         return this.evaluateBinaryExpression(statement, environment);
       case "FilterExpression":
         return this.evaluateFilterExpression(statement, environment);
+      case "FilterStatement":
+        return this.evaluateFilterStatement(statement, environment);
       case "TestExpression":
         return this.evaluateTestExpression(statement, environment);
+      case "SelectExpression":
+        return this.evaluateSelectExpression(statement, environment);
+      case "Ternary":
+        return this.evaluateTernaryExpression(statement, environment);
+      case "Comment":
+        return new NullValue();
       default:
         throw new SyntaxError(`Unknown node type: ${statement.type}`);
     }
@@ -1982,7 +2342,7 @@ var Interpreter = class {
 function convertToRuntimeValues(input) {
   switch (typeof input) {
     case "number":
-      return new NumericValue(input);
+      return Number.isInteger(input) ? new IntegerValue(input) : new FloatValue(input);
     case "string":
       return new StringValue(input);
     case "boolean":
@@ -2014,7 +2374,8 @@ function toJSON(input, indent, depth) {
     case "NullValue":
     case "UndefinedValue":
       return "null";
-    case "NumericValue":
+    case "IntegerValue":
+    case "FloatValue":
     case "StringValue":
     case "BooleanValue":
       return JSON.stringify(input.value);
@@ -2043,11 +2404,23 @@ function toJSON(input, indent, depth) {
 var NEWLINE = "\n";
 var OPEN_STATEMENT = "{%- ";
 var CLOSE_STATEMENT = " -%}";
-var OPERATOR_PRECEDENCE = {
-  MultiplicativeBinaryOperator: 2,
-  AdditiveBinaryOperator: 1,
-  ComparisonBinaryOperator: 0
-};
+function getBinaryOperatorPrecedence(expr) {
+  switch (expr.operator.type) {
+    case "MultiplicativeBinaryOperator":
+      return 4;
+    case "AdditiveBinaryOperator":
+      return 3;
+    case "ComparisonBinaryOperator":
+      return 2;
+    case "Identifier":
+      if (expr.operator.value === "and")
+        return 1;
+      if (expr.operator.value === "in" || expr.operator.value === "not in")
+        return 2;
+      return 0;
+  }
+  return 0;
+}
 function format(program, indent = "	") {
   const indentStr = typeof indent === "number" ? " ".repeat(indent) : indent;
   const body = formatStatements(program.body, 0, indentStr);
@@ -2076,6 +2449,12 @@ function formatStatement(node, depth, indentStr) {
       return pad + createStatement("break");
     case "Continue":
       return pad + createStatement("continue");
+    case "CallStatement":
+      return formatCallStatement(node, depth, indentStr);
+    case "FilterStatement":
+      return formatFilterStatement(node, depth, indentStr);
+    case "Comment":
+      return pad + "{# " + node.value + " #}";
     default:
       return pad + "{{- " + formatExpression(node) + " -}}";
   }
@@ -2093,7 +2472,7 @@ function formatIf(node, depth, indentStr) {
     }
   }
   let out = pad + createStatement("if", formatExpression(clauses[0].test)) + NEWLINE + formatStatements(clauses[0].body, depth + 1, indentStr);
-  for (let i = 1; i < clauses.length; i++) {
+  for (let i = 1; i < clauses.length; ++i) {
     out += NEWLINE + pad + createStatement("elif", formatExpression(clauses[i].test)) + NEWLINE + formatStatements(clauses[i].body, depth + 1, indentStr);
   }
   if (current && current.alternate.length > 0) {
@@ -2107,7 +2486,7 @@ function formatFor(node, depth, indentStr) {
   let formattedIterable = "";
   if (node.iterable.type === "SelectExpression") {
     const n = node.iterable;
-    formattedIterable = `${formatExpression(n.iterable)} if ${formatExpression(n.test)}`;
+    formattedIterable = `${formatExpression(n.lhs)} if ${formatExpression(n.test)}`;
   } else {
     formattedIterable = formatExpression(node.iterable);
   }
@@ -2133,20 +2512,40 @@ function formatMacro(node, depth, indentStr) {
   const args = node.args.map(formatExpression).join(", ");
   return pad + createStatement("macro", `${node.name.value}(${args})`) + NEWLINE + formatStatements(node.body, depth + 1, indentStr) + NEWLINE + pad + createStatement("endmacro");
 }
+function formatCallStatement(node, depth, indentStr) {
+  const pad = indentStr.repeat(depth);
+  const params = node.callerArgs && node.callerArgs.length > 0 ? `(${node.callerArgs.map(formatExpression).join(", ")})` : "";
+  const callExpr = formatExpression(node.call);
+  let out = pad + createStatement(`call${params}`, callExpr) + NEWLINE;
+  out += formatStatements(node.body, depth + 1, indentStr) + NEWLINE;
+  out += pad + createStatement("endcall");
+  return out;
+}
+function formatFilterStatement(node, depth, indentStr) {
+  const pad = indentStr.repeat(depth);
+  const spec = node.filter.type === "Identifier" ? node.filter.value : formatExpression(node.filter);
+  let out = pad + createStatement("filter", spec) + NEWLINE;
+  out += formatStatements(node.body, depth + 1, indentStr) + NEWLINE;
+  out += pad + createStatement("endfilter");
+  return out;
+}
 function formatExpression(node, parentPrec = -1) {
   switch (node.type) {
+    case "SpreadExpression": {
+      const n = node;
+      return `*${formatExpression(n.argument)}`;
+    }
     case "Identifier":
       return node.value;
-    case "NullLiteral":
-      return "none";
-    case "NumericLiteral":
-    case "BooleanLiteral":
+    case "IntegerLiteral":
+      return `${node.value}`;
+    case "FloatLiteral":
       return `${node.value}`;
     case "StringLiteral":
       return JSON.stringify(node.value);
     case "BinaryExpression": {
       const n = node;
-      const thisPrecedence = OPERATOR_PRECEDENCE[n.operator.type] ?? 0;
+      const thisPrecedence = getBinaryOperatorPrecedence(n);
       const left = formatExpression(n.left, thisPrecedence);
       const right = formatExpression(n.right, thisPrecedence + 1);
       const expr = `${left} ${n.operator.value} ${right}`;
@@ -2157,20 +2556,28 @@ function formatExpression(node, parentPrec = -1) {
       const val = n.operator.value + (n.operator.value === "not" ? " " : "") + formatExpression(n.argument, Infinity);
       return val;
     }
-    case "LogicalNegationExpression":
-      return `not ${formatExpression(node.argument, Infinity)}`;
     case "CallExpression": {
       const n = node;
-      const args = n.args.map((a) => formatExpression(a, -1)).join(", ");
-      return `${formatExpression(n.callee, -1)}(${args})`;
+      const args = n.args.map(formatExpression).join(", ");
+      return `${formatExpression(n.callee)}(${args})`;
     }
     case "MemberExpression": {
       const n = node;
-      let obj = formatExpression(n.object, -1);
-      if (n.object.type !== "Identifier") {
+      let obj = formatExpression(n.object);
+      if (![
+        "Identifier",
+        "MemberExpression",
+        "CallExpression",
+        "StringLiteral",
+        "IntegerLiteral",
+        "FloatLiteral",
+        "ArrayLiteral",
+        "TupleLiteral",
+        "ObjectLiteral"
+      ].includes(n.object.type)) {
         obj = `(${obj})`;
       }
-      let prop = formatExpression(n.property, -1);
+      let prop = formatExpression(n.property);
       if (!n.computed && n.property.type !== "Identifier") {
         prop = `(${prop})`;
       }
@@ -2180,47 +2587,47 @@ function formatExpression(node, parentPrec = -1) {
       const n = node;
       const operand = formatExpression(n.operand, Infinity);
       if (n.filter.type === "CallExpression") {
-        return `${operand} | ${formatExpression(n.filter, -1)}`;
+        return `${operand} | ${formatExpression(n.filter)}`;
       }
       return `${operand} | ${n.filter.value}`;
     }
     case "SelectExpression": {
       const n = node;
-      return `${formatExpression(n.iterable, -1)} | select(${formatExpression(n.test, -1)})`;
+      return `${formatExpression(n.lhs)} if ${formatExpression(n.test)}`;
     }
     case "TestExpression": {
       const n = node;
-      return `${formatExpression(n.operand, -1)} is${n.negate ? " not" : ""} ${n.test.value}`;
+      return `${formatExpression(n.operand)} is${n.negate ? " not" : ""} ${n.test.value}`;
     }
     case "ArrayLiteral":
     case "TupleLiteral": {
-      const elems = node.value.map((e) => formatExpression(e, -1));
+      const elems = node.value.map(formatExpression);
       const brackets = node.type === "ArrayLiteral" ? "[]" : "()";
       return `${brackets[0]}${elems.join(", ")}${brackets[1]}`;
     }
     case "ObjectLiteral": {
       const entries = Array.from(node.value.entries()).map(
-        ([k, v]) => `${formatExpression(k, -1)}: ${formatExpression(v, -1)}`
+        ([k, v]) => `${formatExpression(k)}: ${formatExpression(v)}`
       );
-      return `{ ${entries.join(", ")} }`;
+      return `{${entries.join(", ")}}`;
     }
     case "SliceExpression": {
       const n = node;
-      const s = n.start ? formatExpression(n.start, -1) : "";
-      const t = n.stop ? formatExpression(n.stop, -1) : "";
-      const st = n.step ? `:${formatExpression(n.step, -1)}` : "";
+      const s = n.start ? formatExpression(n.start) : "";
+      const t = n.stop ? formatExpression(n.stop) : "";
+      const st = n.step ? `:${formatExpression(n.step)}` : "";
       return `${s}:${t}${st}`;
     }
     case "KeywordArgumentExpression": {
       const n = node;
-      return `${n.key.value}=${formatExpression(n.value, -1)}`;
+      return `${n.key.value}=${formatExpression(n.value)}`;
     }
-    case "If": {
+    case "Ternary": {
       const n = node;
-      const test = formatExpression(n.test, -1);
-      const body = formatExpression(n.body[0], 0);
-      const alternate = formatExpression(n.alternate[0], -1);
-      return `${body} if ${test} else ${alternate}`;
+      const expr = `${formatExpression(n.trueExpr)} if ${formatExpression(n.condition, 0)} else ${formatExpression(
+        n.falseExpr
+      )}`;
+      return parentPrec > -1 ? `(${expr})` : expr;
     }
     default:
       throw new Error(`Unknown expression type: ${node.type}`);
@@ -2242,12 +2649,7 @@ var Template = class {
   }
   render(items) {
     const env = new Environment();
-    env.set("false", false);
-    env.set("true", true);
-    env.set("raise_exception", (args) => {
-      throw new Error(args);
-    });
-    env.set("range", range);
+    setupGlobals(env);
     if (items) {
       for (const [key, value] of Object.entries(items)) {
         env.set(key, value);
@@ -4374,7 +4776,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-const VERSION = '3.6.2';
+const VERSION = '3.6.3';
 
 // Check if various APIs are available (depends on environment)
 const IS_BROWSER_ENV = typeof window !== "undefined" && typeof window.document !== "undefined";