miki-template 2.3.2 → 2.3.4

package/README.md

@@ -18,7 +18,9 @@ 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 %}`.
+- **Extended Tag Set**: Includes `{% filter %}`, `{% verbatim %}`, `{% resetcycle %}`, `{% endfirstof %}`, `{% translate %}`, and `{% blocktranslate %}` for full vscode-django-support parity.
+- **Extended Filter Set**: 25 additional Django contrib filters: `center`, `escapejs`, `first`, `fix_ampersands`, `force_escape`, `get_digit`, `intcomma`, `intword`, `iriencode`, `last`, `linenumbers`, `ljust`, `make_list`, `naturalday`, `ordinal`, `phone2numeric`, `pprint`, `rjust`, `safeseq`, `STATIC_PREFIX`, `truncatewords_html`, `unordered_list`, `urlizetrunc`, `wordwrap`, `apnumber`.
 - **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.4",
   "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];
@@ -362,6 +362,35 @@ function genNode(node, stmts, level, buf = 'out', loopVarMap = {}) {
     stmts.push(pad(`${buf} += _firstof(_ctx, ${js(node.args)});`, level));
     return;
 
+  case 'EndFirstofNode':
+    return;
+
+  case 'FilterNode': {
+    stmts.push(pad('{', level));
+    stmts.push(pad('let _filterBuf = \'\';', level + 1));
+    genNodes(node.body, stmts, level + 1, '_filterBuf', loopVarMap);
+    stmts.push(pad(`${buf} += _applyFilter(_ctx, ${js(node.filterName)}, _filterBuf, ${js(node.filterArg)});`, level));
+    stmts.push(pad('}', level));
+    return;
+  }
+
+  case 'VerbatimNode': {
+    stmts.push(pad('{', level));
+    stmts.push(pad('let _verbatimBuf = \'\';', level + 1));
+    for (const n of node.body) {
+      if (n.constructor.name === 'TextNode' && n.content) {
+        stmts.push(pad(`_verbatimBuf += ${js(n.content)};`, level + 1));
+      }
+    }
+    stmts.push(pad(`${buf} += _verbatimBuf;`, level));
+    stmts.push(pad('}', level));
+    return;
+  }
+
+  case 'ResetCycleNode':
+    stmts.push(pad(`_resetCycle(_ctx, ${js(node.key)});`, level));
+    return;
+
   case 'PartialDefNode': {
     stmts.push(pad(`_registerPartial(_ctx, ${js(node.name)}, _partials[${node._partialId}]);`, level));
     if (node.inline) {
@@ -635,7 +664,8 @@ function buildCode(nodes) {
     '_csp_nonce', '_loadLibs', '_debug', '_now', '_set', '_ifchanged',
     '_resolveVal', '_helperCall', '_missingFilter', '_normalizeFor',
     '_trans', '_blocktrans', '_registerPartial', '_extends', '_block',
-    '_language', '_fallback', '_SafeString', '_astNodes', '_partials', '_languages', '_in'
+    '_language', '_fallback', '_SafeString', '_astNodes', '_partials', '_languages', '_in',
+    '_applyFilter', '_resetCycle'
   ];
 
   const src = `"use strict"; return function(${args.join(',')}) { ${body} }`;
@@ -670,14 +700,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);
+
+  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 (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);
+
+  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) {
@@ -721,6 +882,22 @@ function firstofHelper(ctx, args) {
   return '';
 }
 
+function applyFilterHelper(ctx, filterName, raw, filterArg) {
+  const { getFilter } = require('./filters');
+  const fn = getFilter(filterName);
+  if (!fn) throw new Error(`Unknown filter: '${filterName}'`);
+  return fn(raw, filterArg, ctx);
+}
+
+function resetCycleHelper(ctx, key) {
+  if (!ctx.cycleStates) ctx.cycleStates = new Map();
+  if (key) {
+    ctx.cycleStates.set(key, 0);
+  } else {
+    ctx.cycleStates.clear();
+  }
+}
+
 function partialHelper(ctx, name, extra) {
   const partial = ctx.getPartial(name);
   if (!partial) throw new Error(`Partial '${name}' not found`);
@@ -888,7 +1065,9 @@ function generateCode(nodes) {
       flat,
       partialsList,
       languagesList,
-      inHelper
+      inHelper,
+      applyFilterHelper,
+      resetCycleHelper
     );
   };
 }

package/src/filters.js

@@ -301,6 +301,11 @@ registerFilter('timeuntil', (val, arg) => {
   return `${diffDays} day${diffDays !== 1 ? 's' : ''}`;
 });
 
+registerFilter('timeutil', (val, arg) => {
+  const fn = getFilter('timeuntil');
+  return fn(val, arg);
+});
+
 // --- Numeric Filters ---
 registerFilter('add', (val, arg) => {
   const numVal = Number(val);
@@ -786,15 +791,42 @@ registerFilter('reverse', (val) => {
 
 registerFilter('sort', (val) => {
   if (!Array.isArray(val)) return val;
+
   return [...val].sort((a, b) => {
+    // Handle equality
     if (a === b) return 0;
-    if (a === null || a === undefined) return 1;
-    if (b === null || b === undefined) return -1;
-    if (typeof a === 'string' && typeof b === 'string') return a.localeCompare(b);
-    return a < b ? -1 : 1;
+
+    // Handle null/undefined consistently
+    if (a == null && b == null) return 0;
+    if (a == null) return 1;
+    if (b == null) return -1;
+
+    // Try numeric comparison
+    const numA = parseFloat(a);
+    const numB = parseFloat(b);
+    const isNumA = !Number.isNaN(numA);
+    const isNumB = !Number.isNaN(numB);
+
+    if (isNumA && isNumB) {
+      return numA - numB;
+    }
+
+    // Handle booleans explicitly
+    if (typeof a === 'boolean' && typeof b === 'boolean') {
+      return (a === b) ? 0 : (a ? 1 : -1);
+    }
+
+    // Handle strings with locale-aware comparison
+    if (typeof a === 'string' && typeof b === 'string') {
+      return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+    }
+
+    // Fallback: convert to string and compare
+    return String(a).localeCompare(String(b), undefined, { numeric: true, sensitivity: 'base' });
   });
 });
 
+
 registerFilter('unique', (val) => {
   if (!Array.isArray(val)) return val;
   return [...new Set(val)];
@@ -987,5 +1019,212 @@ registerFilter('range', (val, arg) => {
   return out;
 });
 
+// --- Django contrib filters ---
+
+registerFilter('center', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const width = parseInt(arg, 10);
+  if (Number.isNaN(width) || width <= 0) return str;
+  const len = str.length;
+  if (len >= width) return str;
+  const pad = width - len;
+  const left = Math.floor(pad / 2);
+  const right = pad - left;
+  return ' '.repeat(left) + str + ' '.repeat(right);
+});
+
+registerFilter('escapejs', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  return str.replace(/\\/g, '\\\\')
+    .replace(/'/g, '\\\'')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t')
+    .replace(/</g, '\\x3C')
+    .replace(/>/g, '\\x3E')
+    .replace(/&/g, '\\x26');
+});
+
+registerFilter('first', (val) => {
+  if (Array.isArray(val) && val.length > 0) return val[0];
+  if (typeof val === 'string' && val.length > 0) return val[0];
+  return '';
+});
+
+registerFilter('fix_ampersands', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  return str.replace(/&/g, '&amp;').replace(/&amp;#/g, '&#');
+});
+
+registerFilter('force_escape', (val) => {
+  const { escapeHtml } = require('./security');
+  return escapeHtml(String(val === null || val === undefined ? '' : val), true);
+});
+
+registerFilter('get_digit', (val, arg) => {
+  const str = String(Math.abs(Number(val)));
+  const idx = parseInt(arg, 10);
+  if (Number.isNaN(idx) || idx < 0 || idx >= str.length) return '';
+  return str[str.length - 1 - idx];
+});
+
+registerFilter('intcomma', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const num = parseInt(str, 10);
+  if (Number.isNaN(num)) return str;
+  return num.toLocaleString('en-US');
+});
+
+registerFilter('intword', (val) => {
+  const num = parseInt(val, 10);
+  if (Number.isNaN(num)) return '';
+  if (num >= 1000000) {
+    const w = (num / 1000000).toFixed(1).replace(/\.0$/, '');
+    return w + ' million';
+  }
+  if (num >= 1000) {
+    const w = (num / 1000).toFixed(1).replace(/\.0$/, '');
+    return w + ' thousand';
+  }
+
+  return String(num);
+});
+
+registerFilter('iriencode', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  return encodeURIComponent(str);
+});
+
+registerFilter('last', (val) => {
+  if (Array.isArray(val) && val.length > 0) return val[val.length - 1];
+  if (typeof val === 'string' && val.length > 0) return val[val.length - 1];
+  return '';
+});
+
+registerFilter('linenumbers', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const lines = str.split('\n');
+  return lines.map((line, i) => `${i + 1}. ${line}`).join('\n');
+});
+
+registerFilter('ljust', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const width = parseInt(arg, 10);
+  if (Number.isNaN(width) || width <= 0) return str;
+  return str.padEnd(width, ' ');
+});
+
+registerFilter('make_list', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  return str.split('');
+});
+
+registerFilter('naturalday', (val) => {
+  const date = new Date(val);
+  if (Number.isNaN(date.getTime())) return String(val);
+  const now = new Date();
+  const diff = Math.floor((now.setHours(0, 0, 0, 0) - date.setHours(0, 0, 0, 0)) / 86400000);
+  if (diff === 0) return 'today';
+  if (diff === 1) return 'yesterday';
+  if (diff === -1) return 'tomorrow';
+  return date.toLocaleDateString();
+});
+
+registerFilter('ordinal', (val) => {
+  const num = parseInt(val, 10);
+  if (Number.isNaN(num)) return String(val);
+  const s = ['th', 'st', 'nd', 'rd'];
+  const v = num % 100;
+  return num + (s[(v - 20) % 10] || s[v] || s[0]);
+});
+
+registerFilter('phone2numeric', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const map = { a: '2', b: '2', c: '2', d: '3', e: '3', f: '3', g: '4', h: '4', i: '4', j: '5', k: '5', l: '5', m: '6', n: '6', o: '6', p: '7', q: '7', r: '7', s: '7', t: '8', u: '8', v: '8', w: '9', x: '9', y: '9', z: '9' };
+  return str.toLowerCase().replace(/[a-z]/g, (c) => map[c] || c);
+});
+
+registerFilter('pprint', (val) => {
+  return JSON.stringify(val, null, 2);
+});
+
+registerFilter('rjust', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const width = parseInt(arg, 10);
+  if (Number.isNaN(width) || width <= 0) return str;
+  return str.padStart(width, ' ');
+});
+
+registerFilter('safeseq', (val) => {
+  const { markSafe } = require('./security');
+  if (Array.isArray(val)) return val.map(markSafe);
+  return val;
+});
+
+registerFilter('STATIC_PREFIX', (val) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  return '/static/' + str.replace(/^\/+/, '');
+});
+
+registerFilter('truncatewords_html', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const count = parseInt(arg, 10);
+  if (Number.isNaN(count) || count <= 0) return '';
+  const words = str.replace(/<[^>]*>/g, '').split(/\s+/).filter(Boolean);
+  if (words.length <= count) return str;
+  const plain = words.slice(0, count).join(' ');
+  return plain + '...';
+});
+
+registerFilter('unordered_list', (val) => {
+  if (!Array.isArray(val)) return String(val);
+  const items = val.map(item => {
+    if (Array.isArray(item)) {
+      const nested = item.map(sub => `<li>${String(sub)}</li>`).join('');
+      return `<ul>${nested}</ul>`;
+    }
+    return `<li>${String(item)}</li>`;
+  }).join('');
+  return `<ul>${items}</ul>`;
+});
+
+registerFilter('urlizetrunc', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const maxlen = arg !== undefined && arg !== null ? parseInt(arg, 10) : 30;
+  const urlRe = /(https?:\/\/[^\s]+)/g;
+  return str.replace(urlRe, (url) => {
+    const display = url.length > maxlen ? url.slice(0, maxlen) + '...' : url;
+    return `<a href="${url}" rel="nofollow">${display}</a>`;
+  });
+});
+
+registerFilter('wordwrap', (val, arg) => {
+  const str = String(val === null || val === undefined ? '' : val);
+  const width = parseInt(arg, 10);
+  if (Number.isNaN(width) || width <= 0) return str;
+  const words = str.split(/\s+/);
+  const lines = [];
+  let line = '';
+  for (const word of words) {
+    if ((line + ' ' + word).trim().length > width) {
+      if (line) lines.push(line);
+      line = word;
+    } else {
+      line = (line + ' ' + word).trim();
+    }
+  }
+  if (line) lines.push(line);
+  return lines.join('\n');
+});
+
+registerFilter('apnumber', (val) => {
+  const num = parseInt(val, 10);
+  if (Number.isNaN(num)) return String(val);
+  const map = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen', 'twenty'];
+  if (num <= 20) return map[num] || String(num);
+  return String(num);
+});
+
 module.exports = { registerFilter, getFilter };
 

package/src/libraries.js

@@ -142,7 +142,7 @@ registerLibrary('humanize', {
     apnumber: (val) => {
       const n = parseInt(val, 10);
       const words = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
-        'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
+        'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen', 'twenty'];
       if (!isNaN(n) && n >= 0 && n < words.length) return words[n];
       return String(val);
     },

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
 };