binja 0.4.6 → 0.5.1

package/dist/index.js

@@ -660,6 +660,28 @@ class Parser {
       case "autoescape":
       case "verbatim":
         return this.parseSimpleBlock(start, tagName.value);
+      case "cycle":
+        return this.parseCycle(start);
+      case "firstof":
+        return this.parseFirstof(start);
+      case "ifchanged":
+        return this.parseIfchanged(start);
+      case "regroup":
+        return this.parseRegroup(start);
+      case "widthratio":
+        return this.parseWidthratio(start);
+      case "lorem":
+        return this.parseLorem(start);
+      case "csrf_token":
+        return this.parseCsrfToken(start);
+      case "debug":
+        return this.parseDebug(start);
+      case "templatetag":
+        return this.parseTemplatetag(start);
+      case "ifequal":
+        return this.parseIfequal(start, false);
+      case "ifnotequal":
+        return this.parseIfequal(start, true);
       default:
         this.skipToBlockEnd();
         return null;
@@ -963,7 +985,7 @@ class Parser {
       column: start.column
     };
   }
-  parseComment(start) {
+  parseComment(_start) {
     this.expect("BLOCK_END" /* BLOCK_END */);
     while (!this.isAtEnd()) {
       if (this.checkBlockTag("endcomment"))
@@ -973,7 +995,7 @@ class Parser {
     this.expectBlockTag("endcomment");
     return null;
   }
-  parseSimpleBlock(start, tagName) {
+  parseSimpleBlock(_start, tagName) {
     this.skipToBlockEnd();
     const endTag = `end${tagName}`;
     while (!this.isAtEnd()) {
@@ -988,6 +1010,236 @@ class Parser {
     }
     return null;
   }
+  parseCycle(start) {
+    const values = [];
+    let asVar = null;
+    let silent = false;
+    while (!this.check("BLOCK_END" /* BLOCK_END */)) {
+      if (this.check("NAME" /* NAME */) && this.peek().value === "as") {
+        this.advance();
+        asVar = this.expect("NAME" /* NAME */).value;
+        if (this.check("NAME" /* NAME */) && this.peek().value === "silent") {
+          this.advance();
+          silent = true;
+        }
+        break;
+      }
+      values.push(this.parseExpression());
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Cycle",
+      values,
+      asVar,
+      silent,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseFirstof(start) {
+    const values = [];
+    let fallback = null;
+    let asVar = null;
+    while (!this.check("BLOCK_END" /* BLOCK_END */)) {
+      if (this.check("NAME" /* NAME */) && this.peek().value === "as") {
+        this.advance();
+        asVar = this.expect("NAME" /* NAME */).value;
+        break;
+      }
+      values.push(this.parseExpression());
+    }
+    if (values.length > 0) {
+      const last = values[values.length - 1];
+      if (last.type === "Literal" && typeof last.value === "string") {
+        fallback = values.pop();
+      }
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Firstof",
+      values,
+      fallback,
+      asVar,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseIfchanged(start) {
+    const values = [];
+    while (!this.check("BLOCK_END" /* BLOCK_END */)) {
+      values.push(this.parseExpression());
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    const body = [];
+    let else_ = [];
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("else") || this.checkBlockTag("endifchanged"))
+        break;
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    if (this.checkBlockTag("else")) {
+      this.advance();
+      this.advance();
+      this.expect("BLOCK_END" /* BLOCK_END */);
+      while (!this.isAtEnd()) {
+        if (this.checkBlockTag("endifchanged"))
+          break;
+        const node = this.parseStatement();
+        if (node)
+          else_.push(node);
+      }
+    }
+    this.expectBlockTag("endifchanged");
+    return {
+      type: "Ifchanged",
+      values,
+      body,
+      else_,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseRegroup(start) {
+    const target = this.parseExpression();
+    this.expectName("by");
+    const key = this.expect("NAME" /* NAME */).value;
+    this.expectName("as");
+    const asVar = this.expect("NAME" /* NAME */).value;
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Regroup",
+      target,
+      key,
+      asVar,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseWidthratio(start) {
+    const value = this.parseExpression();
+    const maxValue = this.parseExpression();
+    const maxWidth = this.parseExpression();
+    let asVar = null;
+    if (this.check("NAME" /* NAME */) && this.peek().value === "as") {
+      this.advance();
+      asVar = this.expect("NAME" /* NAME */).value;
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Widthratio",
+      value,
+      maxValue,
+      maxWidth,
+      asVar,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseLorem(start) {
+    let count = null;
+    let method = "p";
+    let random = false;
+    if (this.check("NUMBER" /* NUMBER */)) {
+      count = {
+        type: "Literal",
+        value: parseInt(this.advance().value, 10),
+        line: start.line,
+        column: start.column
+      };
+    }
+    if (this.check("NAME" /* NAME */)) {
+      const m = this.peek().value.toLowerCase();
+      if (m === "w" || m === "p" || m === "b") {
+        method = m;
+        this.advance();
+      }
+    }
+    if (this.check("NAME" /* NAME */) && this.peek().value === "random") {
+      random = true;
+      this.advance();
+    }
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Lorem",
+      count,
+      method,
+      random,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseCsrfToken(start) {
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "CsrfToken",
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseDebug(start) {
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Debug",
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseTemplatetag(start) {
+    const tagType = this.expect("NAME" /* NAME */).value;
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    return {
+      type: "Templatetag",
+      tagType,
+      line: start.line,
+      column: start.column
+    };
+  }
+  parseIfequal(start, negated) {
+    const left = this.parseExpression();
+    const right = this.parseExpression();
+    this.expect("BLOCK_END" /* BLOCK_END */);
+    const test = {
+      type: "Compare",
+      left,
+      ops: [{ operator: negated ? "!=" : "==", right }],
+      line: start.line,
+      column: start.column
+    };
+    const body = [];
+    let else_ = [];
+    const endTag = negated ? "endifnotequal" : "endifequal";
+    while (!this.isAtEnd()) {
+      if (this.checkBlockTag("else") || this.checkBlockTag(endTag))
+        break;
+      const node = this.parseStatement();
+      if (node)
+        body.push(node);
+    }
+    if (this.checkBlockTag("else")) {
+      this.advance();
+      this.advance();
+      this.expect("BLOCK_END" /* BLOCK_END */);
+      while (!this.isAtEnd()) {
+        if (this.checkBlockTag(endTag))
+          break;
+        const node = this.parseStatement();
+        if (node)
+          else_.push(node);
+      }
+    }
+    this.expectBlockTag(endTag);
+    return {
+      type: "If",
+      test,
+      body,
+      elifs: [],
+      else_,
+      line: start.line,
+      column: start.column
+    };
+  }
   parseExpression() {
     return this.parseConditional();
   }
@@ -2231,6 +2483,195 @@ ${indent2}`;
   safeString.__safe__ = true;
   return safeString;
 };
+var addslashes = (value) => {
+  const result = String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"");
+  const safeString = new String(result);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var get_digit = (value, digit) => {
+  const num = parseInt(String(value), 10);
+  if (isNaN(num))
+    return value;
+  const str = String(Math.abs(num));
+  const pos = Number(digit) || 1;
+  if (pos < 1 || pos > str.length)
+    return value;
+  return parseInt(str[str.length - pos], 10);
+};
+var iriencode = (value) => {
+  return String(value).replace(/ /g, "%20").replace(/"/g, "%22").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\\/g, "%5C").replace(/\^/g, "%5E").replace(/`/g, "%60").replace(/\{/g, "%7B").replace(/\|/g, "%7C").replace(/\}/g, "%7D");
+};
+var json_script = (value, elementId) => {
+  const jsonStr = JSON.stringify(value).replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/&/g, "\\u0026");
+  const id = elementId ? ` id="${String(elementId)}"` : "";
+  const html = `<script${id} type="application/json">${jsonStr}</script>`;
+  const safeString = new String(html);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var safeseq = (value) => {
+  if (!Array.isArray(value))
+    return value;
+  return value.map((item) => {
+    const safeString = new String(item);
+    safeString.__safe__ = true;
+    return safeString;
+  });
+};
+var stringformat = (value, formatStr) => {
+  const fmt = String(formatStr);
+  const val = value;
+  if (fmt === "s")
+    return String(val);
+  if (fmt === "d" || fmt === "i")
+    return String(parseInt(String(val), 10) || 0);
+  if (fmt === "f")
+    return String(parseFloat(String(val)) || 0);
+  if (fmt === "x")
+    return (parseInt(String(val), 10) || 0).toString(16);
+  if (fmt === "X")
+    return (parseInt(String(val), 10) || 0).toString(16).toUpperCase();
+  if (fmt === "o")
+    return (parseInt(String(val), 10) || 0).toString(8);
+  if (fmt === "b")
+    return (parseInt(String(val), 10) || 0).toString(2);
+  if (fmt === "e")
+    return (parseFloat(String(val)) || 0).toExponential();
+  const precisionMatch = fmt.match(/^\.?(\d+)f$/);
+  if (precisionMatch) {
+    const precision = parseInt(precisionMatch[1], 10);
+    return (parseFloat(String(val)) || 0).toFixed(precision);
+  }
+  const widthMatch = fmt.match(/^(\d+)([sd])$/);
+  if (widthMatch) {
+    const width = parseInt(widthMatch[1], 10);
+    const type = widthMatch[2];
+    const strVal = type === "d" ? String(parseInt(String(val), 10) || 0) : String(val);
+    return strVal.padStart(width, type === "d" ? "0" : " ");
+  }
+  return String(val);
+};
+var truncatechars_html = (value, length2 = 30) => {
+  const str = String(value);
+  const maxLen = Number(length2);
+  let result = "";
+  let textLen = 0;
+  let inTag = false;
+  const openTags = [];
+  for (let i = 0;i < str.length && textLen < maxLen; i++) {
+    const char = str[i];
+    if (char === "<") {
+      inTag = true;
+      const closeMatch = str.slice(i).match(/^<\/(\w+)/);
+      const openMatch = str.slice(i).match(/^<(\w+)/);
+      if (closeMatch) {
+        const tagName = closeMatch[1].toLowerCase();
+        const lastOpen = openTags.lastIndexOf(tagName);
+        if (lastOpen !== -1)
+          openTags.splice(lastOpen, 1);
+      } else if (openMatch && !str.slice(i).match(/^<\w+[^>]*\/>/)) {
+        openTags.push(openMatch[1].toLowerCase());
+      }
+    }
+    result += char;
+    if (char === ">") {
+      inTag = false;
+    } else if (!inTag) {
+      textLen++;
+    }
+  }
+  if (textLen >= maxLen && str.length > result.length) {
+    result += "...";
+  }
+  for (let i = openTags.length - 1;i >= 0; i--) {
+    result += `</${openTags[i]}>`;
+  }
+  const safeString = new String(result);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var truncatewords_html = (value, count = 15) => {
+  const str = String(value);
+  const maxWords = Number(count);
+  let result = "";
+  let wordCount = 0;
+  let inTag = false;
+  let inWord = false;
+  const openTags = [];
+  for (let i = 0;i < str.length && wordCount < maxWords; i++) {
+    const char = str[i];
+    if (char === "<") {
+      inTag = true;
+      const closeMatch = str.slice(i).match(/^<\/(\w+)/);
+      const openMatch = str.slice(i).match(/^<(\w+)/);
+      if (closeMatch) {
+        const tagName = closeMatch[1].toLowerCase();
+        const lastOpen = openTags.lastIndexOf(tagName);
+        if (lastOpen !== -1)
+          openTags.splice(lastOpen, 1);
+      } else if (openMatch && !str.slice(i).match(/^<\w+[^>]*\/>/)) {
+        openTags.push(openMatch[1].toLowerCase());
+      }
+    }
+    result += char;
+    if (char === ">") {
+      inTag = false;
+    } else if (!inTag) {
+      const isSpace = /\s/.test(char);
+      if (!isSpace && !inWord) {
+        inWord = true;
+      } else if (isSpace && inWord) {
+        inWord = false;
+        wordCount++;
+      }
+    }
+  }
+  if (inWord)
+    wordCount++;
+  if (wordCount >= maxWords) {
+    result = result.trimEnd() + "...";
+  }
+  for (let i = openTags.length - 1;i >= 0; i--) {
+    result += `</${openTags[i]}>`;
+  }
+  const safeString = new String(result);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var urlizetrunc = (value, limit = 15) => {
+  const maxLen = Number(limit);
+  const html = String(value).replace(URLIZE_REGEX, (url) => {
+    const displayUrl = url.length > maxLen ? url.slice(0, maxLen) + "..." : url;
+    return `<a href="${url}">${displayUrl}</a>`;
+  });
+  const safeString = new String(html);
+  safeString.__safe__ = true;
+  return safeString;
+};
+var items = (value) => {
+  if (value == null || typeof value !== "object")
+    return [];
+  return Object.entries(value);
+};
+var xmlattr = (value, autospace = true) => {
+  if (value == null || typeof value !== "object")
+    return "";
+  const attrs = [];
+  for (const [key, val] of Object.entries(value)) {
+    if (val === true) {
+      attrs.push(key);
+    } else if (val !== false && val != null) {
+      const escaped = String(val).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      attrs.push(`${key}="${escaped}"`);
+    }
+  }
+  const result = attrs.join(" ");
+  const output = autospace && result ? " " + result : result;
+  const safeString = new String(output);
+  safeString.__safe__ = true;
+  return safeString;
+};
 var builtinFilters = {
   upper,
   lower,
@@ -2309,7 +2750,18 @@ var builtinFilters = {
   forceescape,
   phone2numeric,
   linenumbers,
-  unordered_list
+  unordered_list,
+  addslashes,
+  get_digit,
+  iriencode,
+  json_script,
+  safeseq,
+  stringformat,
+  truncatechars_html,
+  truncatewords_html,
+  urlizetrunc,
+  items,
+  xmlattr
 };
 
 // src/tests/index.ts
@@ -2625,6 +3077,24 @@ class Runtime {
       case "Load":
       case "Extends":
         return null;
+      case "Cycle":
+        return this.renderCycleSync(node, ctx);
+      case "Firstof":
+        return this.renderFirstofSync(node, ctx);
+      case "Ifchanged":
+        return this.renderIfchangedSync(node, ctx);
+      case "Regroup":
+        return this.renderRegroupSync(node, ctx);
+      case "Widthratio":
+        return this.renderWidthratioSync(node, ctx);
+      case "Lorem":
+        return this.renderLoremSync(node, ctx);
+      case "CsrfToken":
+        return this.renderCsrfTokenSync();
+      case "Debug":
+        return this.renderDebugSync(ctx);
+      case "Templatetag":
+        return this.renderTemplatetagSync(node);
       default:
         return null;
     }
@@ -2642,13 +3112,13 @@ class Runtime {
   }
   renderForSync(node, ctx) {
     const iterable2 = this.eval(node.iter, ctx);
-    const items = this.toIterable(iterable2);
-    const len = items.length;
+    const items2 = this.toIterable(iterable2);
+    const len = items2.length;
     if (len === 0) {
       return this.renderNodesSync(node.else_, ctx);
     }
     ctx.push();
-    ctx.pushForLoop(items, 0);
+    ctx.pushForLoop(items2, 0);
     let result;
     if (Array.isArray(node.target)) {
       const targets = node.target;
@@ -2656,9 +3126,9 @@ class Runtime {
       if (len < 50) {
         result = "";
         for (let i = 0;i < len; i++) {
-          const item = items[i];
+          const item = items2[i];
           if (i > 0)
-            ctx.updateForLoop(i, items);
+            ctx.updateForLoop(i, items2);
           let values;
           if (Array.isArray(item)) {
             values = item;
@@ -2675,9 +3145,9 @@ class Runtime {
       } else {
         const parts = new Array(len);
         for (let i = 0;i < len; i++) {
-          const item = items[i];
+          const item = items2[i];
           if (i > 0)
-            ctx.updateForLoop(i, items);
+            ctx.updateForLoop(i, items2);
           let values;
           if (Array.isArray(item)) {
             values = item;
@@ -2699,16 +3169,16 @@ class Runtime {
         result = "";
         for (let i = 0;i < len; i++) {
           if (i > 0)
-            ctx.updateForLoop(i, items);
-          ctx.set(target, items[i]);
+            ctx.updateForLoop(i, items2);
+          ctx.set(target, items2[i]);
           result += this.renderNodesSync(node.body, ctx);
         }
       } else {
         const parts = new Array(len);
         for (let i = 0;i < len; i++) {
           if (i > 0)
-            ctx.updateForLoop(i, items);
-          ctx.set(target, items[i]);
+            ctx.updateForLoop(i, items2);
+          ctx.set(target, items2[i]);
           parts[i] = this.renderNodesSync(node.body, ctx);
         }
         result = parts.join("");
@@ -2770,6 +3240,217 @@ class Runtime {
     }
     return result;
   }
+  cycleState = new Map;
+  renderCycleSync(node, ctx) {
+    const key = node.values.map((v) => JSON.stringify(v)).join(",");
+    const currentIndex = this.cycleState.get(key) ?? 0;
+    const values = node.values.map((v) => this.eval(v, ctx));
+    const value = values[currentIndex % values.length];
+    this.cycleState.set(key, currentIndex + 1);
+    if (node.asVar) {
+      ctx.set(node.asVar, value);
+      return node.silent ? "" : this.stringify(value);
+    }
+    return this.stringify(value);
+  }
+  renderFirstofSync(node, ctx) {
+    for (const expr of node.values) {
+      const value = this.eval(expr, ctx);
+      if (this.isTruthy(value)) {
+        if (node.asVar) {
+          ctx.set(node.asVar, value);
+          return "";
+        }
+        return this.stringify(value);
+      }
+    }
+    const fallback = node.fallback ? this.eval(node.fallback, ctx) : "";
+    if (node.asVar) {
+      ctx.set(node.asVar, fallback);
+      return "";
+    }
+    return this.stringify(fallback);
+  }
+  ifchangedState = new Map;
+  renderIfchangedSync(node, ctx) {
+    const key = `ifchanged_${node.line}_${node.column}`;
+    let currentValue;
+    if (node.values.length > 0) {
+      currentValue = node.values.map((v) => this.eval(v, ctx));
+    } else {
+      currentValue = this.renderNodesSync(node.body, ctx);
+    }
+    const lastValue = this.ifchangedState.get(key);
+    const changed = JSON.stringify(currentValue) !== JSON.stringify(lastValue);
+    this.ifchangedState.set(key, currentValue);
+    if (changed) {
+      if (node.values.length > 0) {
+        return this.renderNodesSync(node.body, ctx);
+      }
+      return currentValue;
+    } else {
+      return this.renderNodesSync(node.else_, ctx);
+    }
+  }
+  renderRegroupSync(node, ctx) {
+    const list2 = this.toIterable(this.eval(node.target, ctx));
+    const groups = [];
+    let currentGrouper = Symbol("initial");
+    let currentList = [];
+    for (const item of list2) {
+      const grouper = item && typeof item === "object" ? item[node.key] : undefined;
+      if (grouper !== currentGrouper) {
+        if (currentList.length > 0) {
+          groups.push({ grouper: currentGrouper, list: currentList });
+        }
+        currentGrouper = grouper;
+        currentList = [item];
+      } else {
+        currentList.push(item);
+      }
+    }
+    if (currentList.length > 0) {
+      groups.push({ grouper: currentGrouper, list: currentList });
+    }
+    ctx.set(node.asVar, groups);
+    return "";
+  }
+  renderWidthratioSync(node, ctx) {
+    const value = Number(this.eval(node.value, ctx));
+    const maxValue = Number(this.eval(node.maxValue, ctx));
+    const maxWidth = Number(this.eval(node.maxWidth, ctx));
+    const ratio = maxValue === 0 ? 0 : Math.round(value / maxValue * maxWidth);
+    if (node.asVar) {
+      ctx.set(node.asVar, ratio);
+      return "";
+    }
+    return String(ratio);
+  }
+  renderLoremSync(node, ctx) {
+    const count = node.count ? Number(this.eval(node.count, ctx)) : 1;
+    const method = node.method;
+    const words = [
+      "lorem",
+      "ipsum",
+      "dolor",
+      "sit",
+      "amet",
+      "consectetur",
+      "adipiscing",
+      "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",
+      "reprehenderit",
+      "voluptate",
+      "velit",
+      "esse",
+      "cillum",
+      "fugiat",
+      "nulla",
+      "pariatur",
+      "excepteur",
+      "sint",
+      "occaecat",
+      "cupidatat",
+      "non",
+      "proident",
+      "sunt",
+      "culpa",
+      "qui",
+      "officia",
+      "deserunt",
+      "mollit",
+      "anim",
+      "id",
+      "est",
+      "laborum"
+    ];
+    const getWord = (index) => {
+      if (node.random) {
+        return words[Math.floor(Math.random() * words.length)];
+      }
+      return words[index % words.length];
+    };
+    if (method === "w") {
+      const result = [];
+      for (let i = 0;i < count; i++) {
+        result.push(getWord(i));
+      }
+      return result.join(" ");
+    } else if (method === "p" || method === "b") {
+      const paragraphs = [];
+      for (let p = 0;p < count; p++) {
+        const sentenceCount = 3 + p % 3;
+        const sentences = [];
+        for (let s = 0;s < sentenceCount; s++) {
+          const wordCount = 8 + s % 7;
+          const sentenceWords = [];
+          for (let w = 0;w < wordCount; w++) {
+            sentenceWords.push(getWord(p * 100 + s * 20 + w));
+          }
+          sentenceWords[0] = sentenceWords[0].charAt(0).toUpperCase() + sentenceWords[0].slice(1);
+          sentences.push(sentenceWords.join(" ") + ".");
+        }
+        paragraphs.push(sentences.join(" "));
+      }
+      if (method === "b") {
+        return paragraphs.join(`
+
+`);
+      }
+      return paragraphs.map((p) => `<p>${p}</p>`).join(`
+`);
+    }
+    return "";
+  }
+  renderCsrfTokenSync() {
+    return '<input type="hidden" name="csrfmiddlewaretoken" value="CSRF_TOKEN_PLACEHOLDER">';
+  }
+  renderDebugSync(ctx) {
+    const data = ctx.toObject?.() || {};
+    return `<pre>${JSON.stringify(data, null, 2)}</pre>`;
+  }
+  renderTemplatetagSync(node) {
+    const tagMap = {
+      openblock: "{%",
+      closeblock: "%}",
+      openvariable: "{{",
+      closevariable: "}}",
+      openbrace: "{",
+      closebrace: "}",
+      opencomment: "{#",
+      closecomment: "#}"
+    };
+    return tagMap[node.tagType] || "";
+  }
   getDateInTimezone(d, tz) {
     if (!tz) {
       return {
@@ -3192,6 +3873,24 @@ class Runtime {
         return this.renderStaticSync(node, ctx);
       case "Now":
         return this.renderNowSync(node, ctx);
+      case "Cycle":
+        return this.renderCycleSync(node, ctx);
+      case "Firstof":
+        return this.renderFirstofSync(node, ctx);
+      case "Ifchanged":
+        return this.renderIfchangedSync(node, ctx);
+      case "Regroup":
+        return this.renderRegroupSync(node, ctx);
+      case "Widthratio":
+        return this.renderWidthratioSync(node, ctx);
+      case "Lorem":
+        return this.renderLoremSync(node, ctx);
+      case "CsrfToken":
+        return this.renderCsrfTokenSync();
+      case "Debug":
+        return this.renderDebugSync(ctx);
+      case "Templatetag":
+        return this.renderTemplatetagSync(node);
       default:
         return null;
     }
@@ -3209,19 +3908,19 @@ class Runtime {
   }
   async renderForAsync(node, ctx) {
     const iterable2 = this.eval(node.iter, ctx);
-    const items = this.toIterable(iterable2);
-    const len = items.length;
+    const items2 = this.toIterable(iterable2);
+    const len = items2.length;
     if (len === 0) {
       return this.renderNodesAsync(node.else_, ctx);
     }
     const parts = new Array(len);
     const isUnpacking = Array.isArray(node.target);
     ctx.push();
-    ctx.pushForLoop(items, 0);
+    ctx.pushForLoop(items2, 0);
     for (let i = 0;i < len; i++) {
-      const item = items[i];
+      const item = items2[i];
       if (i > 0)
-        ctx.updateForLoop(i, items);
+        ctx.updateForLoop(i, items2);
       if (isUnpacking) {
         let values;
         if (Array.isArray(item)) {
@@ -4233,8 +4932,8 @@ class DebugCollector {
       if (value.length === 0)
         return "[]";
       if (value.length <= 3) {
-        const items = value.map((v) => this.getPreview(v, 15)).join(", ");
-        return `[${items}]`;
+        const items2 = value.map((v) => this.getPreview(v, 15)).join(", ");
+        return `[${items2}]`;
       }
       return `[${this.getPreview(value[0], 15)}, ... +${value.length - 1}]`;
     }
@@ -4546,7 +5245,7 @@ function generateContextSection(data) {
   const keys = Object.keys(data.contextSnapshot);
   if (keys.length === 0)
     return "";
-  const items = keys.map((key) => renderContextValue(key, data.contextSnapshot[key])).join("");
+  const items2 = keys.map((key) => renderContextValue(key, data.contextSnapshot[key])).join("");
   return `
 <div class="dbg-section">
   <div class="dbg-section-header" onclick="this.parentElement.classList.toggle('open')">
@@ -4555,7 +5254,7 @@ function generateContextSection(data) {
     <span class="dbg-chevron">${icons.chevron}</span>
   </div>
   <div class="dbg-section-content">
-    <div class="dbg-ctx-grid">${items}</div>
+    <div class="dbg-ctx-grid">${items2}</div>
   </div>
 </div>`;
 }
@@ -4585,7 +5284,7 @@ function generateFiltersSection(data) {
   const filters = Array.from(data.filtersUsed.entries());
   if (filters.length === 0)
     return "";
-  const items = filters.map(([name, count]) => `<span class="dbg-filter">${name}<span class="dbg-filter-count">\xD7${count}</span></span>`).join("");
+  const items2 = filters.map(([name, count]) => `<span class="dbg-filter">${name}<span class="dbg-filter-count">\xD7${count}</span></span>`).join("");
   return `
 <div class="dbg-section">
   <div class="dbg-section-header" onclick="this.parentElement.classList.toggle('open')">
@@ -4594,7 +5293,7 @@ function generateFiltersSection(data) {
     <span class="dbg-chevron">${icons.chevron}</span>
   </div>
   <div class="dbg-section-content">
-    <div class="dbg-filters">${items}</div>
+    <div class="dbg-filters">${items2}</div>
   </div>
 </div>`;
 }
@@ -4626,7 +5325,7 @@ function generateCacheSection(data) {
 function generateWarningsSection(data) {
   if (data.warnings.length === 0)
     return "";
-  const items = data.warnings.map((w) => `
+  const items2 = data.warnings.map((w) => `
     <div class="dbg-warning">
       ${icons.warning}
       <span class="dbg-warning-text">${escapeHtml(w)}</span>
@@ -4640,7 +5339,7 @@ function generateWarningsSection(data) {
     <span class="dbg-chevron">${icons.chevron}</span>
   </div>
   <div class="dbg-section-content">
-    <div class="dbg-warnings">${items}</div>
+    <div class="dbg-warnings">${items2}</div>
   </div>
 </div>`;
 }