miki-template 2.3.3 → 2.3.4

package/README.md

@@ -19,6 +19,8 @@ you can register your own custom filters and filters in miki templates.
 - **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 (`{% %}`). **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.3",
+  "version": "2.3.4",
   "description": "Django-Style template engine for Node.js and Express",
   "main": "src/index.js",
   "exports": {

package/src/codegen.js

@@ -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} }`;
@@ -852,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`);
@@ -1019,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/tags/control.js

@@ -333,6 +333,12 @@ class FirstofNode {
   }
 }
 
+class EndFirstofNode {
+  render(_context) {
+    return '';
+  }
+}
+
 class CommentNode {
   constructor(body) {
     this.body = body;
@@ -758,12 +764,39 @@ function parseFirstof(tagContent, _parser) {
   return new FirstofNode(args);
 }
 
+class ResetCycleNode {
+  constructor(key) {
+    this.key = key ? key.trim() : null;
+  }
+
+  render(context) {
+    if (!context.cycleStates) context.cycleStates = new Map();
+    if (this.key) {
+      context.cycleStates.set(this.key, 0);
+    } else {
+      context.cycleStates.clear();
+    }
+    return '';
+  }
+}
+
+function parseResetCycle(tagContent, _parser) {
+  const key = tagContent.slice(11).trim() || null;
+  return new ResetCycleNode(key);
+}
+
+function parseEndFirstof(_tagContent, _parser) {
+  return new EndFirstofNode();
+}
+
 module.exports = {
   IfNode,
   ForNode,
   WithNode,
   CycleNode,
   FirstofNode,
+  EndFirstofNode,
+  ResetCycleNode,
   CommentNode,
   AutoescapeNode,
   PartialDefNode,
@@ -779,6 +812,8 @@ module.exports = {
     comment: parseComment,
     partialdef: parsePartialDef,
     partial: parsePartial,
-    firstof: parseFirstof
+    firstof: parseFirstof,
+    endfirstof: parseEndFirstof,
+    resetcycle: parseResetCycle
   }
 };

package/src/tags/i18n.js

@@ -119,6 +119,76 @@ function parseTrans(tagContent, _parser) {
   return new TransNode(key, Object.keys(args).length ? args : null);
 }
 
+function parseTranslate(tagContent, _parser) {
+  const trimmed = tagContent.slice(9).trim(); // strip "translate"
+  const tokens = trimmed.match(/(?:"[^"]*"|'[^']*'|\S+)/g) || [];
+
+  let keyIdx = 0;
+  if (tokens[0] && tokens[0] === 'context') {
+    keyIdx = 2;
+  }
+  const key = tokens[keyIdx] || '';
+  const args = {};
+  for (let i = keyIdx + 1; i < tokens.length; i++) {
+    const eq = tokens[i].indexOf('=');
+    if (eq > 0) {
+      const name = tokens[i].slice(0, eq);
+      let val = tokens[i].slice(eq + 1);
+      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith('\'') && val.endsWith('\''))) {
+        val = val.slice(1, -1);
+      }
+      args[name] = val;
+    }
+  }
+  return new TransNode(key, Object.keys(args).length ? args : null);
+}
+
+function parseBlockTranslate(tagContent, parser) {
+  const body = parser.parse(['endblocktranslate']);
+  const next = parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endblocktranslate') {
+    parser.advance();
+  }
+
+  const withMappings = [];
+  const pluralMappings = [];
+  const afterTrans = tagContent.replace(/^blocktranslate\s*/, '').trim();
+  const tokens = afterTrans.match(/(?:"[^"]*"|'[^']*'|\S+)/g) || [];
+  let i = 0;
+  if (tokens[i] === 'context') i += 2;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (tok === 'with') {
+      i++;
+      while (i < tokens.length && tokens[i].indexOf('=') > 0) {
+        const pair = tokens[i];
+        const eq = pair.indexOf('=');
+        const name = pair.slice(0, eq);
+        let val = pair.slice(eq + 1);
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith('\'') && val.endsWith('\''))) {
+          val = val.slice(1, -1);
+        }
+        withMappings.push({ name, valPath: val });
+        i++;
+      }
+    } else if (tok === 'count') {
+      i++;
+      const countVal = tokens[i] || '1';
+      pluralMappings.push({ name: 'count', valPath: countVal });
+      i++;
+    } else {
+      i++;
+    }
+  }
+
+  return new BlockTransNode(
+    extractTextAndVars(body),
+    withMappings.length ? withMappings : extractWithMappings(body),
+    pluralMappings,
+    body
+  );
+}
+
 function parseLanguage(tagContent, parser) {
   const lang = tagContent.slice(9).trim(); // strip "language"
   const body = parser.parse(['endlanguage']);
@@ -238,8 +308,10 @@ module.exports = {
   PluralMappingNode,
   parsers: {
     trans: parseTrans,
+    translate: parseTranslate,
     language: parseLanguage,
     blocktrans: parseBlockTrans,
+    blocktranslate: parseBlockTranslate,
     plural: parsePlural
   }
 };

package/src/tags/util.js

@@ -2,7 +2,7 @@
  * Utility template tags: static, url, regroup, spaceless.
  */
 
-const { evaluateExpression } = require('../parser');
+const { evaluateExpression, parseVariableExpression, VariableNode } = require('../parser');
 
 class StaticNode {
   constructor(pathExpr) {
@@ -315,6 +315,147 @@ class LoadNode {
   }
 }
 
+class FilterNode {
+  constructor(filterName, filterArg, body) {
+    this.filterName = filterName;
+    this.filterArg = filterArg;
+    this.body = body || [];
+  }
+
+  render(context) {
+    const raw = this.body.map(n => n.render(context)).join('');
+    const { getFilter } = require('../filters');
+    const fn = getFilter(this.filterName);
+    if (!fn) throw new Error(`Unknown filter: '${this.filterName}'`);
+    return fn(raw, this.filterArg, context);
+  }
+}
+
+function parseFilter(tagContent, parser) {
+  const expr = tagContent.slice(6).trim();
+  const nameMatch = expr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+  const filterName = nameMatch ? nameMatch[1] : expr;
+  const rest = expr.slice(filterName.length).trim();
+  let filterArg = undefined;
+  if (rest.startsWith(':')) {
+    const argStr = rest.slice(1).trim();
+    if ((argStr.startsWith('"') && argStr.endsWith('"')) || (argStr.startsWith('\'') && argStr.endsWith('\''))) {
+      filterArg = argStr.slice(1, -1);
+    } else if (argStr) {
+      const num = Number(argStr);
+      filterArg = Number.isNaN(num) ? argStr : num;
+    }
+  }
+  const body = parser.parse(['endfilter']);
+  const next = parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endfilter') {
+    parser.advance();
+  }
+  return new FilterNode(filterName, filterArg, body);
+}
+
+class VerbatimNode {
+  constructor(body) {
+    this.body = body || [];
+  }
+
+  render(_context) {
+    return this.body.map(n => {
+      if (n.constructor.name === 'TextNode') return n.content;
+      return '';
+    }).join('');
+  }
+}
+
+function parseVerbatim(tagContent, _parser) {
+  const body = _parser.parse(['endverbatim']);
+  const next = _parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endverbatim') {
+    _parser.advance();
+  }
+  return new VerbatimNode(body);
+}
+
+class QueryStringNode {
+  constructor(args) {
+    this.args = args || [];
+  }
+
+  render(context) {
+    const params = new URLSearchParams();
+
+    for (const arg of this.args) {
+      const parsed = parseVariableExpression(arg.valueExpr);
+      const node = new VariableNode(parsed.varPath, parsed.filters, parsed.isLiteral, parsed.literalValue);
+      const value = node.render(context);
+
+      if (value === null || value === undefined || value === '') {
+        continue;
+      }
+      params.append(arg.name, String(value));
+    }
+
+    const qs = params.toString();
+    return qs ? '?' + qs : '';
+  }
+}
+
+function parseQuerystring(tagContent, _parser) {
+  const trimmed = tagContent.replace(/^querystring\s+/, '').trim();
+  const args = [];
+
+  const isQuotedString = (str) => {
+    if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith('\'') && str.endsWith('\''))) {
+      const quote = str[0];
+      const inner = str.slice(1, -1);
+      return !inner.includes(quote);
+    }
+    return false;
+  };
+
+  if (isQuotedString(trimmed)) {
+    const raw = trimmed.slice(1, -1);
+    const pairs = raw.split('&');
+    for (const pair of pairs) {
+      const [name, value] = pair.split('=');
+      if (name) {
+        args.push({ name, valueExpr: value ? `'${value}'` : '\'\'' });
+      }
+    }
+    return new QueryStringNode(args);
+  }
+
+  const argRegex = /(".*?"|'.*?'|[^\s]+)/g;
+  const matches = trimmed.match(argRegex) || [];
+
+  for (let i = 0; i < matches.length; i++) {
+    const tok = matches[i];
+    const isQuoted = (tok.startsWith('"') && tok.endsWith('"')) ||
+                     (tok.startsWith('\'') && tok.endsWith('\''));
+    if (isQuoted) {
+      const name = tok.slice(1, -1);
+      if (name.includes('=')) {
+        const [n, v] = name.split('=');
+        args.push({ name: n, valueExpr: v ? `"${v}"` : '""' });
+      } else if (i + 1 < matches.length) {
+        const valueExpr = matches[i + 1];
+        i++;
+        args.push({ name, valueExpr });
+      }
+      continue;
+    }
+
+    const eq = tok.indexOf('=');
+    if (eq > 0) {
+      const name = tok.slice(0, eq);
+      const valueExpr = tok.slice(eq + 1);
+      args.push({ name, valueExpr });
+    }
+  }
+
+  return new QueryStringNode(args);
+}
+
 class TemplatetagNode {
   constructor(token) {
     this.token = token;
@@ -370,9 +511,14 @@ module.exports = {
   TemplatetagNode,
   WidthRatioNode,
   DebugNode,
+  FilterNode,
+  VerbatimNode,
+  QueryStringNode,
   parsers: {
     static: parseStatic,
     url: parseUrl,
+    urlpk: parseUrl,
+    urlslug: parseUrl,
     regroup: parseRegroup,
     spaceless: parseSpaceless,
     csrf_token: parseCsrfToken,
@@ -380,6 +526,9 @@ module.exports = {
     load: parseLoad,
     templatetag: parseTemplatetag,
     widthratio: parseWidthRatio,
-    debug: parseDebug
+    debug: parseDebug,
+    filter: parseFilter,
+    verbatim: parseVerbatim,
+    querystring: parseQuerystring
   }
 };