miki-template 2.3.2 → 2.3.3

package/README.md

@@ -18,7 +18,7 @@ you can register your own custom filters and filters in miki templates.
 - **Partial-powered templating**: Define reusable chunks with `{% partialdef %}` and render them by name anywhere — `res.render('home#card')`, `renderPartialFromSource(...)`, or `compiled.renderBlock('block')`. Built for HTMX-style partial responses without the hassle.
 - **Smart template discovery**: Stop hardcoding view paths. The engine searches `templates/`, nested app directories, and custom folder names automatically — just like Django. `setupExpress()` expands your views roots so templates live where they make sense.
 - **One-line Express integration**: `miki.setupExpress(app, { extension: 'html', views: dir })` — wires the engine, views directory, and a `res.render` shim that makes `res.render('home#card', ...)` Just Work for HTMX-style partial responses. **No boilerplate, no extra middleware.**
-- **Full Syntax Parity**: Supports variables, dotted lookups, filters (`|`), and block tags (`{% %}`).
+- **Full Syntax Parity**: Supports variables, dotted lookups, filters (`|`), and block tags (`{% %}`). **All tag arguments now support filter chains** — e.g. `{% set x = "  hello  "|trim|upper %}`, `{% for i in "5,1,2"|split:","|sort %}`, `{% with greeting="hello"|upper %}`.
 - **Template Inheritance**: Multi-level inheritance with `extends`, block overrides, and `{{ block.super }}` support.
 - **Built-in libraries**: `humanize`, `cache`, and `lorem` ship pre-activated. `{% lorem 5 p %}` works without `{% load lorem %}`.
 - **ESM & CommonJS**: Works seamlessly with both `import` and `require` syntax.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miki-template",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "description": "Django-Style template engine for Node.js and Express",
   "main": "src/index.js",
   "exports": {
@@ -32,28 +32,6 @@
     "src/tags/i18n.js",
     "src/tags/extra.js"
   ],
-  "files": [
-    "src/index.js",
-    "src/esm.mjs",
-    "src/lexer.js",
-    "src/parser.js",
-    "src/context.js",
-    "src/context_processors.js",
-    "src/filters.js",
-    "src/security.js",
-    "src/cache.js",
-    "src/utils.js",
-    "src/codegen.js",
-    "src/i18n.js",
-    "src/libraries.js",
-    "src/tags/helpers.js",
-    "src/tags/registry.js",
-    "src/tags/control.js",
-    "src/tags/inheritance.js",
-    "src/tags/util.js",
-    "src/tags/i18n.js",
-    "src/tags/extra.js"
-  ],
   "keywords": [
     "django",
     "template",
@@ -91,4 +69,4 @@
     "release:minor": "npm version minor --no-git-tag-version -m \"chore(release): v%s\" && git push origin main",
     "release:major": "npm version major --no-git-tag-version -m \"chore(release): v%s\" && git push origin main"
   }
-}
+}

package/src/codegen.js

