miki-template 1.2.0 → 1.3.3

package/src/lexer.js

@@ -14,74 +14,96 @@ function tokenize(template) {
     throw new TypeError('Template must be a string');
   }
 
-  // Regex to split by delimiters: {{ ... }}, {% ... %}, and {# ... #}
-  // Using 's' flag to match dot as newline (dotAll)
-  const tagRegexp = /(\{\{.*?\}\}|\{\%.*?\%\}|\{\#.*?\#\})/gs;
-  const parts = template.split(tagRegexp);
   const tokens = [];
-  
+  let i = 0;
+  const len = template.length;
   let inVerbatim = false;
   let verbatimBuffer = [];
 
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (part === undefined || part === null) continue;
+  while (i < len) {
+    // Detect the start of a variable, block, or comment.
+    if (template[i] === '{' && i + 1 < len) {
+      const next = template[i + 1];
+      if (next === '{' || next === '%' || next === '#') {
+        // Find the matching closer, accounting for nested {{ }} and {% %}
+        // so expressions like {{ x|default:"{{ y }}" }} parse correctly.
+        const isVar = next === '{';
+        const isBlock = next === '%';
+        const isComment = next === '#';
+        const closer = isVar ? '}}' : (isBlock ? '%}' : '#}');
+        let j = i + 2;
+        let depth = 1;
+        while (j < len && depth > 0) {
+          if (isVar && template[j] === '{' && template[j + 1] === '{') {
+            depth++;
+            j += 2;
+            continue;
+          }
+          if (isBlock && template[j] === '{' && template[j + 1] === '%') {
+            depth++;
+            j += 2;
+            continue;
+          }
+          if (template.substr(j, closer.length) === closer) {
+            depth--;
+            if (depth === 0) break;
+            j += closer.length;
+            continue;
+          }
+          j++;
+        }
+        if (depth !== 0) {
+          throw new Error(`Unclosed template tag at position ${i}`);
+        }
+        const raw = template.slice(i, j + closer.length);
+        const inner = template.slice(i + 2, j).trim();
 
-    // Handle verbatim mode
-    if (inVerbatim) {
-      if (part.startsWith('{%') && part.endsWith('%}') && part.slice(2, -2).trim() === 'endverbatim') {
-        inVerbatim = false;
-        if (verbatimBuffer.length > 0) {
-          tokens.push({
-            type: 'text',
-            content: verbatimBuffer.join('')
-          });
-          verbatimBuffer = [];
+        if (inVerbatim) {
+          if (isBlock && inner === 'endverbatim') {
+            inVerbatim = false;
+            if (verbatimBuffer.length > 0) {
+              tokens.push({ type: 'text', content: verbatimBuffer.join('') });
+              verbatimBuffer = [];
+            }
+          } else {
+            verbatimBuffer.push(raw);
+          }
+        } else if (isComment) {
+          // Comments are ignored
+        } else if (isVar) {
+          tokens.push({ type: 'var', content: inner, raw });
+        } else {
+          // Block tag
+          if (inner === 'verbatim') {
+            inVerbatim = true;
+          } else {
+            tokens.push({ type: 'block', content: inner, raw });
+          }
         }
-      } else {
-        verbatimBuffer.push(part);
+        i = j + closer.length;
+        continue;
       }
-      continue;
     }
 
-    if (part.startsWith('{#') && part.endsWith('#}')) {
-      // Comments are ignored in the token output
-      continue;
-    } else if (part.startsWith('{{') && part.endsWith('}}')) {
-      const content = part.slice(2, -2).trim();
-      tokens.push({
-        type: 'var',
-        content,
-        raw: part
-      });
-    } else if (part.startsWith('{%') && part.endsWith('%}')) {
-      const content = part.slice(2, -2).trim();
-      if (content === 'verbatim') {
-        inVerbatim = true;
-      } else {
-        tokens.push({
-          type: 'block',
-          content,
-          raw: part
-        });
-      }
-    } else {
-      // Do not push empty text tokens to keep AST clean
-      if (part !== '') {
-        tokens.push({
-          type: 'text',
-          content: part
-        });
+    // Plain text — collect until the next special delimiter.
+    let textStart = i;
+    while (i < len) {
+      if (template[i] === '{' && i + 1 < len) {
+        const nx = template[i + 1];
+        if (nx === '{' || nx === '%' || nx === '#') break;
       }
+      i++;
+    }
+    const text = template.slice(textStart, i);
+    if (inVerbatim) {
+      verbatimBuffer.push(text);
+    } else if (text !== '') {
+      tokens.push({ type: 'text', content: text });
     }
   }
 
-  // If verbatim wasn't closed, treat the remaining buffer as text
   if (inVerbatim && verbatimBuffer.length > 0) {
-    tokens.push({
-      type: 'text',
-      content: verbatimBuffer.join('')
-    });
+    tokens.push({ type: 'text', content: verbatimBuffer.join('') });
   }
 
   return tokens;

package/src/libraries.js

@@ -18,6 +18,13 @@ const path = require('path');
 
 const libraries = new Map(); // Map<name, libraryDef>
 
+// Registration functions are injected by index.js to break the
+// circular dependency between libraries.js and index.js.
+let registrationFunctions = null;
+function setRegistrationFunctions(fns) {
+  registrationFunctions = fns;
+}
+
 /**
  * Register a library.
  *
@@ -92,7 +99,9 @@ function activateLibrary(name) {
   if (!lib) {
     throw new Error(`Library not found: '${name}'`);
   }
-  const { registerTag, registerFilter, registerHelper } = require('./index');
+  // Require lazily; index.js will pass the real registration
+  // functions via setRegistrationFunctions() before calling us.
+  const { registerTag, registerFilter, registerHelper } = registrationFunctions || require('./index');
   for (const [tagName, parserFn] of Object.entries(lib.tags || {})) {
     registerTag(tagName, parserFn);
   }
@@ -199,15 +208,15 @@ registerLibrary('cache', {
   }
 });
 
-/** Lorem: generate placeholder text. */
+/** Lorem: generate placeholder text (Django-compatible). */
 registerLibrary('lorem', {
   filters: {
     lorem: (val, arg) => {
-      const text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.';
       let n = parseInt(arg, 10);
       if (isNaN(n)) n = 5;
       if (n < 1) n = 1;
       if (n > 100) n = 100;
+      const text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.';
       const words = text.split(' ');
       let result = [];
       for (let i = 0; i < n; i++) {
@@ -215,6 +224,127 @@ registerLibrary('lorem', {
       }
       return result.join(' ');
     }
+  },
+  tags: {
+    // Django-compatible lorem tag.
+    //
+    //   {% lorem [count] [method] [random] %}
+    //
+    //   count   - number of words/paragraphs to generate (default 1)
+    //   method  - w (words), p (HTML paragraphs), b (plain-text blocks, default)
+    //   random  - skip the common "Lorem ipsum dolor sit amet..." opening
+    //
+    //   {% lorem %}             -> one block of common Lorem ipsum
+    //   {% lorem 3 p %}         -> common paragraph + 2 random <p> blocks
+    //   {% lorem 2 w random %}  -> 2 random words
+    //
+    // The tag is built into the engine and requires no {% load lorem %}.
+    lorem: (tagContent, _parser) => {
+      return {
+        render: () => {
+          // The tag registry calls the parser with the full content
+          // including the tag name. For "{% lorem 3 p random %}" the
+          // tagContent is "lorem 3 p random".
+          const parts = tagContent.trim().split(/\s+/);
+
+          // count = first numeric token (or 1 if none)
+          let n = 1;
+          for (let i = 0; i < parts.length; i++) {
+            const num = parseInt(parts[i], 10);
+            if (!isNaN(num) && String(num) === parts[i]) { n = Math.max(1, num); break; }
+          }
+          // method = w | b | p (default b, like Django)
+          let unit = 'b';
+          for (let i = 0; i < parts.length; i++) {
+            if (/^(w|b|p|words?|blocks?|paragraphs?)$/i.test(parts[i])) {
+              unit = parts[i][0].toLowerCase();
+              break;
+            }
+          }
+          // random = presence of the literal word "random"
+          const random = parts.some(t => t.toLowerCase() === 'random');
+
+          // The famous "common paragraph" Django uses as the seed.
+          const COMMON = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.';
+          // Word bank used to assemble random text when the "random"
+          // keyword is given. Picked from the same Latin vocabulary.
+          const WORDS = ('lorem ipsum dolor sit amet consectetur adipisicing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua enim ad minim veniam quis nostrud exercitation ullamco laboris nisi aliquip ex ea commodo consequat duis aute irure in voluptate velit esse cillum fugiat nulla pariatur excepteur sint occaecat cupidatat non proident sunt culpa qui officia deserunt mollit anim id est laborum').split(' ');
+
+          // The non-random blocks cycle through a fixed set of
+          // sentences taken from the COMMON paragraph above (the
+          // first one is the "Lorem ipsum dolor sit amet" line).
+          const SENTENCES = [
+            'Lorem ipsum dolor sit amet, consectetur adipisicing elit.',
+            'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.',
+            'Ut enim ad minim veniam, quis nostrud exercitation.',
+            'Duis aute irure dolor in reprehenderit in voluptate velit.',
+            'Excepteur sint occaecat cupidatat non proident.'
+          ];
+
+          if (unit === 'w') {
+            // Words
+            if (random) {
+              const out = [];
+              for (let i = 0; i < n; i++) {
+                out.push(WORDS[Math.floor(Math.random() * WORDS.length)]);
+              }
+              return out.join(' ');
+            }
+            // Non-random: first word is always "lorem", the rest
+            // continue the common paragraph.
+            const commonWords = COMMON.replace(/[.,]/g, '').split(/\s+/);
+            const out = [];
+            for (let i = 0; i < n; i++) {
+              out.push(commonWords[i % commonWords.length]);
+            }
+            return out.join(' ');
+          }
+
+          if (unit === 'p') {
+            // HTML paragraphs (each wrapped in <p>...</p>)
+            const out = [];
+            for (let i = 0; i < n; i++) {
+              let paragraph;
+              if (i === 0 && !random) {
+                paragraph = COMMON;
+              } else if (random) {
+                // Generate a sentence worth of random words
+                const len = 12 + Math.floor(Math.random() * 16);
+                const words = [];
+                for (let j = 0; j < len; j++) {
+                  words.push(WORDS[Math.floor(Math.random() * WORDS.length)]);
+                }
+                paragraph = words.join(' ') + '.';
+              } else {
+                paragraph = SENTENCES[(i - 1) % (SENTENCES.length - 1) + 1];
+              }
+              out.push('<p>' + paragraph + '</p>');
+            }
+            return out.join('\n');
+          }
+
+          // unit === 'b' (default): plain-text blocks separated by blank lines
+          const out = [];
+          for (let i = 0; i < n; i++) {
+            let paragraph;
+            if (i === 0 && !random) {
+              paragraph = COMMON;
+            } else if (random) {
+              const len = 30 + Math.floor(Math.random() * 20);
+              const words = [];
+              for (let j = 0; j < len; j++) {
+                words.push(WORDS[Math.floor(Math.random() * WORDS.length)]);
+              }
+              paragraph = words.join(' ') + '.';
+            } else {
+              paragraph = SENTENCES[(i - 1) % (SENTENCES.length - 1) + 1];
+            }
+            out.push(paragraph);
+          }
+          return out.join('\n\n');
+        }
+      };
+    }
   }
 });
 
@@ -236,5 +366,6 @@ module.exports = {
   hasLibrary,
   registerLibraryFromPath,
   activateLibrary,
+  setRegistrationFunctions,
   libraries
 };

package/src/parser.js

@@ -40,7 +40,7 @@ class VariableNode {
         }
       }
 
-      val = filterFn(val, argVal);
+      val = filterFn(val, argVal, context);
     }
 
     // Auto-escape logic – skip escaping if value is marked safe
@@ -123,6 +123,26 @@ function parseVariableExpression(expr) {
           idx++; // Skip opening quote
           let argVal = '';
           while (idx < len && expr[idx] !== quote) {
+            // Track nested {{ ... }} and {% ... %} so the closing
+            // quote isn't confused with one inside a nested template
+            // expression. This lets us write
+            //   {{ x|default:"{{ y|upper }}" }}
+            // where the inner `}}` must not close the outer string.
+            if (expr[idx] === '{' && idx + 1 < len && (expr[idx + 1] === '{' || expr[idx + 1] === '%')) {
+              const open = expr.substr(idx, 2);
+              const close = open === '{{' ? '}}' : '%}';
+              argVal += open;
+              idx += 2;
+              while (idx < len && expr.substr(idx, close.length) !== close) {
+                argVal += expr[idx];
+                idx++;
+              }
+              if (idx < len) {
+                argVal += close;
+                idx += close.length;
+              }
+              continue;
+            }
             if (expr[idx] === '\\') {
               idx++;
             }
@@ -131,7 +151,7 @@ function parseVariableExpression(expr) {
               idx++;
             }
           }
-          idx++; // Skip closing quote
+          if (idx < len) idx++; // Skip closing quote
           arg = { type: 'literal', value: argVal };
         } else {
           // Read unquoted token

package/src/security.js

@@ -32,9 +32,11 @@ function isSafe(value) {
 
 /**
  * Escape a string's HTML special characters unless it is marked safe.
+ * If `force` is true (used by the |escape filter), even a SafeString is
+ * re-escaped. This matches Django's `{{ value|escape }}` semantics.
  */
-function escapeHtml(value) {
-  if (value instanceof SafeString) {
+function escapeHtml(value, force = false) {
+  if (value instanceof SafeString && !force) {
     return value.toString();
   }
 

package/src/tags/control.js

@@ -282,15 +282,40 @@ class ForNode {
 }
 
 class WithNode {
-  constructor(mappings, body) {
+  constructor(mappings, body, aliasName = null) {
     this.mappings = mappings;
     this.body = body;
+    this.aliasName = aliasName;
   }
 
   render(context) {
     const scope = {};
     for (const mapping of this.mappings) {
-      scope[mapping.name] = context.get(mapping.valPath);
+      // 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;
+    }
+    // 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 %}` →
+    // `answ` holds the same value as `a`.
+    if (this.aliasName && this.mappings.length > 0) {
+      const last = this.mappings[this.mappings.length - 1];
+      scope[this.aliasName] = scope[last.name];
     }
     context.push(scope);
     const result = this.body.map(n => n.render(context)).join('');
@@ -314,6 +339,9 @@ class CycleNode {
 
     if (this.asName) {
       context.scopes[0][this.asName] = val;
+      // Django semantics: {% cycle "x" "y" as v %} produces NO output;
+      // the value is stored in `v` for later use (e.g. {{ v }}).
+      return '';
     }
     return String(val);
   }
@@ -379,8 +407,9 @@ class PartialDefNode {
 }
 
 class PartialNode {
-  constructor(name) {
+  constructor(name, extraMappings = []) {
     this.name = name;
+    this.extraMappings = extraMappings;
   }
 
   render(context) {
@@ -388,6 +417,34 @@ class PartialNode {
     if (!partial) {
       throw new Error(`Partial '${this.name}' not found`);
     }
+    // If the partial reference provided `with k=v ...`, push those
+    // values onto the scope before rendering the partial body so the
+    // body sees the overrides.
+    if (this.extraMappings && this.extraMappings.length > 0) {
+      const scope = {};
+      for (const m of this.extraMappings) {
+        const raw = m.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[m.name] = value;
+      }
+      context.push(scope);
+      const out = partial.body.map(n => n.render(context)).join('');
+      context.pop();
+      return out;
+    }
     return partial.body.map(n => n.render(context)).join('');
   }
 }
@@ -402,7 +459,8 @@ function parsePartialDef(tagContent, parser) {
   if ((name.startsWith('"') && name.endsWith('"')) || (name.startsWith('\'') && name.endsWith('\''))) {
     name = name.slice(1, -1);
   }
-  const inline = content.includes('inline');
+  // Recognize `inline` or `inline=true` as a keyword (case-insensitive)
+  const inline = /\binline\b/.test(content);
   const body = parser.parse(['endpartialdef']);
   const next = parser.peek();
   if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endpartialdef') {
@@ -412,6 +470,8 @@ function parsePartialDef(tagContent, parser) {
 }
 
 function parsePartial(tagContent, _parser) {
+  // {% partial "name" %}
+  // {% partial "name" with k1=v1 k2=v2 %}
   const content = tagContent.slice(7).trim();
   const nameMatch = content.match(/^(".*?"|'.*?'|\S+)/);
   if (!nameMatch) {
@@ -421,7 +481,16 @@ function parsePartial(tagContent, _parser) {
   if ((name.startsWith('"') && name.endsWith('"')) || (name.startsWith('\'') && name.endsWith('\''))) {
     name = name.slice(1, -1);
   }
-  return new PartialNode(name);
+
+  // Optional `with k=v k=v` clause
+  let extraMappings = [];
+  const remaining = content.slice(nameMatch[0].length).trim();
+  const withMatch = remaining.match(/^with\s+(.+)$/s);
+  if (withMatch) {
+    extraMappings = parseKeyValuePairs(withMatch[1]);
+  }
+
+  return new PartialNode(name, extraMappings);
 }
 
 /* --- Tag Registry Parsers --- */
@@ -511,25 +580,30 @@ function parseFor(tagContent, parser) {
 function parseWith(tagContent, parser) {
   const mappings = [];
   const content = tagContent.slice(4).trim();
+  let aliasName = null;
 
+  // Support three forms (matching Django plus common extensions):
+  //   1. {% with x as y %}        — alias a single expression
+  //   2. {% with a=1, b=2 %}       — bind multiple key=value pairs
+  //   3. {% with a=1, b=2 as ans %} — bind pairs then alias the last
+  //      (the `as` introduces an extra alias for the last key)
   if (content.includes(' as ')) {
     const asIdx = content.indexOf(' as ');
-    const valPath = content.slice(0, asIdx).trim();
-    const name = content.slice(asIdx + 4).trim();
-    mappings.push({ name, valPath });
-  } else {
-    // Parse key=value pairs, handling quoted values
-    const tokens = content.match(/(?:[a-zA-Z_][a-zA-Z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+))+/g) || [];
-    for (const token of tokens) {
-      const eqIdx = token.indexOf('=');
-      if (eqIdx === -1) continue;
-      const name = token.slice(0, eqIdx).trim();
-      let valPath = token.slice(eqIdx + 1).trim();
-      if ((valPath.startsWith('"') && valPath.endsWith('"')) || (valPath.startsWith('\'') && valPath.endsWith('\''))) {
-        valPath = valPath.slice(1, -1);
-      }
-      mappings.push({ name, valPath });
+    const left = content.slice(0, asIdx).trim();
+    aliasName = content.slice(asIdx + 4).trim();
+    if (left.includes('=')) {
+      // Form 3: pairs followed by `as alias`
+      const pairMappings = parseKeyValuePairs(left);
+      mappings.push(...pairMappings);
+    } else {
+      // Form 1: simple alias — left is an expression (literal or var)
+      mappings.push({ name: aliasName, valPath: left });
+      aliasName = null; // already used as the mapping name
     }
+  } else {
+    // Form 2: key=value pairs only
+    const pairMappings = parseKeyValuePairs(content);
+    mappings.push(...pairMappings);
   }
 
   const body = parser.parse(['endwith']);
@@ -538,7 +612,62 @@ function parseWith(tagContent, parser) {
     parser.advance();
   }
 
-  return new WithNode(mappings, body);
+  return new WithNode(mappings, body, aliasName);
+}
+
+/**
+ * Parse a comma-separated list of `key=value` pairs. Values may be
+ * quoted (single or double quotes) and may contain commas. Unquoted
+ * values are read up to the next comma or whitespace.
+ */
+function parseKeyValuePairs(content) {
+  const tokens = [];
+  let i = 0;
+  while (i < content.length) {
+    while (i < content.length && /\s/.test(content[i])) i++;
+    if (i >= content.length) break;
+
+    // Read identifier (key)
+    let key = '';
+    while (i < content.length && /[a-zA-Z0-9_]/.test(content[i])) {
+      key += content[i++];
+    }
+    if (!key) {
+      // Not a key — skip a char to avoid infinite loop
+      i++;
+      continue;
+    }
+    while (i < content.length && /\s/.test(content[i])) i++;
+
+    if (content[i] !== '=') {
+      // Malformed pair; skip to next comma
+      while (i < content.length && content[i] !== ',') i++;
+      if (content[i] === ',') i++;
+      continue;
+    }
+    i++; // consume '='
+    while (i < content.length && /\s/.test(content[i])) i++;
+
+    let val = '';
+    if (content[i] === '"' || content[i] === '\'') {
+      const quote = content[i++];
+      while (i < content.length && content[i] !== quote) {
+        if (content[i] === '\\' && i + 1 < content.length) i++;
+        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++];
+      }
+    }
+    tokens.push({ name: key, valPath: val });
+    while (i < content.length && /\s/.test(content[i])) i++;
+    if (content[i] === ',') i++;
+  }
+  return tokens;
 }
 
 function parseCycle(tagContent, _parser) {