@dogsbay/minja 0.2.0-beta.48

package/bin/minja.js

@@ -0,0 +1,1062 @@
+#!/usr/bin/env node
+/**
+ * minja v0.2.0-beta.48
+ * Minimal, secure Jinja2/Nunjucks subset for documentation preprocessing
+ * @license MIT
+ */
+
+// src/cli.ts
+import { readFile, writeFile } from "fs/promises";
+import { resolve, dirname } from "path";
+import { Command } from "commander";
+import { parse as parseYAML } from "yaml";
+
+// 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.ts
+var FileSystemLoader = class {
+  /**
+   * Create a filesystem loader
+   * @param basePath - Base directory for resolving relative paths
+   */
+  constructor(basePath = process.cwd()) {
+    this.basePath = basePath;
+  }
+  /**
+   * Load a file from the filesystem
+   * @param path - Path to load (relative or absolute)
+   * @param basePath - Base path to resolve relative paths (overrides constructor basePath)
+   * @returns File contents
+   */
+  async load(path, basePath) {
+    const fs = await import("fs/promises");
+    const pathModule = await import("path");
+    const resolvedBasePath = basePath || this.basePath;
+    const resolvedPath = pathModule.isAbsolute(path) ? path : pathModule.resolve(resolvedBasePath, path);
+    try {
+      return await fs.readFile(resolvedPath, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load ${resolvedPath}: ${message}`);
+    }
+  }
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("minja").description("Minimal, secure Jinja2/Nunjucks subset for documentation preprocessing").version("0.1.0").argument("[template]", "Template file to render (or read from stdin)").option("-c, --context <file>", "Context file (JSON or YAML)").option("-o, --output <file>", "Output file (default: stdout)").option("-d, --max-depth <number>", "Maximum include depth", "10").option("-t, --timeout <ms>", "Rendering timeout in milliseconds", "5000").option("-v, --vars <json>", "Inline context variables as JSON").action(async (templatePath, options) => {
+  try {
+    let template;
+    let baseDir = process.cwd();
+    if (templatePath) {
+      const fullPath = resolve(templatePath);
+      template = await readFile(fullPath, "utf-8");
+      baseDir = dirname(fullPath);
+    } else {
+      template = await readStdin();
+    }
+    let context = {};
+    if (options.context) {
+      const contextPath = resolve(options.context);
+      const contextContent = await readFile(contextPath, "utf-8");
+      if (contextPath.endsWith(".json")) {
+        context = JSON.parse(contextContent);
+      } else if (contextPath.endsWith(".yaml") || contextPath.endsWith(".yml")) {
+        context = parseYAML(contextContent);
+      } else {
+        throw new Error("Context file must be .json, .yaml, or .yml");
+      }
+    }
+    if (options.vars) {
+      const inlineVars = JSON.parse(options.vars);
+      context = { ...context, ...inlineVars };
+    }
+    const loader = new FileSystemLoader(baseDir);
+    const result = await render(template, {
+      loader,
+      basePath: baseDir,
+      context,
+      maxIncludeDepth: parseInt(options.maxDepth || "10"),
+      timeout: parseInt(options.timeout || "5000")
+    });
+    if (options.output) {
+      const outputPath = resolve(options.output);
+      await writeFile(outputPath, result, "utf-8");
+      console.error(`\u2713 Rendered to ${outputPath}`);
+    } else {
+      process.stdout.write(result);
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.parse();
+async function readStdin() {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", () => {
+      resolve2(Buffer.concat(chunks).toString("utf-8"));
+    });
+    process.stdin.on("error", (error) => {
+      reject(error);
+    });
+  });
+}