@@ -212,7 +212,7 @@ function genNode(node, stmts, level, buf = 'out', loopVarMap = {}) {
   case 'ForNode': {
     const s = '_' + level;
     stmts.push(pad('{', level));
-    const iterExpr = (loopVarMap && loopVarMap[node.iterablePath]) ? loopVarMap[node.iterablePath] : `_get(_ctx, ${js(node.iterablePath)})`;
+    const iterExpr = node.isLiteral ? js(node.literalValue) : ((loopVarMap && loopVarMap[node.iterablePath]) ? loopVarMap[node.iterablePath] : `_get(_ctx, ${js(node.iterablePath)})`);
     stmts.push(pad(`let _raw${s} = ${iterExpr};`, level + 1));
     for (let i = 0; i < node.filters.length; i++) {
       const f = node.filters[i];
@@ -670,14 +670,145 @@ function resolveVal(token, context) {
   if (token === undefined || token === null) return '';
   if (typeof token !== 'string') return token;
   if (token === '') return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
-  return context.get(token);
+
+  let idx = 0;
+  const len = token.length;
+
+  function skipWs() {
+    while (idx < len && /\s/.test(token[idx])) idx++;
+  }
+
+  let isLiteral = false;
+  let literalValue = null;
+  let varPath = '';
+
+  if (idx < len && (token[idx] === '"' || token[idx] === '\'')) {
+    const quote = token[idx];
+    idx++;
+    let str = '';
+    while (idx < len && token[idx] !== quote) {
+      if (token[idx] === '\\' && idx + 1 < len) idx++;
+      str += token[idx];
+      idx++;
+    }
+    idx++;
+    isLiteral = true;
+    literalValue = str;
+    skipWs();
+  }
+
+  if (!isLiteral && idx < len) {
+    const remaining = token.slice(idx);
+    if (remaining.startsWith('true') || remaining.startsWith('True')) {
+      isLiteral = true;
+      literalValue = true;
+      idx += remaining.startsWith('True') ? 4 : 5;
+      skipWs();
+    } else if (remaining.startsWith('false') || remaining.startsWith('False')) {
+      isLiteral = true;
+      literalValue = false;
+      idx += remaining.startsWith('False') ? 5 : 6;
+      skipWs();
+    } else if (remaining.startsWith('null') || remaining.startsWith('None') || remaining.startsWith('none')) {
+      isLiteral = true;
+      literalValue = null;
+      idx += 4;
+      skipWs();
+    }
+  }
+
+  if (!isLiteral && idx < len && /[\d.-]/.test(token[idx])) {
+    let numStr = '';
+    if (token[idx] === '-') {
+      numStr += '-';
+      idx++;
+    }
+    while (idx < len && /[\d]/.test(token[idx])) {
+      numStr += token[idx];
+      idx++;
+    }
+    if (token[idx] === '.') {
+      numStr += '.';
+      idx++;
+      while (idx < len && /[\d]/.test(token[idx])) {
+        numStr += token[idx];
+        idx++;
+      }
+    }
+    isLiteral = true;
+    literalValue = Number(numStr);
+    skipWs();
+  }
+
+  if (!isLiteral) {
+    while (idx < len && token[idx] !== '|') {
+      varPath += token[idx];
+      idx++;
+    }
+    varPath = varPath.trim();
+  }
+
+  let val = isLiteral ? literalValue : (varPath ? context.get(varPath) : undefined);
+
+  while (idx < len) {
+    if (token[idx] === '|') {
+      idx++;
+      skipWs();
+      let name = '';
+      while (idx < len && token[idx] !== ':' && token[idx] !== '|' && !/\s/.test(token[idx])) {
+        name += token[idx];
+        idx++;
+      }
+      skipWs();
+      let argVal = undefined;
+      if (idx < len && token[idx] === ':') {
+        idx++;
+        skipWs();
+        if (idx < len && (token[idx] === '"' || token[idx] === '\'')) {
+          const quote = token[idx];
+          idx++;
+          let s = '';
+          while (idx < len && token[idx] !== quote) {
+            if (token[idx] === '\\' && idx + 1 < len) idx++;
+            s += token[idx];
+            idx++;
+          }
+          idx++;
+          argVal = s;
+        } else {
+          let s = '';
+          while (idx < len && token[idx] !== '|' && !/\s/.test(token[idx])) {
+            s += token[idx];
+            idx++;
+          }
+          s = s.trim();
+          if (s !== '' && !isNaN(s)) argVal = Number(s);
+          else if (s === 'true') argVal = true;
+          else if (s === 'false') argVal = false;
+          else if (s === 'null' || s === 'None' || s === 'none') argVal = null;
+          else argVal = s;
+        }
+      }
+      const fn = filtersModule.getFilter(name);
+      if (!fn) throw new Error(`Unknown filter: '${name}'`);
+      val = fn(val, argVal, context);
+      skipWs();
+    } else {
+      idx++;
+    }
+  }
+
+  if (val === undefined) {
+    if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
+      return token.slice(1, -1);
+    }
+    if (token === 'true' || token === 'True') return true;
+    if (token === 'false' || token === 'False') return false;
+    if (token === 'none' || token === 'None' || token === 'null') return null;
+    if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
+    return context.get(token);
+  }
+  return val;
 }
 
 function getVal(ctx, path) {

package/src/parser.js

@@ -88,6 +88,51 @@ function parseVariableExpression(expr) {
     skipWhitespace();
   }
 
+  // Check for boolean/null literals as base value
+  if (!isLiteral && idx < len) {
+    const remaining = expr.slice(idx);
+    if (remaining.startsWith('true') || remaining.startsWith('True')) {
+      isLiteral = true;
+      literalValue = true;
+      idx += remaining.startsWith('True') ? 4 : 5;
+      skipWhitespace();
+    } else if (remaining.startsWith('false') || remaining.startsWith('False')) {
+      isLiteral = true;
+      literalValue = false;
+      idx += remaining.startsWith('False') ? 5 : 6;
+      skipWhitespace();
+    } else if (remaining.startsWith('null') || remaining.startsWith('None') || remaining.startsWith('none')) {
+      isLiteral = true;
+      literalValue = null;
+      idx += remaining.startsWith('None') ? 4 : (remaining.startsWith('null') ? 4 : 4);
+      skipWhitespace();
+    }
+  }
+
+  // Check for numeric literal as base value
+  if (!isLiteral && idx < len && /[\d.-]/.test(expr[idx])) {
+    let numStr = '';
+    if (expr[idx] === '-') {
+      numStr += '-';
+      idx++;
+    }
+    while (idx < len && /[\d]/.test(expr[idx])) {
+      numStr += expr[idx];
+      idx++;
+    }
+    if (expr[idx] === '.') {
+      numStr += '.';
+      idx++;
+      while (idx < len && /[\d]/.test(expr[idx])) {
+        numStr += expr[idx];
+        idx++;
+      }
+    }
+    isLiteral = true;
+    literalValue = Number(numStr);
+    skipWhitespace();
+  }
+
   // Parse main variable path
   if (!isLiteral) {
     while (idx < len && expr[idx] !== '|') {
@@ -262,9 +307,32 @@ class Parser {
   }
 }
 
+function evaluateExpression(exprStr, context) {
+  if (!exprStr || typeof exprStr !== 'string') return exprStr === undefined || exprStr === null ? '' : exprStr;
+  const parsed = parseVariableExpression(exprStr);
+  let val = parsed.isLiteral ? parsed.literalValue : (parsed.varPath ? context.get(parsed.varPath) : undefined);
+  for (const filterInfo of parsed.filters) {
+    const filterFn = filtersModule.getFilter(filterInfo.name);
+    if (!filterFn) {
+      throw new Error(`Unknown filter: '${filterInfo.name}'`);
+    }
+    let argVal = undefined;
+    if (filterInfo.arg) {
+      if (filterInfo.arg.type === 'literal') {
+        argVal = filterInfo.arg.value;
+      } else if (filterInfo.arg.type === 'variable') {
+        argVal = context.get(filterInfo.arg.value);
+      }
+    }
+    val = filterFn(val, argVal, context);
+  }
+  return val === undefined ? '' : val;
+}
+
 module.exports = {
   Parser,
   TextNode,
   VariableNode,
-  parseVariableExpression
+  parseVariableExpression,
+  evaluateExpression
 };

package/src/tags/control.js

@@ -1,7 +1,7 @@
 /**
  * Control flow template tags: if, for, with, cycle, comment, with, firstof.
  */
-const { parseVariableExpression } = require('../parser');
+const { parseVariableExpression, evaluateExpression } = require('../parser');
 const { getFilter } = require('../filters');
 
 /**
@@ -81,23 +81,6 @@ function tokenizeExpr(exprStr) {
   return tokens;
 }
 
-/**
- * Helper to resolve a token to its runtime value.
- */
-function resolveValue(token, context) {
-  if (!token) return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (!isNaN(token) && token !== '') {
-    return Number(token);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  return context.get(token);
-}
-
 /**
  * Shunting-yard style expression evaluator supporting:
  * == != < <= > >= in not in and or not
@@ -161,7 +144,7 @@ function evaluateCondition(exprStr, context) {
       continue;
     }
 
-    vals.push(resolveValue(t, context));
+    vals.push(evaluateExpression(t, context));
   }
 
   while (ops.length > 0) {
@@ -201,12 +184,14 @@ class IfNode {
 }
 
 class ForNode {
-  constructor(loopVars, iterablePath, body, emptyBody, filters = []) {
+  constructor(loopVars, iterablePath, body, emptyBody, filters = [], isLiteral = false, literalValue = null) {
     this.loopVars = loopVars;
     this.iterablePath = iterablePath;
     this.filters = filters;
     this.body = body;
     this.emptyBody = emptyBody;
+    this.isLiteral = isLiteral;
+    this.literalValue = literalValue;
     this._filterFns = filters.map(f => {
       const fn = getFilter(f.name);
       return { fn, arg: f.arg };
@@ -214,7 +199,7 @@ class ForNode {
   }
 
   render(context) {
-    let rawItems = context.get(this.iterablePath);
+    let rawItems = this.isLiteral ? this.literalValue : context.get(this.iterablePath);
 
     for (const { fn, arg } of this._filterFns) {
       if (!fn) {
@@ -293,24 +278,7 @@ class WithNode {
   render(context) {
     const scope = {};
     for (const mapping of this.mappings) {
-      // The valPath may be a literal string (e.g. "Hello" with quotes) or
-      // a variable lookup (e.g. user.name). Parse quotes here.
-      const raw = mapping.valPath;
-      let value;
-      if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith('\'') && raw.endsWith('\''))) {
-        value = raw.slice(1, -1);
-      } else if (raw === 'true' || raw === 'True') {
-        value = true;
-      } else if (raw === 'false' || raw === 'False') {
-        value = false;
-      } else if (raw === 'none' || raw === 'None' || raw === 'null') {
-        value = null;
-      } else if (raw !== '' && !isNaN(Number(raw))) {
-        value = Number(raw);
-      } else {
-        value = context.get(raw);
-      }
-      scope[mapping.name] = value;
+      scope[mapping.name] = evaluateExpression(mapping.valPath, context);
     }
     // If an `as alias` was used after key=value pairs, alias the last
     // key to the alias name. This supports `{% with a=5 as answ %}` →
@@ -336,7 +304,7 @@ class CycleNode {
     const key = this.args.join(',');
     let idx = context.cycleStates.get(key) || 0;
     const token = this.args[idx % this.args.length];
-    const val = resolveValue(token, context);
+    const val = evaluateExpression(token, context);
     context.cycleStates.set(key, idx + 1);
 
     if (this.asName) {
@@ -356,7 +324,7 @@ class FirstofNode {
 
   render(context) {
     for (const arg of this.args) {
-      const val = resolveValue(arg, context);
+      const val = evaluateExpression(arg, context);
       if (val && val !== '' && val !== null && val !== undefined) {
         return String(val);
       }
@@ -576,7 +544,7 @@ function parseFor(tagContent, parser) {
 
   // Parse the iterable expression to support filters: items|regroup:"category"
   const parsedIterable = parseVariableExpression(iterableExpr);
-  return new ForNode(loopVars, parsedIterable.varPath, body, emptyBody, parsedIterable.filters);
+  return new ForNode(loopVars, parsedIterable.varPath, body, emptyBody, parsedIterable.filters, parsedIterable.isLiteral, parsedIterable.literalValue);
 }
 
 function parseWith(tagContent, parser) {
@@ -658,13 +626,36 @@ function parseKeyValuePairs(content) {
         val += content[i++];
       }
       if (content[i] === quote) i++;
-      // Keep the quotes around the literal so WithNode can recognize it
       val = quote + val + quote;
     } else {
       while (i < content.length && content[i] !== ',' && !/\s/.test(content[i])) {
         val += content[i++];
       }
     }
+
+    while (i < content.length && /\s/.test(content[i])) i++;
+    if (i < content.length && content[i] === '|') {
+      val += '|';
+      i++;
+      while (i < content.length) {
+        if (/\s/.test(content[i])) { i++; continue; }
+        if (content[i] === ',') break;
+        if (content[i] === '|') { val += '|'; i++; continue; }
+        if (content[i] === ':') { val += ':'; i++; continue; }
+        if (content[i] === '"' || content[i] === '\'') {
+          const quote = content[i++];
+          val += quote;
+          while (i < content.length && content[i] !== quote) {
+            if (content[i] === '\\' && i + 1 < content.length) { val += content[i]; i++; }
+            val += content[i++];
+          }
+          if (content[i] === quote) { val += quote; i++; }
+        } else {
+          val += content[i++];
+        }
+      }
+    }
+
     tokens.push({ name: key, valPath: val });
     while (i < content.length && /\s/.test(content[i])) i++;
     if (content[i] === ',') i++;
@@ -674,17 +665,16 @@ function parseKeyValuePairs(content) {
 
 function parseCycle(tagContent, _parser) {
   const content = tagContent.slice(5).trim();
-  const argRegex = /(".*?"|'.*?'|[^\s]+)/g;
-  const matches = content.match(argRegex) || [];
+  const parts = content.split(/\s+/).filter(Boolean);
   let asName = null;
   const args = [];
 
-  for (let i = 0; i < matches.length; i++) {
-    if (matches[i] === 'as' && i < matches.length - 1) {
-      asName = matches[i + 1];
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] === 'as' && i < parts.length - 1) {
+      asName = parts[i + 1];
       break;
     }
-    args.push(matches[i]);
+    args.push(parts[i]);
   }
 
   return new CycleNode(args, asName);
@@ -692,8 +682,79 @@ function parseCycle(tagContent, _parser) {
 
 function parseFirstof(tagContent, _parser) {
   const content = tagContent.slice(8).trim();
-  const argRegex = /(".*?"|'.*?'|[^\s]+)/g;
-  const args = (content.match(argRegex) || []).map(a => a.trim()).filter(Boolean);
+  const args = [];
+  let i = 0;
+  const len = content.length;
+
+  while (i < len) {
+    while (i < len && /\s/.test(content[i])) i++;
+    if (i >= len) break;
+
+    let expr = '';
+    if (content[i] === '"' || content[i] === '\'') {
+      const quote = content[i];
+      expr += content[i];
+      i++;
+      while (i < len && content[i] !== quote) {
+        if (content[i] === '\\' && i + 1 < len) {
+          expr += content[i];
+          i++;
+        }
+        expr += content[i];
+        i++;
+      }
+      if (i < len) {
+        expr += content[i];
+        i++;
+      }
+      while (i < len && !/\s/.test(content[i])) {
+        if (content[i] === '|') {
+          expr += content[i];
+          i++;
+          while (i < len && content[i] !== ':' && content[i] !== '|' && !/\s/.test(content[i])) {
+            expr += content[i];
+            i++;
+          }
+          if (i < len && content[i] === ':') {
+            expr += content[i];
+            i++;
+            if (i < len && (content[i] === '"' || content[i] === '\'')) {
+              const q = content[i];
+              expr += content[i];
+              i++;
+              while (i < len && content[i] !== q) {
+                if (content[i] === '\\' && i + 1 < len) {
+                  expr += content[i];
+                  i++;
+                }
+                expr += content[i];
+                i++;
+              }
+              if (i < len) {
+                expr += content[i];
+                i++;
+              }
+            } else {
+              while (i < len && content[i] !== '|' && !/\s/.test(content[i])) {
+                expr += content[i];
+                i++;
+              }
+            }
+          }
+        } else {
+          break;
+        }
+      }
+    } else {
+      while (i < len && !/\s/.test(content[i])) {
+        expr += content[i];
+        i++;
+      }
+    }
+
+    if (expr) args.push(expr);
+  }
+
   return new FirstofNode(args);
 }
 

package/src/tags/extra.js

@@ -2,20 +2,7 @@
  * Additional utility template tags: now, set, ifchanged.
  */
 
-// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
-function resolveValue(token, context) {
-  if (token === undefined || token === null) return '';
-  if (typeof token !== 'string') return token;
-  if (token === '') return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
-  return context.get(token);
-}
+const { evaluateExpression } = require('../parser');
 
 // --- {% now %} tag ---
 
@@ -25,7 +12,7 @@ class NowNode {
   }
 
   render(context) {
-    const fmt = resolveValue(this.formatExpr, context);
+    const fmt = evaluateExpression(this.formatExpr, context);
     const now = new Date();
     if (!fmt) return now.toISOString();
     const dateFilter = require('../filters');
@@ -49,7 +36,7 @@ class SetNode {
 
   render(context) {
     const name = String(this.nameExpr);
-    const value = this.valueExpr !== undefined ? resolveValue(this.valueExpr, context) : '';
+    const value = this.valueExpr !== undefined ? evaluateExpression(this.valueExpr, context) : '';
     if (name) {
       context.scopes[0][name] = value;
     }
@@ -90,7 +77,7 @@ class IfChangedNode {
   }
 
   render(context) {
-    const currentVal = this.conditionStr ? resolveValue(this.conditionStr, context) : undefined;
+    const currentVal = this.conditionStr ? evaluateExpression(this.conditionStr, context) : undefined;
 
     if (!context.ifChangedState) {
       context.ifChangedState = new Map();

package/src/tags/i18n.js

@@ -2,6 +2,7 @@
  * i18n template tags: trans, blocktrans, language.
  */
 const i18n = require('../i18n');
+const { evaluateExpression } = require('../parser');
 
 /**
  * {% trans "translation key" %}
@@ -18,19 +19,10 @@ class TransNode {
     const params = {};
     if (this.args) {
       for (const [k, v] of Object.entries(this.args)) {
-        params[k] = context.get(v);
+        params[k] = evaluateExpression(v, context);
       }
     }
-    // For unquoted keys: if the key is a variable name, resolve it
-    let key = this.key;
-    if (!key.startsWith('"') && !key.startsWith('\'') && !key.includes(' ')) {
-      const resolved = context.get(key);
-      if (typeof resolved === 'string' && resolved.length > 0) {
-        key = resolved;
-      }
-    } else {
-      key = key.slice(1, -1);
-    }
+    const key = evaluateExpression(this.key, context);
     return i18n.lookup(key, params);
   }
 }
@@ -42,10 +34,7 @@ class LanguageNode {
   }
 
   render(context) {
-    // Strip quotes
-    const lang = this.lang.startsWith('"') || this.lang.startsWith('\'')
-      ? this.lang.slice(1, -1)
-      : (context.get(this.lang) || this.lang);
+    const lang = evaluateExpression(this.lang, context);
     const previous = i18n.getLanguage();
     i18n.setLanguage(lang);
     try {
@@ -75,11 +64,11 @@ class BlockTransNode {
     // 1. Apply {% with %} mappings to a local scope
     const localParams = {};
     for (const m of this.withMappings) {
-      localParams[m.name] = context.get(m.valPath);
+      localParams[m.name] = evaluateExpression(m.valPath, context);
     }
     // 2. Apply {% plural count %} mappings
     for (const m of this.pluralMappings) {
-      localParams[m.name] = context.get(m.valPath);
+      localParams[m.name] = evaluateExpression(m.valPath, context);
     }
 
     // 3. Reassemble the full text

package/src/tags/inheritance.js

@@ -4,21 +4,7 @@
 const fs = require('fs');
 const path = require('path');
 const { Context } = require('../context');
-
-// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
-function resolveValue(token, context) {
-  if (token === undefined || token === null) return '';
-  if (typeof token !== 'string') return token;
-  if (token === '') return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
-  return context.get(token);
-}
+const { evaluateExpression } = require('../parser');
 
 class ExtendsNode {
   constructor(parentTemplateExpr) {
@@ -26,7 +12,7 @@ class ExtendsNode {
   }
 
   render(context) {
-    const parentName = resolveValue(this.parentTemplateExpr, context);
+    const parentName = evaluateExpression(this.parentTemplateExpr, context);
     if (!parentName) return '';
     context.parentTemplate = parentName;
     return '';
@@ -98,7 +84,7 @@ class IncludeNode {
   }
 
   render(context) {
-    const rawName = resolveValue(this.templateNameExpr, context);
+    const rawName = evaluateExpression(this.templateNameExpr, context);
     if (!rawName) return '';
 
     // Django-style partial selector: "home.html#card" means render
@@ -183,7 +169,7 @@ class IncludeNode {
       if (this.extraMappings && this.extraMappings.length > 0) {
         const extraScope = {};
         for (const m of this.extraMappings) {
-          extraScope[m.name] = resolveValue(m.valPath, context);
+          extraScope[m.name] = evaluateExpression(m.valPath, context);
         }
         renderCtx.push(extraScope);
         const out = partial.body.map(n => n.render(renderCtx)).join('');
@@ -198,7 +184,7 @@ class IncludeNode {
     if (this.extraMappings && this.extraMappings.length > 0) {
       const extraScope = {};
       for (const mapping of this.extraMappings) {
-        extraScope[mapping.name] = resolveValue(mapping.valPath, context);
+        extraScope[mapping.name] = evaluateExpression(mapping.valPath, context);
       }
       context.push(extraScope);
       const res = nodes.map(n => n.render(context)).join('');
@@ -308,7 +294,7 @@ function parseKeyValuePairs(str) {
         val += str[i++];
       }
       if (str[i] === quote) i++;
-      // Preserve quotes so resolveValue can recognize the literal
+      // Preserve quotes so evaluateExpression can recognize the literal
       val = quote + val + quote;
     } else {
       // Unquoted value: read until comma or whitespace

package/src/tags/util.js

@@ -2,22 +2,7 @@
  * Utility template tags: static, url, regroup, spaceless.
  */
 
-// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
-function resolveValue(token, context) {
-  if (token === undefined || token === null) return '';
-  if (typeof token !== 'string') return token;
-  if (token === '') return '';
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
-    return token.slice(1, -1);
-  }
-  if (token === 'true' || token === 'True') return true;
-  if (token === 'false' || token === 'False') return false;
-  if (token === 'none' || token === 'None' || token === 'null') return null;
-  // Numeric literal (integer or float)
-  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
-  // Otherwise treat as a context variable lookup
-  return context.get(token);
-}
+const { evaluateExpression } = require('../parser');
 
 class StaticNode {
   constructor(pathExpr) {
@@ -25,7 +10,7 @@ class StaticNode {
   }
 
   render(context) {
-    const resolvedPath = resolveValue(this.pathExpr, context);
+    const resolvedPath = evaluateExpression(this.pathExpr, context);
 
     // Resolve static prefix
     let prefix = '/static/';
@@ -55,11 +40,11 @@ class UrlNode {
   }
 
   render(context) {
-    const routeName = resolveValue(this.routeNameExpr, context);
-    const resolvedPositional = this.positionalArgs.map(arg => resolveValue(arg, context));
+    const routeName = evaluateExpression(this.routeNameExpr, context);
+    const resolvedPositional = this.positionalArgs.map(arg => evaluateExpression(arg, context));
     const resolvedKwargs = {};
     for (const kw of this.kwargs) {
-      resolvedKwargs[kw.name] = resolveValue(kw.valueExpr, context);
+      resolvedKwargs[kw.name] = evaluateExpression(kw.valueExpr, context);
     }
     const hasKwargs = Object.keys(resolvedKwargs).length > 0;