mutorjs 1.2.0 → 1.3.1

package/dist/cli.cjs

@@ -0,0 +1,1783 @@
+#!/usr/bin/env node
+"use strict";
+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/bin/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  handleBuildCommand: () => handleBuildCommand,
+  handleCompileCommand: () => handleCompileCommand,
+  handleRenderCommand: () => handleRenderCommand,
+  parseArgs: () => parseArgs,
+  safeParseJsonFile: () => safeParseJsonFile,
+  safeReadFile: () => safeReadFile,
+  safeWriteFile: () => safeWriteFile
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_fs2 = require("fs");
+var import_node_process = require("process");
+
+// package.json
+var version = "1.3.1";
+
+// src/core/mutor.server.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/utils/construct-pointer.ts
+function constructPointer(pos, offset) {
+  return `${" ".repeat(pos + offset + 1)}^`;
+}
+
+// src/core/error.ts
+var MutorError = class _MutorError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MutorError";
+    Object.setPrototypeOf(this, _MutorError.prototype);
+  }
+};
+var MutorCompilerError = class _MutorCompilerError extends MutorError {
+  constructor(message, line, lineText, column, file) {
+    const gutterWidth = line.toString().length + 2;
+    let report = `${message}
+
+`;
+    report += `at ${file}:${line}:${column + 1}
+`;
+    if (line > 1) {
+      report += `${(line - 1).toString().padStart(gutterWidth - 2)} | ...
+`;
+    }
+    report += `${line} | ${lineText}
+`;
+    report += constructPointer(column, gutterWidth);
+    super(report);
+    this.name = "MutorCompilerError";
+    Object.setPrototypeOf(this, _MutorCompilerError.prototype);
+  }
+};
+
+// src/core/constants.ts
+var keywords = /* @__PURE__ */ new Set([
+  "for",
+  "if",
+  "else",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "end",
+  "in",
+  "of"
+]);
+var operators = /* @__PURE__ */ new Set([
+  "::",
+  // Namespace access
+  "||",
+  // Or
+  "??",
+  // Nullish coalesce
+  "&&",
+  // And
+  "**",
+  // Power
+  "^",
+  // Bitwise XOr
+  "|",
+  // Bitwise Or
+  "&",
+  // Bitwise And
+  "!",
+  // Not
+  "-",
+  // Minus
+  "%",
+  // Modulus
+  "+",
+  // Plus
+  "*",
+  // Times
+  "/",
+  // Divide
+  ">",
+  // Greater than
+  "<",
+  // Less than
+  ">=",
+  // Greater or equal
+  "<=",
+  // Less or equal
+  "==",
+  // Strict equal
+  "!=",
+  // Strict not equal
+  ">>",
+  // Bitwise right shift
+  "<<",
+  // Bitwise left shift
+  ".",
+  // Property acess
+  "?.",
+  // Optional property access
+  "(",
+  // Open parentheses
+  ")",
+  // Close parentheses
+  "[",
+  // Square open parentheses
+  "]",
+  // Square close parentheses
+  ",",
+  // Comma
+  ":",
+  // Column
+  "?"
+  // Ternary operator
+]);
+var equalityOperators = /* @__PURE__ */ new Set(["==", "!="]);
+var comparisonOperators = /* @__PURE__ */ new Set([">", "<", ">=", "<="]);
+var additiveOperators = /* @__PURE__ */ new Set(["+", "-"]);
+var multiplicativeOperators = /* @__PURE__ */ new Set(["*", "/", "%"]);
+var propertyAccessOperators = /* @__PURE__ */ new Set([".", "?.", "[", "::"]);
+var unaryOperators = /* @__PURE__ */ new Set(["-", "+", "!"]);
+var ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var defaultConfig = {
+  build: {
+    include: /* @__PURE__ */ new Set([".html", ".txt"]),
+    exclude: /* @__PURE__ */ new Set(["node_modules", ".git"])
+  },
+  autoEscape: true,
+  allowedProps: /* @__PURE__ */ new Set(),
+  forbiddenProps: /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]),
+  allowFnCalls: false,
+  delimiters: {
+    closingTag: "}}",
+    openingTag: "{{",
+    openingTagEscape: "\\",
+    whitespaceTrim: "~",
+    commentTag: "#"
+  },
+  keepOpeningTagEscapeDelimiter: false,
+  cache: {
+    active: true,
+    maxSize: 50 * 1024 * 1024
+    // 50MB
+  }
+};
+var namespaces = {
+  JSON: {
+    stringify(value) {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        throw new MutorError("JSON.stringify failed: invalid value");
+      }
+    },
+    parse(str) {
+      if (typeof str !== "string") {
+        throw new MutorError("JSON.parse expects a string");
+      }
+      try {
+        return JSON.parse(str);
+      } catch {
+        throw new MutorError("JSON.parse failed: invalid JSON string");
+      }
+    }
+  },
+  Object: {
+    keys(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.keys expects an object");
+      }
+      return Object.keys(obj);
+    },
+    values(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.values expects an object");
+      }
+      return Object.values(obj);
+    },
+    entries(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.entries expects an object");
+      }
+      return Object.entries(obj);
+    },
+    hasOwn(obj, key) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.hasOwn expects an object");
+      }
+      return Object.hasOwn(obj, key);
+    },
+    freeze(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.freeze expects an object");
+      }
+      return Object.freeze(obj);
+    },
+    seal(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.seal expects an object");
+      }
+      return Object.seal(obj);
+    },
+    fromEntries(entries) {
+      if (!Array.isArray(entries)) {
+        throw new MutorError("Object.fromEntries expects an array");
+      }
+      return Object.fromEntries(entries);
+    }
+  },
+  Array: {
+    isArray(value) {
+      return Array.isArray(value);
+    },
+    from(value) {
+      return Array.from(value);
+    }
+  },
+  Number: {
+    isFinite(value) {
+      return Number.isFinite(value);
+    },
+    isNaN(value) {
+      return Number.isNaN(value);
+    },
+    parseInt(value, radix = 10) {
+      return Number.parseInt(value, radix);
+    },
+    parseFloat(value) {
+      return Number.parseFloat(value);
+    }
+  },
+  String: {
+    fromCharCode(...args) {
+      return String.fromCharCode(...args);
+    }
+  },
+  Math: {
+    abs(x) {
+      return Math.abs(x);
+    },
+    floor(x) {
+      return Math.floor(x);
+    },
+    ceil(x) {
+      return Math.ceil(x);
+    },
+    round(x) {
+      return Math.round(x);
+    },
+    max(...args) {
+      return Math.max(...args);
+    },
+    min(...args) {
+      return Math.min(...args);
+    },
+    random() {
+      return Math.random();
+    }
+  },
+  Date: {
+    now() {
+      return Date.now();
+    },
+    parse(str) {
+      if (typeof str !== "string") {
+        throw new MutorError("Date.parse expects a string");
+      }
+      return Date.parse(str);
+    }
+  },
+  Boolean: {
+    valueOf(value) {
+      return Boolean(value);
+    }
+  }
+};
+
+// src/utils/escape-fn.ts
+function escapeFn(e) {
+  if (typeof e !== "string") return e;
+  return /[&<>"']/.test(e) ? e.replace(/[&<>"']/g, (char) => ESCAPE_MAP[char]) : e;
+}
+
+// src/utils/to-absolute-path.ts
+var import_node_path = require("path");
+function toAbsolutePath(basePath, ...relativePaths) {
+  const absoluteBase = (0, import_node_path.isAbsolute)(basePath) ? basePath : (0, import_node_path.resolve)(process.cwd(), basePath);
+  if (relativePaths.length) {
+    const baseDir = (0, import_node_path.dirname)(absoluteBase);
+    return (0, import_node_path.resolve)(baseDir, ...relativePaths);
+  }
+  return absoluteBase;
+}
+
+// src/utils/validate-computed-prop.ts
+function validateComputedProp(r, allowedProps, forbiddenProps) {
+  if (forbiddenProps.has(r) && !allowedProps.has(r)) {
+    throw new MutorError(
+      `Forbidden property access. Access to this computed property "${r}" is forbidden.`
+    );
+  }
+  return r;
+}
+
+// src/utils/validate-context.ts
+var OBJECT = "object";
+var MUTOR_SAFE = /* @__PURE__ */ Symbol("__mutor_safe_context");
+function validateContext(ctx) {
+  if (!ctx || typeof ctx !== OBJECT) {
+    return ctx;
+  }
+  if (MUTOR_SAFE in ctx) {
+    return ctx;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  function walk(value, path = "") {
+    if (!value || typeof value !== OBJECT) return value;
+    if (seen.has(value)) return value;
+    seen.add(value);
+    const proto = Object.getPrototypeOf(value);
+    if (proto && proto !== Object.prototype && proto !== Array.prototype) {
+      throw new MutorError(`Unsafe prototype detected at ${path || "root"}`);
+    }
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        value[i] = walk(value[i], `${path}[${i}]`);
+      }
+      return value;
+    }
+    if (value instanceof Map) {
+      for (const [k, v] of value.entries()) {
+        if (typeof k === OBJECT) walk(k, `${path}.mapKey`);
+        value.set(k, walk(v, `${path}.mapValue`));
+      }
+      return value;
+    }
+    if (value instanceof Set) {
+      const next = /* @__PURE__ */ new Set();
+      for (const v of value.values()) {
+        next.add(walk(v, path));
+      }
+      value.clear();
+      for (const v of next) value.add(v);
+      return value;
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Object.keys(descriptors)) {
+      const desc = descriptors[key];
+      if (desc.get || desc.set) {
+        throw new MutorError(`Getter/setter not allowed: ${path}.${key}`);
+      }
+      const prop = value[key];
+      if (prop && typeof prop === OBJECT) {
+        value[key] = walk(prop, `${path}.${key}`);
+      }
+    }
+    return value;
+  }
+  const safeData = walk(ctx);
+  if (safeData && typeof safeData === OBJECT) {
+    Object.defineProperty(safeData, MUTOR_SAFE, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  return safeData;
+}
+
+// src/utils/escape-raw-text.ts
+function escapeRawText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+}
+
+// src/utils/get-line-and-column-nums.ts
+function getLineAndColumnNumbers(str, idx) {
+  const lines = str.slice(0, idx).split("\n");
+  const line = lines.length;
+  const lineIndex = str.lastIndexOf("\n", idx - 1) + 1;
+  return { line, lineIndex };
+}
+
+// src/utils/get-line-snapshot.ts
+function getLineSnapshot(str, lineIdx, idx) {
+  const nextNewlineIdx = str.indexOf("\n", lineIdx);
+  const line = str.slice(
+    lineIdx,
+    nextNewlineIdx === -1 ? void 0 : nextNewlineIdx
+  );
+  return { line, pos: idx - lineIdx };
+}
+
+// src/core/build.ts
+function build(ast, context) {
+  const { scope, forbiddenProps, allowedProps } = context;
+  function prefixWithCtx(ident) {
+    return scope.includes(ident) ? ident : `ctx.${ident}`;
+  }
+  function buildExpr(expr) {
+    switch (expr.type) {
+      case 17 /* END */:
+        return "}";
+      case 5 /* NUMBER */:
+        return expr.value;
+      case 4 /* STRING */:
+        return `\`${/\$/.test(expr.value) ? expr.value.replaceAll("$", "\\$") : expr.value}\``;
+      case 10 /* BOOLEAN */:
+        return expr.true ? "true" : "false";
+      case 12 /* NULL */:
+        return "null";
+      case 11 /* UNDEFINED */:
+        return "undefined";
+      case 7 /* IDENT */:
+        return prefixWithCtx(expr.value);
+      case 9 /* GROUP */:
+        return `(${buildExpr(expr.expr)})`;
+      case 2 /* UNARY */:
+        return `${expr.operator}${buildExpr(expr.expr)}`;
+      case 0 /* BINARY */:
+        return `${buildExpr(expr.left)} ${expr.operator} ${buildExpr(expr.right)}`;
+      case 1 /* TERNARY */:
+        return `${buildExpr(expr.condition)} ? ${buildExpr(expr.left)} : ${buildExpr(expr.right)}`;
+      case 8 /* PROP_ACCESS */:
+        return buildPropAccess(expr);
+      case 3 /* CALL */:
+        return buildCall(expr);
+      case 6 /* NAMESPACE */:
+        return buildNamespace(expr);
+      case 13 /* FOR */:
+        return buildForLoop(expr);
+      case 16 /* ELSE */:
+        return "} else {";
+      case 14 /* IF */:
+        return buildIfBlock(expr);
+      case 15 /* ELSE_IF */:
+        return buildElseIfBlock(expr);
+      default:
+        throw new MutorError(
+          `Unsupported expression type: ${expr.type}`
+        );
+    }
+  }
+  function buildNamespace(expr) {
+    if (expr.left.type !== 7 /* IDENT */) {
+      throw {
+        message: "Invalid usage of namespace operator.",
+        pos: expr.pos
+      };
+    }
+    return `namespaces.${expr.left.value}.${expr.right.value}`;
+  }
+  function buildPropAccess(expr) {
+    const left = buildExpr(expr.left);
+    if (expr.bracketNotation) {
+      const right = buildExpr(expr.right);
+      const optionalChain = expr.optional ? "?." : "";
+      return expr.right.type === 4 /* STRING */ || expr.right.type === 5 /* NUMBER */ ? `${left}${optionalChain}[${right}]` : `${left}${optionalChain}[validateComputedProps(${right}, allowedProps, forbiddenProps)]`;
+    } else {
+      const propName = expr.right.value;
+      const optionalChain = expr.optional ? "?." : ".";
+      if (forbiddenProps.has(propName) && !allowedProps.has(propName)) {
+        throw { message: "Forbidden property access.", pos: expr.right.pos };
+      }
+      return `${left}${optionalChain}${propName}`;
+    }
+  }
+  function buildCall(expr) {
+    const func = buildExpr(expr.expr);
+    const optionalChain = expr.optional ? "?." : "";
+    const args = expr.args.map((arg) => buildExpr(arg)).join(", ");
+    return `${func}${optionalChain}(${args})`;
+  }
+  function buildForLoop(expr) {
+    const { iterable, loopType, variable } = expr;
+    return `for(const ${variable} ${loopType === 1 /* IN */ ? "in" : "of"} ${build(iterable, context)}){`;
+  }
+  function buildIfBlock(expr) {
+    const { condition } = expr;
+    return `if(${build(condition, context)}){`;
+  }
+  function buildElseIfBlock(expr) {
+    const { condition } = expr;
+    return `}else if(${build(condition, context)}){`;
+  }
+  return buildExpr(ast);
+}
+
+// src/utils/get-token-type-words.ts
+function getTokenTypeWords(type) {
+  switch (type) {
+    case 0 /* IDENT */:
+      return "identifier";
+    case 1 /* KEYWORD */:
+      return "keyword";
+    case 2 /* NUMBER */:
+      return "number";
+    case 4 /* OPERATOR */:
+      return "operator";
+    case 3 /* STRING */:
+      return "string";
+  }
+}
+
+// src/core/generate-ast.ts
+function generateAst(tokens, config) {
+  let cursor = 0, generatingNamespace = false;
+  function expectOrThrow(type, value) {
+    const token = tokens[cursor];
+    const lastToken = tokens[tokens.length - 1];
+    if (!token) {
+      throw {
+        message: `Unexpected end of expression. Expected ${value ? `'${value}'` : `${type === 0 /* IDENT */ ? "an" : "a"} ${getTokenTypeWords(type)}`}.`,
+        pos: lastToken.pos + lastToken.value.length - 1
+      };
+    }
+    if (token.type !== type) {
+      throw {
+        message: `Unexpected token type. Expected ${value ? `'${value}'` : getTokenTypeWords(type)} but got ${getTokenTypeWords(token.type)} instead.`,
+        pos: token.pos
+      };
+    }
+    if (value !== void 0 && token.value !== value) {
+      throw {
+        message: `Unexpected token '${token?.value}'. Expected ${type === 0 /* IDENT */ ? "an" : "a"} ${getTokenTypeWords(type)} instead.`,
+        pos: token.pos
+      };
+    }
+    return tokens[cursor++];
+  }
+  function parseForLoop() {
+    const pos = tokens[cursor - 1].pos;
+    const variable = expectOrThrow(0 /* IDENT */).value;
+    let token;
+    try {
+      token = expectOrThrow(1 /* KEYWORD */, "in");
+    } catch {
+      token = expectOrThrow(1 /* KEYWORD */, "of");
+    }
+    const loopType = token.value === "in" ? 1 /* IN */ : 0 /* OF */;
+    const iterable = parseTernaryExpr();
+    return { type: 13 /* FOR */, loopType, iterable, variable, pos };
+  }
+  function parseIfExpression() {
+    const condition = parseTernaryExpr();
+    return { condition, pos: condition.pos, type: 14 /* IF */ };
+  }
+  function parseElseExpression() {
+    const pos = tokens[cursor - 1].pos;
+    try {
+      expectOrThrow(1 /* KEYWORD */, "if");
+      return { ...parseIfExpression(), type: 15 /* ELSE_IF */, pos };
+    } catch {
+      return { type: 16 /* ELSE */, pos };
+    }
+  }
+  function extractFnArgs() {
+    const args = [];
+    const emptyArgs = tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === ")";
+    if (emptyArgs) {
+      return args;
+    }
+    args.push(parseTernaryExpr());
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "," && tokens[cursor]?.value !== ")") {
+      cursor++;
+      args.push(parseTernaryExpr());
+    }
+    return args;
+  }
+  function parsePrimaryExpr() {
+    const token = tokens[cursor++];
+    if (token?.type === 2 /* NUMBER */) {
+      return { type: 5 /* NUMBER */, value: token.value, pos: token.pos };
+    }
+    if (token?.type === 3 /* STRING */) {
+      return { type: 4 /* STRING */, value: token.value, pos: token.pos };
+    }
+    if (token?.type === 1 /* KEYWORD */) {
+      if (token.value === "for" && cursor === 1) {
+        return parseForLoop();
+      }
+      if (token.value === "true" || token.value === "false") {
+        return {
+          type: 10 /* BOOLEAN */,
+          true: token.value === "true",
+          pos: token.pos
+        };
+      }
+      if (token.value === "undefined") {
+        return { type: 11 /* UNDEFINED */, pos: token.pos };
+      }
+      if (token.value === "null") {
+        return { type: 12 /* NULL */, pos: token.pos };
+      }
+      if (token.value === "end" && tokens.length === 1) {
+        return { type: 17 /* END */, pos: token.pos };
+      }
+      if (token.value === "if" && cursor === 1) {
+        return parseIfExpression();
+      }
+      if (token.value === "else" && cursor === 1) {
+        return parseElseExpression();
+      }
+    }
+    if (token?.type === 0 /* IDENT */) {
+      return { type: 7 /* IDENT */, value: token.value, pos: token.pos };
+    }
+    if (token?.type === 4 /* OPERATOR */ && token.value === "(") {
+      const expr = parseTernaryExpr();
+      expectOrThrow(4 /* OPERATOR */, ")");
+      return { type: 9 /* GROUP */, expr, pos: token.pos };
+    }
+    if (token?.type === 4 /* OPERATOR */ && unaryOperators.has(token.value)) {
+      const operator = token.value;
+      const expr = parseTernaryExpr();
+      return { type: 2 /* UNARY */, operator, expr, pos: token.pos };
+    }
+    if (cursor > tokens.length) {
+      throw {
+        message: `Unexpected end of expression.`,
+        pos: tokens[tokens.length - 1].pos
+      };
+    }
+    throw {
+      message: `Unexpected token '${token?.value}'.`,
+      pos: token.pos
+    };
+  }
+  function parsePropertyAccess() {
+    let left = parsePrimaryExpr();
+    while (tokens[cursor]) {
+      const token = tokens[cursor];
+      if (token?.type === 4 /* OPERATOR */ && token?.value === "(") {
+        cursor++;
+        if (!generatingNamespace && !config.allowFnCalls) {
+          throw {
+            message: "Function calls are not allowed.",
+            pos: tokens[cursor - 1].pos
+          };
+        }
+        const args = extractFnArgs();
+        expectOrThrow(4 /* OPERATOR */, ")");
+        left = {
+          type: 3 /* CALL */,
+          expr: left,
+          args,
+          pos: tokens[cursor - 1].pos
+        };
+      } else if (token?.type === 4 /* OPERATOR */ && token?.value === "?." && tokens[cursor + 1]?.type === 4 /* OPERATOR */ && tokens[cursor + 1]?.value === "(") {
+        cursor++;
+        cursor++;
+        if (!generatingNamespace && !config.allowFnCalls) {
+          throw {
+            message: "Function calls are not allowed.",
+            pos: tokens[cursor - 1].pos
+          };
+        }
+        const args = extractFnArgs();
+        expectOrThrow(4 /* OPERATOR */, ")");
+        left = {
+          type: 3 /* CALL */,
+          expr: left,
+          args,
+          optional: true,
+          pos: tokens[cursor - 1].pos
+        };
+      } else if (token?.type === 4 /* OPERATOR */ && propertyAccessOperators.has(token?.value)) {
+        const isNamespace = token?.value === "::";
+        const isBracketNotation = token?.value === "[";
+        const isOptional = token?.value === "?.";
+        cursor++;
+        if (isNamespace && (tokens[cursor - 2]?.type !== 0 /* IDENT */ || tokens[cursor]?.type !== 0 /* IDENT */)) {
+          throw {
+            message: `Invalid namespaces access. Expected syntax <IDENTIFIER>::<IDENTIFIER>, but got '${tokens[cursor - 2]?.value}::${tokens[cursor]?.value}' instead.`,
+            pos: tokens[cursor]?.pos
+          };
+        }
+        if (isNamespace) {
+          generatingNamespace = true;
+          const right = parsePrimaryExpr();
+          left = {
+            type: 6 /* NAMESPACE */,
+            left,
+            right,
+            pos: tokens[cursor - 1].pos
+          };
+        } else if (isBracketNotation) {
+          const right = parseTernaryExpr();
+          expectOrThrow(4 /* OPERATOR */, "]");
+          left = {
+            type: 8 /* PROP_ACCESS */,
+            right,
+            left,
+            bracketNotation: true,
+            pos: tokens[cursor - 1].pos
+          };
+        } else if (isOptional) {
+          if (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "[") {
+            cursor++;
+            const right = parseTernaryExpr();
+            expectOrThrow(4 /* OPERATOR */, "]");
+            left = {
+              type: 8 /* PROP_ACCESS */,
+              left,
+              right,
+              bracketNotation: true,
+              optional: true,
+              pos: tokens[cursor - 1].pos
+            };
+          } else {
+            const right = parsePrimaryExpr();
+            left = {
+              type: 8 /* PROP_ACCESS */,
+              left,
+              right,
+              optional: true,
+              pos: tokens[cursor - 1].pos
+            };
+          }
+        } else {
+          const right = parsePrimaryExpr();
+          left = {
+            type: 8 /* PROP_ACCESS */,
+            left,
+            right,
+            pos: tokens[cursor - 1].pos
+          };
+        }
+      } else {
+        break;
+      }
+    }
+    generatingNamespace = false;
+    return left;
+  }
+  function parseMultiplicativeExpr() {
+    let left = parsePropertyAccess();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && multiplicativeOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parsePropertyAccess();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseAdditiveExpr() {
+    let left = parseMultiplicativeExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && additiveOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseMultiplicativeExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseBitwiseExpr() {
+    let left = parseAdditiveExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && comparisonOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseAdditiveExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseComparisonExpr() {
+    let left = parseBitwiseExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && comparisonOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseBitwiseExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseEqualityExpr() {
+    let left = parseComparisonExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && equalityOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseComparisonExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseLogicalOrExpr() {
+    let left = parseLogicalAndExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "||") {
+      const operator = tokens[cursor++].value;
+      const right = parseLogicalAndExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseLogicalAndExpr() {
+    let left = parseNullishCoalesceExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "&&") {
+      const operator = tokens[cursor++].value;
+      const right = parseNullishCoalesceExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseNullishCoalesceExpr() {
+    let left = parseEqualityExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "??") {
+      const operator = tokens[cursor++].value;
+      const right = parseEqualityExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseTernaryExpr() {
+    const condition = parseLogicalOrExpr();
+    if (tokens[cursor]?.type !== 4 /* OPERATOR */ || tokens[cursor]?.value !== "?") {
+      return condition;
+    }
+    cursor++;
+    const left = parseTernaryExpr();
+    expectOrThrow(4 /* OPERATOR */, ":");
+    const right = parseTernaryExpr();
+    return {
+      type: 1 /* TERNARY */,
+      left,
+      right,
+      condition,
+      pos: tokens[cursor - 1].pos
+    };
+  }
+  const ast = parseTernaryExpr();
+  return ast;
+}
+
+// src/core/parse.ts
+function parse(templateBlock, { delimiters }) {
+  const openingTagWithWhitespaceCtrl = `${delimiters.openingTag}${delimiters.whitespaceTrim}`;
+  const closingTagWithWhitespaceCtrl = `${delimiters.whitespaceTrim}${delimiters.closingTag}`;
+  const leftTrim = templateBlock.startsWith(openingTagWithWhitespaceCtrl);
+  const rightTrim = templateBlock.endsWith(closingTagWithWhitespaceCtrl);
+  const isComment = templateBlock.startsWith(
+    leftTrim ? openingTagWithWhitespaceCtrl + delimiters.commentTag : delimiters.openingTag + delimiters.commentTag
+  );
+  if (isComment) {
+    return { isComment, leftTrim, rightTrim };
+  }
+  const inner = templateBlock.slice(
+    leftTrim ? openingTagWithWhitespaceCtrl.length : delimiters.openingTag.length,
+    templateBlock.length - (rightTrim ? closingTagWithWhitespaceCtrl.length : delimiters.closingTag.length)
+  );
+  const trimmed = inner.trim();
+  const isBlock = trimmed.startsWith("for") || trimmed.startsWith("if") || trimmed.startsWith("else");
+  const requiresBlockClose = trimmed.startsWith("for") || trimmed.startsWith("if");
+  const isBlockEnd = trimmed === "end";
+  const hasContext = trimmed.startsWith("for");
+  return {
+    leftTrim,
+    rightTrim,
+    inner,
+    isBlock,
+    isBlockEnd,
+    hasContext,
+    requiresBlockClose
+  };
+}
+
+// src/core/tokenize.ts
+function tokenize(expr) {
+  let cursor = 0, char = "";
+  const tokens = [];
+  function accumulateKeywordOrIdentifier() {
+    let buffer = "";
+    if (/[a-zA-Z$_]/.test(char)) {
+      let j = cursor;
+      while (/[a-zA-Z$_0-9]/.test(expr[j]) && j < expr.length) {
+        buffer += expr[j];
+        j++;
+      }
+      tokens.push({
+        type: keywords.has(buffer) ? 1 /* KEYWORD */ : 0 /* IDENT */,
+        value: buffer,
+        pos: cursor
+      });
+      cursor = j;
+      char = expr[cursor];
+    }
+  }
+  function accumulateStr() {
+    let buffer = "";
+    if (char === '"' || char === "'" || char === "`") {
+      let j = cursor + 1;
+      while (expr[j] !== char && j < expr.length) {
+        buffer += expr[j];
+        j++;
+      }
+      if (j > expr.length) {
+        throw { pos: cursor, message: `Found string without closing quote.` };
+      }
+      tokens.push({ type: 3 /* STRING */, value: buffer, pos: cursor });
+      cursor = j;
+    }
+  }
+  function accumulateNumber() {
+    if (/[0-9]/.test(char)) {
+      let j = cursor, buffer = "";
+      while (/[0-9.oxe]/.test(expr[j]) && j < expr.length) {
+        buffer += expr[j];
+        j++;
+      }
+      const numVal = Number(buffer);
+      const isNan = Number.isNaN(numVal);
+      if (isNan) {
+        throw { pos: cursor, message: "Found invalid number literal." };
+      }
+      tokens.push({ type: 2 /* NUMBER */, value: `${numVal}`, pos: cursor });
+      cursor = j - 1;
+      char = expr[cursor];
+    }
+  }
+  function accumulateOperator() {
+    const op = `${char}${expr[cursor + 1]}`;
+    if (operators.has(op)) {
+      tokens.push({ type: 4 /* OPERATOR */, value: op, pos: cursor });
+      cursor++;
+      return;
+    }
+    if (operators.has(char)) {
+      tokens.push({ type: 4 /* OPERATOR */, value: char, pos: cursor });
+      return;
+    }
+  }
+  while (cursor < expr.length) {
+    char = expr[cursor];
+    accumulateNumber();
+    accumulateKeywordOrIdentifier();
+    accumulateStr();
+    accumulateOperator();
+    if (!/[a-zA-Z$_0-9\s\t\r\n'"`]/.test(char) && !operators.has(char) && !operators.has(expr[cursor - 1] + char)) {
+      throw {
+        message: `Unexpected token '${char}' in expression.`,
+        pos: cursor
+      };
+    }
+    cursor++;
+  }
+  return tokens;
+}
+
+// src/core/compile.ts
+function compile(src, config, meta) {
+  const scope = [];
+  const blockOpeningStack = [];
+  const {
+    delimiters,
+    keepOpeningTagEscapeDelimiter,
+    allowFnCalls,
+    allowedProps,
+    forbiddenProps,
+    autoEscape
+  } = config;
+  let trimNext = false, cursor = 0, body = `let acc="";`;
+  while (cursor < src.length) {
+    let isEscaped2 = function() {
+      let j = templateOpenTagIdx, count = 0;
+      while (j >= delimiters.openingTagEscape.length && src.slice(j - delimiters.openingTagEscape.length, j) === delimiters.openingTagEscape) {
+        count++;
+        j -= delimiters.openingTagEscape.length;
+      }
+      return count % 2 === 1;
+    };
+    var isEscaped = isEscaped2;
+    const templateOpenTagIdx = src.indexOf(delimiters.openingTag, cursor);
+    if (templateOpenTagIdx === -1) {
+      let lastChunk = src.slice(cursor);
+      if (trimNext) lastChunk = lastChunk.trimStart();
+      if (lastChunk) body += `acc+=\`${escapeRawText(lastChunk)}\`;`;
+      break;
+    }
+    if (isEscaped2()) {
+      let escapedChunk = src.slice(
+        cursor,
+        keepOpeningTagEscapeDelimiter ? templateOpenTagIdx + delimiters.openingTagEscape.length + 1 : templateOpenTagIdx - delimiters.openingTag.length + 1
+      );
+      if (trimNext) {
+        escapedChunk = escapedChunk.trimStart();
+        trimNext = false;
+      }
+      body += `acc+=\`${escapeRawText(escapedChunk)}\`;`;
+      if (!keepOpeningTagEscapeDelimiter)
+        body += `acc+=\`${delimiters.openingTag}\`;`;
+      cursor = templateOpenTagIdx + delimiters.openingTag.length;
+      continue;
+    }
+    const templateEndTagIdx = src.indexOf(
+      delimiters.closingTag,
+      templateOpenTagIdx
+    );
+    if (templateEndTagIdx === -1) {
+      const { line, lineIndex } = getLineAndColumnNumbers(
+        src,
+        templateOpenTagIdx
+      );
+      const { line: lineText, pos } = getLineSnapshot(
+        src,
+        lineIndex,
+        templateOpenTagIdx
+      );
+      throw new MutorCompilerError(
+        "No closing tag found.",
+        line,
+        lineText,
+        pos,
+        meta.path
+      );
+    }
+    const template = src.slice(
+      templateOpenTagIdx,
+      templateEndTagIdx + delimiters.closingTag.length
+    );
+    const {
+      inner,
+      leftTrim,
+      rightTrim,
+      isBlock,
+      isBlockEnd,
+      hasContext,
+      requiresBlockClose,
+      isComment
+    } = parse(template, { delimiters });
+    let rawText = src.slice(cursor, templateOpenTagIdx);
+    if (rawText) {
+      if (trimNext) {
+        rawText = rawText.trimStart();
+      }
+      if (leftTrim) {
+        rawText = rawText.trimEnd();
+      }
+      if (rawText) {
+        body += `acc+=\`${escapeRawText(rawText)}\`;`;
+      }
+    }
+    trimNext = false;
+    cursor = templateEndTagIdx + delimiters.closingTag.length;
+    try {
+      if (!isComment) {
+        const tokens = tokenize(inner);
+        const ast = generateAst(tokens, { allowFnCalls });
+        if (isBlock && requiresBlockClose && hasContext) {
+          scope.push(ast.variable);
+          blockOpeningStack.push({
+            type: 0 /* LOOP */,
+            pos: templateOpenTagIdx
+          });
+        } else if (isBlock && requiresBlockClose && !hasContext) {
+          blockOpeningStack.push({
+            type: 1 /* NON_LOOP */,
+            pos: templateOpenTagIdx
+          });
+        }
+        if (isBlockEnd) {
+          const lastBlockOpened = blockOpeningStack.pop();
+          if (lastBlockOpened?.type === 0 /* LOOP */) scope.pop();
+          if (lastBlockOpened === void 0)
+            throw {
+              message: "Unexpected end of block",
+              pos: templateOpenTagIdx
+            };
+        }
+        const js = build(ast, { allowedProps, forbiddenProps, scope });
+        if (isBlock || isBlockEnd) {
+          body += js;
+        } else {
+          body += autoEscape && !js.startsWith("namespaces.Mutor.include") ? `acc+=escapeFn(${js});` : `acc+=${js};`;
+        }
+      }
+      if (rightTrim) trimNext = true;
+    } catch (e) {
+      const { message, pos: relPos } = e;
+      const { line, lineIndex } = getLineAndColumnNumbers(
+        src,
+        templateOpenTagIdx
+      );
+      const { line: lineText, pos } = getLineSnapshot(
+        src,
+        lineIndex,
+        templateOpenTagIdx
+      );
+      throw new MutorCompilerError(
+        message,
+        line,
+        lineText,
+        pos + relPos + (leftTrim ? delimiters.openingTag.length + delimiters.whitespaceTrim.length : delimiters.openingTag.length),
+        meta.path
+      );
+    }
+  }
+  if (blockOpeningStack.length) {
+    const lastPos = blockOpeningStack.pop()?.pos;
+    const { line, lineIndex } = getLineAndColumnNumbers(src, lastPos);
+    const { line: lineText, pos } = getLineSnapshot(src, lineIndex, lastPos);
+    throw new MutorCompilerError(
+      "Unclosed block detected.",
+      line,
+      lineText,
+      pos + delimiters.openingTag.length,
+      meta.path
+    );
+  }
+  body += `return acc;`;
+  return new Function(
+    "ctx",
+    "namespaces",
+    "allowedProps",
+    "forbiddenProps",
+    "escapeFn",
+    "validateComputedProps",
+    body
+  );
+}
+
+// src/core/mutor.ts
+var Mutor = class {
+  constructor(config = {}) {
+    this.__currentRenderedPath = "";
+    this.__includeStack = /* @__PURE__ */ new Set();
+    this.__cacheSize = 0;
+    this.__config = { ...defaultConfig };
+    this.__compiledTemplatesMap = /* @__PURE__ */ new Map();
+    this.__currentContext = null;
+    this.__namespaces = {
+      ...namespaces,
+      Mutor: {
+        include: (path, ctx) => {
+          if (this.__includeStack.has(path)) {
+            throw new MutorError(
+              `Circular include detected:
+${Array.from(this.__includeStack).join("\n")}
+${path}`
+            );
+          }
+          try {
+            this.__includeStack.add(path);
+            return this.renderComponent(path, ctx ?? this.__currentContext);
+          } finally {
+            this.__includeStack.delete(path);
+          }
+        }
+      }
+    };
+    this.addConfig(config);
+    Object.defineProperty(this.__namespaces.Mutor, "$$context", {
+      get: () => {
+        return this.__currentContext;
+      }
+    });
+  }
+  addConfig(conf) {
+    const {
+      autoEscape,
+      delimiters: overrideDelimeters,
+      allowedProps,
+      forbiddenProps,
+      keepOpeningTagEscapeDelimiter,
+      allowFnCalls,
+      cache,
+      build: build2
+    } = conf;
+    this.__config = {
+      build: {
+        include: /* @__PURE__ */ new Set([...build2?.include || defaultConfig.build.include]),
+        exclude: /* @__PURE__ */ new Set([
+          ...defaultConfig.build.exclude,
+          ...build2?.exclude || []
+        ])
+      },
+      autoEscape: autoEscape === true ? true : autoEscape !== false,
+      allowedProps: allowedProps || defaultConfig.allowedProps,
+      allowFnCalls: !!allowFnCalls,
+      cache: { ...defaultConfig.cache, ...cache || {} },
+      forbiddenProps: /* @__PURE__ */ new Set([
+        ...defaultConfig.forbiddenProps,
+        ...forbiddenProps || []
+      ]),
+      keepOpeningTagEscapeDelimiter: keepOpeningTagEscapeDelimiter === true ? true : keepOpeningTagEscapeDelimiter !== false,
+      delimiters: {
+        ...defaultConfig.delimiters,
+        ...overrideDelimeters || {}
+      }
+    };
+    return this.__config;
+  }
+  restoreDefaultConfig() {
+    this.__config = { ...defaultConfig };
+  }
+  compile(template) {
+    return compile(template, this.__config, {
+      path: this.__currentRenderedPath || "anonymous"
+    });
+  }
+  render(template, context) {
+    const prevContext = this.__currentContext;
+    if (prevContext !== context) {
+      this.__currentContext = context;
+    }
+    const result = this.compile(template)(
+      validateContext(context),
+      this.__namespaces,
+      this.__config.allowedProps,
+      this.__config.forbiddenProps,
+      escapeFn,
+      validateComputedProp
+    );
+    this.__currentContext = prevContext;
+    return result;
+  }
+  renderComponent(identifier, context) {
+    if (!this.__compiledTemplatesMap.has(identifier)) {
+      throw new MutorError(
+        `No template exists with the identifier '${identifier}'`
+      );
+    }
+    const prevRenderComponentIdentifier = this.__currentRenderedPath;
+    const prevContext = this.__currentContext;
+    const compiled = this.__compiledTemplatesMap.get(identifier);
+    this.__currentContext = context;
+    this.__currentRenderedPath = identifier;
+    const result = compiled.fn(
+      validateContext(context),
+      this.__namespaces,
+      this.__config.allowedProps,
+      this.__config.forbiddenProps,
+      escapeFn,
+      validateComputedProp
+    );
+    this.__currentContext = prevContext;
+    this.__currentRenderedPath = prevRenderComponentIdentifier;
+    return result;
+  }
+  registerComponent(identifier, template) {
+    const templateSize = template.length * 2 + 500;
+    if (this.__cacheSize + templateSize > this.__config.cache.maxSize) {
+      if (!this.createEntrySpaceForTemplate(templateSize)) {
+        throw new MutorError(
+          `The template for the component '${identifier}' is too large. Consider increasing 'cache.maxSize' in the config`
+        );
+      }
+    }
+    this.__cacheSize += template.length * 2 + 500;
+    this.__compiledTemplatesMap.set(identifier, {
+      fn: this.compile(template),
+      size: templateSize
+    });
+  }
+  reset() {
+    this.__config = { ...defaultConfig };
+    this.__compiledTemplatesMap.clear();
+    this.__currentContext = null;
+    this.__cacheSize = 0;
+  }
+  createEntrySpaceForTemplate(targetSize) {
+    if (this.__cacheSize + targetSize < this.__config.cache.maxSize) {
+      return true;
+    }
+    if (targetSize > this.__config.cache.maxSize) {
+      return false;
+    }
+    const firstEntry = this.__compiledTemplatesMap.entries().next().value;
+    if (firstEntry) {
+      const [oldestKey, oldestData] = firstEntry;
+      this.__compiledTemplatesMap.delete(oldestKey);
+      this.__cacheSize -= oldestData.size;
+    }
+    return this.createEntrySpaceForTemplate(targetSize);
+  }
+  getDiagnostics() {
+    const maxSize = this.__config.cache.maxSize;
+    return {
+      bytesUsed: this.__cacheSize,
+      bytesMax: maxSize,
+      readableUsed: `${(this.__cacheSize / 1024 / 1024).toFixed(2)} MB`,
+      readableMax: `${(maxSize / 1024 / 1024).toFixed(2)} MB`,
+      totalEntries: this.__compiledTemplatesMap.size,
+      percentFull: maxSize > 0 ? Math.min(100, Math.round(this.__cacheSize / maxSize * 100)) : 0,
+      avgTemplateSize: this.__compiledTemplatesMap.size > 0 ? Math.round(this.__cacheSize / this.__compiledTemplatesMap.size) : 0
+    };
+  }
+};
+
+// src/core/mutor.server.ts
+var Mutor2 = class extends Mutor {
+  constructor(config = {}) {
+    super(config);
+    this.__namespaces.Mutor.include = (path, context) => {
+      const resolvedPath = toAbsolutePath(this.__currentRenderedPath, path);
+      if (this.__includeStack.has(resolvedPath)) {
+        throw new MutorError(
+          `Circular include detected:
+${Array.from(this.__includeStack).join("\n")}
+${resolvedPath}`
+        );
+      }
+      try {
+        this.__includeStack.add(resolvedPath);
+        return this.renderFile(resolvedPath, context ?? this.__currentContext);
+      } finally {
+        this.__includeStack.delete(resolvedPath);
+      }
+    };
+  }
+  renderFile(path, context) {
+    const absolutePath = toAbsolutePath(path);
+    let compiled;
+    const prevContext = this.__currentContext;
+    const prevRenderComponentIdentifier = this.__currentRenderedPath;
+    this.__currentContext = context;
+    this.__currentRenderedPath = path;
+    if (this.__config.cache.active && this.__compiledTemplatesMap.has(absolutePath)) {
+      compiled = this.__compiledTemplatesMap.get(absolutePath).fn;
+    } else {
+      const template = (0, import_node_fs.readFileSync)(absolutePath, "utf-8");
+      compiled = this.compile(template);
+      if (this.__config.cache.active) {
+        const templateSize = template.length * 2 + 500;
+        if (this.__cacheSize + templateSize > this.__config.cache.maxSize) {
+          if (this.createEntrySpaceForTemplate(templateSize)) {
+            this.__compiledTemplatesMap.set(absolutePath, {
+              fn: compiled,
+              size: templateSize
+            });
+            this.__cacheSize += templateSize;
+          }
+        } else {
+          this.__compiledTemplatesMap.set(absolutePath, {
+            fn: compiled,
+            size: templateSize
+          });
+          this.__cacheSize += templateSize;
+        }
+      }
+    }
+    const result = compiled(
+      validateContext(context),
+      this.__namespaces,
+      this.__config.allowedProps,
+      this.__config.forbiddenProps,
+      escapeFn,
+      validateComputedProp
+    );
+    this.__currentContext = prevContext;
+    this.__currentRenderedPath = prevRenderComponentIdentifier;
+    return result;
+  }
+  async buildDir(src, destination, context) {
+    const absoluteDestinationPath = toAbsolutePath(destination);
+    const absoluteSrcPath = toAbsolutePath(src);
+    await (0, import_promises.mkdir)(absoluteDestinationPath, { recursive: true });
+    const entries = await (0, import_promises.readdir)(absoluteSrcPath, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const srcPath = (0, import_node_path2.join)(absoluteSrcPath, entry.name);
+        const destinationPath = (0, import_node_path2.join)(absoluteDestinationPath, entry.name);
+        if (this.__config.build.exclude.has(entry.name)) {
+          return;
+        }
+        if (entry.isDirectory()) {
+          return this.buildDir(srcPath, destinationPath, context);
+        }
+        const extension = (0, import_node_path2.extname)(srcPath);
+        if (this.__config.build.include.has(extension)) {
+          const rendered = this.renderFile(srcPath, context);
+          await (0, import_promises.writeFile)(destinationPath, rendered, "utf-8");
+        } else {
+          return await (0, import_promises.copyFile)(srcPath, destinationPath);
+        }
+      })
+    );
+  }
+  async compileDir(src) {
+    const absolutePath = toAbsolutePath(src);
+    const entries = await (0, import_promises.readdir)(absolutePath, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const absoluteSrcPath = (0, import_node_path2.join)(absolutePath, entry.name);
+        if (this.__config.build.exclude.has(entry.name)) {
+          return;
+        }
+        if (entry.isDirectory()) {
+          return this.compileDir(absoluteSrcPath);
+        }
+        const extension = (0, import_node_path2.extname)(absoluteSrcPath);
+        if (this.__config.build.include.has(extension)) {
+          try {
+            const template = await (0, import_promises.readFile)(absoluteSrcPath, "utf-8");
+            this.registerComponent(absoluteSrcPath, template);
+          } catch {
+          }
+        }
+      })
+    );
+  }
+};
+
+// src/bin/cli-errors.ts
+var ExitCodes = {
+  Success: 0,
+  RuntimeError: 1,
+  ArgumentError: 2
+};
+var CliError = class extends Error {
+  constructor(message, exitCode = ExitCodes.RuntimeError) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
+var ArgumentError = class extends CliError {
+  constructor(message) {
+    super(message, ExitCodes.ArgumentError);
+    this.name = "ArgumentError";
+  }
+};
+var FileReadError = class extends CliError {
+  constructor(filePath, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(
+      `could not read file '${filePath}': ${reason}`,
+      ExitCodes.RuntimeError
+    );
+    this.name = "FileReadError";
+  }
+};
+var FileWriteError = class extends CliError {
+  constructor(filePath, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(
+      `could not write file '${filePath}': ${reason}`,
+      ExitCodes.RuntimeError
+    );
+    this.name = "FileWriteError";
+  }
+};
+var JsonParseError = class extends CliError {
+  constructor(filePath, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(
+      `failed to parse JSON in '${filePath}': ${reason}`,
+      ExitCodes.RuntimeError
+    );
+    this.name = "JsonParseError";
+  }
+};
+
+// src/bin/cli.ts
+var COMMANDS = /* @__PURE__ */ new Set(["compile", "build", "render"]);
+var OPTIONS = /* @__PURE__ */ new Set(["--out", "--data", "--config"]);
+var VERSION = `Mutor.js v${version}`;
+var USAGE = `
+Usage: mutor <command> <input> [options]
+
+Commands:
+  compile <template>   Compile a template file to its intermediate form
+  build   <dir>        Render all templates in a directory using a data source
+  render  <template>   Compile and immediately render a template
+
+Options:
+  --out     <path>     Output file or directory (defaults to stdout for compile/render)
+  --data    <path>     JSON data file to use as render context (required for build/render)
+  --config  <path>     JSON config file to pass to Mutor
+  --version            Print the version and exit
+  --help               Show this help message
+
+Exit codes:
+  0  success
+  1  runtime error  (I/O failure, render failure, etc.)
+  2  argument error (bad flags, missing or wrong-typed values)
+`.trim();
+function safeReadFile(filePath) {
+  try {
+    return (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+  } catch (err) {
+    throw new FileReadError(filePath, err);
+  }
+}
+function safeWriteFile(filePath, content) {
+  try {
+    (0, import_node_fs2.writeFileSync)(filePath, content, "utf-8");
+  } catch (err) {
+    throw new FileWriteError(filePath, err);
+  }
+}
+function safeParseJsonFile(filePath) {
+  const raw = safeReadFile(filePath);
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new JsonParseError(filePath, err);
+  }
+}
+function assertIsFile(filePath, flag) {
+  let stat;
+  try {
+    stat = (0, import_node_fs2.statSync)(filePath);
+  } catch {
+    throw new ArgumentError(`${flag} path '${filePath}' does not exist`);
+  }
+  if (!stat.isFile()) {
+    throw new ArgumentError(`${flag} path '${filePath}' is not a file`);
+  }
+}
+function assertIsDirectory(dirPath, flag) {
+  let stat;
+  try {
+    stat = (0, import_node_fs2.statSync)(dirPath);
+  } catch {
+    throw new ArgumentError(`${flag} path '${dirPath}' does not exist`);
+  }
+  if (!stat.isDirectory()) {
+    throw new ArgumentError(`${flag} path '${dirPath}' is not a directory`);
+  }
+}
+function assertExtension(filePath, flag, ...extensions) {
+  const matches = extensions.some((ext) => filePath.endsWith(ext));
+  if (!matches) {
+    throw new ArgumentError(
+      `${flag} expects a file with extension ${extensions.join(" or ")} \u2014 got '${filePath}'`
+    );
+  }
+}
+function parseArgs(rawArgs) {
+  if (rawArgs.length === 0 || rawArgs[0] === "--help") {
+    console.log(USAGE);
+    (0, import_node_process.exit)(ExitCodes.Success);
+  }
+  if (rawArgs[0] === "--version") {
+    console.log(VERSION);
+    (0, import_node_process.exit)(ExitCodes.Success);
+  }
+  const command = rawArgs[0];
+  if (!COMMANDS.has(command)) {
+    throw new ArgumentError(`unknown command '${command}'
+
+${USAGE}`);
+  }
+  const commandData = rawArgs[1];
+  if (!commandData || commandData.startsWith("--")) {
+    throw new ArgumentError(
+      `command '${command}' requires an input path as its first argument
+
+${USAGE}`
+    );
+  }
+  const struct = { command, commandData };
+  for (let i = 2; i < rawArgs.length; i++) {
+    const flag = rawArgs[i];
+    if (!OPTIONS.has(flag)) {
+      throw new ArgumentError(`unknown option '${flag}'
+
+${USAGE}`);
+    }
+    const value = rawArgs[i + 1];
+    if (!value || value.startsWith("--")) {
+      throw new ArgumentError(`option '${flag}' requires a value`);
+    }
+    struct[flag] = value;
+    i++;
+  }
+  return struct;
+}
+function handleCompileCommand(mutor, args) {
+  const inputPath = toAbsolutePath(args.commandData);
+  assertIsFile(inputPath, "<input>");
+  const template = safeReadFile(inputPath);
+  const compiled = mutor.compile(template);
+  const output = compiled.toString();
+  if (args["--out"]) {
+    const outPath = toAbsolutePath(args["--out"]);
+    registerCleanup(() => {
+      try {
+        (0, import_node_fs2.rmSync)(outPath, { force: true });
+      } catch {
+      }
+    });
+    safeWriteFile(outPath, output);
+    console.log(`Compiled \u2192 ${args["--out"]}`);
+  } else {
+    console.log(output);
+  }
+}
+async function handleBuildCommand(mutor, args) {
+  if (!args["--data"]) {
+    throw new ArgumentError("'build' requires a data source via --data");
+  }
+  if (!args["--out"]) {
+    throw new ArgumentError("'build' requires an output directory via --out");
+  }
+  const inputPath = toAbsolutePath(args.commandData);
+  const dataPath = toAbsolutePath(args["--data"]);
+  const outPath = toAbsolutePath(args["--out"]);
+  assertIsDirectory(inputPath, "<input>");
+  assertIsFile(dataPath, "--data");
+  assertExtension(dataPath, "--data", ".json");
+  const context = safeParseJsonFile(dataPath);
+  let buildStarted = false;
+  registerCleanup(() => {
+    if (buildStarted) {
+      console.warn("\nBuild interrupted \u2014 removing partial output...");
+      try {
+        (0, import_node_fs2.rmSync)(outPath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  });
+  buildStarted = true;
+  await mutor.buildDir(inputPath, outPath, context);
+  buildStarted = false;
+  console.log(`Built \u2192 ${args["--out"]}`);
+}
+async function handleRenderCommand(mutor, args) {
+  if (!args["--data"]) {
+    throw new ArgumentError("'render' requires a data source via --data");
+  }
+  const inputPath = toAbsolutePath(args.commandData);
+  const dataPath = toAbsolutePath(args["--data"]);
+  assertIsFile(inputPath, "<input>");
+  assertIsFile(dataPath, "--data");
+  assertExtension(dataPath, "--data", ".json");
+  const context = safeParseJsonFile(dataPath);
+  const template = safeReadFile(inputPath);
+  const output = mutor.render(template, context);
+  if (args["--out"]) {
+    const outPath = toAbsolutePath(args["--out"]);
+    registerCleanup(() => {
+      try {
+        (0, import_node_fs2.rmSync)(outPath, { force: true });
+      } catch {
+      }
+    });
+    safeWriteFile(outPath, output);
+    console.log(`Rendered \u2192 ${args["--out"]}`);
+  } else {
+    console.log(output);
+  }
+}
+var cleanupFn = null;
+function registerCleanup(fn) {
+  cleanupFn = fn;
+}
+function handleSignal(signal) {
+  console.warn(`
+Received ${signal}.`);
+  cleanupFn?.();
+  (0, import_node_process.exit)(ExitCodes.RuntimeError);
+}
+process.on("SIGINT", () => handleSignal("SIGINT"));
+process.on("SIGTERM", () => handleSignal("SIGTERM"));
+async function main() {
+  const args = parseArgs(import_node_process.argv.slice(2));
+  const mutor = new Mutor2();
+  if (args["--config"]) {
+    const configPath = toAbsolutePath(args["--config"]);
+    assertIsFile(configPath, "--config");
+    assertExtension(configPath, "--config", ".json");
+    const config = safeParseJsonFile(configPath);
+    mutor.addConfig(config);
+  }
+  switch (args.command) {
+    case "compile":
+      handleCompileCommand(mutor, args);
+      break;
+    case "build":
+      await handleBuildCommand(mutor, args);
+      break;
+    case "render":
+      await handleRenderCommand(mutor, args);
+      break;
+  }
+}
+main().catch((err) => {
+  if (err instanceof CliError) {
+    console.error(`error: ${err.message}`);
+    (0, import_node_process.exit)(err.exitCode);
+  }
+  console.error("unexpected error:", err);
+  (0, import_node_process.exit)(ExitCodes.RuntimeError);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleBuildCommand,
+  handleCompileCommand,
+  handleRenderCommand,
+  parseArgs,
+  safeParseJsonFile,
+  safeReadFile,
+  safeWriteFile
+});
+//# sourceMappingURL=cli.cjs.map