tina4-nodejs 3.13.83 → 3.13.84

package/packages/frond/dist/index.js

@@ -0,0 +1,2543 @@
+// src/engine.ts
+import { createHash, createHmac, randomBytes } from "node:crypto";
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+var SafeString = class {
+  constructor(value) {
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+};
+function inspectValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "bigint") return `${value.toString()}n`;
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "function") {
+    const name = value.name || "(anonymous)";
+    return `[Function: ${name}]`;
+  }
+  const obj = value;
+  if (seen.has(obj)) return "[Circular]";
+  seen.add(obj);
+  if (depth > 8) return "[...]";
+  try {
+    if (obj instanceof Date) {
+      return `Date(${obj.toISOString()})`;
+    }
+    if (obj instanceof RegExp) {
+      return obj.toString();
+    }
+    if (obj instanceof Error) {
+      return `${obj.constructor.name}(${JSON.stringify(obj.message)})`;
+    }
+    if (obj instanceof Map) {
+      if (obj.size === 0) return "Map(0) {}";
+      const entries = [];
+      for (const [k, v] of obj) {
+        entries.push(`${inspectValue(k, seen, depth + 1)} => ${inspectValue(v, seen, depth + 1)}`);
+      }
+      return `Map(${obj.size}) { ${entries.join(", ")} }`;
+    }
+    if (obj instanceof Set) {
+      if (obj.size === 0) return "Set(0) {}";
+      const items = [];
+      for (const v of obj) {
+        items.push(inspectValue(v, seen, depth + 1));
+      }
+      return `Set(${obj.size}) { ${items.join(", ")} }`;
+    }
+    if (Array.isArray(obj)) {
+      if (obj.length === 0) return "[]";
+      const items = obj.map((v) => inspectValue(v, seen, depth + 1));
+      return `[${items.join(", ")}]`;
+    }
+    const keys = Object.keys(obj);
+    const className = obj.constructor && obj.constructor.name !== "Object" ? `${obj.constructor.name} ` : "";
+    if (keys.length === 0) return `${className}{}`;
+    const props = keys.map((k) => {
+      const v = obj[k];
+      return `${k}: ${inspectValue(v, seen, depth + 1)}`;
+    });
+    return `${className}{ ${props.join(", ")} }`;
+  } finally {
+    seen.delete(obj);
+  }
+}
+function renderDump(value) {
+  const debugMode = (process.env.TINA4_DEBUG ?? "").toLowerCase() === "true";
+  if (!debugMode) {
+    return new SafeString("");
+  }
+  const dumped = inspectValue(value);
+  const escaped = dumped.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  return new SafeString(`<pre>${escaped}</pre>`);
+}
+var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+var METHOD_CALL_RE = /^(\w+)\s*\(([\s\S]*)?\)$/;
+var FN_CALL_RE = /^([\w.]+)\s*\(([\s\S]*)?\)$/;
+var IS_NOT_RE = /^(.+?)\s+is\s+not\s+(\w+)(.*)$/;
+var IS_RE = /^(.+?)\s+is\s+(\w+)(.*)$/;
+var NOT_IN_RE = /^(.+?)\s+not\s+in\s+(.+)$/;
+var IN_RE = /^(.+?)\s+in\s+(.+)$/;
+var DIVISIBLE_BY_RE = /\s*by\s*\(\s*(\d+)\s*\)/;
+var FILTER_WITH_ARGS_RE = /^(\w+)\s*\(([\s\S]*)\)$/;
+var FILTER_COMPARISON_RE = /^(\w+)\s*(!=|==|>=|<=|>|<)\s*(.+)$/;
+var TITLE_WORD_RE = /\b\w/g;
+var STRIP_TAGS_RE = /<[^>]+>/g;
+var FORMAT_RE = /%%|%([-+ 0]*)(\d+)?(?:\.(\d+))?([sdifFeEgGxXob])/g;
+var LEADING_WS_RE = /^\s+/;
+var TRAILING_WS_RE = /\s+$/;
+var THOUSANDS_RE = /\B(?=(\d{3})+(?!\d))/g;
+var LIVE_RE = /^live\s+["']([^"']+)["']([\s\S]*)$/;
+var LIVE_WS_RE = /ws\s+["']([^"']+)["']/;
+var LIVE_SRC_RE = /src\s+["']([^"']+)["']/;
+function liveAttr(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var filterChainCache = /* @__PURE__ */ new Map();
+var pathParseCache = /* @__PURE__ */ new Map();
+var TOKEN_RE = /(\{%-?\s*[\s\S]*?\s*-?%\})|(\{\{-?\s*[\s\S]*?\s*-?\}\})|(\{#[\s\S]*?#\})/g;
+var RAW_BLOCK_RE = /\{%-?\s*raw\s*-?%\}([\s\S]*?)\{%-?\s*endraw\s*-?%\}/g;
+function tokenize(source) {
+  const rawBlocks = [];
+  source = source.replace(RAW_BLOCK_RE, (_match, content) => {
+    const idx = rawBlocks.length;
+    rawBlocks.push(content);
+    return `\0RAW_${idx}\0`;
+  });
+  const tokens = [];
+  let pos = 0;
+  TOKEN_RE.lastIndex = 0;
+  let m;
+  while ((m = TOKEN_RE.exec(source)) !== null) {
+    const start = m.index;
+    if (start > pos) {
+      tokens.push(["TEXT", source.slice(pos, start)]);
+    }
+    const raw = m[0];
+    if (raw.startsWith("{#")) {
+      tokens.push(["COMMENT", raw]);
+    } else if (raw.startsWith("{{")) {
+      tokens.push(["VAR", raw]);
+    } else if (raw.startsWith("{%")) {
+      tokens.push(["BLOCK", raw]);
+    }
+    pos = m.index + raw.length;
+  }
+  if (pos < source.length) {
+    tokens.push(["TEXT", source.slice(pos)]);
+  }
+  if (rawBlocks.length > 0) {
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i][0] === "TEXT" && tokens[i][1].includes("\0RAW_")) {
+        let value = tokens[i][1];
+        for (let idx = 0; idx < rawBlocks.length; idx++) {
+          value = value.replace(`\0RAW_${idx}\0`, rawBlocks[idx]);
+        }
+        tokens[i] = ["TEXT", value];
+      }
+    }
+  }
+  return tokens;
+}
+function stripTag(raw) {
+  let inner;
+  if (raw.startsWith("{{")) {
+    inner = raw.slice(2, -2);
+  } else if (raw.startsWith("{%")) {
+    inner = raw.slice(2, -2);
+  } else {
+    inner = raw.slice(2, -2);
+  }
+  let stripBefore = false;
+  let stripAfter = false;
+  if (inner.startsWith("-")) {
+    stripBefore = true;
+    inner = inner.slice(1);
+  }
+  if (inner.endsWith("-")) {
+    stripAfter = true;
+    inner = inner.slice(0, -1);
+  }
+  return [inner.trim(), stripBefore, stripAfter];
+}
+function resolveVar(expr, context) {
+  expr = expr.trim();
+  if (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) {
+    return expr.slice(1, -1);
+  }
+  if (NUMERIC_RE.test(expr)) {
+    return expr.includes(".") ? parseFloat(expr) : parseInt(expr, 10);
+  }
+  if (expr === "true") return true;
+  if (expr === "false") return false;
+  if (expr === "null" || expr === "none" || expr === "None") return null;
+  if (expr.startsWith("[") && expr.endsWith("]")) {
+    const inner = expr.slice(1, -1).trim();
+    if (inner === "") return [];
+    const items = splitArgs(inner);
+    return items.map((item) => evalExpr(item.trim(), context));
+  }
+  let parts;
+  let fromBracket;
+  const cachedPath = pathParseCache.get(expr);
+  if (cachedPath) {
+    [parts, fromBracket] = cachedPath;
+  } else {
+    parts = [];
+    fromBracket = [];
+    {
+      let current = "";
+      let depth = 0;
+      let inQuote = null;
+      for (let i = 0; i < expr.length; i++) {
+        const ch = expr[i];
+        if (inQuote) {
+          current += ch;
+          if (ch === inQuote) inQuote = null;
+          continue;
+        }
+        if (ch === '"' || ch === "'") {
+          inQuote = ch;
+          current += ch;
+          continue;
+        }
+        if (ch === "(") {
+          depth++;
+          current += ch;
+          continue;
+        }
+        if (ch === ")") {
+          depth--;
+          current += ch;
+          continue;
+        }
+        if (ch === "." && depth === 0) {
+          if (current) {
+            parts.push(current);
+            fromBracket.push(false);
+          }
+          current = "";
+          continue;
+        }
+        if (ch === "[" && depth === 0) {
+          if (current) {
+            parts.push(current);
+            fromBracket.push(false);
+          }
+          current = "";
+          const end = expr.indexOf("]", i + 1);
+          if (end !== -1) {
+            parts.push(expr.slice(i + 1, end));
+            fromBracket.push(true);
+            i = end;
+          }
+          continue;
+        }
+        current += ch;
+      }
+      if (current) {
+        parts.push(current);
+        fromBracket.push(false);
+      }
+    }
+    pathParseCache.set(expr, [parts, fromBracket]);
+  }
+  let value = context;
+  for (let pi = 0; pi < parts.length; pi++) {
+    const part = parts[pi];
+    const isBracket = fromBracket[pi];
+    if (value === null || value === void 0) return null;
+    const methodMatch = part.match(METHOD_CALL_RE);
+    if (methodMatch) {
+      const methodName = methodMatch[1];
+      const rawArgs = methodMatch[2] || "";
+      if (typeof value === "object" && value !== null && methodName in value) {
+        const fn = value[methodName];
+        if (typeof fn === "function") {
+          if (rawArgs.trim()) {
+            const argParts = splitArgs(rawArgs);
+            const evalArgs = argParts.map((a) => evalExpr(a.trim(), context));
+            value = fn.apply(value, evalArgs);
+          } else {
+            value = fn.call(value);
+          }
+          continue;
+        }
+      }
+      return null;
+    }
+    const isQuotedPart = part.startsWith('"') && part.endsWith('"') || part.startsWith("'") && part.endsWith("'");
+    if (isBracket && part.includes(":") && !isQuotedPart) {
+      const sliceParts = part.split(":", 2);
+      const sStart = sliceParts[0].trim() ? parseInt(String(evalExpr(sliceParts[0].trim(), context)), 10) : void 0;
+      const sEnd = sliceParts[1].trim() ? parseInt(String(evalExpr(sliceParts[1].trim(), context)), 10) : void 0;
+      if (Array.isArray(value)) {
+        value = value.slice(sStart ?? 0, sEnd);
+      } else if (typeof value === "string") {
+        value = value.slice(sStart ?? 0, sEnd);
+      } else {
+        return null;
+      }
+      continue;
+    }
+    let key;
+    if (isQuotedPart) {
+      key = part.slice(1, -1);
+    } else {
+      const asNum = parseInt(part, 10);
+      if (!isNaN(asNum) && String(asNum) === part) {
+        key = asNum;
+      } else if (isBracket) {
+        const resolved = evalExpr(part, context);
+        key = resolved !== void 0 ? String(resolved) : part;
+      } else {
+        key = part;
+      }
+    }
+    if (typeof value === "object" && value !== null) {
+      if (Array.isArray(value) && typeof key === "number") {
+        value = value[key];
+      } else if (key in value) {
+        const v = value[key];
+        value = typeof v === "function" ? v.call(value) : v;
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  return value;
+}
+function findOutsideQuotes(expr, needle) {
+  let inQuote = null;
+  let depth = 0;
+  let bracketDepth = 0;
+  let i = 0;
+  while (i <= expr.length - needle.length) {
+    const ch = expr[i];
+    if ((ch === '"' || ch === "'") && depth === 0 && bracketDepth === 0) {
+      if (inQuote === null) {
+        inQuote = ch;
+      } else if (ch === inQuote) {
+        inQuote = null;
+      }
+      i++;
+      continue;
+    }
+    if (inQuote) {
+      i++;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    if (depth === 0 && bracketDepth === 0 && expr.slice(i, i + needle.length) === needle) {
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function splitOutsideQuotes(expr, sep) {
+  const parts = [];
+  let currentStart = 0;
+  let inQuote = null;
+  let depth = 0;
+  let bracketDepth = 0;
+  let i = 0;
+  while (i <= expr.length - sep.length) {
+    const ch = expr[i];
+    if ((ch === '"' || ch === "'") && depth === 0 && bracketDepth === 0) {
+      if (inQuote === null) {
+        inQuote = ch;
+      } else if (ch === inQuote) {
+        inQuote = null;
+      }
+      i++;
+      continue;
+    }
+    if (inQuote) {
+      i++;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    if (depth === 0 && bracketDepth === 0 && expr.slice(i, i + sep.length) === sep) {
+      parts.push(expr.slice(currentStart, i));
+      i += sep.length;
+      currentStart = i;
+      continue;
+    }
+    i++;
+  }
+  parts.push(expr.slice(currentStart));
+  return parts;
+}
+function evalExpr(expr, context) {
+  expr = expr.trim();
+  if (expr.length >= 2) {
+    const q = expr[0];
+    if ((q === '"' || q === "'") && expr.endsWith(q) && !expr.slice(1, -1).includes(q)) {
+      return expr.slice(1, -1);
+    }
+  }
+  if (expr.length >= 2 && expr[0] === "(" && expr.endsWith(")")) {
+    let depth = 0;
+    let matched = true;
+    for (let pi = 0; pi < expr.length; pi++) {
+      if (expr[pi] === "(") depth++;
+      else if (expr[pi] === ")") depth--;
+      if (depth === 0 && pi < expr.length - 1) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      return evalExpr(expr.slice(1, -1), context);
+    }
+  }
+  const ternaryIdx = findTernary(expr);
+  if (ternaryIdx !== -1) {
+    const condPart = expr.slice(0, ternaryIdx).trim();
+    const rest = expr.slice(ternaryIdx + 1);
+    const colonIdx = findColon(rest);
+    if (colonIdx !== -1) {
+      const truePart = rest.slice(0, colonIdx).trim();
+      const falsePart = rest.slice(colonIdx + 1).trim();
+      const cond = evalExpr(condPart, context);
+      return cond ? evalExpr(truePart, context) : evalExpr(falsePart, context);
+    }
+  }
+  const ifIdx = findOutsideQuotes(expr, " if ");
+  if (ifIdx >= 0) {
+    const elseIdx = findOutsideQuotes(expr, " else ");
+    if (elseIdx >= 0 && elseIdx > ifIdx) {
+      const valuePart = expr.slice(0, ifIdx).trim();
+      const condPart = expr.slice(ifIdx + 4, elseIdx).trim();
+      const elsePart = expr.slice(elseIdx + 6).trim();
+      const cond = evalExpr(condPart, context);
+      return cond ? evalExpr(valuePart, context) : evalExpr(elsePart, context);
+    }
+  }
+  const qqIdx = findOutsideQuotes(expr, "??");
+  if (qqIdx !== -1) {
+    const left = expr.slice(0, qqIdx).trim();
+    const right = expr.slice(qqIdx + 2).trim();
+    const val = evalExpr(left, context);
+    if (val === null || val === void 0) {
+      return evalExpr(right, context);
+    }
+    return val;
+  }
+  if (findOutsideQuotes(expr, "~") >= 0) {
+    const parts = splitOutsideQuotes(expr, "~");
+    if (parts.length > 1) {
+      return parts.map((p) => {
+        const v = evalExpr(p.trim(), context);
+        return v === null || v === void 0 ? "" : String(v);
+      }).join("");
+    }
+  }
+  for (const op of [" not in ", " in ", " is not ", " is ", "!=", "==", ">=", "<=", ">", "<", " and ", " or ", " not "]) {
+    if (findOutsideQuotes(expr, op) >= 0) {
+      return evalComparison(expr, context);
+    }
+  }
+  for (const op of [" + ", " - ", " * ", " // ", " / ", " % ", " ** "]) {
+    const pos = findOutsideQuotes(expr, op);
+    if (pos >= 0) {
+      const left = expr.slice(0, pos).trim();
+      const right = expr.slice(pos + op.length).trim();
+      const lVal = evalExpr(left, context);
+      const rVal = evalExpr(right, context);
+      try {
+        let lNum = lVal != null ? Number(lVal) : 0;
+        let rNum = rVal != null ? Number(rVal) : 0;
+        if (isNaN(lNum)) lNum = 0;
+        if (isNaN(rNum)) rNum = 0;
+        const opS = op.trim();
+        const bothInt = Number.isInteger(lNum) && Number.isInteger(rNum) && opS !== "/";
+        let result;
+        switch (opS) {
+          case "+":
+            result = lNum + rNum;
+            break;
+          case "-":
+            result = lNum - rNum;
+            break;
+          case "*":
+            result = lNum * rNum;
+            break;
+          case "//":
+            result = rNum !== 0 ? Math.floor(lNum / rNum) : 0;
+            break;
+          case "/":
+            result = rNum !== 0 ? lNum / rNum : 0;
+            break;
+          case "%":
+            result = rNum !== 0 ? lNum % rNum : 0;
+            break;
+          case "**":
+            result = lNum ** rNum;
+            break;
+          default:
+            result = 0;
+        }
+        return bothInt && Number.isInteger(result) ? result : result;
+      } catch {
+        return null;
+      }
+    }
+  }
+  if (findOutsideQuotes(expr, "|") >= 0) {
+    const [baseExpr, filters] = parseFilterChain(expr);
+    if (filters.length > 0) {
+      const baseValue = evalExpr(baseExpr, context);
+      const applier = context.__frond_apply_filters__;
+      if (applier) {
+        return applier(baseValue, filters, context);
+      }
+      let value = baseValue;
+      for (const [fname, rawArgs] of filters) {
+        if (fname === "raw" || fname === "safe") continue;
+        const args = rawArgs.map((a) => a instanceof VarRef ? evalExpr(a.name, context) : a);
+        const fn = BUILTIN_FILTERS[fname];
+        if (fn) value = fn(value, ...args);
+      }
+      return value;
+    }
+  }
+  const fnMatch = expr.match(FN_CALL_RE);
+  if (fnMatch) {
+    const fnName = fnMatch[1];
+    const rawArgs = fnMatch[2] || "";
+    if (fnName.includes(".")) {
+      const lastDot = fnName.lastIndexOf(".");
+      const objPath = fnName.slice(0, lastDot);
+      const methodName = fnName.slice(lastDot + 1);
+      const obj = resolveVar(objPath, context);
+      if (obj && typeof obj === "object" && methodName in obj) {
+        const method = obj[methodName];
+        if (typeof method === "function") {
+          if (rawArgs.trim()) {
+            const parts = splitArgs(rawArgs);
+            const evalArgs = parts.map((a) => evalExpr(a.trim(), context));
+            return method.apply(obj, evalArgs);
+          }
+          return method.call(obj);
+        }
+      }
+    } else {
+      const fn = context[fnName] ?? resolveVar(fnName, context);
+      if (typeof fn === "function") {
+        if (rawArgs.trim()) {
+          const parts = splitArgs(rawArgs);
+          const evalArgs = parts.map((a) => evalExpr(a.trim(), context));
+          return fn(...evalArgs);
+        }
+        return fn();
+      }
+    }
+  }
+  return resolveVar(expr, context);
+}
+function findTernary(expr) {
+  let depth = 0;
+  let inQuote = null;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      continue;
+    }
+    if (ch === "?" && depth === 0 && expr[i + 1] !== "?") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findColon(expr) {
+  let depth = 0;
+  let inQuote = null;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      continue;
+    }
+    if (ch === ":" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function evalComparison(expr, context, evalFn) {
+  const ev = evalFn ?? evalExpr;
+  expr = expr.trim();
+  if (expr.startsWith("not ")) {
+    return !evalComparison(expr.slice(4), context, evalFn);
+  }
+  const orParts = splitOnKeyword(expr, " or ");
+  if (orParts.length > 1) {
+    return orParts.some((p) => evalComparison(p, context, evalFn));
+  }
+  const andParts = splitOnKeyword(expr, " and ");
+  if (andParts.length > 1) {
+    return andParts.every((p) => evalComparison(p, context, evalFn));
+  }
+  let m = expr.match(IS_NOT_RE);
+  if (m) {
+    return !evalTest(m[1].trim(), m[2], m[3].trim(), context, evalFn);
+  }
+  m = expr.match(IS_RE);
+  if (m) {
+    return evalTest(m[1].trim(), m[2], m[3].trim(), context, evalFn);
+  }
+  m = expr.match(NOT_IN_RE);
+  if (m) {
+    const val2 = ev(m[1].trim(), context);
+    const collection = ev(m[2].trim(), context);
+    if (Array.isArray(collection)) return !collection.includes(val2);
+    if (typeof collection === "string") return !collection.includes(val2);
+    return true;
+  }
+  m = expr.match(IN_RE);
+  if (m) {
+    const val2 = ev(m[1].trim(), context);
+    const collection = ev(m[2].trim(), context);
+    if (Array.isArray(collection)) return collection.includes(val2);
+    if (typeof collection === "string") return collection.includes(val2);
+    return false;
+  }
+  const ops = [
+    ["!=", (a, b) => a !== b],
+    ["==", (a, b) => a == b],
+    // intentional loose equality to match Python
+    [">=", (a, b) => a >= b],
+    ["<=", (a, b) => a <= b],
+    [">", (a, b) => a > b],
+    ["<", (a, b) => a < b]
+  ];
+  for (const [op, fn] of ops) {
+    const opIdx = expr.indexOf(op);
+    if (opIdx !== -1) {
+      const left = expr.slice(0, opIdx).trim();
+      const right = expr.slice(opIdx + op.length).trim();
+      const l = ev(left, context);
+      const r = ev(right, context);
+      try {
+        return fn(l, r);
+      } catch {
+        return false;
+      }
+    }
+  }
+  const val = ev(expr, context);
+  return val !== null && val !== void 0 && val !== false && val !== 0 && val !== "";
+}
+function splitOnKeyword(expr, keyword) {
+  const parts = [];
+  let current = "";
+  let inQuote = null;
+  let depth = 0;
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (inQuote) {
+      current += ch;
+      if (ch === inQuote) inQuote = null;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (depth === 0 && expr.slice(i, i + keyword.length) === keyword) {
+      parts.push(current);
+      current = "";
+      i += keyword.length;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+function evalTest(valueExpr, testName, args, context, evalFn) {
+  const ev = evalFn ?? evalExpr;
+  const val = ev(valueExpr, context);
+  const customTests = context.__frond_tests__;
+  if (customTests && customTests[testName]) {
+    return customTests[testName](val);
+  }
+  const tests = {
+    defined: (v) => v !== null && v !== void 0,
+    empty: (v) => !v || Array.isArray(v) && v.length === 0 || typeof v === "object" && v !== null && Object.keys(v).length === 0,
+    null: (v) => v === null || v === void 0,
+    none: (v) => v === null || v === void 0,
+    even: (v) => typeof v === "number" && Number.isInteger(v) && v % 2 === 0,
+    odd: (v) => typeof v === "number" && Number.isInteger(v) && v % 2 !== 0,
+    iterable: (v) => Array.isArray(v) || typeof v === "object" && v !== null,
+    string: (v) => typeof v === "string",
+    number: (v) => typeof v === "number",
+    boolean: (v) => typeof v === "boolean"
+  };
+  if (testName === "divisible") {
+    const dm = args.match(DIVISIBLE_BY_RE);
+    if (dm) {
+      const n = parseInt(dm[1], 10);
+      return typeof val === "number" && Number.isInteger(val) && val % n === 0;
+    }
+    return false;
+  }
+  if (testName in tests) {
+    return tests[testName](val);
+  }
+  return false;
+}
+function splitFilterNameAndPath(fname) {
+  let depth = 0;
+  let inQ = null;
+  for (let i = 0; i < fname.length; i++) {
+    const ch = fname[i];
+    if (inQ !== null) {
+      if (ch === inQ && (i === 0 || fname[i - 1] !== "\\")) inQ = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQ = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      continue;
+    }
+    if (ch === "." && depth === 0) {
+      return [fname.slice(0, i), fname.slice(i + 1)];
+    }
+  }
+  return [fname, ""];
+}
+function parseFilterChain(expr) {
+  const cached = filterChainCache.get(expr);
+  if (cached) return cached;
+  const parts = [];
+  let current = "";
+  let inQuote = null;
+  let depth = 0;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (inQuote) {
+      current += ch;
+      if (ch === inQuote) inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      current += ch;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      current += ch;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current) parts.push(current);
+  const variable = parts[0].trim();
+  const filters = [];
+  for (let i = 1; i < parts.length; i++) {
+    const f = parts[i].trim();
+    const fm = f.match(FILTER_WITH_ARGS_RE);
+    if (fm) {
+      const name = fm[1];
+      const rawArgs = fm[2].trim();
+      const args = rawArgs ? parseArgs(rawArgs) : [];
+      filters.push([name, args]);
+    } else {
+      filters.push([f.trim(), []]);
+    }
+  }
+  const result = [variable, filters];
+  filterChainCache.set(expr, result);
+  return result;
+}
+var VarRef = class {
+  constructor(name) {
+    this.name = name;
+  }
+};
+function coerceArg(t) {
+  if (/^-?\d+$/.test(t)) return parseInt(t, 10);
+  if (/^-?\d*\.\d+$/.test(t)) return parseFloat(t);
+  if (t === "true") return true;
+  if (t === "false") return false;
+  if (t === "null" || t === "none" || t === "nil") return null;
+  if (t.startsWith("{") && t.endsWith("}") || t.startsWith("[") && t.endsWith("]")) {
+    try {
+      return JSON.parse(t);
+    } catch {
+    }
+  }
+  return new VarRef(t);
+}
+function parseArgs(raw) {
+  const args = [];
+  let current = "";
+  let inQuote = null;
+  let wasQuoted = false;
+  let depth = 0;
+  const flush = () => {
+    if (wasQuoted) args.push(current);
+    else {
+      const t = current.trim();
+      if (t !== "") args.push(coerceArg(t));
+    }
+    current = "";
+    wasQuoted = false;
+  };
+  for (const ch of raw) {
+    if (inQuote) {
+      if (ch === inQuote) {
+        inQuote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      wasQuoted = true;
+      if (current.trim() === "") current = "";
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      current += ch;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      current += ch;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      flush();
+      continue;
+    }
+    current += ch;
+  }
+  flush();
+  return args;
+}
+function splitArgs(raw) {
+  const args = [];
+  let current = "";
+  let inQuote = null;
+  let depth = 0;
+  for (const ch of raw) {
+    if (inQuote) {
+      current += ch;
+      if (ch === inQuote) inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[") {
+      depth++;
+      current += ch;
+      continue;
+    }
+    if (ch === ")" || ch === "]") {
+      depth--;
+      current += ch;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      args.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) args.push(current.trim());
+  return args;
+}
+function htmlEscape(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function dateFilter(value, fmt) {
+  let dt;
+  if (value instanceof Date) {
+    dt = value;
+  } else if (typeof value === "string") {
+    dt = new Date(value);
+    if (isNaN(dt.getTime())) return String(value);
+  } else if (typeof value === "number") {
+    dt = new Date(value);
+  } else {
+    return String(value);
+  }
+  return fmt.replace(/%Y/g, String(dt.getFullYear())).replace(/%m/g, String(dt.getMonth() + 1).padStart(2, "0")).replace(/%d/g, String(dt.getDate()).padStart(2, "0")).replace(/%H/g, String(dt.getHours()).padStart(2, "0")).replace(/%M/g, String(dt.getMinutes()).padStart(2, "0")).replace(/%S/g, String(dt.getSeconds()).padStart(2, "0")).replace(/%I/g, String(dt.getHours() % 12 || 12).padStart(2, "0")).replace(/%p/g, dt.getHours() >= 12 ? "PM" : "AM").replace(/%B/g, dt.toLocaleString("en-US", { month: "long" })).replace(/%b/g, dt.toLocaleString("en-US", { month: "short" })).replace(/%A/g, dt.toLocaleString("en-US", { weekday: "long" })).replace(/%a/g, dt.toLocaleString("en-US", { weekday: "short" }));
+}
+function wordwrap(text, width) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (current && current.length + 1 + word.length > width) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.join("\n");
+}
+function numberFormat(value, decimals, decimalPoint = ".", thousandsSep = ",") {
+  const num = parseFloat(String(value));
+  const fixed = num.toFixed(decimals);
+  const [intPart, decPart] = fixed.split(".");
+  const formatted = intPart.replace(THOUSANDS_RE, thousandsSep);
+  return decPart ? `${formatted}${decimalPoint}${decPart}` : formatted;
+}
+var BUILTIN_FILTERS = {
+  upper: (v) => String(v).toUpperCase(),
+  lower: (v) => String(v).toLowerCase(),
+  capitalize: (v) => {
+    const s = String(v);
+    return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+  },
+  title: (v) => String(v).replace(TITLE_WORD_RE, (c) => c.toUpperCase()),
+  trim: (v) => String(v).trim(),
+  ltrim: (v) => String(v).replace(LEADING_WS_RE, ""),
+  rtrim: (v) => String(v).replace(TRAILING_WS_RE, ""),
+  length: (v) => {
+    if (Array.isArray(v)) return v.length;
+    if (typeof v === "string") return v.length;
+    if (typeof v === "object" && v !== null) return Object.keys(v).length;
+    return 0;
+  },
+  reverse: (v) => Array.isArray(v) ? [...v].reverse() : String(v).split("").reverse().join(""),
+  sort: (v) => Array.isArray(v) ? [...v].sort() : v,
+  shuffle: (v) => {
+    if (!Array.isArray(v)) return v;
+    const arr = [...v];
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr;
+  },
+  first: (v) => Array.isArray(v) ? v[0] ?? null : null,
+  last: (v) => Array.isArray(v) ? v[v.length - 1] ?? null : null,
+  join: (v, sep) => Array.isArray(v) ? v.map(String).join(sep !== void 0 ? String(sep) : ", ") : String(v),
+  split: (v, sep) => String(v).split(sep !== void 0 ? String(sep) : " "),
+  replace: (v, from, to) => {
+    const s = String(v);
+    if (from !== void 0 && typeof from === "object" && from !== null && !Array.isArray(from)) {
+      let result = s;
+      for (const [old, newVal] of Object.entries(from)) {
+        result = result.split(old).join(String(newVal));
+      }
+      return result;
+    }
+    if (from !== void 0 && to !== void 0) {
+      return s.split(String(from)).join(String(to));
+    }
+    return s;
+  },
+  default: (v, fallback) => v !== null && v !== void 0 && v !== "" ? v : fallback !== void 0 ? fallback : "",
+  raw: (v) => v,
+  safe: (v) => v,
+  escape: (v) => htmlEscape(String(v)),
+  e: (v) => htmlEscape(String(v)),
+  striptags: (v) => String(v).replace(STRIP_TAGS_RE, ""),
+  nl2br: (v) => new SafeString(htmlEscape(String(v)).replace(/\n/g, "<br />\n")),
+  abs: (v) => typeof v === "number" ? Math.abs(v) : v,
+  round: (v, decimals) => {
+    const d = decimals !== void 0 ? parseInt(String(decimals), 10) : 0;
+    return parseFloat(parseFloat(String(v)).toFixed(d));
+  },
+  int: (v) => v ? parseInt(String(v), 10) || 0 : 0,
+  float: (v) => v ? parseFloat(String(v)) || 0 : 0,
+  string: (v) => String(v),
+  json_encode: (v) => JSON.stringify(v),
+  json_decode: (v) => typeof v === "string" ? JSON.parse(v) : v,
+  keys: (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? Object.keys(v) : [],
+  values: (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? Object.values(v) : [],
+  merge: (v, other) => {
+    if (typeof v === "object" && v !== null && !Array.isArray(v) && typeof other === "object" && other !== null) {
+      return { ...v, ...other };
+    }
+    return v;
+  },
+  slice: (v, start, end) => {
+    if (Array.isArray(v) || typeof v === "string") {
+      return v.slice(
+        start !== void 0 ? parseInt(String(start), 10) : 0,
+        end !== void 0 ? parseInt(String(end), 10) : void 0
+      );
+    }
+    return v;
+  },
+  batch: (v, size) => {
+    if (!Array.isArray(v) || size === void 0) return [v];
+    const s = parseInt(String(size), 10);
+    const result = [];
+    for (let i = 0; i < v.length; i += s) {
+      result.push(v.slice(i, i + s));
+    }
+    return result;
+  },
+  unique: (v) => {
+    if (!Array.isArray(v)) return v;
+    return [...new Set(v)];
+  },
+  map: (v, key) => {
+    if (!Array.isArray(v) || key === void 0) return v;
+    return v.map((item) => {
+      if (typeof item === "object" && item !== null) {
+        return item[String(key)] ?? null;
+      }
+      return null;
+    });
+  },
+  filter: (v) => Array.isArray(v) ? v.filter(Boolean) : v,
+  column: (v, key) => {
+    if (!Array.isArray(v) || key === void 0) return v;
+    return v.map((row) => {
+      if (typeof row === "object" && row !== null) {
+        return row[String(key)] ?? null;
+      }
+      return null;
+    });
+  },
+  // Twig signature: number_format(decimals=0, decimalPoint='.', thousandsSep=',').
+  // 1-arg (or no-arg) calls keep the original output; args 2/3 enable localized
+  // formats like `1.234,50`. (#170)
+  number_format: (v, decimals, decimalPoint, thousandsSep) => numberFormat(
+    v,
+    decimals !== void 0 ? parseInt(String(decimals), 10) : 0,
+    decimalPoint !== void 0 ? String(decimalPoint) : ".",
+    thousandsSep !== void 0 ? String(thousandsSep) : ","
+  ),
+  date: (v, fmt) => dateFilter(v, fmt !== void 0 ? String(fmt) : "%Y-%m-%d"),
+  truncate: (v, length) => {
+    const s = String(v);
+    if (length !== void 0 && s.length > parseInt(String(length), 10)) {
+      return s.slice(0, parseInt(String(length), 10)) + "...";
+    }
+    return s;
+  },
+  wordwrap: (v, width) => wordwrap(String(v), width !== void 0 ? parseInt(String(width), 10) : 75),
+  slug: (v) => String(v).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""),
+  md5: (v) => createHash("md5").update(String(v)).digest("hex"),
+  sha256: (v) => createHash("sha256").update(String(v)).digest("hex"),
+  base64_encode: (v) => Buffer.isBuffer(v) ? v.toString("base64") : Buffer.from(String(v)).toString("base64"),
+  base64encode: (v) => Buffer.isBuffer(v) ? v.toString("base64") : Buffer.from(String(v)).toString("base64"),
+  base64_decode: (v) => Buffer.from(String(v), "base64").toString("utf-8"),
+  base64decode: (v) => Buffer.from(String(v), "base64").toString("utf-8"),
+  data_uri: (v) => {
+    if (v && typeof v === "object" && "content" in v) {
+      const ct = v.type ?? "application/octet-stream";
+      const raw = Buffer.isBuffer(v.content) ? v.content : Buffer.from(String(v.content));
+      return `data:${ct};base64,${raw.toString("base64")}`;
+    }
+    return String(v);
+  },
+  url_encode: (v) => encodeURIComponent(String(v)),
+  format: (v, ...args) => {
+    let idx = 0;
+    return String(v).replace(FORMAT_RE, (m, flags, width, prec, type) => {
+      if (m === "%%") return "%";
+      const arg = args[idx++];
+      const p = prec !== void 0 ? parseInt(String(prec), 10) : void 0;
+      let out;
+      switch (type) {
+        case "s":
+          out = String(arg ?? "");
+          break;
+        case "d":
+        case "i":
+          out = String(Math.trunc(Number(arg) || 0));
+          break;
+        case "f":
+        case "F":
+          out = Number(arg).toFixed(p !== void 0 ? p : 6);
+          break;
+        case "e":
+        case "E": {
+          out = Number(arg).toExponential(p !== void 0 ? p : 6);
+          if (type === "E") out = out.toUpperCase();
+          break;
+        }
+        case "g":
+        case "G":
+          out = String(Number(arg));
+          break;
+        case "x":
+          out = Math.trunc(Number(arg) || 0).toString(16);
+          break;
+        case "X":
+          out = Math.trunc(Number(arg) || 0).toString(16).toUpperCase();
+          break;
+        case "o":
+          out = Math.trunc(Number(arg) || 0).toString(8);
+          break;
+        case "b":
+          out = Math.trunc(Number(arg) || 0).toString(2);
+          break;
+        default:
+          out = String(arg ?? "");
+      }
+      if (width) {
+        const w = parseInt(String(width), 10);
+        if (out.length < w) {
+          const f = String(flags || "");
+          if (f.includes("-")) out = out.padEnd(w, " ");
+          else out = out.padStart(w, f.includes("0") ? "0" : " ");
+        }
+      }
+      return out;
+    });
+  },
+  dump: (v) => JSON.stringify(v),
+  formToken: (v) => _generateFormToken(v != null ? String(v) : ""),
+  form_token: (v) => _generateFormToken(v != null ? String(v) : ""),
+  formTokenValue: (v) => _generateFormTokenValue(v != null ? String(v) : ""),
+  form_token_value: (v) => _generateFormTokenValue(v != null ? String(v) : ""),
+  tojson: (v, indent) => new SafeString(indent !== void 0 ? JSON.stringify(v, null, parseInt(String(indent), 10)) : JSON.stringify(v)),
+  to_json: (v, indent) => new SafeString(indent !== void 0 ? JSON.stringify(v, null, parseInt(String(indent), 10)) : JSON.stringify(v)),
+  js_escape: (v) => new SafeString(String(v).replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t"))
+};
+function _b64url(data) {
+  return data.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+var _formTokenSessionId = "";
+function _buildFormTokenJwt(descriptor = "") {
+  const secret = process.env.TINA4_SECRET || "tina4-default-secret";
+  const ttlMinutes = parseInt(process.env.TINA4_TOKEN_LIMIT || "60", 10);
+  const header = { alg: "HS256", typ: "JWT" };
+  const now = Math.floor(Date.now() / 1e3);
+  const payload = { type: "form", nonce: randomBytes(8).toString("hex"), iat: now, exp: now + ttlMinutes * 60 };
+  if (descriptor) {
+    if (descriptor.includes("|")) {
+      const [ctx, ref] = descriptor.split("|", 2);
+      payload.context = ctx;
+      payload.ref = ref;
+    } else {
+      payload.context = descriptor;
+    }
+  }
+  if (_formTokenSessionId) {
+    payload.session_id = _formTokenSessionId;
+  }
+  const h = _b64url(Buffer.from(JSON.stringify(header)));
+  const p = _b64url(Buffer.from(JSON.stringify(payload)));
+  const sigInput = `${h}.${p}`;
+  const sig = _b64url(createHmac("sha256", secret).update(sigInput).digest());
+  return `${h}.${p}.${sig}`;
+}
+function _generateFormToken(descriptor = "") {
+  const token = _buildFormTokenJwt(descriptor);
+  const escaped = token.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return new SafeString(`<input type="hidden" name="formToken" value="${escaped}">`);
+}
+function _generateFormTokenValue(descriptor = "") {
+  return new SafeString(_buildFormTokenJwt(descriptor));
+}
+var Frond = class _Frond {
+  // ── Class-level registries ──────────────────────────────────
+  // Persist globals, filters, and tests across hot-reloads and at
+  // app-startup before any instance exists. When app.ts calls
+  // ``Frond.addFilter("money", fn)`` once, the class remembers it
+  // and every future ``new Frond()`` inherits it automatically.
+  // Mirrors Python's _class_globals / _class_filters / _class_tests.
+  static classFilters = /* @__PURE__ */ new Map();
+  static classGlobals = /* @__PURE__ */ new Map();
+  static classTests = /* @__PURE__ */ new Map();
+  // ── Live-block registries (server-rendered {% live %} regions) ──
+  // A {% live %} block registers three things when its page first renders:
+  //   liveFragments[name] -> the raw body source, re-rendered on every
+  //                          refresh by GET /__frond/live/<name> or pushLive
+  //   liveSources[name]   -> an optional data provider (liveSource) that
+  //                          re-runs with the LIVE request each refresh, so
+  //                          auth re-applies (IDOR guard)
+  //   liveWsPaths[name]   -> the ws path a `ws "path"` block declared, the
+  //                          pushLive broadcast target
+  // Static so they persist across requests in the long-lived server. Mirrors
+  // the Python master's class-level dicts and PHP/Ruby static registries.
+  static liveFragments = /* @__PURE__ */ new Map();
+  static liveSources = /* @__PURE__ */ new Map();
+  static liveWsPaths = /* @__PURE__ */ new Map();
+  // Best-effort WebSocket broadcaster wired by @tina4/core at boot (frond is a
+  // zero-dep leaf package and cannot import core). pushLive calls it if set.
+  static liveBroadcaster = null;
+  /**
+   * Register a custom filter at the class level — available to every
+   * future ``new Frond()`` instance. Callable as ``Frond.addFilter()``
+   * (static) or ``frond.addFilter()`` (instance). See instance method
+   * below for the dual-call semantics.
+   */
+  static addFilter(name, fn) {
+    _Frond.classFilters.set(name, fn);
+  }
+  /**
+   * Register a global variable available in all templates of every
+   * future instance. Callable as ``Frond.addGlobal()`` (static) or
+   * ``frond.addGlobal()`` (instance).
+   */
+  static addGlobal(name, value) {
+    _Frond.classGlobals.set(name, value);
+  }
+  /**
+   * Register a custom test (``{% if x is positive %}``) at the class
+   * level. Callable as ``Frond.addTest()`` (static) or
+   * ``frond.addTest()`` (instance).
+   */
+  static addTest(name, fn) {
+    _Frond.classTests.set(name, fn);
+  }
+  /**
+   * Clear the class-level globals/filters/tests registries.
+   * Useful in test fixtures to prevent leaking state between tests.
+   * Does NOT affect built-in filters or globals — only user-registered
+   * ones via Frond.addFilter / addGlobal / addTest.
+   */
+  static clearRegistry() {
+    _Frond.classFilters.clear();
+    _Frond.classGlobals.clear();
+    _Frond.classTests.clear();
+    _Frond.liveFragments.clear();
+    _Frond.liveSources.clear();
+    _Frond.liveWsPaths.clear();
+  }
+  templateDir;
+  filters;
+  globals;
+  tests;
+  _sandbox;
+  _allowedFilters;
+  _allowedTags;
+  _allowedVars;
+  fragmentCache;
+  _autoEscape;
+  /**
+   * Token pre-compilation cache for file templates.
+   *
+   * `cachedAt` is captured so the TINA4_TEMPLATE_CACHE_TTL env var can
+   * force re-compilation after N seconds even in production. TTL of 0
+   * means "no time-based invalidation" — entries live forever.
+   */
+  compiled = /* @__PURE__ */ new Map();
+  /** Token pre-compilation cache for string templates */
+  compiledStrings = /* @__PURE__ */ new Map();
+  /**
+   * Bound reference to `applyFilters`, stashed into the render context as
+   * `__frond_apply_filters__` so the module-level `evalExpr` can resolve a
+   * filter pipe using THIS instance's registered filters. Bound once. (#171)
+   */
+  _applyFiltersBound = this.applyFilters.bind(this);
+  getTemplateDir() {
+    return this.templateDir;
+  }
+  constructor(templateDir = "src/templates") {
+    this.templateDir = resolve(templateDir);
+    this.filters = { ...BUILTIN_FILTERS };
+    this.globals = {};
+    this.tests = {};
+    this._sandbox = false;
+    this._allowedFilters = null;
+    this._allowedTags = null;
+    this._allowedVars = null;
+    this.fragmentCache = /* @__PURE__ */ new Map();
+    this._autoEscape = true;
+    this.globals.formToken = (descriptor) => _generateFormToken(descriptor || "");
+    this.globals.form_token = (descriptor) => _generateFormToken(descriptor || "");
+    this.globals.formTokenValue = (descriptor) => _generateFormTokenValue(descriptor || "");
+    this.globals.form_token_value = (descriptor) => _generateFormTokenValue(descriptor || "");
+    this.globals.dump = (value) => renderDump(value);
+    for (const [k, v] of _Frond.classFilters) this.filters[k] = v;
+    for (const [k, v] of _Frond.classGlobals) this.globals[k] = v;
+    for (const [k, v] of _Frond.classTests) this.tests[k] = v;
+  }
+  sandbox(filters, tags, vars) {
+    this._sandbox = true;
+    this._allowedFilters = filters ? new Set(filters) : null;
+    this._allowedTags = tags ? new Set(tags) : null;
+    this._allowedVars = vars ? new Set(vars) : null;
+    return this;
+  }
+  unsandbox() {
+    this._sandbox = false;
+    this._allowedFilters = null;
+    this._allowedTags = null;
+    this._allowedVars = null;
+    return this;
+  }
+  /**
+   * Register a custom filter. The filter is persisted at class level
+   * so new instances created by hot-reload inherit it automatically;
+   * the live instance's local filter map also receives the addition
+   * immediately. Mirrors Python's _ClassOrInstanceMethod dual-call.
+   */
+  addFilter(name, fn) {
+    _Frond.classFilters.set(name, fn);
+    this.filters[name] = fn;
+  }
+  /**
+   * Register a global variable available in all templates. Persisted
+   * at class level — see ``addFilter`` for the dual-call semantics.
+   */
+  addGlobal(name, value) {
+    _Frond.classGlobals.set(name, value);
+    this.globals[name] = value;
+  }
+  /**
+   * Register a custom test. Persisted at class level — see
+   * ``addFilter`` for the dual-call semantics.
+   */
+  addTest(name, fn) {
+    _Frond.classTests.set(name, fn);
+    this.tests[name] = fn;
+  }
+  /**
+   * Read the cache TTL in seconds. `TINA4_TEMPLATE_CACHE_TTL=0` (the
+   * default) keeps the existing "cache forever in prod" behaviour — any
+   * positive value invalidates compiled tokens after N seconds, useful
+   * when running long-lived servers behind a slow file sync where mtime
+   * isn't a reliable freshness signal.
+   */
+  cacheTtlSeconds() {
+    const raw = process.env.TINA4_TEMPLATE_CACHE_TTL;
+    if (raw === void 0) return 0;
+    const n = parseInt(raw, 10);
+    return isNaN(n) || n < 0 ? 0 : n;
+  }
+  render(template, data) {
+    const context = { ...this.globals, ...data || {} };
+    const filePath = join(this.templateDir, template);
+    if (!existsSync(filePath)) {
+      throw new Error(`Template not found: ${filePath}`);
+    }
+    const debugMode = (process.env.TINA4_DEBUG || "").toLowerCase() === "true";
+    const ttlMs = this.cacheTtlSeconds() * 1e3;
+    if (!debugMode) {
+      const cached = this.compiled.get(template);
+      if (cached) {
+        if (ttlMs === 0 || Date.now() - cached.cachedAt < ttlMs) {
+          return this.executeCached(cached.tokens, context);
+        }
+      }
+    }
+    const source = readFileSync(filePath, "utf-8");
+    const mtime = statSync(filePath).mtimeMs;
+    const tokens = tokenize(source);
+    this.compiled.set(template, { tokens, mtime, cachedAt: Date.now() });
+    return this.executeWithSource(source, tokens, context);
+  }
+  renderString(source, data) {
+    const context = { ...this.globals, ...data || {} };
+    const key = createHash("md5").update(source).digest("hex");
+    const ttlMs = this.cacheTtlSeconds() * 1e3;
+    const cached = this.compiledStrings.get(key);
+    if (cached) {
+      if (ttlMs === 0 || Date.now() - cached.cachedAt < ttlMs) {
+        return this.executeCached(cached.tokens, context);
+      }
+    }
+    const tokens = tokenize(source);
+    this.compiledStrings.set(key, { tokens, cachedAt: Date.now() });
+    return this.executeCached(tokens, context);
+  }
+  /** Clear all compiled template caches. */
+  clearCache() {
+    this.compiled.clear();
+    this.compiledStrings.clear();
+  }
+  /** Render a debug dump of a value as HTML — parity with PHP/Ruby/Python.
+   * Gated on TINA4_DEBUG=true. Returns empty string in production. */
+  renderDump(value) {
+    return renderDump(value).toString();
+  }
+  load(name) {
+    const filePath = join(this.templateDir, name);
+    if (!existsSync(filePath)) {
+      throw new Error(`Template not found: ${filePath}`);
+    }
+    return readFileSync(filePath, "utf-8");
+  }
+  /** Execute pre-tokenized template against context. */
+  executeCached(tokens, context) {
+    if (Object.keys(this.tests).length > 0) {
+      context.__frond_tests__ = this.tests;
+    }
+    for (const [ttype, raw] of tokens) {
+      if (ttype === "TEXT") {
+        if (raw.trim()) break;
+        continue;
+      }
+      if (ttype === "BLOCK") {
+        const [content] = stripTag(raw);
+        if (content.startsWith("extends ")) {
+          const source = tokens.map(([, v]) => v).join("");
+          return this.execute(source, context);
+        }
+      }
+      break;
+    }
+    return this.renderTokens(tokens, context);
+  }
+  /** Execute with both source and pre-tokenized tokens available. */
+  executeWithSource(source, tokens, context) {
+    if (Object.keys(this.tests).length > 0) {
+      context.__frond_tests__ = this.tests;
+    }
+    const extendsMatch = source.match(/\{%[-\s]*extends\s+["'](.+?)["']\s*[-]?%\}/);
+    if (extendsMatch) {
+      const parentName = extendsMatch[1];
+      const parentSource = this.load(parentName);
+      const childBlocks = this.extractBlocks(source);
+      return this.renderWithBlocks(parentSource, context, childBlocks);
+    }
+    return this.renderTokens(tokens, context);
+  }
+  execute(source, context) {
+    if (Object.keys(this.tests).length > 0) {
+      context.__frond_tests__ = this.tests;
+    }
+    const extendsMatch = source.match(/\{%[-\s]*extends\s+["'](.+?)["']\s*[-]?%\}/);
+    if (extendsMatch) {
+      const parentName = extendsMatch[1];
+      const parentSource = this.load(parentName);
+      const childBlocks = this.extractBlocks(source);
+      return this.renderWithBlocks(parentSource, context, childBlocks);
+    }
+    return this.renderTokens(tokenize(source), context);
+  }
+  extractBlocks(source) {
+    const blocks = {};
+    const blockOpen = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}/g;
+    const blockClose = /\{%[-\s]*endblock\s*[-]?%\}/g;
+    let pos = 0;
+    while (pos < source.length) {
+      blockOpen.lastIndex = pos;
+      const mOpen = blockOpen.exec(source);
+      if (!mOpen) break;
+      const name = mOpen[1];
+      const contentStart = mOpen.index + mOpen[0].length;
+      let depth = 1;
+      let scan = contentStart;
+      while (depth > 0 && scan < source.length) {
+        blockOpen.lastIndex = scan;
+        blockClose.lastIndex = scan;
+        const nextOpen = blockOpen.exec(source);
+        const nextClose = blockClose.exec(source);
+        if (!nextClose) break;
+        if (nextOpen && nextOpen.index < nextClose.index) {
+          depth++;
+          scan = nextOpen.index + nextOpen[0].length;
+        } else {
+          depth--;
+          if (depth === 0) {
+            blocks[name] = source.slice(contentStart, nextClose.index);
+            pos = nextClose.index + nextClose[0].length;
+            break;
+          }
+          scan = nextClose.index + nextClose[0].length;
+        }
+      }
+      if (depth > 0) {
+        pos = contentStart;
+      }
+    }
+    return blocks;
+  }
+  renderWithBlocks(parentSource, context, childBlocks) {
+    const extendsMatch = parentSource.trimStart().match(/\{%[-\s]*extends\s+["'](.+?)["']\s*[-]?%\}/);
+    if (extendsMatch) {
+      const grandparentName = extendsMatch[1];
+      const grandparentSource = this.load(grandparentName);
+      const parentBlocks = this.extractBlocks(parentSource);
+      const mergedBlocks = { ...parentBlocks, ...childBlocks };
+      const nestedBlockRe = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}([\s\S]*?)\{%[-\s]*endblock\s*[-]?%\}/g;
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const name of Object.keys(mergedBlocks)) {
+          const resolved = mergedBlocks[name].replace(nestedBlockRe, (_m, innerName, innerDefault) => {
+            return mergedBlocks[innerName] ?? innerDefault;
+          });
+          if (resolved !== mergedBlocks[name]) {
+            mergedBlocks[name] = resolved;
+            changed = true;
+          }
+        }
+      }
+      return this.renderWithBlocks(grandparentSource, context, mergedBlocks);
+    }
+    const pattern = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}([\s\S]*?)\{%[-\s]*endblock\s*[-]?%\}/g;
+    const engine = this;
+    const result = parentSource.replace(pattern, (_match, name, parentContent) => {
+      const blockSource = childBlocks[name] ?? parentContent;
+      let renderedParent = null;
+      const getParent = () => {
+        if (renderedParent === null) {
+          renderedParent = new SafeString(
+            engine.renderTokens(tokenize(parentContent), context)
+          );
+        }
+        return renderedParent;
+      };
+      const blockCtx = { ...context, parent: getParent, super: getParent };
+      return this.renderTokens(tokenize(blockSource), blockCtx);
+    });
+    return this.renderTokens(tokenize(result), context);
+  }
+  renderTokens(tokens, context) {
+    context.__frond_apply_filters__ = this._applyFiltersBound;
+    const output = [];
+    let i = 0;
+    while (i < tokens.length) {
+      const [ttype, raw] = tokens[i];
+      if (ttype === "TEXT") {
+        output.push(raw);
+        i++;
+      } else if (ttype === "COMMENT") {
+        i++;
+      } else if (ttype === "VAR") {
+        const [content, stripB, stripA] = stripTag(raw);
+        if (stripB && output.length > 0) {
+          output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
+        }
+        const result = this.evalVar(content, context);
+        output.push(result !== null && result !== void 0 ? String(result) : "");
+        if (stripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
+          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
+        }
+        i++;
+      } else if (ttype === "BLOCK") {
+        const [content, stripB, stripA] = stripTag(raw);
+        if (stripB && output.length > 0) {
+          output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
+        }
+        const parts = content.split(/\s+/);
+        const tag = parts[0] || "";
+        if (stripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
+          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
+        }
+        if (tag === "if") {
+          if (this._sandbox && this._allowedTags !== null && !this._allowedTags.has("if")) {
+            const skip = this.skipBlock(tokens, i, "if", "endif");
+            i = skip;
+          } else {
+            const [result, skip] = this.handleIf(tokens, i, context);
+            output.push(result);
+            i = skip;
+          }
+        } else if (tag === "for") {
+          if (this._sandbox && this._allowedTags !== null && !this._allowedTags.has("for")) {
+            const skip = this.skipBlock(tokens, i, "for", "endfor");
+            i = skip;
+          } else {
+            const [result, skip] = this.handleFor(tokens, i, context);
+            output.push(result);
+            i = skip;
+          }
+        } else if (tag === "set") {
+          if (this._sandbox && this._allowedTags !== null && !this._allowedTags.has("set")) {
+            i++;
+          } else {
+            this.handleSet(content, context);
+            i++;
+          }
+        } else if (tag === "include") {
+          if (this._sandbox && this._allowedTags !== null && !this._allowedTags.has("include")) {
+            i++;
+          } else {
+            const result = this.handleInclude(content, context);
+            output.push(result);
+            i++;
+          }
+        } else if (tag === "macro") {
+          const skip = this.handleMacro(tokens, i, context);
+          i = skip;
+        } else if (tag === "from") {
+          this.handleFromImport(content, context);
+          i++;
+        } else if (tag === "cache") {
+          const [result, skip] = this.handleCache(tokens, i, context);
+          output.push(result);
+          i = skip;
+        } else if (tag === "live") {
+          const [result, skip] = this.handleLive(tokens, i, context);
+          output.push(result);
+          i = skip;
+        } else if (tag === "spaceless") {
+          const [result, skip] = this.handleSpaceless(tokens, i, context);
+          output.push(result);
+          i = skip;
+        } else if (tag === "autoescape") {
+          const [result, skip] = this.handleAutoescape(tokens, i, context);
+          output.push(result);
+          i = skip;
+        } else if (tag === "block" || tag === "endblock" || tag === "extends") {
+          i++;
+        } else {
+          i++;
+        }
+        if (stripA && i < tokens.length && tokens[i][0] === "TEXT") {
+          tokens[i] = ["TEXT", tokens[i][1].replace(LEADING_WS_RE, "")];
+        }
+      } else {
+        i++;
+      }
+    }
+    return output.join("");
+  }
+  skipBlock(tokens, start, openTag, closeTag) {
+    let depth = 0;
+    let i = start + 1;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK") {
+        const [content] = stripTag(tokens[i][1]);
+        const tag = content.split(/\s+/)[0] || "";
+        if (tag === openTag) depth++;
+        else if (tag === closeTag) {
+          if (depth === 0) return i + 1;
+          depth--;
+        }
+      }
+      i++;
+    }
+    return i;
+  }
+  /**
+   * Apply a parsed filter chain to an already-evaluated value. This is the
+   * instance-aware filter engine used by `evalExpr` (via the
+   * `__frond_apply_filters__` hook in the render context) so filters resolve
+   * with this Frond's registered/custom filters at ANY nesting depth — inside
+   * concat operands, ternary branches, and parenthesised sub-expressions — not
+   * only at the top-level {{ }} output. Mirrors the filter loop in
+   * `evalVarRaw`: `first`/`last` tail-paths, registered `this.filters`, and the
+   * trailing-comparison form (`length != 1`). Auto-escaping stays the caller's
+   * concern (`evalVarInner`). (#171)
+   */
+  applyFilters(value, filters, context) {
+    for (const [fname, rawArgs] of filters) {
+      const args = rawArgs.map((a) => a instanceof VarRef ? evalExpr(a.name, context) : a);
+      if (fname === "raw" || fname === "safe") continue;
+      if (this._sandbox && this._allowedFilters !== null && !this._allowedFilters.has(fname)) continue;
+      const [realFname, tailPath] = splitFilterNameAndPath(fname);
+      if (tailPath) {
+        let applied = false;
+        if (realFname === "first") {
+          value = Array.isArray(value) ? value[0] ?? null : null;
+          applied = true;
+        } else if (realFname === "last") {
+          value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
+          applied = true;
+        } else if (this.filters[realFname]) {
+          value = this.filters[realFname](value, ...args);
+          applied = true;
+        }
+        if (applied) {
+          value = evalExpr("__frondFilterTmp." + tailPath, { __frondFilterTmp: value });
+          continue;
+        }
+      }
+      const fn = this.filters[fname];
+      if (fn) {
+        value = fn(value, ...args);
+      } else {
+        const m = fname.match(FILTER_COMPARISON_RE);
+        if (m) {
+          const fn2 = this.filters[m[1]];
+          if (fn2) value = fn2(value, ...args);
+          const right = evalExpr(m[3].trim(), context);
+          switch (m[2]) {
+            case "!=":
+              value = value !== right;
+              break;
+            case "==":
+              value = value === right;
+              break;
+            case ">=":
+              value = value >= right;
+              break;
+            case "<=":
+              value = value <= right;
+              break;
+            case ">":
+              value = value > right;
+              break;
+            case "<":
+              value = value < right;
+              break;
+          }
+        } else {
+          value = evalExpr(fname, context);
+        }
+      }
+    }
+    return value;
+  }
+  evalVar(expr, context) {
+    const ternaryIdx = findTernary(expr);
+    if (ternaryIdx !== -1) {
+      const condPart = expr.slice(0, ternaryIdx).trim();
+      const rest = expr.slice(ternaryIdx + 1);
+      const colonIdx = findColon(rest);
+      if (colonIdx !== -1) {
+        const truePart = rest.slice(0, colonIdx).trim();
+        const falsePart = rest.slice(colonIdx + 1).trim();
+        const cond = this.evalVarRaw(condPart, context);
+        return cond ? this.evalVar(truePart, context) : this.evalVar(falsePart, context);
+      }
+    }
+    return this.evalVarInner(expr, context);
+  }
+  evalVarRaw(expr, context) {
+    const [varName, filters] = parseFilterChain(expr);
+    let value = evalExpr(varName, context);
+    for (const [fname, rawArgs] of filters) {
+      const args = rawArgs.map((a) => a instanceof VarRef ? evalExpr(a.name, context) : a);
+      if (fname === "raw" || fname === "safe") continue;
+      if (this._sandbox && this._allowedFilters !== null && !this._allowedFilters.has(fname)) continue;
+      const [realFname, tailPath] = splitFilterNameAndPath(fname);
+      if (tailPath) {
+        let applied = false;
+        if (realFname === "first") {
+          value = Array.isArray(value) ? value[0] ?? null : null;
+          applied = true;
+        } else if (realFname === "last") {
+          value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
+          applied = true;
+        } else if (this.filters[realFname]) {
+          value = this.filters[realFname](value, ...args);
+          applied = true;
+        }
+        if (applied) {
+          value = evalExpr(
+            "__frondFilterTmp." + tailPath,
+            { __frondFilterTmp: value }
+          );
+          continue;
+        }
+      }
+      const fn = this.filters[fname];
+      if (fn) {
+        value = fn(value, ...args);
+      } else {
+        const m = fname.match(FILTER_COMPARISON_RE);
+        if (m) {
+          const realFilter = m[1];
+          const op = m[2];
+          const rightExpr = m[3].trim();
+          const fn2 = this.filters[realFilter];
+          if (fn2) {
+            value = fn2(value, ...args);
+          }
+          const right = evalExpr(rightExpr, context);
+          switch (op) {
+            case "!=":
+              value = value !== right;
+              break;
+            case "==":
+              value = value === right;
+              break;
+            case ">=":
+              value = value >= right;
+              break;
+            case "<=":
+              value = value <= right;
+              break;
+            case ">":
+              value = value > right;
+              break;
+            case "<":
+              value = value < right;
+              break;
+          }
+        } else {
+          value = evalExpr(fname, context);
+        }
+      }
+    }
+    return value;
+  }
+  evalVarInner(expr, context) {
+    const [varName, filters] = parseFilterChain(expr);
+    if (this._sandbox && this._allowedVars !== null) {
+      const rootVar = varName.split(".")[0].split("[")[0].trim();
+      if (rootVar && !this._allowedVars.has(rootVar) && rootVar !== "loop") {
+        return "";
+      }
+    }
+    if (findOutsideQuotes(expr, "~") >= 0) {
+      let concatValue = evalExpr(expr, context);
+      if (concatValue instanceof SafeString) return concatValue.value;
+      if (this._autoEscape && typeof concatValue === "string") {
+        concatValue = htmlEscape(concatValue);
+      }
+      return concatValue;
+    }
+    let value = evalExpr(varName, context);
+    let isSafe = false;
+    for (const [fname, rawArgs] of filters) {
+      const args = rawArgs.map((a) => a instanceof VarRef ? evalExpr(a.name, context) : a);
+      if (fname === "raw" || fname === "safe") {
+        isSafe = true;
+        continue;
+      }
+      if (fname === "escape" || fname === "e") {
+        isSafe = true;
+      }
+      if (this._sandbox && this._allowedFilters !== null) {
+        if (!this._allowedFilters.has(fname)) {
+          continue;
+        }
+      }
+      const [realFname, tailPath] = splitFilterNameAndPath(fname);
+      if (tailPath) {
+        let applied = false;
+        if (realFname === "first") {
+          value = Array.isArray(value) ? value[0] ?? null : null;
+          applied = true;
+        } else if (realFname === "last") {
+          value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
+          applied = true;
+        } else if (this.filters[realFname]) {
+          value = this.filters[realFname](value, ...args);
+          applied = true;
+        }
+        if (applied) {
+          value = evalExpr(
+            "__frondFilterTmp." + tailPath,
+            { __frondFilterTmp: value }
+          );
+          continue;
+        }
+      }
+      if (args.length === 0) {
+        switch (fname) {
+          case "upper":
+            value = String(value).toUpperCase();
+            continue;
+          case "lower":
+            value = String(value).toLowerCase();
+            continue;
+          case "trim":
+            value = String(value).trim();
+            continue;
+          case "length":
+            if (Array.isArray(value)) {
+              value = value.length;
+            } else if (typeof value === "string") {
+              value = value.length;
+            } else if (typeof value === "object" && value !== null) {
+              value = Object.keys(value).length;
+            } else {
+              value = 0;
+            }
+            continue;
+          case "capitalize": {
+            const s = String(value);
+            value = s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+            continue;
+          }
+          case "title":
+            value = String(value).replace(TITLE_WORD_RE, (c) => c.toUpperCase());
+            continue;
+          case "string":
+            value = String(value);
+            continue;
+          case "int":
+            value = value ? parseInt(String(value), 10) || 0 : 0;
+            continue;
+          case "float":
+            value = value ? parseFloat(String(value)) || 0 : 0;
+            continue;
+          case "abs":
+            value = typeof value === "number" ? Math.abs(value) : value;
+            continue;
+          case "striptags":
+            value = String(value).replace(STRIP_TAGS_RE, "");
+            continue;
+          case "first":
+            value = Array.isArray(value) ? value[0] ?? null : null;
+            continue;
+          case "last":
+            value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
+            continue;
+          case "keys":
+            value = typeof value === "object" && value !== null && !Array.isArray(value) ? Object.keys(value) : [];
+            continue;
+          case "values":
+            value = typeof value === "object" && value !== null && !Array.isArray(value) ? Object.values(value) : [];
+            continue;
+          case "json_encode":
+            value = JSON.stringify(value);
+            continue;
+          case "dump":
+            value = renderDump(value);
+            continue;
+          case "nl2br":
+            value = new SafeString(htmlEscape(String(value)).replace(/\n/g, "<br />\n"));
+            continue;
+          case "unique":
+            value = Array.isArray(value) ? [...new Set(value)] : value;
+            continue;
+          case "sort":
+            value = Array.isArray(value) ? [...value].sort() : value;
+            continue;
+          case "reverse":
+            value = Array.isArray(value) ? [...value].reverse() : String(value).split("").reverse().join("");
+            continue;
+          case "filter":
+            value = Array.isArray(value) ? value.filter(Boolean) : value;
+            continue;
+        }
+      }
+      const fn = this.filters[fname];
+      if (fn) {
+        value = fn(value, ...args);
+      }
+    }
+    if (value instanceof SafeString) {
+      return value.value;
+    }
+    if (!isSafe && this._autoEscape && typeof value === "string") {
+      value = htmlEscape(value);
+    }
+    return value;
+  }
+  handleIf(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const conditionExpr = content.slice(3).trim();
+    const branches = [];
+    let currentTokens = [];
+    let currentCond = conditionExpr;
+    let depth = 0;
+    let i = start + 1;
+    while (i < tokens.length) {
+      const [ttype, raw] = tokens[i];
+      if (ttype === "BLOCK") {
+        const [tagContent, tagStripB, tagStripA] = stripTag(raw);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "if") {
+          depth++;
+          currentTokens.push(tokens[i]);
+        } else if (tag === "endif" && depth > 0) {
+          depth--;
+          currentTokens.push(tokens[i]);
+        } else if (tag === "endif" && depth === 0) {
+          if (tagStripB && currentTokens.length > 0 && currentTokens[currentTokens.length - 1][0] === "TEXT") {
+            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
+          }
+          branches.push([currentCond, currentTokens]);
+          if (tagStripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
+            tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
+          }
+          i++;
+          break;
+        } else if ((tag === "elseif" || tag === "elif") && depth === 0) {
+          if (tagStripB && currentTokens.length > 0 && currentTokens[currentTokens.length - 1][0] === "TEXT") {
+            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
+          }
+          branches.push([currentCond, currentTokens]);
+          currentCond = tagContent.slice(tag.length).trim();
+          currentTokens = [];
+        } else if (tag === "else" && depth === 0) {
+          if (tagStripB && currentTokens.length > 0 && currentTokens[currentTokens.length - 1][0] === "TEXT") {
+            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
+          }
+          branches.push([currentCond, currentTokens]);
+          currentCond = null;
+          currentTokens = [];
+        } else {
+          currentTokens.push(tokens[i]);
+        }
+      } else {
+        currentTokens.push(tokens[i]);
+      }
+      i++;
+    }
+    for (const [cond, branchTokens] of branches) {
+      if (cond === null || evalComparison(cond, context, this.evalVarRaw.bind(this))) {
+        return [this.renderTokens([...branchTokens], context), i];
+      }
+    }
+    return ["", i];
+  }
+  handleFor(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const forMatch = content.match(/^for\s+(\w+)(?:\s*,\s*(\w+))?\s+in\s+(.+)/);
+    if (!forMatch) return ["", start + 1];
+    const var1 = forMatch[1];
+    const var2 = forMatch[2] || null;
+    const iterableExpr = forMatch[3].trim();
+    const bodyTokens = [];
+    const elseTokens = [];
+    let inElse = false;
+    let forDepth = 0;
+    let ifDepth = 0;
+    let i = start + 1;
+    while (i < tokens.length) {
+      const [ttype, raw] = tokens[i];
+      if (ttype === "BLOCK") {
+        const [tagContent] = stripTag(raw);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "for") {
+          forDepth++;
+          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+        } else if (tag === "endfor" && forDepth > 0) {
+          forDepth--;
+          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+        } else if (tag === "endfor" && forDepth === 0) {
+          i++;
+          break;
+        } else if (tag === "if") {
+          ifDepth++;
+          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+        } else if (tag === "endif") {
+          ifDepth--;
+          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+        } else if (tag === "else" && forDepth === 0 && ifDepth === 0) {
+          inElse = true;
+        } else {
+          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+        }
+      } else {
+        (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+      }
+      i++;
+    }
+    const iterable = evalExpr(iterableExpr, context);
+    if (!iterable || Array.isArray(iterable) && iterable.length === 0 || typeof iterable === "object" && !Array.isArray(iterable) && Object.keys(iterable).length === 0) {
+      if (elseTokens.length > 0) {
+        return [this.renderTokens([...elseTokens], context), i];
+      }
+      return ["", i];
+    }
+    const output = [];
+    const isDict = typeof iterable === "object" && !Array.isArray(iterable);
+    const items = isDict ? Object.entries(iterable) : Array.isArray(iterable) ? iterable : [];
+    const total = items.length;
+    const loopObj = {
+      index: 0,
+      index0: 0,
+      first: false,
+      last: false,
+      length: total,
+      revindex: 0,
+      revindex0: 0,
+      even: false,
+      odd: false
+    };
+    for (let idx = 0; idx < total; idx++) {
+      const item = items[idx];
+      loopObj.index = idx + 1;
+      loopObj.index0 = idx;
+      loopObj.first = idx === 0;
+      loopObj.last = idx === total - 1;
+      loopObj.revindex = total - idx;
+      loopObj.revindex0 = total - idx - 1;
+      loopObj.even = (idx + 1) % 2 === 0;
+      loopObj.odd = (idx + 1) % 2 !== 0;
+      const locals = { loop: loopObj };
+      if (isDict) {
+        const [key, value] = item;
+        locals[var1] = key;
+        if (var2) locals[var2] = value;
+      } else {
+        if (var2) {
+          locals[var1] = idx;
+          locals[var2] = item;
+        } else {
+          locals[var1] = item;
+        }
+      }
+      const loopCtx = new Proxy(locals, {
+        get(target, prop) {
+          if (prop in target) return target[prop];
+          return context[prop];
+        },
+        set(target, prop, value) {
+          target[prop] = value;
+          return true;
+        },
+        has(target, prop) {
+          return prop in target || prop in context;
+        },
+        ownKeys() {
+          return [.../* @__PURE__ */ new Set([...Object.keys(locals), ...Object.keys(context)])];
+        },
+        getOwnPropertyDescriptor(target, prop) {
+          if (prop in target) return { configurable: true, enumerable: true, value: target[prop] };
+          if (prop in context) return { configurable: true, enumerable: true, value: context[prop] };
+          return void 0;
+        }
+      });
+      output.push(this.renderTokens([...bodyTokens], loopCtx));
+    }
+    return [output.join(""), i];
+  }
+  handleSet(content, context) {
+    const m = content.match(/^set\s+(\w+)\s*=\s*([\s\S]+)/);
+    if (m) {
+      const name = m[1];
+      const expr = m[2].trim();
+      context[name] = this.evalVarRaw(expr, context);
+    }
+  }
+  handleInclude(content, context) {
+    const ignoreMissing = content.includes("ignore missing");
+    const cleanContent = content.replace("ignore missing", "").trim();
+    const m = cleanContent.match(/^include\s+["'](.+?)["'](?:\s+with\s+(.+))?/);
+    if (!m) return "";
+    const filename = m[1];
+    const withExpr = m[2];
+    let source;
+    try {
+      source = this.load(filename);
+    } catch {
+      if (ignoreMissing) return "";
+      throw new Error(`Template not found: ${join(this.templateDir, filename)}`);
+    }
+    const incContext = { ...context };
+    if (withExpr) {
+      const extra = evalExpr(withExpr, context);
+      if (typeof extra === "object" && extra !== null) {
+        Object.assign(incContext, extra);
+      }
+    }
+    return this.execute(source, incContext);
+  }
+  handleMacro(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const m = content.match(/^macro\s+(\w+)\s*\(([^)]*)\)/);
+    if (!m) {
+      let i2 = start + 1;
+      while (i2 < tokens.length) {
+        if (tokens[i2][0] === "BLOCK" && tokens[i2][1].includes("endmacro")) {
+          return i2 + 1;
+        }
+        i2++;
+      }
+      return i2;
+    }
+    const macroName = m[1];
+    const paramNames = m[2].split(",").map((p) => p.trim()).filter(Boolean);
+    const bodyTokens = [];
+    let i = start + 1;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK" && tokens[i][1].includes("endmacro")) {
+        i++;
+        break;
+      }
+      bodyTokens.push(tokens[i]);
+      i++;
+    }
+    const engine = this;
+    const capturedContext = { ...context };
+    context[macroName] = (...args) => {
+      const macroCtx = { ...capturedContext };
+      for (let pi = 0; pi < paramNames.length; pi++) {
+        macroCtx[paramNames[pi]] = pi < args.length ? args[pi] : null;
+      }
+      return new SafeString(engine.renderTokens([...bodyTokens], macroCtx));
+    };
+    return i;
+  }
+  handleFromImport(content, context) {
+    const m = content.match(/^from\s+["'](.+?)["']\s+import\s+(.+)/);
+    if (!m) return;
+    const filename = m[1];
+    const names = m[2].split(",").map((n) => n.trim()).filter(Boolean);
+    const source = this.load(filename);
+    const tokens = tokenize(source);
+    let i = 0;
+    while (i < tokens.length) {
+      const [ttype, raw] = tokens[i];
+      if (ttype === "BLOCK") {
+        const [tagContent] = stripTag(raw);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "macro") {
+          const macroM = tagContent.match(/^macro\s+(\w+)\s*\(([^)]*)\)/);
+          if (macroM && names.includes(macroM[1])) {
+            const macroName = macroM[1];
+            const paramNames = macroM[2].split(",").map((p) => p.trim()).filter(Boolean);
+            const bodyTokens = [];
+            i++;
+            while (i < tokens.length) {
+              if (tokens[i][0] === "BLOCK" && tokens[i][1].includes("endmacro")) {
+                i++;
+                break;
+              }
+              bodyTokens.push(tokens[i]);
+              i++;
+            }
+            const capturedBody = [...bodyTokens];
+            const capturedParams = [...paramNames];
+            const capturedCtx = { ...context };
+            const engine = this;
+            context[macroName] = (...args) => {
+              const macroCtx = { ...capturedCtx };
+              for (let pi = 0; pi < capturedParams.length; pi++) {
+                macroCtx[capturedParams[pi]] = pi < args.length ? args[pi] : null;
+              }
+              return new SafeString(engine.renderTokens([...capturedBody], macroCtx));
+            };
+            continue;
+          }
+        }
+      }
+      i++;
+    }
+  }
+  handleCache(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const m = content.match(/^cache\s+["'](.+?)["']\s*(\d+)?/);
+    const cacheKey = m ? m[1] : "default";
+    const ttl = m && m[2] ? parseInt(m[2], 10) : 60;
+    const cached = this.fragmentCache.get(cacheKey);
+    if (cached) {
+      const [htmlContent, expiresAt] = cached;
+      if (Date.now() < expiresAt) {
+        let i2 = start + 1;
+        let depth2 = 0;
+        while (i2 < tokens.length) {
+          if (tokens[i2][0] === "BLOCK") {
+            const [tagContent] = stripTag(tokens[i2][1]);
+            const tag = tagContent.split(/\s+/)[0] || "";
+            if (tag === "cache") depth2++;
+            else if (tag === "endcache") {
+              if (depth2 === 0) return [htmlContent, i2 + 1];
+              depth2--;
+            }
+          }
+          i2++;
+        }
+        return [htmlContent, i2];
+      }
+    }
+    const bodyTokens = [];
+    let i = start + 1;
+    let depth = 0;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK") {
+        const [tagContent] = stripTag(tokens[i][1]);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "cache") {
+          depth++;
+          bodyTokens.push(tokens[i]);
+        } else if (tag === "endcache") {
+          if (depth === 0) {
+            i++;
+            break;
+          }
+          depth--;
+          bodyTokens.push(tokens[i]);
+        } else {
+          bodyTokens.push(tokens[i]);
+        }
+      } else {
+        bodyTokens.push(tokens[i]);
+      }
+      i++;
+    }
+    const rendered = this.renderTokens([...bodyTokens], context);
+    this.fragmentCache.set(cacheKey, [rendered, Date.now() + ttl * 1e3]);
+    return [rendered, i];
+  }
+  /**
+   * Handle {% live "name" poll N | sse | ws "path" [src "url"] %}...{% endlive %}.
+   *
+   * Server-rendered live region. The body renders once for first paint, is
+   * registered under <name> so GET /__frond/live/<name> (or a liveSource
+   * provider) can re-render it, and is wrapped in a marker element that
+   * frond.js wires to the chosen transport (poll / sse / ws). Mirrors the
+   * Python master's _handle_live and PHP/Ruby handleLive.
+   */
+  handleLive(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const m = content.match(LIVE_RE);
+    if (!m) {
+      throw new Error('live: expected {% live "name" poll N | sse | ws "path" %}');
+    }
+    const name = m[1];
+    const rest = (m[2] || "").trim();
+    const parts = rest.split(/\s+/).filter(Boolean);
+    const mode = parts[0] || "";
+    const sm = rest.match(LIVE_SRC_RE);
+    const src = sm ? sm[1] : null;
+    if (src && (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("//"))) {
+      throw new Error("live: src must be a same-origin path, not an absolute URL");
+    }
+    let interval = null;
+    let wsPath = null;
+    if (mode === "poll") {
+      if (!parts[1] || !/^\d+$/.test(parts[1])) {
+        throw new Error('live: poll requires seconds, e.g. {% live "x" poll 5 %}');
+      }
+      interval = parseInt(parts[1], 10);
+    } else if (mode === "sse") {
+    } else if (mode === "ws") {
+      const wm = rest.match(LIVE_WS_RE);
+      if (!wm) {
+        throw new Error('live: ws requires a path, e.g. {% live "x" ws "/ws/x" %}');
+      }
+      wsPath = wm[1];
+    } else {
+      throw new Error(`live: unknown transport "${mode}" (use poll N, sse, or ws "path")`);
+    }
+    const bodyTokens = [];
+    let i = start + 1;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK") {
+        const [tagContent] = stripTag(tokens[i][1]);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "live") throw new Error("live: nested live blocks are not supported");
+        if (tag === "endlive") {
+          i++;
+          break;
+        }
+        bodyTokens.push(tokens[i]);
+      } else {
+        bodyTokens.push(tokens[i]);
+      }
+      i++;
+    }
+    _Frond.liveFragments.set(name, bodyTokens.map((t) => t[1]).join(""));
+    const endpoint = src || `/__frond/live/${name}`;
+    const attrs = [`data-frond-live="${liveAttr(name)}"`, `id="live-${liveAttr(name)}"`];
+    if (mode === "poll") {
+      attrs.push('data-mode="poll"', `data-interval="${interval}"`, `data-src="${liveAttr(endpoint)}"`);
+    } else if (mode === "sse") {
+      attrs.push('data-mode="sse"', `data-src="${liveAttr(endpoint)}"`);
+    } else if (mode === "ws") {
+      _Frond.liveWsPaths.set(name, wsPath);
+      attrs.push('data-mode="ws"', `data-ws="${liveAttr(wsPath)}"`);
+    }
+    const firstPaint = this.renderTokens([...bodyTokens], context);
+    return [`<div ${attrs.join(" ")}>${firstPaint}</div>`, i];
+  }
+  // ── Live-block class API (mirrors Python master + PHP/Ruby facades) ──
+  /**
+   * Re-render a registered {% live %} fragment by name with fresh data.
+   * Returns the rendered HTML, or null if no fragment is registered under that
+   * name yet (its page has not rendered). GET /__frond/live/<name> calls this
+   * after resolving the provider data.
+   */
+  static renderLive(name, data) {
+    const source = _Frond.liveFragments.get(name);
+    if (source === void 0) return null;
+    return new _Frond().renderString(source, data || {});
+  }
+  /** Register a data provider for a {% live %} block. Invoked with the live
+   * request on every refresh so auth re-applies. Mirrors Python's @live_source. */
+  static liveSource(name, fn) {
+    _Frond.liveSources.set(name, fn);
+  }
+  /** The provider registered for a live block, or null. */
+  static getLiveSource(name) {
+    return _Frond.liveSources.get(name) ?? null;
+  }
+  /** Whether a live fragment has been registered (its page rendered). */
+  static hasLiveFragment(name) {
+    return _Frond.liveFragments.has(name);
+  }
+  /** The ws path a live block declared (data-ws), or null. */
+  static getLiveWsPath(name) {
+    return _Frond.liveWsPaths.get(name) ?? null;
+  }
+  /**
+   * Resolve GET /__frond/live/{name}: run the provider with the live request
+   * (auth re-applies), re-render the fragment, and return a pure {status, body}
+   * descriptor the route handler applies to the response. 404 for an unknown
+   * name / unrendered fragment. Mirrors Python's live_endpoint / PHP respondLive.
+   */
+  static respondLive(req, name) {
+    const provider = _Frond.liveSources.get(name);
+    if (!_Frond.liveFragments.has(name) && provider === void 0) {
+      return { status: 404, body: `live block not found: ${name}` };
+    }
+    let context = {};
+    if (provider !== void 0) {
+      const result = provider(req);
+      context = result && typeof result === "object" ? result : {};
+    }
+    const html = _Frond.renderLive(name, context);
+    if (html === null) {
+      return { status: 404, body: `live fragment not registered yet: ${name}` };
+    }
+    return { status: 200, body: html };
+  }
+  /** Wire the WebSocket broadcaster used by pushLive. Called once by @tina4/core
+   * at server boot (frond is a zero-dep leaf and cannot import core). */
+  static setLiveBroadcaster(fn) {
+    _Frond.liveBroadcaster = fn;
+  }
+  /**
+   * Re-render the '<name>' live fragment and push it to connected clients.
+   * Broadcasts a {type,name,html} envelope over WebSocket to the block's
+   * declared data-ws path (else a room named <name>). Returns the rendered
+   * HTML, or null if the fragment is not registered. Mirrors Python push_live
+   * / PHP pushLive. The broadcast is best-effort — a missing/failed broadcaster
+   * never throws into the caller.
+   */
+  static pushLive(name, data) {
+    const html = _Frond.renderLive(name, data);
+    if (html === null) return null;
+    if (_Frond.liveBroadcaster) {
+      try {
+        const envelope = JSON.stringify({ type: "live", name, html });
+        _Frond.liveBroadcaster(_Frond.getLiveWsPath(name), name, envelope);
+      } catch {
+      }
+    }
+    return html;
+  }
+  handleSpaceless(tokens, start, context) {
+    const bodyTokens = [];
+    let i = start + 1;
+    let depth = 0;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK") {
+        const [tagContent] = stripTag(tokens[i][1]);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "spaceless") {
+          depth++;
+          bodyTokens.push(tokens[i]);
+        } else if (tag === "endspaceless") {
+          if (depth === 0) {
+            i++;
+            break;
+          }
+          depth--;
+          bodyTokens.push(tokens[i]);
+        } else {
+          bodyTokens.push(tokens[i]);
+        }
+      } else {
+        bodyTokens.push(tokens[i]);
+      }
+      i++;
+    }
+    let rendered = this.renderTokens([...bodyTokens], context);
+    rendered = rendered.replace(/>\s+</g, "><");
+    return [rendered, i];
+  }
+  handleAutoescape(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const modeMatch = content.match(/^autoescape\s+(false|true)/);
+    const autoEscapeOn = !(modeMatch && modeMatch[1] === "false");
+    const bodyTokens = [];
+    let i = start + 1;
+    let depth = 0;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK") {
+        const [tagContent] = stripTag(tokens[i][1]);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === "autoescape") {
+          depth++;
+          bodyTokens.push(tokens[i]);
+        } else if (tag === "endautoescape") {
+          if (depth === 0) {
+            i++;
+            break;
+          }
+          depth--;
+          bodyTokens.push(tokens[i]);
+        } else {
+          bodyTokens.push(tokens[i]);
+        }
+      } else {
+        bodyTokens.push(tokens[i]);
+      }
+      i++;
+    }
+    if (!autoEscapeOn) {
+      const oldAutoEscape = this._autoEscape;
+      this._autoEscape = false;
+      const rendered = this.renderTokens([...bodyTokens], context);
+      this._autoEscape = oldAutoEscape;
+      return [rendered, i];
+    }
+    return [this.renderTokens([...bodyTokens], context), i];
+  }
+};
+export {
+  Frond
+};