@dogsbay/minja 0.2.0-beta.48

package/dist/index.umd.js

@@ -0,0 +1,1026 @@
+/**
+ * minja v0.2.0-beta.48
+ * Minimal, secure Jinja2/Nunjucks subset for documentation preprocessing
+ * @license MIT
+ */
+"use strict";
+var minja = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/browser.ts
+  var browser_exports = {};
+  __export(browser_exports, {
+    Context: () => Context,
+    FetchLoader: () => FetchLoader,
+    MemoryLoader: () => MemoryLoader,
+    evaluateExpression: () => evaluateExpression,
+    parse: () => parse,
+    parseExpression: () => parseExpression,
+    render: () => render
+  });
+
+  // src/evaluator.ts
+  function parseExpression(expr) {
+    expr = expr.trim();
+    if (expr === "true") {
+      return { type: "literal", value: true };
+    }
+    if (expr === "false") {
+      return { type: "literal", value: false };
+    }
+    if (expr === "null") {
+      return { type: "literal", value: null };
+    }
+    if (expr.startsWith('"') && expr.endsWith('"')) {
+      return { type: "literal", value: expr.slice(1, -1) };
+    }
+    if (expr.startsWith("'") && expr.endsWith("'")) {
+      return { type: "literal", value: expr.slice(1, -1) };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(expr)) {
+      return { type: "literal", value: parseFloat(expr) };
+    }
+    if (expr.startsWith("(") && expr.endsWith(")")) {
+      let depth = 0;
+      let balanced = true;
+      for (let i = 0; i < expr.length; i++) {
+        if (expr[i] === "(") {
+          depth++;
+        } else if (expr[i] === ")") {
+          depth--;
+        }
+        if (depth === 0 && i < expr.length - 1) {
+          balanced = false;
+          break;
+        }
+      }
+      if (balanced && depth === 0) {
+        return parseExpression(expr.slice(1, -1));
+      }
+    }
+    if (expr.startsWith("not ")) {
+      return {
+        type: "unary",
+        operator: "not",
+        operand: parseExpression(expr.substring(4))
+      };
+    }
+    const orMatch = findOperator(expr, " or ");
+    if (orMatch !== -1) {
+      return {
+        type: "binary",
+        operator: "or",
+        left: parseExpression(expr.substring(0, orMatch)),
+        right: parseExpression(expr.substring(orMatch + 4))
+      };
+    }
+    const andMatch = findOperator(expr, " and ");
+    if (andMatch !== -1) {
+      return {
+        type: "binary",
+        operator: "and",
+        left: parseExpression(expr.substring(0, andMatch)),
+        right: parseExpression(expr.substring(andMatch + 5))
+      };
+    }
+    const comparisonOps = ["==", "!=", "<=", ">=", "<", ">"];
+    for (const op of comparisonOps) {
+      const opMatch = findOperator(expr, ` ${op} `);
+      if (opMatch !== -1) {
+        return {
+          type: "binary",
+          operator: op,
+          left: parseExpression(expr.substring(0, opMatch)),
+          right: parseExpression(expr.substring(opMatch + op.length + 2))
+        };
+      }
+    }
+    if (/^[\w.]+$/.test(expr)) {
+      return { type: "variable", name: expr };
+    }
+    throw new Error(`Invalid expression: ${expr}`);
+  }
+  function findOperator(expr, operator) {
+    let inString = null;
+    let depth = 0;
+    for (let i = 0; i < expr.length; i++) {
+      const char = expr[i];
+      if ((char === '"' || char === "'") && (i === 0 || expr[i - 1] !== "\\")) {
+        if (inString === char) {
+          inString = null;
+        } else if (inString === null) {
+          inString = char;
+        }
+        continue;
+      }
+      if (!inString) {
+        if (char === "(") {
+          depth++;
+        } else if (char === ")") {
+          depth--;
+        }
+      }
+      if (!inString && depth === 0) {
+        if (expr.substring(i, i + operator.length) === operator) {
+          return i;
+        }
+      }
+    }
+    return -1;
+  }
+  function evaluateExpression(expr, context) {
+    switch (expr.type) {
+      case "literal":
+        return expr.value;
+      case "variable":
+        return context.get(expr.name);
+      case "binary": {
+        const left = evaluateExpression(expr.left, context);
+        const right = evaluateExpression(expr.right, context);
+        switch (expr.operator) {
+          case "==":
+            return left == right;
+          case "!=":
+            return left != right;
+          case "<":
+            return left < right;
+          case ">":
+            return left > right;
+          case "<=":
+            return left <= right;
+          case ">=":
+            return left >= right;
+          case "and":
+            return isTruthy(left) && isTruthy(right);
+          case "or":
+            return isTruthy(left) || isTruthy(right);
+        }
+        break;
+      }
+      case "unary": {
+        const operand = evaluateExpression(expr.operand, context);
+        switch (expr.operator) {
+          case "not":
+            return !isTruthy(operand);
+        }
+        break;
+      }
+    }
+    return void 0;
+  }
+  function isTruthy(value) {
+    if (value === void 0 || value === null || value === false) {
+      return false;
+    }
+    if (value === 0 || value === "") {
+      return false;
+    }
+    return true;
+  }
+
+  // src/parser.ts
+  function parse(template) {
+    const errors = [];
+    const ast = [];
+    let position = 0;
+    let line = 1;
+    let column = 1;
+    function createError(message) {
+      return { message, position, line, column };
+    }
+    function advance(count) {
+      for (let i = 0; i < count; i++) {
+        if (template[position + i] === "\n") {
+          line++;
+          column = 1;
+        } else {
+          column++;
+        }
+      }
+      position += count;
+    }
+    function findNext(str, from = position) {
+      return template.indexOf(str, from);
+    }
+    function extractTo(target) {
+      const text = template.substring(position, target);
+      advance(target - position);
+      return text;
+    }
+    while (position < template.length) {
+      const varStart = findNext("{{", position);
+      const tagStart = findNext("{%", position);
+      const commentStart = findNext("{#", position);
+      const candidates = [
+        { pos: varStart, type: "var" },
+        { pos: tagStart, type: "tag" },
+        { pos: commentStart, type: "comment" }
+      ].filter((c) => c.pos !== -1);
+      if (candidates.length === 0) {
+        const text = template.substring(position);
+        if (text) {
+          ast.push({ type: "text", value: text });
+        }
+        break;
+      }
+      candidates.sort((a, b) => a.pos - b.pos);
+      const nearest = candidates[0];
+      if (nearest.pos > position) {
+        ast.push({ type: "text", value: extractTo(nearest.pos) });
+      }
+      if (nearest.type === "var") {
+        advance(2);
+        const endPos = findNext("}}", position);
+        if (endPos === -1) {
+          errors.push(createError("Unclosed variable tag"));
+          break;
+        }
+        const varName = extractTo(endPos).trim();
+        advance(2);
+        ast.push({ type: "variable", name: varName });
+      } else if (nearest.type === "comment") {
+        if (ast.length > 0 && ast[ast.length - 1].type === "text") {
+          const lastNode = ast[ast.length - 1];
+          if (/\n[ \t]*$/.test(lastNode.value)) {
+            lastNode.value = lastNode.value.replace(/[ \t]*\n[ \t]*$/, "");
+          }
+        }
+        advance(2);
+        const endPos = findNext("#}", position);
+        if (endPos === -1) {
+          errors.push(createError("Unclosed comment tag"));
+          break;
+        }
+        const commentText = extractTo(endPos);
+        advance(2);
+        ast.push({ type: "comment", value: commentText });
+        if (position < template.length && template[position] === "\n") {
+          advance(1);
+          while (position < template.length && /[ \t]/.test(template[position])) {
+            advance(1);
+          }
+        }
+      } else if (nearest.type === "tag") {
+        advance(2);
+        const endPos = findNext("%}", position);
+        if (endPos === -1) {
+          errors.push(createError("Unclosed statement tag"));
+          break;
+        }
+        let statement = extractTo(endPos).trim();
+        const hasLeftStrip = statement.startsWith("-");
+        const hasRightStrip = statement.endsWith("-");
+        if (hasLeftStrip) {
+          statement = statement.substring(1).trim();
+          if (ast.length > 0 && ast[ast.length - 1].type === "text") {
+            const lastNode = ast[ast.length - 1];
+            lastNode.value = lastNode.value.replace(/[ \t]*\n[ \t\n]*$/, "");
+          }
+        }
+        if (hasRightStrip) {
+          statement = statement.substring(0, statement.length - 1).trim();
+        }
+        advance(2);
+        if (hasRightStrip) {
+          while (position < template.length && /[ \t\n]/.test(template[position])) {
+            advance(1);
+          }
+        }
+        if (statement.startsWith("set ")) {
+          const setMatch = /^set\s+(\w+)\s*=\s*(.+)$/.exec(statement);
+          if (setMatch) {
+            try {
+              const expr = parseExpression(setMatch[2]);
+              ast.push({
+                type: "set",
+                name: setMatch[1],
+                value: expr
+              });
+            } catch (error) {
+              errors.push(createError(`Invalid set expression: ${error.message}`));
+            }
+          } else {
+            errors.push(createError("Invalid set syntax"));
+          }
+        } else if (statement.startsWith("if ")) {
+          const condition = statement.substring(3).trim();
+          try {
+            const expr = parseExpression(condition);
+            const { trueBranch, elifBranches, elseBranch, parseErrors } = parseIfBlock();
+            errors.push(...parseErrors);
+            ast.push({
+              type: "if",
+              condition: expr,
+              trueBranch,
+              elifBranches: elifBranches.length > 0 ? elifBranches : void 0,
+              elseBranch: elseBranch.length > 0 ? elseBranch : void 0
+            });
+          } catch (error) {
+            errors.push(createError(`Invalid if expression: ${error.message}`));
+          }
+        } else if (statement.startsWith("include ")) {
+          const includeMatch = /^include\s+["']([^"']+)["']/.exec(statement);
+          if (includeMatch) {
+            ast.push({
+              type: "include",
+              path: includeMatch[1]
+            });
+          } else {
+            errors.push(createError("Invalid include syntax"));
+          }
+        } else if (statement.startsWith("switch ")) {
+          const switchExpr = statement.substring(7).trim();
+          try {
+            const expr = parseExpression(switchExpr);
+            const { cases, parseErrors } = parseSwitchBlock();
+            errors.push(...parseErrors);
+            ast.push({
+              type: "switch",
+              expression: expr,
+              cases
+            });
+          } catch (error) {
+            errors.push(createError(`Invalid switch expression: ${error.message}`));
+          }
+        } else if (statement.startsWith("leveloffset ")) {
+          const offsetMatch = /^leveloffset\s+([-+]?\d+)$/.exec(statement);
+          if (!offsetMatch) {
+            errors.push(createError("Invalid leveloffset syntax"));
+          } else {
+            const offsetStr = offsetMatch[1];
+            const isRelative = offsetStr.startsWith("+") || offsetStr.startsWith("-");
+            const offset = parseInt(offsetStr, 10);
+            if (isNaN(offset)) {
+              errors.push(createError("Invalid leveloffset value"));
+            } else {
+              let depth = 0;
+              let searchPos = position;
+              let endPos2 = -1;
+              while (searchPos < template.length) {
+                const leveloffsetMatch = /{%-?\s*leveloffset\s+[-+]?\d+\s*-?%}/.exec(template.substring(searchPos));
+                const endleveloffsetMatch = /{%-?\s*endleveloffset\s*-?%}/.exec(template.substring(searchPos));
+                const leveloffsetPos = leveloffsetMatch ? searchPos + leveloffsetMatch.index : Infinity;
+                const endleveloffsetPos = endleveloffsetMatch ? searchPos + endleveloffsetMatch.index : Infinity;
+                if (leveloffsetPos < endleveloffsetPos) {
+                  depth++;
+                  searchPos = leveloffsetPos + (leveloffsetMatch?.[0].length || 0);
+                } else if (endleveloffsetPos < Infinity) {
+                  if (depth === 0) {
+                    endPos2 = endleveloffsetPos;
+                    break;
+                  } else {
+                    depth--;
+                    searchPos = endleveloffsetPos + (endleveloffsetMatch?.[0].length || 0);
+                  }
+                } else {
+                  break;
+                }
+              }
+              if (endPos2 === -1) {
+                errors.push(createError("Missing endleveloffset"));
+              } else {
+                const bodyTemplate = extractTo(endPos2);
+                const endMatch = /{%-?\s*endleveloffset\s*-?%}/.exec(template.substring(position));
+                if (endMatch) {
+                  advance(endMatch[0].length);
+                }
+                const bodyResult = parse(bodyTemplate);
+                errors.push(...bodyResult.errors);
+                ast.push({
+                  type: "leveloffset",
+                  offset,
+                  isRelative,
+                  body: bodyResult.ast
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return { ast, errors };
+    function findEndTag(tagName) {
+      const pattern = new RegExp(`{%\\s*${tagName}\\s*%}`);
+      const match = pattern.exec(template.substring(position));
+      if (match) {
+        return {
+          start: position + match.index,
+          length: match[0].length
+        };
+      }
+      return null;
+    }
+    function parseIfBlock() {
+      const elifBranches = [];
+      const parseErrors = [];
+      let elseBranch = [];
+      let depth = 0;
+      let searchPos = position;
+      while (searchPos < template.length) {
+        const ifMatch = /{%-?\s*if\s+/.exec(template.substring(searchPos));
+        const elifMatch = /{%-?\s*elif\s+/.exec(template.substring(searchPos));
+        const elseMatch = /{%-?\s*else\s*-?%}/.exec(template.substring(searchPos));
+        const endifMatch = /{%-?\s*endif\s*-?%}/.exec(template.substring(searchPos));
+        const matches = [
+          { type: "if", match: ifMatch, pos: ifMatch ? searchPos + ifMatch.index : Infinity },
+          { type: "elif", match: elifMatch, pos: elifMatch ? searchPos + elifMatch.index : Infinity },
+          { type: "else", match: elseMatch, pos: elseMatch ? searchPos + elseMatch.index : Infinity },
+          { type: "endif", match: endifMatch, pos: endifMatch ? searchPos + endifMatch.index : Infinity }
+        ].sort((a, b) => a.pos - b.pos);
+        const nearest = matches[0];
+        if (!nearest.match || nearest.pos === Infinity) {
+          parseErrors.push(createError("Missing endif"));
+          break;
+        }
+        if (nearest.type === "if") {
+          depth++;
+          searchPos = nearest.pos + nearest.match[0].length;
+        } else if (nearest.type === "endif") {
+          if (depth === 0) {
+            const bodyTemplate = extractTo(nearest.pos);
+            advance(nearest.match[0].length);
+            const bodyResult = parse(bodyTemplate);
+            parseErrors.push(...bodyResult.errors);
+            return {
+              trueBranch: bodyResult.ast,
+              elifBranches,
+              elseBranch,
+              parseErrors
+            };
+          } else {
+            depth--;
+            searchPos = nearest.pos + nearest.match[0].length;
+          }
+        } else if (depth === 0 && (nearest.type === "elif" || nearest.type === "else")) {
+          const bodyTemplate = extractTo(nearest.pos);
+          const bodyResult = parse(bodyTemplate);
+          if (elifBranches.length === 0 && elseBranch.length === 0) {
+            parseErrors.push(...bodyResult.errors);
+            const trueBranch = bodyResult.ast;
+            if (nearest.type === "elif") {
+              advance(nearest.match[0].length);
+              const condMatch = /^([^%]+)%}/.exec(template.substring(position));
+              if (condMatch) {
+                const condStr = condMatch[1].trim();
+                advance(condMatch[0].length);
+                try {
+                  const elifCondition = parseExpression(condStr);
+                  const elifResult = parseIfBlock();
+                  parseErrors.push(...elifResult.parseErrors);
+                  elifBranches.push({
+                    condition: elifCondition,
+                    body: elifResult.trueBranch
+                  });
+                  elifBranches.push(...elifResult.elifBranches || []);
+                  elseBranch = elifResult.elseBranch;
+                  return {
+                    trueBranch,
+                    elifBranches,
+                    elseBranch,
+                    parseErrors
+                  };
+                } catch (error) {
+                  parseErrors.push(createError(`Invalid elif expression: ${error.message}`));
+                }
+              }
+            } else {
+              advance(nearest.match[0].length);
+              const endifMatch2 = findEndTag("endif");
+              if (!endifMatch2) {
+                parseErrors.push(createError("Missing endif after else"));
+              } else {
+                const elseBodyTemplate = extractTo(endifMatch2.start);
+                advance(endifMatch2.length);
+                const elseBodyResult = parse(elseBodyTemplate);
+                parseErrors.push(...elseBodyResult.errors);
+                elseBranch = elseBodyResult.ast;
+              }
+              return {
+                trueBranch,
+                elifBranches,
+                elseBranch,
+                parseErrors
+              };
+            }
+          }
+        } else {
+          searchPos = nearest.pos + nearest.match[0].length;
+        }
+      }
+      return {
+        trueBranch: [],
+        elifBranches,
+        elseBranch,
+        parseErrors
+      };
+    }
+    function parseSwitchBlock() {
+      const cases = [];
+      const parseErrors = [];
+      while (position < template.length) {
+        const caseMatch = /{%-?\s*case\s+/.exec(template.substring(position));
+        const endswitchMatch = /{%-?\s*endswitch\s*-?%}/.exec(template.substring(position));
+        const casePos = caseMatch ? position + caseMatch.index : Infinity;
+        const endswitchPos = endswitchMatch ? position + endswitchMatch.index : Infinity;
+        if (endswitchPos < casePos) {
+          if (cases.length > 0 && position < endswitchPos) {
+            const bodyTemplate = extractTo(endswitchPos);
+            const bodyResult = parse(bodyTemplate);
+            parseErrors.push(...bodyResult.errors);
+            cases[cases.length - 1].body = bodyResult.ast;
+          }
+          advance(endswitchPos - position + (endswitchMatch?.[0].length || 0));
+          break;
+        } else if (casePos < Infinity) {
+          if (cases.length > 0 && position < casePos) {
+            const bodyTemplate = extractTo(casePos);
+            const bodyResult = parse(bodyTemplate);
+            parseErrors.push(...bodyResult.errors);
+            cases[cases.length - 1].body = bodyResult.ast;
+          } else if (position < casePos) {
+            extractTo(casePos);
+          }
+          advance(caseMatch[0].length);
+          const valueMatch = /([^%]+)%}/.exec(template.substring(position));
+          if (valueMatch) {
+            const valueStr = valueMatch[1].trim();
+            advance(valueMatch[0].length);
+            try {
+              const caseValue = parseExpression(valueStr);
+              cases.push({
+                value: caseValue,
+                body: []
+                // Will be filled in next iteration or at endswitch
+              });
+            } catch (error) {
+              parseErrors.push(createError(`Invalid case value: ${error.message}`));
+            }
+          } else {
+            parseErrors.push(createError("Invalid case syntax"));
+            break;
+          }
+        } else {
+          parseErrors.push(createError("Missing endswitch"));
+          break;
+        }
+      }
+      return { cases, parseErrors };
+    }
+  }
+
+  // src/context.ts
+  var Context = class _Context {
+    constructor(parent, options) {
+      this.variables = /* @__PURE__ */ new Map();
+      this.parent = parent || null;
+      this.options = options || parent?.options || {};
+    }
+    /**
+     * Get a variable from the context (supports dot notation)
+     * @param name - Variable name (can use dot notation like "obj.prop.subprop")
+     * @returns The variable value or undefined
+     */
+    get(name) {
+      const normalizedName = this.options.hyphenToUnderscore ? name.replace(/-/g, "_") : name;
+      const parts = normalizedName.split(".");
+      const rootName = parts[0];
+      let value;
+      if (this.variables.has(rootName)) {
+        value = this.variables.get(rootName);
+      } else if (this.parent) {
+        value = this.parent.get(rootName);
+      } else {
+        return void 0;
+      }
+      for (let i = 1; i < parts.length; i++) {
+        if (value === null || value === void 0) {
+          return void 0;
+        }
+        if (typeof value !== "object" || Array.isArray(value)) {
+          return void 0;
+        }
+        if (!Object.prototype.hasOwnProperty.call(value, parts[i])) {
+          return void 0;
+        }
+        value = value[parts[i]];
+      }
+      return value;
+    }
+    /**
+     * Set a variable in the current context
+     * @param name - Variable name (can use dot notation)
+     * @param value - Value to set
+     */
+    set(name, value) {
+      const parts = name.split(".");
+      if (parts.length === 1) {
+        this.variables.set(name, value);
+        return;
+      }
+      const rootName = parts[0];
+      let target = this.variables.get(rootName);
+      if (!target || typeof target !== "object" || Array.isArray(target)) {
+        target = {};
+        this.variables.set(rootName, target);
+      }
+      for (let i = 1; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (!target[key] || typeof target[key] !== "object" || Array.isArray(target[key])) {
+          target[key] = {};
+        }
+        target = target[key];
+      }
+      target[parts[parts.length - 1]] = value;
+    }
+    /**
+     * Create a child scope
+     * @returns A new Context with this context as parent
+     */
+    push() {
+      return new _Context(this, this.options);
+    }
+    /**
+     * Return to parent scope
+     * @returns The parent context or null if at root
+     */
+    pop() {
+      return this.parent;
+    }
+    /**
+     * Create a context from a plain object
+     * @param data - Plain object to convert to context
+     * @param options - Context options
+     * @returns New Context instance
+     */
+    static from(data, options) {
+      const ctx = new _Context(void 0, options);
+      for (const [key, value] of Object.entries(data)) {
+        ctx.set(key, value);
+      }
+      return ctx;
+    }
+  };
+
+  // src/loader-fetch.ts
+  var FetchLoader = class {
+    async load(path, basePath) {
+      const url = basePath ? new URL(path, basePath).href : path;
+      const fetchUrl = `${url}?preventCache=${Date.now()}`;
+      const response = await fetch(fetchUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to load ${url}: ${response.status} ${response.statusText}`);
+      }
+      return await response.text();
+    }
+  };
+
+  // src/renderer.ts
+  function transformHeadings(text, offset) {
+    if (offset === 0) {
+      return text;
+    }
+    return text.replace(/^(#{1,6})(\s+)/gm, (_match, hashes, space) => {
+      const currentLevel = hashes.length;
+      const newLevel = Math.max(1, Math.min(6, currentLevel + offset));
+      return "#".repeat(newLevel) + space;
+    });
+  }
+  function resolvePath(path, basePath) {
+    if (path.startsWith("/")) {
+      return path;
+    }
+    const base = basePath.endsWith("/") ? basePath : basePath + "/";
+    const combined = base + path;
+    const parts = combined.split("/");
+    const resolved = [];
+    for (const part of parts) {
+      if (part === "." || part === "") {
+        continue;
+      } else if (part === "..") {
+        resolved.pop();
+      } else {
+        resolved.push(part);
+      }
+    }
+    const prefix = combined.startsWith("/") ? "/" : "";
+    return prefix + resolved.join("/");
+  }
+  async function render(template, options = {}) {
+    const {
+      loader = new FetchLoader(),
+      context: initialContext = {},
+      basePath = "",
+      maxIncludeDepth = 10,
+      timeout = 5e3,
+      hyphenToUnderscore = false,
+      undefinedBehavior = "empty"
+    } = options;
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Template rendering timeout")), timeout);
+    });
+    const renderPromise = renderInternal(template, {
+      loader,
+      context: Context.from(
+        {
+          ...initialContext,
+          // Built-in variables
+          date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+          timestamp: Date.now(),
+          _levelOffset: 0
+        },
+        { hyphenToUnderscore }
+      ),
+      includeDepth: 0,
+      maxIncludeDepth,
+      basePath,
+      undefinedBehavior
+    });
+    return await Promise.race([renderPromise, timeoutPromise]);
+  }
+  async function renderInternal(template, options) {
+    const { includeDepth, maxIncludeDepth } = options;
+    if (includeDepth > maxIncludeDepth) {
+      throw new Error(`Maximum include depth (${maxIncludeDepth}) exceeded`);
+    }
+    const parseResult = parse(template);
+    if (parseResult.errors.length > 0) {
+      const errorMessages = parseResult.errors.map((e) => e.message).join(", ");
+      throw new Error(`Parse errors: ${errorMessages}`);
+    }
+    return await renderNodes(parseResult.ast, options);
+  }
+  async function renderNodes(nodes, options) {
+    const parts = [];
+    for (const node of nodes) {
+      parts.push(await renderNode(node, options));
+    }
+    return parts.join("");
+  }
+  async function renderNode(node, options) {
+    const { loader, context, includeDepth, maxIncludeDepth, basePath } = options;
+    switch (node.type) {
+      case "text": {
+        const currentOffset = context.get("_levelOffset") || 0;
+        if (currentOffset === 0) {
+          return node.value;
+        }
+        return transformHeadings(node.value, currentOffset);
+      }
+      case "variable": {
+        const value = context.get(node.name);
+        if (value === void 0 || value === null) {
+          switch (options.undefinedBehavior) {
+            case "throw":
+              throw new Error(`Undefined variable: ${node.name}`);
+            case "preserve":
+              return `{{ ${node.name} }}`;
+            case "empty":
+            default:
+              return "";
+          }
+        }
+        const str = String(value);
+        if (str.includes("{{") || str.includes("{%")) {
+          return await renderInternal(str, options);
+        }
+        return str;
+      }
+      case "set": {
+        const value = evaluateExpression(node.value, context);
+        context.set(node.name, value);
+        return "";
+      }
+      case "comment":
+        return "";
+      case "if": {
+        if (options.undefinedBehavior === "preserve") {
+          const undefinedRefs = findUndefinedRefs(node.condition, context);
+          if (undefinedRefs.length > 0) {
+            return ifNodeToSource(node);
+          }
+          if (node.elifBranches) {
+            for (const elif of node.elifBranches) {
+              if (findUndefinedRefs(elif.condition, context).length > 0) {
+                return ifNodeToSource(node);
+              }
+            }
+          }
+        }
+        const condition = evaluateExpression(node.condition, context);
+        if (isTruthy2(condition)) {
+          return await renderNodes(node.trueBranch, options);
+        }
+        if (node.elifBranches) {
+          for (const elifBranch of node.elifBranches) {
+            const elifCondition = evaluateExpression(elifBranch.condition, context);
+            if (isTruthy2(elifCondition)) {
+              return await renderNodes(elifBranch.body, options);
+            }
+          }
+        }
+        if (node.elseBranch) {
+          return await renderNodes(node.elseBranch, options);
+        }
+        return "";
+      }
+      case "include": {
+        try {
+          const includedContent = await loader.load(node.path, basePath);
+          let newBasePath = basePath;
+          if (node.path.includes("://")) {
+            const url = new URL(node.path);
+            newBasePath = url.href.substring(0, url.href.lastIndexOf("/") + 1);
+          } else if (basePath) {
+            if (basePath.includes("://")) {
+              const url = new URL(node.path, basePath);
+              newBasePath = url.href.substring(0, url.href.lastIndexOf("/") + 1);
+            } else {
+              const resolvedPath = resolvePath(node.path, basePath);
+              const lastSlash = resolvedPath.lastIndexOf("/");
+              newBasePath = lastSlash >= 0 ? resolvedPath.substring(0, lastSlash + 1) : basePath;
+            }
+          } else if (node.path.includes("/")) {
+            const lastSlash = node.path.lastIndexOf("/");
+            newBasePath = node.path.substring(0, lastSlash + 1);
+          }
+          return await renderInternal(includedContent, {
+            loader,
+            context,
+            includeDepth: includeDepth + 1,
+            maxIncludeDepth,
+            basePath: newBasePath,
+            undefinedBehavior: options.undefinedBehavior
+          });
+        } catch (error) {
+          if (options.undefinedBehavior === "preserve") {
+            return `{% include "${node.path}" %}`;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`Failed to include ${node.path}:`, message);
+          return `<!-- Include error: ${node.path} -->`;
+        }
+      }
+      case "switch": {
+        const switchValue = evaluateExpression(node.expression, context);
+        for (const caseItem of node.cases) {
+          const caseValue = evaluateExpression(caseItem.value, context);
+          if (switchValue == caseValue) {
+            return await renderNodes(caseItem.body, options);
+          }
+        }
+        return "";
+      }
+      case "leveloffset": {
+        const parentOffset = context.get("_levelOffset") || 0;
+        const newOffset = node.isRelative ? parentOffset + node.offset : node.offset;
+        const previousOffset = parentOffset;
+        context.set("_levelOffset", newOffset);
+        try {
+          const result = await renderNodes(node.body, options);
+          return result;
+        } finally {
+          context.set("_levelOffset", previousOffset);
+        }
+      }
+      default:
+        const _exhaustive = node;
+        return _exhaustive;
+    }
+  }
+  function isTruthy2(value) {
+    if (value === void 0 || value === null || value === false) {
+      return false;
+    }
+    if (value === 0 || value === "") {
+      return false;
+    }
+    return true;
+  }
+  function findUndefinedRefs(expr, context) {
+    const out = [];
+    function walk(e) {
+      switch (e.type) {
+        case "variable":
+          if (context.get(e.name) === void 0)
+            out.push(e.name);
+          break;
+        case "binary":
+          walk(e.left);
+          walk(e.right);
+          break;
+        case "unary":
+          walk(e.operand);
+          break;
+        case "literal":
+          break;
+      }
+    }
+    walk(expr);
+    return out;
+  }
+  function expressionToSource(expr) {
+    switch (expr.type) {
+      case "literal":
+        if (typeof expr.value === "string")
+          return JSON.stringify(expr.value);
+        if (expr.value === null)
+          return "null";
+        return String(expr.value);
+      case "variable":
+        return expr.name;
+      case "unary":
+        return `not ${expressionToSource(expr.operand)}`;
+      case "binary":
+        return `(${expressionToSource(expr.left)} ${expr.operator} ${expressionToSource(expr.right)})`;
+    }
+  }
+  function nodesToSource(nodes) {
+    return nodes.map(nodeToSource).join("");
+  }
+  function nodeToSource(node) {
+    switch (node.type) {
+      case "text":
+        return node.value;
+      case "variable":
+        return `{{ ${node.name} }}`;
+      case "set":
+        return `{% set ${node.name} = ${expressionToSource(node.value)} %}`;
+      case "comment":
+        return "{# \u2026 #}";
+      case "if":
+        return ifNodeToSource(node);
+      case "include":
+        return `{% include "${node.path}" %}`;
+      case "leveloffset": {
+        const sign = node.isRelative && node.offset >= 0 ? "+" : "";
+        return `{% leveloffset ${sign}${node.offset} %}${nodesToSource(node.body)}{% endleveloffset %}`;
+      }
+      case "switch": {
+        const cases = node.cases.map((c) => `{% case ${expressionToSource(c.value)} %}${nodesToSource(c.body)}`).join("");
+        return `{% switch ${expressionToSource(node.expression)} %}${cases}{% endswitch %}`;
+      }
+    }
+  }
+  function ifNodeToSource(node) {
+    const parts = [`{% if ${expressionToSource(node.condition)} %}`, nodesToSource(node.trueBranch)];
+    if (node.elifBranches) {
+      for (const elif of node.elifBranches) {
+        parts.push(`{% elif ${expressionToSource(elif.condition)} %}`, nodesToSource(elif.body));
+      }
+    }
+    if (node.elseBranch) {
+      parts.push(`{% else %}`, nodesToSource(node.elseBranch));
+    }
+    parts.push(`{% endif %}`);
+    return parts.join("");
+  }
+
+  // src/loader-memory.ts
+  var MemoryLoader = class {
+    constructor(files = {}) {
+      this.files = new Map(Object.entries(files));
+    }
+    addFile(path, content) {
+      this.files.set(path, content);
+    }
+    async load(path, basePath) {
+      const combined = basePath && !path.startsWith("/") ? `${basePath}/${path}` : path;
+      const parts = combined.split("/");
+      const normalized = [];
+      for (const part of parts) {
+        if (part === "." || part === "")
+          continue;
+        if (part === "..") {
+          normalized.pop();
+          continue;
+        }
+        normalized.push(part);
+      }
+      const prefix = combined.startsWith("/") ? "/" : "";
+      const resolvedPath = prefix + normalized.join("/");
+      const content = this.files.get(resolvedPath);
+      if (content === void 0) {
+        throw new Error(`File not found: ${resolvedPath}`);
+      }
+      return content;
+    }
+  };
+  return __toCommonJS(browser_exports);
+})();
+//# sourceMappingURL=index.umd.js.map