binja 0.1.0 → 0.1.1

package/dist/index.js

@@ -1209,102 +1209,120 @@ class Parser {
 }
 
 // src/runtime/context.ts
+function createForLoop(items, index, depth, lastCycleValue, parentloop) {
+  const length = items.length;
+  const forloop = {
+    _items: items,
+    _idx: index,
+    counter: index + 1,
+    counter0: index,
+    first: index === 0,
+    last: index === length - 1,
+    length,
+    index: index + 1,
+    index0: index,
+    depth,
+    depth0: depth - 1,
+    revcounter: length - index,
+    revcounter0: length - index - 1,
+    revindex: length - index,
+    revindex0: length - index - 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],
+    changed: (value) => {
+      const changed = value !== lastCycleValue.value;
+      lastCycleValue.value = value;
+      return changed;
+    }
+  };
+  if (parentloop) {
+    forloop.parentloop = parentloop;
+  }
+  return forloop;
+}
+
 class Context {
   scopes = [];
   parent = null;
   _forloopStack = [];
-  _lastCycleValue = null;
+  _lastCycleValue = { value: null };
+  _currentForloop = null;
+  _currentScope;
   constructor(data = {}, parent = null) {
     this.parent = parent;
-    this.scopes.push(new Map(Object.entries(data)));
+    this._currentScope = Object.assign(Object.create(null), data);
+    this.scopes.push(this._currentScope);
   }
   get(name) {
     if (name === "forloop" || name === "loop") {
-      return this._forloopStack[this._forloopStack.length - 1] || null;
+      return this._currentForloop;
     }
     for (let i = this.scopes.length - 1;i >= 0; i--) {
-      if (this.scopes[i].has(name)) {
-        return this.scopes[i].get(name);
+      const scope = this.scopes[i];
+      if (name in scope) {
+        return scope[name];
       }
     }
-    if (this.parent) {
-      return this.parent.get(name);
-    }
-    return;
+    return this.parent ? this.parent.get(name) : undefined;
   }
   set(name, value) {
-    this.scopes[this.scopes.length - 1].set(name, value);
+    this._currentScope[name] = value;
   }
   has(name) {
     for (let i = this.scopes.length - 1;i >= 0; i--) {
-      if (this.scopes[i].has(name))
+      if (name in this.scopes[i])
         return true;
     }
     return this.parent ? this.parent.has(name) : false;
   }
   push(data = {}) {
-    this.scopes.push(new Map(Object.entries(data)));
+    this._currentScope = Object.assign(Object.create(null), data);
+    this.scopes.push(this._currentScope);
   }
   pop() {
     if (this.scopes.length > 1) {
       this.scopes.pop();
+      this._currentScope = this.scopes[this.scopes.length - 1];
     }
   }
   derived(data = {}) {
     return new Context(data, this);
   }
   pushForLoop(items, index) {
-    const length = items.length;
     const depth = this._forloopStack.length + 1;
-    const forloop = {
-      counter: index + 1,
-      counter0: index,
-      revcounter: length - index,
-      revcounter0: length - index - 1,
-      first: index === 0,
-      last: index === length - 1,
-      length,
-      index: index + 1,
-      index0: index,
-      revindex: length - index,
-      revindex0: length - index - 1,
-      depth,
-      depth0: depth - 1,
-      previtem: index > 0 ? items[index - 1] : undefined,
-      nextitem: index < length - 1 ? items[index + 1] : undefined,
-      cycle: (...args) => args[index % args.length],
-      changed: (value) => {
-        const changed = value !== this._lastCycleValue;
-        this._lastCycleValue = value;
-        return changed;
-      }
-    };
-    if (this._forloopStack.length > 0) {
-      forloop.parentloop = this._forloopStack[this._forloopStack.length - 1];
-    }
+    const parentloop = this._forloopStack.length > 0 ? this._forloopStack[this._forloopStack.length - 1] : undefined;
+    const forloop = createForLoop(items, index, depth, this._lastCycleValue, parentloop);
     this._forloopStack.push(forloop);
+    this._currentForloop = forloop;
     return forloop;
   }
   popForLoop() {
     this._forloopStack.pop();
+    this._currentForloop = this._forloopStack.length > 0 ? this._forloopStack[this._forloopStack.length - 1] : null;
   }
   updateForLoop(index, items) {
-    const forloop = this._forloopStack[this._forloopStack.length - 1];
+    const forloop = this._currentForloop;
     if (!forloop)
       return;
     const length = items.length;
+    forloop._idx = index;
+    forloop._items = items;
     forloop.counter = index + 1;
     forloop.counter0 = index;
-    forloop.revcounter = length - index;
-    forloop.revcounter0 = length - index - 1;
     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.previtem = index > 0 ? items[index - 1] : undefined;
-    forloop.nextitem = index < length - 1 ? items[index + 1] : undefined;
+    forloop.cycle = (...args) => args[index % args.length];
   }
   toObject() {
     const result = {};
@@ -1312,15 +1330,28 @@ class Context {
       Object.assign(result, this.parent.toObject());
     }
     for (const scope of this.scopes) {
-      for (const [key, value] of scope) {
-        result[key] = value;
-      }
+      Object.assign(result, scope);
     }
     return result;
   }
 }
 
 // src/filters/index.ts
+var TITLE_REGEX = /\b\w/g;
+var STRIPTAGS_REGEX = /<[^>]*>/g;
+var SLUGIFY_NON_WORD_REGEX = /[^\w\s-]/g;
+var SLUGIFY_SPACES_REGEX = /[\s_-]+/g;
+var SLUGIFY_TRIM_REGEX = /^-+|-+$/g;
+var URLIZE_REGEX = /(https?:\/\/[^\s]+)/g;
+var DATE_CHAR_REGEX = /[a-zA-Z]/g;
+var DOUBLE_NEWLINE_REGEX = /\n\n+/;
+var NEWLINE_REGEX = /\n/g;
+var WHITESPACE_REGEX = /\s+/;
+var DAY_NAMES_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var DAY_NAMES_LONG = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var MONTH_NAMES_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var MONTH_NAMES_LONG = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var MONTH_NAMES_AP = ["Jan.", "Feb.", "March", "April", "May", "June", "July", "Aug.", "Sept.", "Oct.", "Nov.", "Dec."];
 var upper = (value) => String(value).toUpperCase();
 var lower = (value) => String(value).toLowerCase();
 var capitalize = (value) => {
@@ -1331,13 +1362,13 @@ var capfirst = (value) => {
   const str = String(value);
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
-var title = (value) => String(value).replace(/\b\w/g, (c) => c.toUpperCase());
+var title = (value) => String(value).replace(TITLE_REGEX, (c) => c.toUpperCase());
 var trim = (value) => String(value).trim();
-var striptags = (value) => String(value).replace(/<[^>]*>/g, "");
+var striptags = (value) => String(value).replace(STRIPTAGS_REGEX, "");
 var escape = (value) => {
   if (value?.__safe__)
     return value;
-  const escaped = String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+  const escaped = Bun.escapeHTML(String(value));
   const safeString = new String(escaped);
   safeString.__safe__ = true;
   return safeString;
@@ -1350,15 +1381,15 @@ var safe = (value) => {
 var escapejs = (value) => JSON.stringify(String(value)).slice(1, -1);
 var linebreaks = (value) => {
   const str = String(value);
-  const paragraphs = str.split(/\n\n+/);
-  const html = paragraphs.map((p) => `<p>${p.replace(/\n/g, "<br>")}</p>`).join(`
+  const paragraphs = str.split(DOUBLE_NEWLINE_REGEX);
+  const html = paragraphs.map((p) => `<p>${p.replace(NEWLINE_REGEX, "<br>")}</p>`).join(`
 `);
   const safeString = new String(html);
   safeString.__safe__ = true;
   return safeString;
 };
 var linebreaksbr = (value) => {
-  const html = String(value).replace(/\n/g, "<br>");
+  const html = String(value).replace(NEWLINE_REGEX, "<br>");
   const safeString = new String(html);
   safeString.__safe__ = true;
   return safeString;
@@ -1370,12 +1401,12 @@ var truncatechars = (value, length = 30) => {
   return str.slice(0, length - 3) + "...";
 };
 var truncatewords = (value, count = 15) => {
-  const words = String(value).split(/\s+/);
+  const words = String(value).split(WHITESPACE_REGEX);
   if (words.length <= count)
     return value;
   return words.slice(0, count).join(" ") + "...";
 };
-var wordcount = (value) => String(value).split(/\s+/).filter(Boolean).length;
+var wordcount = (value) => String(value).split(WHITESPACE_REGEX).filter(Boolean).length;
 var center = (value, width = 80) => {
   const str = String(value);
   const padding = Math.max(0, width - str.length);
@@ -1386,7 +1417,7 @@ var center = (value, width = 80) => {
 var ljust = (value, width = 80) => String(value).padEnd(width);
 var rjust = (value, width = 80) => String(value).padStart(width);
 var cut = (value, arg = "") => String(value).split(arg).join("");
-var slugify = (value) => String(value).toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+var slugify = (value) => String(value).toLowerCase().replace(SLUGIFY_NON_WORD_REGEX, "").replace(SLUGIFY_SPACES_REGEX, "-").replace(SLUGIFY_TRIM_REGEX, "");
 var abs = (value) => Math.abs(Number(value));
 var round = (value, precision = 0) => Number(Number(value).toFixed(precision));
 var int = (value) => parseInt(String(value), 10) || 0;
@@ -1426,8 +1457,12 @@ var length = (value) => {
     return 0;
   if (typeof value === "string" || Array.isArray(value))
     return value.length;
-  if (typeof value === "object")
-    return Object.keys(value).length;
+  if (typeof value === "object") {
+    let count = 0;
+    for (const _ in value)
+      count++;
+    return count;
+  }
   return 0;
 };
 var length_is = (value, len) => length(value) === Number(len);
@@ -1507,58 +1542,55 @@ var columns = (value, cols) => {
   }
   return result;
 };
+var formatDateChar = (d, char) => {
+  switch (char) {
+    case "d":
+      return String(d.getDate()).padStart(2, "0");
+    case "j":
+      return String(d.getDate());
+    case "D":
+      return DAY_NAMES_SHORT[d.getDay()];
+    case "l":
+      return DAY_NAMES_LONG[d.getDay()];
+    case "m":
+      return String(d.getMonth() + 1).padStart(2, "0");
+    case "n":
+      return String(d.getMonth() + 1);
+    case "M":
+      return MONTH_NAMES_SHORT[d.getMonth()];
+    case "F":
+      return MONTH_NAMES_LONG[d.getMonth()];
+    case "N":
+      return MONTH_NAMES_AP[d.getMonth()];
+    case "y":
+      return String(d.getFullYear()).slice(-2);
+    case "Y":
+      return String(d.getFullYear());
+    case "H":
+      return String(d.getHours()).padStart(2, "0");
+    case "G":
+      return String(d.getHours());
+    case "i":
+      return String(d.getMinutes()).padStart(2, "0");
+    case "s":
+      return String(d.getSeconds()).padStart(2, "0");
+    case "a":
+      return d.getHours() < 12 ? "a.m." : "p.m.";
+    case "A":
+      return d.getHours() < 12 ? "AM" : "PM";
+    case "g":
+      return String(d.getHours() % 12 || 12);
+    case "h":
+      return String(d.getHours() % 12 || 12).padStart(2, "0");
+    default:
+      return char;
+  }
+};
 var date = (value, format = "N j, Y") => {
   const d = value instanceof Date ? value : new Date(value);
   if (isNaN(d.getTime()))
     return "";
-  const formatMap = {
-    d: () => String(d.getDate()).padStart(2, "0"),
-    j: () => String(d.getDate()),
-    D: () => ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][d.getDay()],
-    l: () => ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][d.getDay()],
-    m: () => String(d.getMonth() + 1).padStart(2, "0"),
-    n: () => String(d.getMonth() + 1),
-    M: () => ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][d.getMonth()],
-    F: () => [
-      "January",
-      "February",
-      "March",
-      "April",
-      "May",
-      "June",
-      "July",
-      "August",
-      "September",
-      "October",
-      "November",
-      "December"
-    ][d.getMonth()],
-    N: () => [
-      "Jan.",
-      "Feb.",
-      "March",
-      "April",
-      "May",
-      "June",
-      "July",
-      "Aug.",
-      "Sept.",
-      "Oct.",
-      "Nov.",
-      "Dec."
-    ][d.getMonth()],
-    y: () => String(d.getFullYear()).slice(-2),
-    Y: () => String(d.getFullYear()),
-    H: () => String(d.getHours()).padStart(2, "0"),
-    G: () => String(d.getHours()),
-    i: () => String(d.getMinutes()).padStart(2, "0"),
-    s: () => String(d.getSeconds()).padStart(2, "0"),
-    a: () => d.getHours() < 12 ? "a.m." : "p.m.",
-    A: () => d.getHours() < 12 ? "AM" : "PM",
-    g: () => String(d.getHours() % 12 || 12),
-    h: () => String(d.getHours() % 12 || 12).padStart(2, "0")
-  };
-  return format.replace(/[a-zA-Z]/g, (char) => formatMap[char]?.() ?? char);
+  return format.replace(DATE_CHAR_REGEX, (char) => formatDateChar(d, char));
 };
 var time = (value, format = "H:i") => date(value, format);
 var timesince = (value, now = new Date) => {
@@ -1621,8 +1653,7 @@ var pluralize = (value, arg = "s") => {
 };
 var urlencode = (value) => encodeURIComponent(String(value));
 var urlize = (value) => {
-  const urlRegex = /(https?:\/\/[^\s]+)/g;
-  const html = String(value).replace(urlRegex, '<a href="$1">$1</a>');
+  const html = String(value).replace(URLIZE_REGEX, '<a href="$1">$1</a>');
   const safeString = new String(html);
   safeString.__safe__ = true;
   return safeString;
@@ -1809,8 +1840,11 @@ var empty = (value) => {
     return true;
   if (typeof value === "string" || Array.isArray(value))
     return value.length === 0;
-  if (typeof value === "object")
-    return Object.keys(value).length === 0;
+  if (typeof value === "object") {
+    for (const _ in value)
+      return false;
+    return true;
+  }
   return false;
 };
 var in_ = (value, container) => {
@@ -1837,8 +1871,11 @@ var truthy = (value) => {
     return value.length > 0;
   if (Array.isArray(value))
     return value.length > 0;
-  if (typeof value === "object")
-    return Object.keys(value).length > 0;
+  if (typeof value === "object") {
+    for (const _ in value)
+      return true;
+    return false;
+  }
   return true;
 };
 var falsy = (value) => !truthy(value);
@@ -1906,91 +1943,154 @@ class Runtime {
     const ctx = new Context({ ...this.options.globals, ...context });
     this.blocks.clear();
     this.parentTemplate = null;
-    await this.collectBlocks(ast, ctx);
-    if (this.parentTemplate) {
-      return this.renderTemplate(this.parentTemplate, ctx);
+    const needsAsync = this.templateNeedsAsync(ast);
+    if (needsAsync) {
+      await this.collectBlocks(ast, ctx);
+      if (this.parentTemplate) {
+        return this.renderTemplateAsync(this.parentTemplate, ctx);
+      }
+      return this.renderTemplateAsync(ast, ctx);
     }
-    return this.renderTemplate(ast, ctx);
+    this.collectBlocksSync(ast);
+    return this.renderTemplateSync(ast, ctx);
   }
-  async collectBlocks(ast, ctx) {
+  templateNeedsAsync(ast) {
     for (const node of ast.body) {
-      if (node.type === "Extends") {
-        const templateName = await this.evaluate(node.template, ctx);
-        this.parentTemplate = await this.options.templateLoader(String(templateName));
-        await this.collectBlocks(this.parentTemplate, ctx);
-      } else if (node.type === "Block") {
+      if (node.type === "Extends" || node.type === "Include")
+        return true;
+      if (node.type === "If") {
+        const ifNode = node;
+        if (this.nodesNeedAsync(ifNode.body))
+          return true;
+        for (const elif of ifNode.elifs) {
+          if (this.nodesNeedAsync(elif.body))
+            return true;
+        }
+        if (this.nodesNeedAsync(ifNode.else_))
+          return true;
+      }
+      if (node.type === "For") {
+        const forNode = node;
+        if (this.nodesNeedAsync(forNode.body))
+          return true;
+        if (this.nodesNeedAsync(forNode.else_))
+          return true;
+      }
+      if (node.type === "Block") {
+        if (this.nodesNeedAsync(node.body))
+          return true;
+      }
+      if (node.type === "With") {
+        if (this.nodesNeedAsync(node.body))
+          return true;
+      }
+    }
+    return false;
+  }
+  nodesNeedAsync(nodes2) {
+    for (const node of nodes2) {
+      if (node.type === "Extends" || node.type === "Include")
+        return true;
+      if (node.type === "If") {
+        const ifNode = node;
+        if (this.nodesNeedAsync(ifNode.body))
+          return true;
+        for (const elif of ifNode.elifs) {
+          if (this.nodesNeedAsync(elif.body))
+            return true;
+        }
+        if (this.nodesNeedAsync(ifNode.else_))
+          return true;
+      }
+      if (node.type === "For") {
+        const forNode = node;
+        if (this.nodesNeedAsync(forNode.body))
+          return true;
+        if (this.nodesNeedAsync(forNode.else_))
+          return true;
+      }
+      if (node.type === "Block") {
+        if (this.nodesNeedAsync(node.body))
+          return true;
+      }
+      if (node.type === "With") {
+        if (this.nodesNeedAsync(node.body))
+          return true;
+      }
+    }
+    return false;
+  }
+  collectBlocksSync(ast) {
+    for (const node of ast.body) {
+      if (node.type === "Block") {
         this.blocks.set(node.name, node);
       }
     }
   }
-  async renderTemplate(ast, ctx) {
+  renderTemplateSync(ast, ctx) {
     const parts = [];
     for (const node of ast.body) {
-      const result = await this.renderNode(node, ctx);
+      const result = this.renderNodeSync(node, ctx);
       if (result !== null)
         parts.push(result);
     }
     return parts.join("");
   }
-  async renderNode(node, ctx) {
+  renderNodeSync(node, ctx) {
     switch (node.type) {
       case "Text":
         return node.value;
       case "Output":
-        return this.renderOutput(node, ctx);
+        return this.stringify(this.eval(node.expression, ctx));
       case "If":
-        return this.renderIf(node, ctx);
+        return this.renderIfSync(node, ctx);
       case "For":
-        return this.renderFor(node, ctx);
+        return this.renderForSync(node, ctx);
       case "Block":
-        return this.renderBlock(node, ctx);
-      case "Extends":
-        return null;
-      case "Include":
-        return this.renderInclude(node, ctx);
+        return this.renderBlockSync(node, ctx);
       case "Set":
-        return this.renderSet(node, ctx);
+        ctx.set(node.target, this.eval(node.value, ctx));
+        return "";
       case "With":
-        return this.renderWith(node, ctx);
-      case "Load":
-        return null;
+        return this.renderWithSync(node, ctx);
       case "Url":
-        return this.renderUrl(node, ctx);
+        return this.renderUrlSync(node, ctx);
       case "Static":
-        return this.renderStatic(node, ctx);
+        return this.renderStaticSync(node, ctx);
+      case "Load":
+      case "Extends":
+        return null;
       default:
         return null;
     }
   }
-  async renderOutput(node, ctx) {
-    const value = await this.evaluate(node.expression, ctx);
-    return this.stringify(value);
-  }
-  async renderIf(node, ctx) {
-    if (this.isTruthy(await this.evaluate(node.test, ctx))) {
-      return this.renderNodes(node.body, ctx);
+  renderIfSync(node, ctx) {
+    if (this.isTruthy(this.eval(node.test, ctx))) {
+      return this.renderNodesSync(node.body, ctx);
     }
     for (const elif of node.elifs) {
-      if (this.isTruthy(await this.evaluate(elif.test, ctx))) {
-        return this.renderNodes(elif.body, ctx);
+      if (this.isTruthy(this.eval(elif.test, ctx))) {
+        return this.renderNodesSync(elif.body, ctx);
       }
     }
-    if (node.else_.length > 0) {
-      return this.renderNodes(node.else_, ctx);
-    }
-    return "";
+    return node.else_.length > 0 ? this.renderNodesSync(node.else_, ctx) : "";
   }
-  async renderFor(node, ctx) {
-    const iterable2 = await this.evaluate(node.iter, ctx);
+  renderForSync(node, ctx) {
+    const iterable2 = this.eval(node.iter, ctx);
     const items = this.toIterable(iterable2);
-    if (items.length === 0) {
-      return this.renderNodes(node.else_, ctx);
+    const len = items.length;
+    if (len === 0) {
+      return this.renderNodesSync(node.else_, ctx);
     }
-    const parts = [];
+    const parts = new Array(len);
+    const isUnpacking = Array.isArray(node.target);
     ctx.push();
-    for (let i = 0;i < items.length; i++) {
+    ctx.pushForLoop(items, 0);
+    for (let i = 0;i < len; i++) {
       const item = items[i];
-      if (Array.isArray(node.target)) {
+      if (i > 0)
+        ctx.updateForLoop(i, items);
+      if (isUnpacking) {
         let values;
         if (Array.isArray(item)) {
           values = item;
@@ -1999,68 +2099,42 @@ class Runtime {
         } else {
           values = [item, item];
         }
-        node.target.forEach((name, idx) => {
-          ctx.set(name, values[idx]);
-        });
+        const targets = node.target;
+        for (let j = 0;j < targets.length; j++) {
+          ctx.set(targets[j], values[j]);
+        }
       } else {
         ctx.set(node.target, item);
       }
-      ctx.pushForLoop(items, i);
-      const result = await this.renderNodes(node.body, ctx);
-      parts.push(result);
-      ctx.popForLoop();
+      parts[i] = this.renderNodesSync(node.body, ctx);
     }
+    ctx.popForLoop();
     ctx.pop();
     return parts.join("");
   }
-  async renderBlock(node, ctx) {
+  renderBlockSync(node, ctx) {
     const blockToRender = this.blocks.get(node.name) || node;
     ctx.push();
     ctx.set("block", {
-      super: async () => {
-        return this.renderNodes(node.body, ctx);
-      }
+      super: () => this.renderNodesSync(node.body, ctx)
     });
-    const result = await this.renderNodes(blockToRender.body, ctx);
+    const result = this.renderNodesSync(blockToRender.body, ctx);
     ctx.pop();
     return result;
   }
-  async renderInclude(node, ctx) {
-    try {
-      const templateName = await this.evaluate(node.template, ctx);
-      const template = await this.options.templateLoader(String(templateName));
-      let includeCtx;
-      if (node.only) {
-        includeCtx = new Context(node.context ? await this.evaluateObject(node.context, ctx) : {});
-      } else {
-        const additional = node.context ? await this.evaluateObject(node.context, ctx) : {};
-        includeCtx = ctx.derived(additional);
-      }
-      return this.renderTemplate(template, includeCtx);
-    } catch (error) {
-      if (node.ignoreMissing)
-        return "";
-      throw error;
-    }
-  }
-  async renderSet(node, ctx) {
-    const value = await this.evaluate(node.value, ctx);
-    ctx.set(node.target, value);
-    return "";
-  }
-  async renderWith(node, ctx) {
+  renderWithSync(node, ctx) {
     ctx.push();
     for (const { target, value } of node.assignments) {
-      ctx.set(target, await this.evaluate(value, ctx));
+      ctx.set(target, this.eval(value, ctx));
     }
-    const result = await this.renderNodes(node.body, ctx);
+    const result = this.renderNodesSync(node.body, ctx);
     ctx.pop();
     return result;
   }
-  async renderUrl(node, ctx) {
-    const name = await this.evaluate(node.name, ctx);
-    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
-    const kwargs = await this.evaluateObject(node.kwargs, ctx);
+  renderUrlSync(node, ctx) {
+    const name = this.eval(node.name, ctx);
+    const args = node.args.map((arg) => this.eval(arg, ctx));
+    const kwargs = this.evalObjectSync(node.kwargs, ctx);
     const url = this.options.urlResolver(String(name), args, kwargs);
     if (node.asVar) {
       ctx.set(node.asVar, url);
@@ -2068,8 +2142,8 @@ class Runtime {
     }
     return url;
   }
-  async renderStatic(node, ctx) {
-    const path = await this.evaluate(node.path, ctx);
+  renderStaticSync(node, ctx) {
+    const path = this.eval(node.path, ctx);
     const url = this.options.staticResolver(String(path));
     if (node.asVar) {
       ctx.set(node.asVar, url);
@@ -2077,114 +2151,86 @@ class Runtime {
     }
     return url;
   }
-  async renderNodes(nodes2, ctx) {
+  renderNodesSync(nodes2, ctx) {
     const parts = [];
     for (const node of nodes2) {
-      const result = await this.renderNode(node, ctx);
+      const result = this.renderNodeSync(node, ctx);
       if (result !== null)
         parts.push(result);
     }
     return parts.join("");
   }
-  async evaluate(node, ctx) {
+  eval(node, ctx) {
     switch (node.type) {
       case "Literal":
         return node.value;
       case "Name":
         return ctx.get(node.name);
       case "GetAttr":
-        return this.evaluateGetAttr(node, ctx);
+        return this.evalGetAttr(node, ctx);
       case "GetItem":
-        return this.evaluateGetItem(node, ctx);
+        return this.evalGetItem(node, ctx);
       case "FilterExpr":
-        return this.evaluateFilter(node, ctx);
+        return this.evalFilter(node, ctx);
       case "BinaryOp":
-        return this.evaluateBinaryOp(node, ctx);
+        return this.evalBinaryOp(node, ctx);
       case "UnaryOp":
-        return this.evaluateUnaryOp(node, ctx);
+        return this.evalUnaryOp(node, ctx);
       case "Compare":
-        return this.evaluateCompare(node, ctx);
+        return this.evalCompare(node, ctx);
       case "Conditional":
-        return this.evaluateConditional(node, ctx);
+        return this.evalConditional(node, ctx);
       case "Array":
-        return Promise.all(node.elements.map((el) => this.evaluate(el, ctx)));
+        return node.elements.map((el) => this.eval(el, ctx));
       case "Object":
-        return this.evaluateObjectLiteral(node, ctx);
+        return this.evalObjectLiteral(node, ctx);
       case "FunctionCall":
-        return this.evaluateFunctionCall(node, ctx);
+        return this.evalFunctionCall(node, ctx);
       case "TestExpr":
-        return this.evaluateTest(node, ctx);
+        return this.evalTest(node, ctx);
       default:
         return;
     }
   }
-  async evaluateTest(node, ctx) {
-    if (node.test === "defined" || node.test === "undefined") {
-      let isDefined = false;
-      if (node.node.type === "Name") {
-        isDefined = ctx.has(node.node.name);
-      } else {
-        const value2 = await this.evaluate(node.node, ctx);
-        isDefined = value2 !== undefined;
-      }
-      const result2 = node.test === "defined" ? isDefined : !isDefined;
-      return node.negated ? !result2 : result2;
-    }
-    const value = await this.evaluate(node.node, ctx);
-    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
-    const test = this.tests[node.test];
-    if (!test) {
-      throw new Error(`Unknown test: ${node.test}`);
-    }
-    const result = test(value, ...args);
-    return node.negated ? !result : result;
-  }
-  async evaluateGetAttr(node, ctx) {
-    const obj = await this.evaluate(node.object, ctx);
+  evalGetAttr(node, ctx) {
+    const obj = this.eval(node.object, ctx);
     if (obj == null)
       return;
     const numIndex = parseInt(node.attribute, 10);
-    if (!isNaN(numIndex) && Array.isArray(obj)) {
+    if (!isNaN(numIndex) && Array.isArray(obj))
       return obj[numIndex];
-    }
     if (typeof obj === "object" && node.attribute in obj) {
       const value = obj[node.attribute];
-      if (typeof value === "function") {
-        return value.call(obj);
-      }
-      return value;
+      return typeof value === "function" ? value.call(obj) : value;
     }
     if (typeof obj[node.attribute] === "function") {
       return obj[node.attribute].bind(obj);
     }
     return;
   }
-  async evaluateGetItem(node, ctx) {
-    const obj = await this.evaluate(node.object, ctx);
-    const index = await this.evaluate(node.index, ctx);
+  evalGetItem(node, ctx) {
+    const obj = this.eval(node.object, ctx);
+    const index = this.eval(node.index, ctx);
     if (obj == null)
       return;
     return obj[index];
   }
-  async evaluateFilter(node, ctx) {
-    const value = await this.evaluate(node.node, ctx);
-    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
-    const kwargs = await this.evaluateObject(node.kwargs, ctx);
+  evalFilter(node, ctx) {
+    const value = this.eval(node.node, ctx);
+    const args = node.args.map((arg) => this.eval(arg, ctx));
+    const kwargs = this.evalObjectSync(node.kwargs, ctx);
     const filter = this.filters[node.filter];
-    if (!filter) {
+    if (!filter)
       throw new Error(`Unknown filter: ${node.filter}`);
-    }
     return filter(value, ...args, ...Object.values(kwargs));
   }
-  async evaluateBinaryOp(node, ctx) {
-    const left = await this.evaluate(node.left, ctx);
-    if (node.operator === "and") {
-      return this.isTruthy(left) ? await this.evaluate(node.right, ctx) : left;
-    }
-    if (node.operator === "or") {
-      return this.isTruthy(left) ? left : await this.evaluate(node.right, ctx);
-    }
-    const right = await this.evaluate(node.right, ctx);
+  evalBinaryOp(node, ctx) {
+    const left = this.eval(node.left, ctx);
+    if (node.operator === "and")
+      return this.isTruthy(left) ? this.eval(node.right, ctx) : left;
+    if (node.operator === "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);
@@ -2193,20 +2239,17 @@ class Runtime {
       case "*":
         return Number(left) * Number(right);
       case "/":
-        const divisor = Number(right);
-        if (divisor === 0)
-          return 0;
-        return Number(left) / divisor;
+        return Number(left) / Number(right);
       case "%":
-        return Number(left) % Number(right);
+        return Number(right) === 0 ? NaN : Number(left) % Number(right);
       case "~":
         return String(left) + String(right);
       default:
         return;
     }
   }
-  async evaluateUnaryOp(node, ctx) {
-    const operand = await this.evaluate(node.operand, ctx);
+  evalUnaryOp(node, ctx) {
+    const operand = this.eval(node.operand, ctx);
     switch (node.operator) {
       case "not":
         return !this.isTruthy(operand);
@@ -2218,10 +2261,10 @@ class Runtime {
         return operand;
     }
   }
-  async evaluateCompare(node, ctx) {
-    let left = await this.evaluate(node.left, ctx);
+  evalCompare(node, ctx) {
+    let left = this.eval(node.left, ctx);
     for (const { operator, right: rightNode } of node.ops) {
-      const right = await this.evaluate(rightNode, ctx);
+      const right = this.eval(rightNode, ctx);
       let result;
       switch (operator) {
         case "==":
@@ -2263,34 +2306,197 @@ class Runtime {
     }
     return true;
   }
-  async evaluateConditional(node, ctx) {
-    const test = await this.evaluate(node.test, ctx);
-    return this.isTruthy(test) ? await this.evaluate(node.trueExpr, ctx) : await this.evaluate(node.falseExpr, ctx);
+  evalConditional(node, ctx) {
+    return this.isTruthy(this.eval(node.test, ctx)) ? this.eval(node.trueExpr, ctx) : this.eval(node.falseExpr, ctx);
   }
-  async evaluateObjectLiteral(node, ctx) {
+  evalObjectLiteral(node, ctx) {
     const result = {};
     for (const { key, value } of node.pairs) {
-      const k = await this.evaluate(key, ctx);
-      result[String(k)] = await this.evaluate(value, ctx);
+      result[String(this.eval(key, ctx))] = this.eval(value, ctx);
     }
     return result;
   }
-  async evaluateFunctionCall(node, ctx) {
-    const callee = await this.evaluate(node.callee, ctx);
-    const args = await Promise.all(node.args.map((arg) => this.evaluate(arg, ctx)));
-    const kwargs = await this.evaluateObject(node.kwargs, ctx);
-    if (typeof callee === "function") {
-      return callee(...args, kwargs);
+  evalFunctionCall(node, ctx) {
+    const callee = this.eval(node.callee, ctx);
+    const args = node.args.map((arg) => this.eval(arg, ctx));
+    const kwargs = this.evalObjectSync(node.kwargs, ctx);
+    return typeof callee === "function" ? callee(...args, kwargs) : undefined;
+  }
+  evalTest(node, ctx) {
+    if (node.test === "defined" || node.test === "undefined") {
+      let isDefined = false;
+      if (node.node.type === "Name") {
+        isDefined = ctx.has(node.node.name);
+      } else {
+        isDefined = this.eval(node.node, ctx) !== undefined;
+      }
+      const result2 = node.test === "defined" ? isDefined : !isDefined;
+      return node.negated ? !result2 : result2;
     }
-    return;
+    const value = this.eval(node.node, ctx);
+    const args = node.args.map((arg) => this.eval(arg, ctx));
+    const test = this.tests[node.test];
+    if (!test)
+      throw new Error(`Unknown test: ${node.test}`);
+    const result = test(value, ...args);
+    return node.negated ? !result : result;
   }
-  async evaluateObject(obj, ctx) {
+  evalObjectSync(obj, ctx) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
-      result[key] = await this.evaluate(value, ctx);
+      result[key] = this.eval(value, ctx);
+    }
+    return result;
+  }
+  async collectBlocks(ast, ctx) {
+    for (const node of ast.body) {
+      if (node.type === "Extends") {
+        const templateName = this.eval(node.template, ctx);
+        this.parentTemplate = await this.options.templateLoader(String(templateName));
+        await this.collectBlocks(this.parentTemplate, ctx);
+      } else if (node.type === "Block") {
+        this.blocks.set(node.name, node);
+      }
+    }
+  }
+  async renderTemplateAsync(ast, ctx) {
+    const parts = [];
+    for (const node of ast.body) {
+      const result = await this.renderNodeAsync(node, ctx);
+      if (result !== null)
+        parts.push(result);
+    }
+    return parts.join("");
+  }
+  async renderNodeAsync(node, ctx) {
+    switch (node.type) {
+      case "Text":
+        return node.value;
+      case "Output":
+        return this.stringify(this.eval(node.expression, ctx));
+      case "If":
+        return this.renderIfAsync(node, ctx);
+      case "For":
+        return this.renderForAsync(node, ctx);
+      case "Block":
+        return this.renderBlockAsync(node, ctx);
+      case "Extends":
+        return null;
+      case "Include":
+        return this.renderInclude(node, ctx);
+      case "Set":
+        ctx.set(node.target, this.eval(node.value, ctx));
+        return "";
+      case "With":
+        return this.renderWithAsync(node, ctx);
+      case "Load":
+        return null;
+      case "Url":
+        return this.renderUrlSync(node, ctx);
+      case "Static":
+        return this.renderStaticSync(node, ctx);
+      default:
+        return null;
+    }
+  }
+  async renderIfAsync(node, ctx) {
+    if (this.isTruthy(this.eval(node.test, ctx))) {
+      return this.renderNodesAsync(node.body, ctx);
+    }
+    for (const elif of node.elifs) {
+      if (this.isTruthy(this.eval(elif.test, ctx))) {
+        return this.renderNodesAsync(elif.body, ctx);
+      }
+    }
+    return node.else_.length > 0 ? this.renderNodesAsync(node.else_, ctx) : "";
+  }
+  async renderForAsync(node, ctx) {
+    const iterable2 = this.eval(node.iter, ctx);
+    const items = this.toIterable(iterable2);
+    const len = items.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);
+    for (let i = 0;i < len; i++) {
+      const item = items[i];
+      if (i > 0)
+        ctx.updateForLoop(i, items);
+      if (isUnpacking) {
+        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];
+        }
+        const targets = node.target;
+        for (let j = 0;j < targets.length; j++) {
+          ctx.set(targets[j], values[j]);
+        }
+      } else {
+        ctx.set(node.target, item);
+      }
+      parts[i] = await this.renderNodesAsync(node.body, ctx);
+    }
+    ctx.popForLoop();
+    ctx.pop();
+    return parts.join("");
+  }
+  async renderBlockAsync(node, ctx) {
+    const blockToRender = this.blocks.get(node.name) || node;
+    ctx.push();
+    const parentContent = await this.renderNodesAsync(node.body, ctx);
+    ctx.set("block", {
+      super: () => parentContent
+    });
+    const result = await this.renderNodesAsync(blockToRender.body, ctx);
+    ctx.pop();
+    return result;
+  }
+  async renderInclude(node, ctx) {
+    try {
+      const templateName = this.eval(node.template, ctx);
+      const template = await this.options.templateLoader(String(templateName));
+      let includeCtx;
+      if (node.only) {
+        includeCtx = new Context(node.context ? this.evalObjectSync(node.context, ctx) : {});
+      } else {
+        const additional = node.context ? this.evalObjectSync(node.context, ctx) : {};
+        includeCtx = ctx.derived(additional);
+      }
+      return this.renderTemplateAsync(template, includeCtx);
+    } catch (error) {
+      if (node.ignoreMissing)
+        return "";
+      throw error;
     }
+  }
+  async renderWithAsync(node, ctx) {
+    ctx.push();
+    for (const { target, value } of node.assignments) {
+      ctx.set(target, this.eval(value, ctx));
+    }
+    const result = await this.renderNodesAsync(node.body, ctx);
+    ctx.pop();
     return result;
   }
+  async renderNodesAsync(nodes2, ctx) {
+    const parts = [];
+    for (const node of nodes2) {
+      const result = await this.renderNodeAsync(node, ctx);
+      if (result !== null)
+        parts.push(result);
+    }
+    return parts.join("");
+  }
+  async evaluate(node, ctx) {
+    return this.eval(node, ctx);
+  }
   stringify(value) {
     if (value == null)
       return "";
@@ -2300,7 +2506,7 @@ class Runtime {
     if (value.__safe__)
       return str;
     if (this.options.autoescape) {
-      return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+      return Bun.escapeHTML(str);
     }
     return str;
   }
@@ -2315,8 +2521,11 @@ class Runtime {
       return value.length > 0;
     if (Array.isArray(value))
       return value.length > 0;
-    if (typeof value === "object")
-      return Object.keys(value).length > 0;
+    if (typeof value === "object") {
+      for (const _ in value)
+        return true;
+      return false;
+    }
     return true;
   }
   isIn(needle, haystack) {
@@ -2354,9 +2563,441 @@ class Runtime {
   }
 }
 
+// src/compiler/index.ts
+function compileToString(ast, options = {}) {
+  const compiler = new Compiler(options);
+  return compiler.compile(ast);
+}
+function compileToFunction(ast, options = {}) {
+  const code = compileToString(ast, options);
+  const fn = new Function("__ctx", "__helpers", `
+    const { escape, isTruthy, toArray, applyFilter, applyTest } = __helpers;
+    ${code}
+    return render(__ctx);
+  `);
+  return (ctx) => fn(ctx, runtimeHelpers);
+}
+var runtimeHelpers = {
+  escape: (value) => {
+    if (value == null)
+      return "";
+    if (typeof value === "object" && value.__safe)
+      return String(value.value ?? "");
+    if (value?.__safe__)
+      return String(value);
+    return Bun.escapeHTML(String(value));
+  },
+  isTruthy: (value) => {
+    if (value == null)
+      return false;
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value !== 0;
+    if (typeof value === "string")
+      return value.length > 0;
+    if (Array.isArray(value))
+      return value.length > 0;
+    if (typeof value === "object") {
+      for (const _ in value)
+        return true;
+      return false;
+    }
+    return true;
+  },
+  toArray: (value) => {
+    if (value == null)
+      return [];
+    if (Array.isArray(value))
+      return value;
+    if (typeof value === "string")
+      return value.split("");
+    if (typeof value === "object") {
+      if (typeof value[Symbol.iterator] === "function")
+        return [...value];
+      return Object.entries(value);
+    }
+    return [];
+  },
+  applyFilter: (name, value, ...args) => {
+    const filter = builtinFilters[name];
+    if (!filter)
+      throw new Error(`Unknown filter: ${name}`);
+    return filter(value, ...args);
+  },
+  applyTest: (name, value, ...args) => {
+    const test = builtinTests[name];
+    if (!test)
+      throw new Error(`Unknown test: ${name}`);
+    return test(value, ...args);
+  }
+};
+
+class Compiler {
+  options;
+  indent = 0;
+  varCounter = 0;
+  loopStack = [];
+  constructor(options = {}) {
+    this.options = {
+      functionName: options.functionName ?? "render",
+      inlineHelpers: options.inlineHelpers ?? true,
+      minify: options.minify ?? false,
+      autoescape: options.autoescape ?? true
+    };
+  }
+  compile(ast) {
+    const body = this.compileNodes(ast.body);
+    const nl = this.options.minify ? "" : `
+`;
+    return `function ${this.options.functionName}(__ctx) {${nl}` + `  let __out = '';${nl}` + body + `  return __out;${nl}` + `}`;
+  }
+  compileNodes(nodes2) {
+    return nodes2.map((node) => this.compileNode(node)).join("");
+  }
+  compileNode(node) {
+    switch (node.type) {
+      case "Text":
+        return this.compileText(node);
+      case "Output":
+        return this.compileOutput(node);
+      case "If":
+        return this.compileIf(node);
+      case "For":
+        return this.compileFor(node);
+      case "Set":
+        return this.compileSet(node);
+      case "With":
+        return this.compileWith(node);
+      case "Comment":
+        return "";
+      case "Extends":
+      case "Block":
+      case "Include":
+        throw new Error(`AOT compilation does not support '${node.type}' - use Environment.render() for templates with inheritance`);
+      case "Url":
+      case "Static":
+        throw new Error(`AOT compilation does not support '${node.type}' tag - use Environment.render() with urlResolver/staticResolver`);
+      default:
+        throw new Error(`Unknown node type in AOT compiler: ${node.type}`);
+    }
+  }
+  compileText(node) {
+    const escaped = JSON.stringify(node.value);
+    return `  __out += ${escaped};${this.nl()}`;
+  }
+  compileOutput(node) {
+    const expr = this.compileExpr(node.expression);
+    if (this.options.autoescape && !this.isMarkedSafe(node.expression)) {
+      return `  __out += escape(${expr});${this.nl()}`;
+    }
+    return `  __out += (${expr}) ?? '';${this.nl()}`;
+  }
+  compileIf(node) {
+    let code = "";
+    const test = this.compileExpr(node.test);
+    code += `  if (isTruthy(${test})) {${this.nl()}`;
+    code += this.compileNodes(node.body);
+    code += `  }`;
+    for (const elif of node.elifs) {
+      const elifTest = this.compileExpr(elif.test);
+      code += ` else if (isTruthy(${elifTest})) {${this.nl()}`;
+      code += this.compileNodes(elif.body);
+      code += `  }`;
+    }
+    if (node.else_.length > 0) {
+      code += ` else {${this.nl()}`;
+      code += this.compileNodes(node.else_);
+      code += `  }`;
+    }
+    code += this.nl();
+    return code;
+  }
+  compileFor(node) {
+    const iterVar = this.genVar("iter");
+    const indexVar = this.genVar("i");
+    const lenVar = this.genVar("len");
+    const loopVar = this.genVar("loop");
+    const itemVar = Array.isArray(node.target) ? node.target[0] : node.target;
+    const valueVar = Array.isArray(node.target) && node.target[1] ? node.target[1] : null;
+    const parentLoopVar = this.loopStack.length > 0 ? this.loopStack[this.loopStack.length - 1] : null;
+    const iter = this.compileExpr(node.iter);
+    let code = "";
+    code += `  const ${iterVar} = toArray(${iter});${this.nl()}`;
+    code += `  const ${lenVar} = ${iterVar}.length;${this.nl()}`;
+    if (node.else_.length > 0) {
+      code += `  if (${lenVar} === 0) {${this.nl()}`;
+      code += this.compileNodes(node.else_);
+      code += `  } else {${this.nl()}`;
+    }
+    code += `  for (let ${indexVar} = 0; ${indexVar} < ${lenVar}; ${indexVar}++) {${this.nl()}`;
+    if (valueVar) {
+      code += `    const ${itemVar} = ${iterVar}[${indexVar}][0];${this.nl()}`;
+      code += `    const ${valueVar} = ${iterVar}[${indexVar}][1];${this.nl()}`;
+    } else {
+      code += `    const ${itemVar} = ${iterVar}[${indexVar}];${this.nl()}`;
+    }
+    code += `    const ${loopVar} = {${this.nl()}`;
+    code += `      counter: ${indexVar} + 1,${this.nl()}`;
+    code += `      counter0: ${indexVar},${this.nl()}`;
+    code += `      revcounter: ${lenVar} - ${indexVar},${this.nl()}`;
+    code += `      revcounter0: ${lenVar} - ${indexVar} - 1,${this.nl()}`;
+    code += `      first: ${indexVar} === 0,${this.nl()}`;
+    code += `      last: ${indexVar} === ${lenVar} - 1,${this.nl()}`;
+    code += `      length: ${lenVar},${this.nl()}`;
+    code += `      index: ${indexVar} + 1,${this.nl()}`;
+    code += `      index0: ${indexVar},${this.nl()}`;
+    if (parentLoopVar) {
+      code += `      parentloop: ${parentLoopVar},${this.nl()}`;
+      code += `      parent: ${parentLoopVar}${this.nl()}`;
+    } else {
+      code += `      parentloop: null,${this.nl()}`;
+      code += `      parent: null${this.nl()}`;
+    }
+    code += `    };${this.nl()}`;
+    code += `    const forloop = ${loopVar};${this.nl()}`;
+    code += `    const loop = ${loopVar};${this.nl()}`;
+    this.loopStack.push(loopVar);
+    const bodyCode = this.compileNodes(node.body);
+    code += bodyCode.replace(new RegExp(`__ctx\\.${itemVar}`, "g"), itemVar);
+    this.loopStack.pop();
+    code += `  }${this.nl()}`;
+    if (node.else_.length > 0) {
+      code += `  }${this.nl()}`;
+    }
+    return code;
+  }
+  compileSet(node) {
+    const value = this.compileExpr(node.value);
+    return `  const ${node.target} = ${value};${this.nl()}`;
+  }
+  compileWith(node) {
+    let code = `  {${this.nl()}`;
+    for (const { target, value } of node.assignments) {
+      const valueExpr = this.compileExpr(value);
+      code += `    const ${target} = ${valueExpr};${this.nl()}`;
+    }
+    code += this.compileNodes(node.body);
+    code += `  }${this.nl()}`;
+    return code;
+  }
+  compileExpr(node) {
+    switch (node.type) {
+      case "Name":
+        return this.compileName(node);
+      case "Literal":
+        return this.compileLiteral(node);
+      case "Array":
+        return this.compileArray(node);
+      case "Object":
+        return this.compileObject(node);
+      case "BinaryOp":
+        return this.compileBinaryOp(node);
+      case "UnaryOp":
+        return this.compileUnaryOp(node);
+      case "Compare":
+        return this.compileCompare(node);
+      case "GetAttr":
+        return this.compileGetAttr(node);
+      case "GetItem":
+        return this.compileGetItem(node);
+      case "FilterExpr":
+        return this.compileFilter(node);
+      case "TestExpr":
+        return this.compileTest(node);
+      case "Conditional":
+        return this.compileConditional(node);
+      default:
+        return "undefined";
+    }
+  }
+  compileName(node) {
+    if (node.name === "true" || node.name === "True")
+      return "true";
+    if (node.name === "false" || node.name === "False")
+      return "false";
+    if (node.name === "none" || node.name === "None" || node.name === "null")
+      return "null";
+    if (node.name === "forloop" || node.name === "loop")
+      return node.name;
+    return `__ctx.${node.name}`;
+  }
+  compileLiteral(node) {
+    if (typeof node.value === "string") {
+      return JSON.stringify(node.value);
+    }
+    return String(node.value);
+  }
+  compileArray(node) {
+    const elements = node.elements.map((el) => this.compileExpr(el)).join(", ");
+    return `[${elements}]`;
+  }
+  compileObject(node) {
+    const pairs = node.pairs.map(({ key, value }) => {
+      const k = this.compileExpr(key);
+      const v = this.compileExpr(value);
+      return `[${k}]: ${v}`;
+    }).join(", ");
+    return `{${pairs}}`;
+  }
+  compileBinaryOp(node) {
+    const left = this.compileExpr(node.left);
+    const right = this.compileExpr(node.right);
+    switch (node.operator) {
+      case "and":
+        return `(${left} && ${right})`;
+      case "or":
+        return `(${left} || ${right})`;
+      case "~":
+        return `(String(${left}) + String(${right}))`;
+      case "in":
+        return `(Array.isArray(${right}) ? ${right}.includes(${left}) : String(${right}).includes(String(${left})))`;
+      case "not in":
+        return `!(Array.isArray(${right}) ? ${right}.includes(${left}) : String(${right}).includes(String(${left})))`;
+      default:
+        return `(${left} ${node.operator} ${right})`;
+    }
+  }
+  compileUnaryOp(node) {
+    const operand = this.compileExpr(node.operand);
+    switch (node.operator) {
+      case "not":
+        return `!isTruthy(${operand})`;
+      case "-":
+        return `-(${operand})`;
+      case "+":
+        return `+(${operand})`;
+      default:
+        return operand;
+    }
+  }
+  compileCompare(node) {
+    let result = this.compileExpr(node.left);
+    for (const { operator, right } of node.ops) {
+      const rightExpr = this.compileExpr(right);
+      switch (operator) {
+        case "==":
+        case "===":
+          result = `(${result} === ${rightExpr})`;
+          break;
+        case "!=":
+        case "!==":
+          result = `(${result} !== ${rightExpr})`;
+          break;
+        default:
+          result = `(${result} ${operator} ${rightExpr})`;
+      }
+    }
+    return result;
+  }
+  compileGetAttr(node) {
+    const obj = this.compileExpr(node.object);
+    return `${obj}?.${node.attribute}`;
+  }
+  compileGetItem(node) {
+    const obj = this.compileExpr(node.object);
+    const index = this.compileExpr(node.index);
+    return `${obj}?.[${index}]`;
+  }
+  compileFilter(node) {
+    const value = this.compileExpr(node.node);
+    const args = node.args.map((arg) => this.compileExpr(arg));
+    switch (node.filter) {
+      case "upper":
+        return `String(${value}).toUpperCase()`;
+      case "lower":
+        return `String(${value}).toLowerCase()`;
+      case "title":
+        return `String(${value}).replace(/\\b\\w/g, c => c.toUpperCase())`;
+      case "trim":
+        return `String(${value}).trim()`;
+      case "length":
+        return `(${value}?.length ?? Object.keys(${value} ?? {}).length)`;
+      case "first":
+        return `(${value})?.[0]`;
+      case "last":
+        return `(${value})?.[(${value})?.length - 1]`;
+      case "default":
+        return `((${value}) ?? ${args[0] ?? '""'})`;
+      case "safe":
+        return `{ __safe: true, value: String(${value}) }`;
+      case "escape":
+      case "e":
+        return `escape(${value})`;
+      case "join":
+        return `(${value} ?? []).join(${args[0] ?? '""'})`;
+      case "abs":
+        return `Math.abs(${value})`;
+      case "round":
+        return args.length ? `Number(${value}).toFixed(${args[0]})` : `Math.round(${value})`;
+      case "int":
+        return `parseInt(${value}, 10)`;
+      case "float":
+        return `parseFloat(${value})`;
+      case "floatformat":
+        return `Number(${value}).toFixed(${args[0] ?? 1})`;
+      case "filesizeformat":
+        return `applyFilter('filesizeformat', ${value})`;
+      default:
+        const argsStr = args.length ? ", " + args.join(", ") : "";
+        return `applyFilter('${node.filter}', ${value}${argsStr})`;
+    }
+  }
+  compileTest(node) {
+    const value = this.compileExpr(node.node);
+    const args = node.args.map((arg) => this.compileExpr(arg));
+    const negation = node.negated ? "!" : "";
+    switch (node.test) {
+      case "defined":
+        return `${negation}(${value} !== undefined)`;
+      case "undefined":
+        return `${negation}(${value} === undefined)`;
+      case "none":
+        return `${negation}(${value} === null)`;
+      case "even":
+        return `${negation}(${value} % 2 === 0)`;
+      case "odd":
+        return `${negation}(${value} % 2 !== 0)`;
+      case "divisibleby":
+        return `${negation}(${value} % ${args[0]} === 0)`;
+      case "empty":
+        return `${negation}((${value} == null) || (${value}.length === 0) || (Object.keys(${value}).length === 0))`;
+      case "iterable":
+        return `${negation}(Array.isArray(${value}) || typeof ${value} === 'string')`;
+      case "number":
+        return `${negation}(typeof ${value} === 'number' && !isNaN(${value}))`;
+      case "string":
+        return `${negation}(typeof ${value} === 'string')`;
+      default:
+        const argsStr = args.length ? ", " + args.join(", ") : "";
+        return `${negation}applyTest('${node.test}', ${value}${argsStr})`;
+    }
+  }
+  compileConditional(node) {
+    const test = this.compileExpr(node.test);
+    const trueExpr = this.compileExpr(node.trueExpr);
+    const falseExpr = this.compileExpr(node.falseExpr);
+    return `(isTruthy(${test}) ? ${trueExpr} : ${falseExpr})`;
+  }
+  isMarkedSafe(node) {
+    if (node.type === "FilterExpr") {
+      const filter = node;
+      return filter.filter === "safe";
+    }
+    return false;
+  }
+  genVar(prefix) {
+    return `__${prefix}${this.varCounter++}`;
+  }
+  nl() {
+    return this.options.minify ? "" : `
+`;
+  }
+}
+
 // src/index.ts
-import * as fs from "fs";
 import * as path from "path";
+var URL_PARAM_REGEX = /<[^>]+>|:[a-zA-Z_]+|\(\?P<[^>]+>\[[^\]]+\]\)/g;
 
 class Environment {
   options;
@@ -2405,7 +3046,7 @@ class Environment {
     if (!templatePath) {
       throw new Error(`Template not found: ${templateName}`);
     }
-    const source = await fs.promises.readFile(templatePath, "utf-8");
+    const source = await Bun.file(templatePath).text();
     const ast = this.compile(source);
     if (this.options.cache) {
       this.templateCache.set(templateName, ast);
@@ -2433,10 +3074,9 @@ class Environment {
     const basePath = path.resolve(this.options.templates, templateName);
     for (const ext of this.options.extensions) {
       const fullPath = basePath + ext;
-      try {
-        await fs.promises.access(fullPath, fs.constants.R_OK);
+      if (await Bun.file(fullPath).exists()) {
         return fullPath;
-      } catch {}
+      }
     }
     return null;
   }
@@ -2447,13 +3087,15 @@ class Environment {
       return `#${name}`;
     }
     let url = pattern;
-    for (const [key, value] of Object.entries(kwargs)) {
-      url = url.replace(`:${key}`, encodeURIComponent(String(value)));
-      url = url.replace(`<${key}>`, encodeURIComponent(String(value)));
-      url = url.replace(`(?P<${key}>[^/]+)`, encodeURIComponent(String(value)));
+    for (const key in kwargs) {
+      const encoded = encodeURIComponent(String(kwargs[key]));
+      url = url.replaceAll(`:${key}`, encoded);
+      url = url.replaceAll(`<${key}>`, encoded);
+      url = url.replaceAll(`(?P<${key}>[^/]+)`, encoded);
     }
     let argIndex = 0;
-    url = url.replace(/<[^>]+>|:[a-zA-Z_]+|\(\?P<[^>]+>\[[^\]]+\]\)/g, () => {
+    URL_PARAM_REGEX.lastIndex = 0;
+    url = url.replace(URL_PARAM_REGEX, () => {
       if (argIndex < args.length) {
         return encodeURIComponent(String(args[argIndex++]));
       }
@@ -2472,22 +3114,39 @@ async function render(source, context = {}, options = {}) {
 function Template(source, options = {}) {
   const env = new Environment(options);
   const ast = env.compile(source);
+  const runtime = new Runtime({
+    autoescape: options.autoescape ?? true,
+    filters: options.filters ?? {},
+    globals: options.globals ?? {},
+    urlResolver: options.urlResolver,
+    staticResolver: options.staticResolver,
+    templateLoader: async () => ast
+  });
   return {
     async render(context = {}) {
-      const runtime = new Runtime({
-        autoescape: options.autoescape ?? true,
-        filters: options.filters ?? {},
-        globals: options.globals ?? {},
-        urlResolver: options.urlResolver,
-        staticResolver: options.staticResolver,
-        templateLoader: async () => ast
-      });
       return runtime.render(ast, context);
     }
   };
 }
+function compile(source, options = {}) {
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  return compileToFunction(ast, options);
+}
+function compileToCode(source, options = {}) {
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  return compileToString(ast, options);
+}
 export {
   render,
+  compileToCode,
+  compile,
+  builtinTests,
   builtinFilters,
   TokenType,
   Template,