binja 0.4.5 → 0.5.0

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();
   }
@@ -1423,6 +1675,7 @@ class Parser {
 // src/runtime/context.ts
 function createForLoop(items, index, depth, lastCycleValue, parentloop) {
   const length = items.length;
+  const revCount = length - index;
   const forloop = {
     _items: items,
     _idx: index,
@@ -1435,17 +1688,19 @@ function createForLoop(items, index, depth, lastCycleValue, parentloop) {
     index0: index,
     depth,
     depth0: depth - 1,
-    revcounter: length - index,
-    revcounter0: length - index - 1,
-    revindex: length - index,
-    revindex0: length - index - 1,
+    revcounter: revCount,
+    revcounter0: revCount - 1,
+    revindex: revCount,
+    revindex0: revCount - 1,
     get previtem() {
       return this._idx > 0 ? this._items[this._idx - 1] : undefined;
     },
     get nextitem() {
       return this._idx < this._items.length - 1 ? this._items[this._idx + 1] : undefined;
     },
-    cycle: (...args) => args[index % args.length],
+    cycle(...args) {
+      return args[this._idx % args.length];
+    },
     changed: (value) => {
       const changed = value !== lastCycleValue.value;
       lastCycleValue.value = value;
@@ -1523,18 +1778,19 @@ class Context {
       return;
     const length = items.length;
     forloop._idx = index;
-    forloop._items = items;
+    if (forloop._items !== items)
+      forloop._items = items;
     forloop.counter = index + 1;
     forloop.counter0 = index;
-    forloop.first = index === 0;
-    forloop.last = index === length - 1;
     forloop.index = index + 1;
     forloop.index0 = index;
-    forloop.revcounter = length - index;
-    forloop.revcounter0 = length - index - 1;
-    forloop.revindex = length - index;
-    forloop.revindex0 = length - index - 1;
-    forloop.cycle = (...args) => args[index % args.length];
+    forloop.first = index === 0;
+    forloop.last = index === length - 1;
+    const revCount = length - index;
+    forloop.revcounter = revCount;
+    forloop.revcounter0 = revCount - 1;
+    forloop.revindex = revCount;
+    forloop.revindex0 = revCount - 1;
   }
   toObject() {
     const result = {};
@@ -2227,6 +2483,172 @@ ${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 builtinFilters = {
   upper,
   lower,
@@ -2305,7 +2727,16 @@ var builtinFilters = {
   forceescape,
   phone2numeric,
   linenumbers,
-  unordered_list
+  unordered_list,
+  addslashes,
+  get_digit,
+  iriencode,
+  json_script,
+  safeseq,
+  stringformat,
+  truncatechars_html,
+  truncatewords_html,
+  urlizetrunc
 };
 
 // src/tests/index.ts
@@ -2594,11 +3025,13 @@ class Runtime {
     return parts.join("");
   }
   renderNodeSync(node, ctx) {
+    if (node.type === "Text") {
+      return node.value;
+    }
+    if (node.type === "Output") {
+      return this.stringify(this.eval(node.expression, ctx));
+    }
     switch (node.type) {
-      case "Text":
-        return node.value;
-      case "Output":
-        return this.stringify(this.eval(node.expression, ctx));
       case "If":
         return this.renderIfSync(node, ctx);
       case "For":
@@ -2619,6 +3052,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;
     }
@@ -2641,41 +3092,76 @@ class Runtime {
     if (len === 0) {
       return this.renderNodesSync(node.else_, ctx);
     }
-    const parts = new Array(len);
     ctx.push();
     ctx.pushForLoop(items, 0);
+    let result;
     if (Array.isArray(node.target)) {
       const targets = node.target;
       const targetsLen = targets.length;
-      for (let i = 0;i < len; i++) {
-        const item = items[i];
-        if (i > 0)
-          ctx.updateForLoop(i, items);
-        let values;
-        if (Array.isArray(item)) {
-          values = item;
-        } else if (item && typeof item === "object" && (("0" in item) || ("key" in item))) {
-          values = [item[0] ?? item.key, item[1] ?? item.value];
-        } else {
-          values = [item, item];
+      if (len < 50) {
+        result = "";
+        for (let i = 0;i < len; i++) {
+          const item = items[i];
+          if (i > 0)
+            ctx.updateForLoop(i, items);
+          let values;
+          if (Array.isArray(item)) {
+            values = item;
+          } else if (item && typeof item === "object" && (("0" in item) || ("key" in item))) {
+            values = [item[0] ?? item.key, item[1] ?? item.value];
+          } else {
+            values = [item, item];
+          }
+          for (let j = 0;j < targetsLen; j++) {
+            ctx.set(targets[j], values[j]);
+          }
+          result += this.renderNodesSync(node.body, ctx);
         }
-        for (let j = 0;j < targetsLen; j++) {
-          ctx.set(targets[j], values[j]);
+      } else {
+        const parts = new Array(len);
+        for (let i = 0;i < len; i++) {
+          const item = items[i];
+          if (i > 0)
+            ctx.updateForLoop(i, items);
+          let values;
+          if (Array.isArray(item)) {
+            values = item;
+          } else if (item && typeof item === "object" && (("0" in item) || ("key" in item))) {
+            values = [item[0] ?? item.key, item[1] ?? item.value];
+          } else {
+            values = [item, item];
+          }
+          for (let j = 0;j < targetsLen; j++) {
+            ctx.set(targets[j], values[j]);
+          }
+          parts[i] = this.renderNodesSync(node.body, ctx);
         }
-        parts[i] = this.renderNodesSync(node.body, ctx);
+        result = parts.join("");
       }
     } else {
       const target = node.target;
-      for (let i = 0;i < len; i++) {
-        if (i > 0)
-          ctx.updateForLoop(i, items);
-        ctx.set(target, items[i]);
-        parts[i] = this.renderNodesSync(node.body, ctx);
+      if (len < 50) {
+        result = "";
+        for (let i = 0;i < len; i++) {
+          if (i > 0)
+            ctx.updateForLoop(i, items);
+          ctx.set(target, items[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]);
+          parts[i] = this.renderNodesSync(node.body, ctx);
+        }
+        result = parts.join("");
       }
     }
     ctx.popForLoop();
     ctx.pop();
-    return parts.join("");
+    return result;
   }
   renderBlockSync(node, ctx) {
     const blockToRender = this.blocks.get(node.name) || node;
@@ -2729,6 +3215,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 {
@@ -2837,22 +3534,36 @@ class Runtime {
     return result;
   }
   renderNodesSync(nodes2, ctx) {
+    const len = nodes2.length;
+    if (len === 0)
+      return "";
+    if (len === 1) {
+      return this.renderNodeSync(nodes2[0], ctx) ?? "";
+    }
+    if (len === 2) {
+      const a = this.renderNodeSync(nodes2[0], ctx) ?? "";
+      const b = this.renderNodeSync(nodes2[1], ctx) ?? "";
+      return a + b;
+    }
     const parts = [];
-    for (const node of nodes2) {
-      const result = this.renderNodeSync(node, ctx);
+    for (let i = 0;i < len; i++) {
+      const result = this.renderNodeSync(nodes2[i], ctx);
       if (result !== null)
         parts.push(result);
     }
     return parts.join("");
   }
   eval(node, ctx) {
+    if (node.type === "Literal") {
+      return node.value;
+    }
+    if (node.type === "Name") {
+      return ctx.get(node.name);
+    }
+    if (node.type === "GetAttr") {
+      return this.evalGetAttr(node, ctx);
+    }
     switch (node.type) {
-      case "Literal":
-        return node.value;
-      case "Name":
-        return ctx.get(node.name);
-      case "GetAttr":
-        return this.evalGetAttr(node, ctx);
       case "GetItem":
         return this.evalGetItem(node, ctx);
       case "FilterExpr":
@@ -2888,13 +3599,13 @@ class Runtime {
     if (obj == null)
       return;
     const attr2 = node.attribute;
-    if (Array.isArray(obj)) {
-      const numIndex = parseInt(attr2, 10);
-      if (!isNaN(numIndex))
-        return obj[numIndex];
-    }
     const value = obj[attr2];
-    if (value === undefined && !(attr2 in Object(obj))) {
+    if (value === undefined) {
+      if (Array.isArray(obj)) {
+        const numIndex = parseInt(attr2, 10);
+        if (!isNaN(numIndex))
+          return obj[numIndex];
+      }
       return;
     }
     if (typeof value === "function") {
@@ -2923,22 +3634,32 @@ class Runtime {
   }
   evalBinaryOp(node, ctx) {
     const left = this.eval(node.left, ctx);
-    if (node.operator === "and")
+    const op = node.operator;
+    if (op === "and")
       return this.isTruthy(left) ? this.eval(node.right, ctx) : left;
-    if (node.operator === "or")
+    if (op === "or")
       return this.isTruthy(left) ? left : this.eval(node.right, ctx);
     const right = this.eval(node.right, ctx);
-    switch (node.operator) {
-      case "+":
-        return typeof left === "string" || typeof right === "string" ? String(left) + String(right) : Number(left) + Number(right);
+    if (op === "%") {
+      if (typeof left === "number" && typeof right === "number") {
+        return right === 0 ? NaN : left % right;
+      }
+      const r = Number(right);
+      return r === 0 ? NaN : Number(left) % r;
+    }
+    if (op === "+") {
+      if (typeof left === "number" && typeof right === "number") {
+        return left + right;
+      }
+      return typeof left === "string" || typeof right === "string" ? String(left) + String(right) : Number(left) + Number(right);
+    }
+    switch (op) {
       case "-":
         return Number(left) - Number(right);
       case "*":
         return Number(left) * Number(right);
       case "/":
         return Number(left) / Number(right);
-      case "%":
-        return Number(right) === 0 ? NaN : Number(left) % Number(right);
       case "~":
         return String(left) + String(right);
       default:
@@ -2959,47 +3680,74 @@ class Runtime {
     }
   }
   evalCompare(node, ctx) {
-    let left = this.eval(node.left, ctx);
-    for (const { operator, right: rightNode } of node.ops) {
+    const left = this.eval(node.left, ctx);
+    const ops = node.ops;
+    if (ops.length === 1) {
+      const { operator, right: rightNode } = ops[0];
+      const right = this.eval(rightNode, ctx);
+      if (operator === "==")
+        return left === right;
+      if (operator === "!=")
+        return left !== right;
+      if (operator === "<")
+        return left < right;
+      if (operator === ">")
+        return left > right;
+      if (operator === "<=")
+        return left <= right;
+      if (operator === ">=")
+        return left >= right;
+      if (operator === "in")
+        return this.isIn(left, right);
+      if (operator === "not in")
+        return !this.isIn(left, right);
+      if (operator === "is")
+        return left === right;
+      if (operator === "is not")
+        return left !== right;
+      return false;
+    }
+    let current = left;
+    for (const { operator, right: rightNode } of ops) {
       const right = this.eval(rightNode, ctx);
       let result;
       switch (operator) {
         case "==":
-          result = left === right;
+          result = current === right;
           break;
         case "!=":
-          result = left !== right;
+          result = current !== right;
           break;
         case "<":
-          result = left < right;
+          result = current < right;
           break;
         case ">":
-          result = left > right;
+          result = current > right;
           break;
         case "<=":
-          result = left <= right;
+          result = current <= right;
           break;
         case ">=":
-          result = left >= right;
+          result = current >= right;
           break;
         case "in":
-          result = this.isIn(left, right);
+          result = this.isIn(current, right);
           break;
         case "not in":
-          result = !this.isIn(left, right);
+          result = !this.isIn(current, right);
           break;
         case "is":
-          result = left === right;
+          result = current === right;
           break;
         case "is not":
-          result = left !== right;
+          result = current !== right;
           break;
         default:
           result = false;
       }
       if (!result)
         return false;
-      left = right;
+      current = right;
     }
     return true;
   }
@@ -3100,6 +3848,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;
     }
@@ -3205,25 +3971,29 @@ class Runtime {
   stringify(value) {
     if (value == null)
       return "";
+    if (typeof value === "string") {
+      if (value.__safe__)
+        return value;
+      return this.options.autoescape ? Bun.escapeHTML(value) : value;
+    }
     if (typeof value === "boolean")
       return value ? "True" : "False";
+    if (typeof value === "number")
+      return String(value);
     const str = String(value);
     if (value.__safe__)
       return str;
-    if (this.options.autoescape) {
-      return Bun.escapeHTML(str);
-    }
-    return str;
+    return this.options.autoescape ? Bun.escapeHTML(str) : str;
   }
   isTruthy(value) {
-    if (value == null)
-      return false;
     if (typeof value === "boolean")
       return value;
-    if (typeof value === "number")
-      return value !== 0;
+    if (value == null)
+      return false;
     if (typeof value === "string")
       return value.length > 0;
+    if (typeof value === "number")
+      return value !== 0;
     if (Array.isArray(value))
       return value.length > 0;
     if (typeof value === "object") {