@doki-land/dejavu-engine 0.0.0

package/dist/index.js

@@ -0,0 +1,3465 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/ast.ts
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2["Program"] = "Program";
+  NodeType2["ExpressionStatement"] = "ExpressionStatement";
+  NodeType2["AssignmentStatement"] = "AssignmentStatement";
+  NodeType2["VariableDeclaration"] = "VariableDeclaration";
+  NodeType2["FunctionDeclaration"] = "FunctionDeclaration";
+  NodeType2["IfStatement"] = "IfStatement";
+  NodeType2["ElseIfClause"] = "ElseIfClause";
+  NodeType2["ForStatement"] = "ForStatement";
+  NodeType2["ForInStatement"] = "ForInStatement";
+  NodeType2["WhileStatement"] = "WhileStatement";
+  NodeType2["MatchStatement"] = "MatchStatement";
+  NodeType2["MatchCase"] = "MatchCase";
+  NodeType2["NamespaceDeclaration"] = "NamespaceDeclaration";
+  NodeType2["UsingDeclaration"] = "UsingDeclaration";
+  NodeType2["BlockStatement"] = "BlockStatement";
+  NodeType2["BreakStatement"] = "BreakStatement";
+  NodeType2["ContinueStatement"] = "ContinueStatement";
+  NodeType2["ExtendsStatement"] = "ExtendsStatement";
+  NodeType2["BlockDeclaration"] = "BlockDeclaration";
+  NodeType2["PrependStatement"] = "PrependStatement";
+  NodeType2["AppendStatement"] = "AppendStatement";
+  NodeType2["SuperExpression"] = "SuperExpression";
+  NodeType2["Identifier"] = "Identifier";
+  NodeType2["Literal"] = "Literal";
+  NodeType2["BinaryExpression"] = "BinaryExpression";
+  NodeType2["UnaryExpression"] = "UnaryExpression";
+  NodeType2["CallExpression"] = "CallExpression";
+  NodeType2["MemberExpression"] = "MemberExpression";
+  NodeType2["ArrayExpression"] = "ArrayExpression";
+  NodeType2["TupleExpression"] = "TupleExpression";
+  NodeType2["ObjectExpression"] = "ObjectExpression";
+  NodeType2["ObjectProperty"] = "ObjectProperty";
+  NodeType2["RangeExpression"] = "RangeExpression";
+  NodeType2["AsExpression"] = "AsExpression";
+  NodeType2["ArrayTypeAnnotation"] = "ArrayTypeAnnotation";
+  NodeType2["TupleTypeAnnotation"] = "TupleTypeAnnotation";
+  NodeType2["TypedParameter"] = "TypedParameter";
+  NodeType2["TemplateLiteral"] = "TemplateLiteral";
+  NodeType2["TemplateExpression"] = "TemplateExpression";
+  NodeType2["Comment"] = "Comment";
+  NodeType2["Text"] = "Text";
+  return NodeType2;
+})(NodeType || {});
+function createIdentifier(name, loc) {
+  return {
+    type: "Identifier" /* Identifier */,
+    name,
+    loc
+  };
+}
+function createLiteral(value, raw, loc) {
+  return {
+    type: "Literal" /* Literal */,
+    value,
+    raw,
+    loc
+  };
+}
+function createProgram(body, loc) {
+  return {
+    type: "Program" /* Program */,
+    body,
+    loc
+  };
+}
+function createExpressionStatement(expression, loc) {
+  return {
+    type: "ExpressionStatement" /* ExpressionStatement */,
+    expression,
+    loc
+  };
+}
+function createVariableDeclaration(name, init, typeAnnotation, loc) {
+  return {
+    type: "VariableDeclaration" /* VariableDeclaration */,
+    name,
+    typeAnnotation,
+    init,
+    loc
+  };
+}
+function createBlockStatement(body, loc) {
+  return {
+    type: "BlockStatement" /* BlockStatement */,
+    body,
+    loc
+  };
+}
+function createBreakStatement(loc) {
+  return {
+    type: "BreakStatement" /* BreakStatement */,
+    loc
+  };
+}
+function createContinueStatement(loc) {
+  return {
+    type: "ContinueStatement" /* ContinueStatement */,
+    loc
+  };
+}
+function createExtendsStatement(template, loc) {
+  return {
+    type: "ExtendsStatement" /* ExtendsStatement */,
+    template,
+    loc
+  };
+}
+function createBlockDeclaration(name, body, loc) {
+  return {
+    type: "BlockDeclaration" /* BlockDeclaration */,
+    name,
+    body,
+    loc
+  };
+}
+function createPrependStatement(name, body, loc) {
+  return {
+    type: "PrependStatement" /* PrependStatement */,
+    name,
+    body,
+    loc
+  };
+}
+function createAppendStatement(name, body, loc) {
+  return {
+    type: "AppendStatement" /* AppendStatement */,
+    name,
+    body,
+    loc
+  };
+}
+function createSuperExpression(loc) {
+  return {
+    type: "SuperExpression" /* SuperExpression */,
+    loc
+  };
+}
+function createBinaryExpression(operator, left, right, loc) {
+  return {
+    type: "BinaryExpression" /* BinaryExpression */,
+    operator,
+    left,
+    right,
+    loc
+  };
+}
+function createCallExpression(callee, args, loc) {
+  return {
+    type: "CallExpression" /* CallExpression */,
+    callee,
+    arguments: args,
+    loc
+  };
+}
+function createText(value, loc) {
+  return {
+    type: "Text" /* Text */,
+    value,
+    loc
+  };
+}
+function createTemplateExpression(content, loc) {
+  return {
+    type: "TemplateExpression" /* TemplateExpression */,
+    content,
+    loc
+  };
+}
+function createUnaryExpression(operator, argument, prefix, loc) {
+  return {
+    type: "UnaryExpression" /* UnaryExpression */,
+    operator,
+    argument,
+    prefix,
+    loc
+  };
+}
+function createMemberExpression(object, property, computed, loc) {
+  return {
+    type: "MemberExpression" /* MemberExpression */,
+    object,
+    property,
+    computed,
+    loc
+  };
+}
+function createArrayExpression(elements, loc) {
+  return {
+    type: "ArrayExpression" /* ArrayExpression */,
+    elements,
+    loc
+  };
+}
+function createTupleExpression(elements, loc) {
+  return {
+    type: "TupleExpression" /* TupleExpression */,
+    elements,
+    loc
+  };
+}
+function createObjectExpression(properties, loc) {
+  return {
+    type: "ObjectExpression" /* ObjectExpression */,
+    properties,
+    loc
+  };
+}
+function createObjectProperty(key, value, shorthand, loc) {
+  return {
+    type: "ObjectProperty" /* ObjectProperty */,
+    key,
+    value,
+    shorthand,
+    loc
+  };
+}
+function createIfStatement(test, consequent, elseIfs, alternate, loc) {
+  return {
+    type: "IfStatement" /* IfStatement */,
+    test,
+    consequent,
+    elseIfs,
+    alternate,
+    loc
+  };
+}
+function createElseIfClause(test, consequent, loc) {
+  return {
+    type: "ElseIfClause" /* ElseIfClause */,
+    test,
+    consequent,
+    loc
+  };
+}
+function createForStatement(init, test, update, body, loc) {
+  return {
+    type: "ForStatement" /* ForStatement */,
+    init,
+    test,
+    update,
+    body,
+    loc
+  };
+}
+function createWhileStatement(test, body, loc) {
+  return {
+    type: "WhileStatement" /* WhileStatement */,
+    test,
+    body,
+    loc
+  };
+}
+function createForInStatement(left, right, body, loc) {
+  return {
+    type: "ForInStatement" /* ForInStatement */,
+    left,
+    right,
+    body,
+    loc
+  };
+}
+function createMatchStatement(discriminant, cases, loc) {
+  return {
+    type: "MatchStatement" /* MatchStatement */,
+    discriminant,
+    cases,
+    loc
+  };
+}
+function createMatchCase(pattern, consequent, loc) {
+  return {
+    type: "MatchCase" /* MatchCase */,
+    pattern,
+    consequent,
+    loc
+  };
+}
+function createNamespaceDeclaration(name, loc) {
+  return {
+    type: "NamespaceDeclaration" /* NamespaceDeclaration */,
+    name,
+    loc
+  };
+}
+function createUsingDeclaration(modulePath, loc) {
+  return {
+    type: "UsingDeclaration" /* UsingDeclaration */,
+    modulePath,
+    loc
+  };
+}
+function createRangeExpression(start, end, loc) {
+  return {
+    type: "RangeExpression" /* RangeExpression */,
+    start,
+    end,
+    loc
+  };
+}
+function createAsExpression(expression, typeAnnotation, loc) {
+  return {
+    type: "AsExpression" /* AsExpression */,
+    expression,
+    typeAnnotation,
+    loc
+  };
+}
+function createArrayTypeAnnotation(elementType, size, loc) {
+  return {
+    type: "ArrayTypeAnnotation" /* ArrayTypeAnnotation */,
+    elementType,
+    size,
+    loc
+  };
+}
+function createTupleTypeAnnotation(elementTypes, loc) {
+  return {
+    type: "TupleTypeAnnotation" /* TupleTypeAnnotation */,
+    elementTypes,
+    loc
+  };
+}
+function createTypedParameter(name, typeAnnotation, loc) {
+  return {
+    type: "TypedParameter" /* TypedParameter */,
+    name,
+    typeAnnotation,
+    loc
+  };
+}
+function createFunctionDeclaration(name, params, body, loc) {
+  return {
+    type: "FunctionDeclaration" /* FunctionDeclaration */,
+    name,
+    params,
+    body,
+    loc
+  };
+}
+function createAssignmentStatement(left, right, loc) {
+  return {
+    type: "AssignmentStatement" /* AssignmentStatement */,
+    left,
+    right,
+    loc
+  };
+}
+function createComment(value, block, loc) {
+  return {
+    type: "Comment" /* Comment */,
+    value,
+    block,
+    loc
+  };
+}
+
+// src/renderer.ts
+var BreakException = class extends Error {
+  constructor() {
+    super("break");
+    this.name = "BreakException";
+  }
+};
+var ContinueException = class extends Error {
+  constructor() {
+    super("continue");
+    this.name = "ContinueException";
+  }
+};
+var DejavuRenderer = class {
+  /**
+   * 创建渲染上下文
+   * @param initialScope 初始作用域
+   * @returns 渲染上下文
+   */
+  createContext(initialScope = {}) {
+    return {
+      scope: { ...initialScope }
+    };
+  }
+  /**
+   * 查找变量
+   * @param context 渲染上下文
+   * @param name 变量名
+   * @returns 变量值
+   */
+  findVariable(context, name) {
+    if (context.scope.hasOwnProperty(name)) {
+      return context.scope[name];
+    }
+    if (context.parent) {
+      return this.findVariable(context.parent, name);
+    }
+    return void 0;
+  }
+  /**
+   * 设置变量
+   * @param context 渲染上下文
+   * @param name 变量名
+   * @param value 变量值
+   */
+  setVariable(context, name, value) {
+    context.scope[name] = value;
+  }
+  /**
+   * 执行二元运算
+   * @param left 左操作数
+   * @param operator 运算符
+   * @param right 右操作数
+   * @returns 运算结果
+   */
+  executeBinaryOperation(left, operator, right) {
+    switch (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 "===":
+        return left === right;
+      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 "&&":
+        return left && right;
+      case "||":
+        return left || right;
+      default:
+        throw new Error(`Unknown operator: ${operator}`);
+    }
+  }
+  /**
+   * 执行一元运算
+   * @param operator 运算符
+   * @param argument 操作数
+   * @returns 运算结果
+   */
+  executeUnaryOperation(operator, argument) {
+    switch (operator) {
+      case "!":
+        return !argument;
+      case "-":
+        return -argument;
+      case "+":
+        return +argument;
+      case "typeof":
+        return typeof argument;
+      case "void":
+        return void 0;
+      default:
+        throw new Error(`Unknown operator: ${operator}`);
+    }
+  }
+  /**
+   * 评估表达式
+   * @param node 表达式节点
+   * @param context 渲染上下文
+   * @returns 表达式结果
+   */
+  evaluateExpression(node, context) {
+    switch (node.type) {
+      case "Identifier" /* Identifier */:
+        return this.findVariable(context, node.name);
+      case "Literal" /* Literal */:
+        return node.value;
+      case "BinaryExpression" /* BinaryExpression */:
+        const binaryExpr = node;
+        const leftValue = this.evaluateExpression(binaryExpr.left, context);
+        const rightValue = this.evaluateExpression(binaryExpr.right, context);
+        return this.executeBinaryOperation(leftValue, binaryExpr.operator, rightValue);
+      case "UnaryExpression" /* UnaryExpression */:
+        const unaryExpr = node;
+        const argValue = this.evaluateExpression(unaryExpr.argument, context);
+        return this.executeUnaryOperation(unaryExpr.operator, argValue);
+      case "CallExpression" /* CallExpression */:
+        const callExpr = node;
+        const callee = this.evaluateExpression(callExpr.callee, context);
+        if (typeof callee !== "function") {
+          throw new Error("Callee is not a function");
+        }
+        const args = callExpr.arguments.map((arg) => this.evaluateExpression(arg, context));
+        return callee(...args);
+      case "MemberExpression" /* MemberExpression */:
+        const memberExpr = node;
+        const object = this.evaluateExpression(memberExpr.object, context);
+        const property = memberExpr.computed ? this.evaluateExpression(memberExpr.property, context) : memberExpr.property.name;
+        return object[property];
+      case "ArrayExpression" /* ArrayExpression */:
+        const arrayExpr = node;
+        return arrayExpr.elements.map((element) => this.evaluateExpression(element, context));
+      case "TupleExpression" /* TupleExpression */:
+        const tupleExpr = node;
+        return tupleExpr.elements.map((element) => this.evaluateExpression(element, context));
+      case "ObjectExpression" /* ObjectExpression */:
+        const objectExpr = node;
+        const obj = {};
+        objectExpr.properties.forEach((prop) => {
+          const key = prop.key.type === "Identifier" /* Identifier */ ? prop.key.name : prop.key.value;
+          const value = this.evaluateExpression(prop.value, context);
+          obj[key] = value;
+        });
+        return obj;
+      case "TemplateLiteral" /* TemplateLiteral */:
+        const templateLiteral = node;
+        let templateResult = "";
+        templateLiteral.quasis.forEach((quasi, index) => {
+          templateResult += quasi.value.cooked || quasi.value.raw;
+          if (index < templateLiteral.expressions.length) {
+            const exprValue = this.evaluateExpression(templateLiteral.expressions[index], context);
+            templateResult += String(exprValue);
+          }
+        });
+        return templateResult;
+      case "TemplateExpression" /* TemplateExpression */:
+        const templateExpr = node;
+        return templateExpr.content;
+      case "RangeExpression" /* RangeExpression */:
+        const rangeExpr = node;
+        const startValue = this.evaluateExpression(rangeExpr.start, context);
+        const endValue = this.evaluateExpression(rangeExpr.end, context);
+        const start = Math.floor(Number(startValue));
+        const end = Math.floor(Number(endValue));
+        const result = [];
+        if (start <= end) {
+          for (let i = start; i <= end; i++) {
+            result.push(i);
+          }
+        } else {
+          for (let i = start; i >= end; i--) {
+            result.push(i);
+          }
+        }
+        return result;
+      case "AsExpression" /* AsExpression */:
+        const asExpr = node;
+        const asValue = this.evaluateExpression(asExpr.expression, context);
+        return asValue;
+      case "SuperExpression" /* SuperExpression */:
+        return "";
+      default:
+        throw new Error(`Unknown expression type: ${node.type}`);
+    }
+  }
+  /**
+   * 渲染语句
+   * @param node 语句节点
+   * @param context 渲染上下文
+   * @returns 渲染结果
+   */
+  renderStatement(node, context) {
+    switch (node.type) {
+      case "ExpressionStatement" /* ExpressionStatement */:
+        const exprStmt = node;
+        const value = this.evaluateExpression(exprStmt.expression, context);
+        return String(value);
+      case "AssignmentStatement" /* AssignmentStatement */:
+        const assignStmt = node;
+        if (assignStmt.left.type === "Identifier" /* Identifier */) {
+          const name = assignStmt.left.name;
+          const value2 = this.evaluateExpression(assignStmt.right, context);
+          this.setVariable(context, name, value2);
+        }
+        return "";
+      case "VariableDeclaration" /* VariableDeclaration */:
+        const varDecl = node;
+        const varName = varDecl.name.name;
+        const initValue = varDecl.init ? this.evaluateExpression(varDecl.init, context) : void 0;
+        this.setVariable(context, varName, initValue);
+        return "";
+      case "FunctionDeclaration" /* FunctionDeclaration */:
+        const funcDecl = node;
+        const funcName = funcDecl.name.name;
+        const func = (...args) => {
+          const funcContext = {
+            scope: {},
+            parent: context
+          };
+          funcDecl.params.forEach((param, index) => {
+            funcContext.scope[param.name] = args[index];
+          });
+          return this.renderBlockStatement(funcDecl.body, funcContext);
+        };
+        this.setVariable(context, funcName, func);
+        return "";
+      case "IfStatement" /* IfStatement */:
+        const ifStmt = node;
+        const ifCondition = this.evaluateExpression(ifStmt.test, context);
+        if (ifCondition) {
+          return this.renderStatement(ifStmt.consequent, context);
+        } else if (ifStmt.elseIfs && ifStmt.elseIfs.length > 0) {
+          for (const elseIf of ifStmt.elseIfs) {
+            const elseIfCondition = this.evaluateExpression(elseIf.test, context);
+            if (elseIfCondition) {
+              return this.renderStatement(elseIf.consequent, context);
+            }
+          }
+        }
+        if (ifStmt.alternate) {
+          return this.renderStatement(ifStmt.alternate, context);
+        }
+        return "";
+      case "ForStatement" /* ForStatement */:
+        const forStmt = node;
+        let forResult = "";
+        if (forStmt.init) {
+          if (forStmt.init.type === "VariableDeclaration" /* VariableDeclaration */ || forStmt.init.type === "AssignmentStatement" /* AssignmentStatement */) {
+            this.renderStatement(forStmt.init, context);
+          } else {
+            this.evaluateExpression(forStmt.init, context);
+          }
+        }
+        try {
+          while (!forStmt.test || this.evaluateExpression(forStmt.test, context)) {
+            try {
+              forResult += this.renderStatement(forStmt.body, context);
+            } catch (e) {
+              if (e instanceof ContinueException) {
+              } else if (e instanceof BreakException) {
+                break;
+              } else {
+                throw e;
+              }
+            }
+            if (forStmt.update) {
+              this.evaluateExpression(forStmt.update, context);
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof BreakException)) {
+            throw e;
+          }
+        }
+        return forResult;
+      case "WhileStatement" /* WhileStatement */:
+        const whileStmt = node;
+        let whileResult = "";
+        try {
+          while (this.evaluateExpression(whileStmt.test, context)) {
+            try {
+              whileResult += this.renderStatement(whileStmt.body, context);
+            } catch (e) {
+              if (e instanceof ContinueException) {
+              } else if (e instanceof BreakException) {
+                break;
+              } else {
+                throw e;
+              }
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof BreakException)) {
+            throw e;
+          }
+        }
+        return whileResult;
+      case "ForInStatement" /* ForInStatement */:
+        const forInStmt = node;
+        let forInResult = "";
+        const iterable = this.evaluateExpression(forInStmt.right, context);
+        if (Array.isArray(iterable)) {
+          try {
+            for (let i = 0; i < iterable.length; i++) {
+              if (Array.isArray(forInStmt.left)) {
+                this.setVariable(context, forInStmt.left[0].name, i);
+                this.setVariable(context, forInStmt.left[1].name, iterable[i]);
+              } else {
+                this.setVariable(context, forInStmt.left.name, iterable[i]);
+              }
+              try {
+                forInResult += this.renderStatement(forInStmt.body, context);
+              } catch (e) {
+                if (e instanceof ContinueException) {
+                } else if (e instanceof BreakException) {
+                  break;
+                } else {
+                  throw e;
+                }
+              }
+            }
+          } catch (e) {
+            if (!(e instanceof BreakException)) {
+              throw e;
+            }
+          }
+        }
+        return forInResult;
+      case "MatchStatement" /* MatchStatement */:
+        const matchStmt = node;
+        const discriminantValue = this.evaluateExpression(matchStmt.discriminant, context);
+        for (const matchCase of matchStmt.cases) {
+          if (matchCase.pattern === null) {
+            return this.renderStatement(matchCase.consequent, context);
+          }
+          const patternValue = this.evaluateExpression(matchCase.pattern, context);
+          if (discriminantValue === patternValue) {
+            return this.renderStatement(matchCase.consequent, context);
+          }
+        }
+        return "";
+      case "NamespaceDeclaration" /* NamespaceDeclaration */:
+        return "";
+      case "UsingDeclaration" /* UsingDeclaration */:
+        return "";
+      case "BlockStatement" /* BlockStatement */:
+        return this.renderBlockStatement(node, context);
+      case "BreakStatement" /* BreakStatement */:
+        throw new BreakException();
+      case "ContinueStatement" /* ContinueStatement */:
+        throw new ContinueException();
+      case "ExtendsStatement" /* ExtendsStatement */:
+        return "";
+      case "BlockDeclaration" /* BlockDeclaration */:
+        const blockDecl = node;
+        return this.renderBlockStatement({ type: "BlockStatement" /* BlockStatement */, body: blockDecl.body }, context);
+      case "PrependStatement" /* PrependStatement */:
+        return "";
+      case "AppendStatement" /* AppendStatement */:
+        return "";
+      default:
+        throw new Error(`Unknown statement type: ${node.type}`);
+    }
+  }
+  /**
+   * 渲染块语句
+   * @param node 块语句节点
+   * @param context 渲染上下文
+   * @returns 渲染结果
+   */
+  renderBlockStatement(node, context) {
+    let result = "";
+    for (const item of node.body) {
+      if (item.type === "Comment" /* Comment */) {
+        const comment = item;
+        if (comment.isTemplateComment) {
+          continue;
+        }
+        result += comment.value;
+      } else {
+        const nodeType = item.type;
+        if (nodeType === "ExpressionStatement" /* ExpressionStatement */ || nodeType === "AssignmentStatement" /* AssignmentStatement */ || nodeType === "VariableDeclaration" /* VariableDeclaration */ || nodeType === "FunctionDeclaration" /* FunctionDeclaration */ || nodeType === "IfStatement" /* IfStatement */ || nodeType === "ForStatement" /* ForStatement */ || nodeType === "ForInStatement" /* ForInStatement */ || nodeType === "WhileStatement" /* WhileStatement */ || nodeType === "MatchStatement" /* MatchStatement */ || nodeType === "NamespaceDeclaration" /* NamespaceDeclaration */ || nodeType === "UsingDeclaration" /* UsingDeclaration */ || nodeType === "BlockStatement" /* BlockStatement */) {
+          result += this.renderStatement(item, context);
+        } else {
+          const value = this.evaluateExpression(item, context);
+          result += String(value);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 渲染程序
+   * @param node 程序节点
+   * @param context 渲染上下文
+   * @returns 渲染结果
+   */
+  renderProgram(node, context) {
+    let result = "";
+    for (const item of node.body) {
+      if (item.type === "Comment" /* Comment */) {
+        continue;
+      } else if (item.type === "Text" /* Text */) {
+        result += item.value;
+      } else {
+        const nodeType = item.type;
+        if (nodeType === "ExpressionStatement" /* ExpressionStatement */ || nodeType === "AssignmentStatement" /* AssignmentStatement */ || nodeType === "VariableDeclaration" /* VariableDeclaration */ || nodeType === "FunctionDeclaration" /* FunctionDeclaration */ || nodeType === "IfStatement" /* IfStatement */ || nodeType === "ForStatement" /* ForStatement */ || nodeType === "ForInStatement" /* ForInStatement */ || nodeType === "WhileStatement" /* WhileStatement */ || nodeType === "MatchStatement" /* MatchStatement */ || nodeType === "NamespaceDeclaration" /* NamespaceDeclaration */ || nodeType === "UsingDeclaration" /* UsingDeclaration */ || nodeType === "BlockStatement" /* BlockStatement */) {
+          result += this.renderStatement(item, context);
+        } else {
+          const value = this.evaluateExpression(item, context);
+          result += String(value);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 渲染 AST
+   * @param ast 抽象语法树
+   * @param initialScope 初始作用域
+   * @returns 渲染结果
+   */
+  render(ast, initialScope = {}) {
+    const context = this.createContext(initialScope);
+    return this.renderProgram(ast, context);
+  }
+};
+var renderer = new DejavuRenderer();
+
+// src/token.ts
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["DELIMITER_START"] = "DELIMITER_START";
+  TokenType2["DELIMITER_END"] = "DELIMITER_END";
+  TokenType2["COMMENT_START"] = "COMMENT_START";
+  TokenType2["COMMENT_END"] = "COMMENT_END";
+  TokenType2["LET"] = "LET";
+  TokenType2["MICRO"] = "MICRO";
+  TokenType2["NAMESPACE"] = "NAMESPACE";
+  TokenType2["USING"] = "USING";
+  TokenType2["IF"] = "IF";
+  TokenType2["ELSE"] = "ELSE";
+  TokenType2["LOOP"] = "LOOP";
+  TokenType2["IN"] = "IN";
+  TokenType2["BREAK"] = "BREAK";
+  TokenType2["CONTINUE"] = "CONTINUE";
+  TokenType2["MATCH"] = "MATCH";
+  TokenType2["CASE"] = "CASE";
+  TokenType2["END"] = "END";
+  TokenType2["AS"] = "AS";
+  TokenType2["EXTENDS"] = "EXTENDS";
+  TokenType2["BLOCK"] = "BLOCK";
+  TokenType2["PREPEND"] = "PREPEND";
+  TokenType2["APPEND"] = "APPEND";
+  TokenType2["SUPER"] = "SUPER";
+  TokenType2["IDENTIFIER"] = "IDENTIFIER";
+  TokenType2["BOOLEAN_LITERAL"] = "BOOLEAN_LITERAL";
+  TokenType2["NUMBER_LITERAL"] = "NUMBER_LITERAL";
+  TokenType2["CHARACTER_LITERAL"] = "CHARACTER_LITERAL";
+  TokenType2["STRING_LITERAL"] = "STRING_LITERAL";
+  TokenType2["RAW_IDENTIFIER"] = "RAW_IDENTIFIER";
+  TokenType2["ASSIGN"] = "ASSIGN";
+  TokenType2["PLUS"] = "PLUS";
+  TokenType2["MINUS"] = "MINUS";
+  TokenType2["MULTIPLY"] = "MULTIPLY";
+  TokenType2["DIVIDE"] = "DIVIDE";
+  TokenType2["MODULO"] = "MODULO";
+  TokenType2["LOGICAL_AND"] = "LOGICAL_AND";
+  TokenType2["LOGICAL_OR"] = "LOGICAL_OR";
+  TokenType2["LOGICAL_NOT"] = "LOGICAL_NOT";
+  TokenType2["EQUAL"] = "EQUAL";
+  TokenType2["NOT_EQUAL"] = "NOT_EQUAL";
+  TokenType2["LESS_THAN"] = "LESS_THAN";
+  TokenType2["GREATER_THAN"] = "GREATER_THAN";
+  TokenType2["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+  TokenType2["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+  TokenType2["LEFT_PAREN"] = "LEFT_PAREN";
+  TokenType2["RIGHT_PAREN"] = "RIGHT_PAREN";
+  TokenType2["LEFT_BRACKET"] = "LEFT_BRACKET";
+  TokenType2["RIGHT_BRACKET"] = "RIGHT_BRACKET";
+  TokenType2["LEFT_BRACE"] = "LEFT_BRACE";
+  TokenType2["RIGHT_BRACE"] = "RIGHT_BRACE";
+  TokenType2["SEMICOLON"] = "SEMICOLON";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["DOT"] = "DOT";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["DOUBLE_COLON"] = "DOUBLE_COLON";
+  TokenType2["RANGE"] = "RANGE";
+  TokenType2["TEXT"] = "TEXT";
+  TokenType2["COMMENT"] = "COMMENT";
+  TokenType2["EOF"] = "EOF";
+  return TokenType2;
+})(TokenType || {});
+function createToken(type, value, startLine, startColumn, endLine, endColumn) {
+  return {
+    type,
+    value,
+    loc: {
+      start: {
+        line: startLine,
+        column: startColumn
+      },
+      end: {
+        line: endLine,
+        column: endColumn
+      }
+    }
+  };
+}
+
+// src/language.ts
+var SyntaxMode = /* @__PURE__ */ ((SyntaxMode2) => {
+  SyntaxMode2["Programming"] = "Programming";
+  SyntaxMode2["Template"] = "Template";
+  return SyntaxMode2;
+})(SyntaxMode || {});
+var DEFAULT_TEMPLATE_CONFIG = {
+  codeStart: "<%",
+  codeEnd: "%>",
+  commentStart: "<#",
+  commentEnd: "#>",
+  supportFilterPipe: false,
+  legacyFor: false
+};
+var DejavuLanguage = class {
+  /**
+   * 创建新的 DejaVu 语言配置
+   */
+  constructor() {
+    /** 语法模式 */
+    __publicField(this, "syntaxMode", "Template" /* Template */);
+    /** 模板配置 */
+    __publicField(this, "template", { ...DEFAULT_TEMPLATE_CONFIG });
+  }
+  /**
+   * 设置语法模式
+   * @param mode 语法模式
+   * @returns 当前实例
+   */
+  withMode(mode) {
+    this.syntaxMode = mode;
+    return this;
+  }
+  /**
+   * 设置模板配置
+   * @param template 模板配置
+   * @returns 当前实例
+   */
+  withTemplate(template) {
+    this.template = { ...this.template, ...template };
+    return this;
+  }
+};
+var language = new DejavuLanguage();
+
+// src/lexer.ts
+var Lexer = class {
+  /**
+   * 构造函数
+   * @param source 模板源代码
+   * @param language 语言配置
+   */
+  constructor(source, language2) {
+    /** 模板源代码 */
+    __publicField(this, "source");
+    /** 当前位置 */
+    __publicField(this, "position");
+    /** 当前行号 */
+    __publicField(this, "line");
+    /** 当前列号 */
+    __publicField(this, "column");
+    /** 定界符配置 */
+    __publicField(this, "delimiters");
+    /** 是否在模板表达式内部 */
+    __publicField(this, "inTemplateExpression");
+    this.source = source;
+    this.position = 0;
+    this.line = 1;
+    this.column = 1;
+    this.inTemplateExpression = false;
+    const lang = language2 || language;
+    this.delimiters = {
+      interpolate: [lang.template.codeStart, lang.template.codeEnd],
+      comment: [lang.template.commentStart, lang.template.commentEnd]
+    };
+  }
+  /**
+   * 查看下一个词法单元（不前进）
+   * @returns 词法单元
+   */
+  peekToken() {
+    const savedPosition = this.position;
+    const savedLine = this.line;
+    const savedColumn = this.column;
+    const savedInTemplateExpression = this.inTemplateExpression;
+    const token = this.nextToken();
+    this.position = savedPosition;
+    this.line = savedLine;
+    this.column = savedColumn;
+    this.inTemplateExpression = savedInTemplateExpression;
+    return token;
+  }
+  /**
+   * 获取下一个词法单元
+   * @returns 词法单元
+   */
+  nextToken() {
+    if (!this.inTemplateExpression) {
+      this.skipWhitespace();
+    } else {
+      this.skipWhitespaceInTemplate();
+    }
+    if (this.position >= this.source.length) {
+      return this.createToken("EOF" /* EOF */, "", this.line, this.column, this.line, this.column);
+    }
+    const commentToken = this.checkComment();
+    if (commentToken) {
+      return commentToken;
+    }
+    const delimiterToken = this.checkDelimiters();
+    if (delimiterToken) {
+      return delimiterToken;
+    }
+    if (!this.inTemplateExpression) {
+      const textToken = this.checkText();
+      if (textToken) {
+        return textToken;
+      }
+    }
+    const identifierToken = this.checkIdentifier();
+    if (identifierToken) {
+      return identifierToken;
+    }
+    const literalToken = this.checkLiteral();
+    if (literalToken) {
+      return literalToken;
+    }
+    const operatorToken = this.checkOperator();
+    if (operatorToken) {
+      return operatorToken;
+    }
+    const char = this.source[this.position];
+    const token = this.createToken("TEXT" /* TEXT */, char, this.line, this.column, this.line, this.column + 1);
+    this.position++;
+    this.column++;
+    return token;
+  }
+  /**
+   * 跳过空白字符
+   */
+  skipWhitespace() {
+    while (this.position < this.source.length) {
+      const char = this.source[this.position];
+      if (char === " " || char === "	" || char === "\r") {
+        this.position++;
+        this.column++;
+      } else if (char === "\n") {
+        this.position++;
+        this.line++;
+        this.column = 1;
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * 跳过模板表达式内的空白字符（保留换行符信息）
+   */
+  skipWhitespaceInTemplate() {
+    while (this.position < this.source.length) {
+      const char = this.source[this.position];
+      if (char === " " || char === "	" || char === "\r") {
+        this.position++;
+        this.column++;
+      } else if (char === "\n") {
+        this.position++;
+        this.line++;
+        this.column = 1;
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * 检查定界符
+   * @returns 词法单元，如果不是定界符则返回null
+   */
+  checkDelimiters() {
+    if (this.source.startsWith(this.delimiters.interpolate[0], this.position)) {
+      const startLine = this.line;
+      const startColumn = this.column;
+      const length = this.delimiters.interpolate[0].length;
+      this.position += length;
+      this.column += length;
+      this.inTemplateExpression = true;
+      return this.createToken(
+        "DELIMITER_START" /* DELIMITER_START */,
+        this.delimiters.interpolate[0],
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    if (this.source.startsWith(this.delimiters.interpolate[1], this.position)) {
+      const startLine = this.line;
+      const startColumn = this.column;
+      const length = this.delimiters.interpolate[1].length;
+      this.position += length;
+      this.column += length;
+      this.inTemplateExpression = false;
+      return this.createToken(
+        "DELIMITER_END" /* DELIMITER_END */,
+        this.delimiters.interpolate[1],
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    if (this.source.startsWith(this.delimiters.comment[0], this.position)) {
+      const startLine = this.line;
+      const startColumn = this.column;
+      const length = this.delimiters.comment[0].length;
+      this.position += length;
+      this.column += length;
+      return this.createToken(
+        "COMMENT_START" /* COMMENT_START */,
+        this.delimiters.comment[0],
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    if (this.source.startsWith(this.delimiters.comment[1], this.position)) {
+      const startLine = this.line;
+      const startColumn = this.column;
+      const length = this.delimiters.comment[1].length;
+      this.position += length;
+      this.column += length;
+      return this.createToken(
+        "COMMENT_END" /* COMMENT_END */,
+        this.delimiters.comment[1],
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    return null;
+  }
+  /**
+   * 检查注释
+   * @returns 词法单元，如果不是注释则返回null
+   */
+  checkComment() {
+    if (!this.source.startsWith(this.delimiters.comment[0], this.position)) {
+      return null;
+    }
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    const endPos = this.source.indexOf(this.delimiters.comment[1], startPos + this.delimiters.comment[0].length);
+    if (endPos === -1) {
+      return null;
+    }
+    const commentContent = this.source.substring(startPos + this.delimiters.comment[0].length, endPos);
+    const endLine = this.line + (commentContent.match(/\n/g) || []).length;
+    const lastNewlineIndex = commentContent.lastIndexOf("\n");
+    const endColumn = lastNewlineIndex === -1 ? startColumn + commentContent.length + this.delimiters.comment[0].length : commentContent.length - lastNewlineIndex;
+    this.position = endPos + this.delimiters.comment[1].length;
+    this.line = endLine;
+    this.column = endColumn + this.delimiters.comment[1].length;
+    return this.createToken(
+      "COMMENT" /* COMMENT */,
+      commentContent,
+      startLine,
+      startColumn,
+      endLine,
+      endColumn
+    );
+  }
+  /**
+   * 检查标识符和关键字
+   * @returns 词法单元，如果不是标识符或关键字则返回null
+   */
+  checkIdentifier() {
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    if (!this.isIdentifierStart(this.source[this.position])) {
+      return null;
+    }
+    this.position++;
+    this.column++;
+    while (this.position < this.source.length && this.isIdentifierPart(this.source[this.position])) {
+      this.position++;
+      this.column++;
+    }
+    const identifier = this.source.substring(startPos, this.position);
+    const keywordToken = this.checkKeyword(identifier, startLine, startColumn);
+    if (keywordToken) {
+      return keywordToken;
+    }
+    if (identifier === "true" || identifier === "false") {
+      return this.createToken(
+        "BOOLEAN_LITERAL" /* BOOLEAN_LITERAL */,
+        identifier,
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    return this.createToken(
+      "IDENTIFIER" /* IDENTIFIER */,
+      identifier,
+      startLine,
+      startColumn,
+      this.line,
+      this.column
+    );
+  }
+  /**
+   * 检查是否为标识符的开始字符
+   * @param char 字符
+   * @returns 是否为标识符的开始字符
+   */
+  isIdentifierStart(char) {
+    return /^[a-zA-Z_]$/.test(char);
+  }
+  /**
+   * 检查是否为标识符的组成字符
+   * @param char 字符
+   * @returns 是否为标识符的组成字符
+   */
+  isIdentifierPart(char) {
+    return /^[a-zA-Z0-9_]$/.test(char);
+  }
+  /**
+   * 检查是否为关键字
+   * @param identifier 标识符
+   * @param startLine 开始行号
+   * @param startColumn 开始列号
+   * @returns 词法单元，如果不是关键字则返回null
+   */
+  checkKeyword(identifier, startLine, startColumn) {
+    switch (identifier) {
+      case "let":
+        return this.createToken("LET" /* LET */, identifier, startLine, startColumn, this.line, this.column);
+      case "micro":
+        return this.createToken("MICRO" /* MICRO */, identifier, startLine, startColumn, this.line, this.column);
+      case "namespace":
+        return this.createToken("NAMESPACE" /* NAMESPACE */, identifier, startLine, startColumn, this.line, this.column);
+      case "using":
+        return this.createToken("USING" /* USING */, identifier, startLine, startColumn, this.line, this.column);
+      case "if":
+        return this.createToken("IF" /* IF */, identifier, startLine, startColumn, this.line, this.column);
+      case "else":
+        return this.createToken("ELSE" /* ELSE */, identifier, startLine, startColumn, this.line, this.column);
+      case "loop":
+        return this.createToken("LOOP" /* LOOP */, identifier, startLine, startColumn, this.line, this.column);
+      case "in":
+        return this.createToken("IN" /* IN */, identifier, startLine, startColumn, this.line, this.column);
+      case "break":
+        return this.createToken("BREAK" /* BREAK */, identifier, startLine, startColumn, this.line, this.column);
+      case "continue":
+        return this.createToken("CONTINUE" /* CONTINUE */, identifier, startLine, startColumn, this.line, this.column);
+      case "match":
+        return this.createToken("MATCH" /* MATCH */, identifier, startLine, startColumn, this.line, this.column);
+      case "case":
+        return this.createToken("CASE" /* CASE */, identifier, startLine, startColumn, this.line, this.column);
+      case "end":
+        return this.createToken("END" /* END */, identifier, startLine, startColumn, this.line, this.column);
+      case "as":
+        return this.createToken("AS" /* AS */, identifier, startLine, startColumn, this.line, this.column);
+      case "extends":
+        return this.createToken("EXTENDS" /* EXTENDS */, identifier, startLine, startColumn, this.line, this.column);
+      case "block":
+        return this.createToken("BLOCK" /* BLOCK */, identifier, startLine, startColumn, this.line, this.column);
+      case "prepend":
+        return this.createToken("PREPEND" /* PREPEND */, identifier, startLine, startColumn, this.line, this.column);
+      case "append":
+        return this.createToken("APPEND" /* APPEND */, identifier, startLine, startColumn, this.line, this.column);
+      case "super":
+        return this.createToken("SUPER" /* SUPER */, identifier, startLine, startColumn, this.line, this.column);
+      default:
+        return null;
+    }
+  }
+  /**
+   * 检查字面量
+   * @returns 词法单元，如果不是字面量则返回null
+   */
+  checkLiteral() {
+    const numberToken = this.checkNumberLiteral();
+    if (numberToken) {
+      return numberToken;
+    }
+    const charToken = this.checkCharacterLiteral();
+    if (charToken) {
+      return charToken;
+    }
+    const stringToken = this.checkStringLiteral();
+    if (stringToken) {
+      return stringToken;
+    }
+    const rawIdentifierToken = this.checkRawIdentifier();
+    if (rawIdentifierToken) {
+      return rawIdentifierToken;
+    }
+    return null;
+  }
+  /**
+   * 检查数字字面量
+   * @returns 词法单元，如果不是数字字面量则返回null
+   */
+  checkNumberLiteral() {
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    if (!this.isDigit(this.source[this.position])) {
+      return null;
+    }
+    this.position++;
+    this.column++;
+    while (this.position < this.source.length && this.isDigit(this.source[this.position])) {
+      this.position++;
+      this.column++;
+    }
+    if (this.position < this.source.length && this.source[this.position] === ".") {
+      this.position++;
+      this.column++;
+      if (this.position < this.source.length && this.isDigit(this.source[this.position])) {
+        while (this.position < this.source.length && this.isDigit(this.source[this.position])) {
+          this.position++;
+          this.column++;
+        }
+      } else {
+        this.position--;
+        this.column--;
+      }
+    }
+    const number = this.source.substring(startPos, this.position);
+    return this.createToken(
+      "NUMBER_LITERAL" /* NUMBER_LITERAL */,
+      number,
+      startLine,
+      startColumn,
+      this.line,
+      this.column
+    );
+  }
+  /**
+   * 检查字符是否为数字
+   * @param char 字符
+   * @returns 是否为数字
+   */
+  isDigit(char) {
+    return /^[0-9]$/.test(char);
+  }
+  /**
+   * 检查字符字面量
+   * @returns 词法单元，如果不是字符字面量则返回null
+   */
+  checkCharacterLiteral() {
+    if (this.position >= this.source.length || this.source[this.position] !== "'") {
+      return null;
+    }
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.position++;
+    this.column++;
+    let charContent = "";
+    while (this.position < this.source.length && this.source[this.position] !== "'") {
+      if (this.source[this.position] === "\\") {
+        this.position++;
+        this.column++;
+        if (this.position < this.source.length) {
+          charContent += this.source[this.position];
+          this.position++;
+          this.column++;
+        }
+      } else {
+        charContent += this.source[this.position];
+        this.position++;
+        this.column++;
+      }
+    }
+    if (this.position < this.source.length && this.source[this.position] === "'") {
+      this.position++;
+      this.column++;
+      return this.createToken(
+        "CHARACTER_LITERAL" /* CHARACTER_LITERAL */,
+        charContent,
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    this.position = startPos;
+    this.line = startLine;
+    this.column = startColumn;
+    return null;
+  }
+  /**
+   * 检查字符串字面量
+   * @returns 词法单元，如果不是字符串字面量则返回null
+   */
+  checkStringLiteral() {
+    if (this.position >= this.source.length || this.source[this.position] !== '"') {
+      return null;
+    }
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.position++;
+    this.column++;
+    let stringContent = "";
+    while (this.position < this.source.length && this.source[this.position] !== '"') {
+      if (this.source[this.position] === "\\") {
+        this.position++;
+        this.column++;
+        if (this.position < this.source.length) {
+          stringContent += this.source[this.position];
+          this.position++;
+          this.column++;
+        }
+      } else {
+        stringContent += this.source[this.position];
+        this.position++;
+        this.column++;
+      }
+    }
+    if (this.position < this.source.length && this.source[this.position] === '"') {
+      this.position++;
+      this.column++;
+      return this.createToken(
+        "STRING_LITERAL" /* STRING_LITERAL */,
+        stringContent,
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    this.position = startPos;
+    this.line = startLine;
+    this.column = startColumn;
+    return null;
+  }
+  /**
+   * 检查原始标识符字面量
+   * @returns 词法单元，如果不是原始标识符字面量则返回null
+   */
+  checkRawIdentifier() {
+    if (this.position >= this.source.length || this.source[this.position] !== "`") {
+      return null;
+    }
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.position++;
+    this.column++;
+    let rawContent = "";
+    while (this.position < this.source.length && this.source[this.position] !== "`") {
+      rawContent += this.source[this.position];
+      this.position++;
+      this.column++;
+    }
+    if (this.position < this.source.length && this.source[this.position] === "`") {
+      this.position++;
+      this.column++;
+      return this.createToken(
+        "RAW_IDENTIFIER" /* RAW_IDENTIFIER */,
+        rawContent,
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    this.position = startPos;
+    this.line = startLine;
+    this.column = startColumn;
+    return null;
+  }
+  /**
+   * 检查运算符和标点符号
+   * @returns 词法单元，如果不是运算符或标点符号则返回null
+   */
+  checkOperator() {
+    const startLine = this.line;
+    const startColumn = this.column;
+    if (this.position + 1 < this.source.length) {
+      const twoChar = this.source.substring(this.position, this.position + 2);
+      switch (twoChar) {
+        case "&&":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("LOGICAL_AND" /* LOGICAL_AND */, twoChar, startLine, startColumn, this.line, this.column);
+        case "||":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("LOGICAL_OR" /* LOGICAL_OR */, twoChar, startLine, startColumn, this.line, this.column);
+        case "==":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("EQUAL" /* EQUAL */, twoChar, startLine, startColumn, this.line, this.column);
+        case "!=":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("NOT_EQUAL" /* NOT_EQUAL */, twoChar, startLine, startColumn, this.line, this.column);
+        case "<=":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("LESS_THAN_OR_EQUAL" /* LESS_THAN_OR_EQUAL */, twoChar, startLine, startColumn, this.line, this.column);
+        case ">=":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("GREATER_THAN_OR_EQUAL" /* GREATER_THAN_OR_EQUAL */, twoChar, startLine, startColumn, this.line, this.column);
+        case "..":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("RANGE" /* RANGE */, twoChar, startLine, startColumn, this.line, this.column);
+        case "::":
+          this.position += 2;
+          this.column += 2;
+          return this.createToken("DOUBLE_COLON" /* DOUBLE_COLON */, twoChar, startLine, startColumn, this.line, this.column);
+      }
+    }
+    if (this.position < this.source.length) {
+      const char = this.source[this.position];
+      switch (char) {
+        case "=":
+          this.position++;
+          this.column++;
+          return this.createToken("ASSIGN" /* ASSIGN */, char, startLine, startColumn, this.line, this.column);
+        case "+":
+          this.position++;
+          this.column++;
+          return this.createToken("PLUS" /* PLUS */, char, startLine, startColumn, this.line, this.column);
+        case "-":
+          this.position++;
+          this.column++;
+          return this.createToken("MINUS" /* MINUS */, char, startLine, startColumn, this.line, this.column);
+        case "*":
+          this.position++;
+          this.column++;
+          return this.createToken("MULTIPLY" /* MULTIPLY */, char, startLine, startColumn, this.line, this.column);
+        case "/":
+          this.position++;
+          this.column++;
+          return this.createToken("DIVIDE" /* DIVIDE */, char, startLine, startColumn, this.line, this.column);
+        case "%":
+          this.position++;
+          this.column++;
+          return this.createToken("MODULO" /* MODULO */, char, startLine, startColumn, this.line, this.column);
+        case "!":
+          this.position++;
+          this.column++;
+          return this.createToken("LOGICAL_NOT" /* LOGICAL_NOT */, char, startLine, startColumn, this.line, this.column);
+        case "<":
+          this.position++;
+          this.column++;
+          return this.createToken("LESS_THAN" /* LESS_THAN */, char, startLine, startColumn, this.line, this.column);
+        case ">":
+          this.position++;
+          this.column++;
+          return this.createToken("GREATER_THAN" /* GREATER_THAN */, char, startLine, startColumn, this.line, this.column);
+        case "(":
+          this.position++;
+          this.column++;
+          return this.createToken("LEFT_PAREN" /* LEFT_PAREN */, char, startLine, startColumn, this.line, this.column);
+        case ")":
+          this.position++;
+          this.column++;
+          return this.createToken("RIGHT_PAREN" /* RIGHT_PAREN */, char, startLine, startColumn, this.line, this.column);
+        case "[":
+          this.position++;
+          this.column++;
+          return this.createToken("LEFT_BRACKET" /* LEFT_BRACKET */, char, startLine, startColumn, this.line, this.column);
+        case "]":
+          this.position++;
+          this.column++;
+          return this.createToken("RIGHT_BRACKET" /* RIGHT_BRACKET */, char, startLine, startColumn, this.line, this.column);
+        case "{":
+          this.position++;
+          this.column++;
+          return this.createToken("LEFT_BRACE" /* LEFT_BRACE */, char, startLine, startColumn, this.line, this.column);
+        case "}":
+          this.position++;
+          this.column++;
+          return this.createToken("RIGHT_BRACE" /* RIGHT_BRACE */, char, startLine, startColumn, this.line, this.column);
+        case ";":
+          this.position++;
+          this.column++;
+          return this.createToken("SEMICOLON" /* SEMICOLON */, char, startLine, startColumn, this.line, this.column);
+        case ",":
+          this.position++;
+          this.column++;
+          return this.createToken("COMMA" /* COMMA */, char, startLine, startColumn, this.line, this.column);
+        case ".":
+          this.position++;
+          this.column++;
+          return this.createToken("DOT" /* DOT */, char, startLine, startColumn, this.line, this.column);
+        case ":":
+          this.position++;
+          this.column++;
+          return this.createToken("COLON" /* COLON */, char, startLine, startColumn, this.line, this.column);
+      }
+    }
+    return null;
+  }
+  /**
+   * 检查文本
+   * @returns 词法单元，如果不是文本则返回null
+   */
+  checkText() {
+    const startPos = this.position;
+    const startLine = this.line;
+    const startColumn = this.column;
+    while (this.position < this.source.length) {
+      if (this.source.startsWith(this.delimiters.interpolate[0], this.position) || this.source.startsWith(this.delimiters.comment[0], this.position) || this.source.startsWith(this.delimiters.interpolate[1], this.position) || this.source.startsWith(this.delimiters.comment[1], this.position)) {
+        break;
+      }
+      if (this.source[this.position] === "\n") {
+        this.position++;
+        this.line++;
+        this.column = 1;
+      } else {
+        this.position++;
+        this.column++;
+      }
+    }
+    if (this.position > startPos) {
+      const text = this.source.substring(startPos, this.position);
+      return this.createToken(
+        "TEXT" /* TEXT */,
+        text,
+        startLine,
+        startColumn,
+        this.line,
+        this.column
+      );
+    }
+    return null;
+  }
+  /**
+   * 创建词法单元
+   * @param type 词法单元类型
+   * @param value 词法单元值
+   * @param startLine 开始行号
+   * @param startColumn 开始列号
+   * @param endLine 结束行号
+   * @param endColumn 结束列号
+   * @returns 词法单元
+   */
+  createToken(type, value, startLine, startColumn, endLine, endColumn) {
+    return createToken(type, value, startLine, startColumn, endLine, endColumn);
+  }
+};
+function createLexer(source, language2) {
+  return new Lexer(source, language2);
+}
+
+// src/error-types.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["E001_UNEXPECTED_TOKEN"] = "E001";
+  ErrorCode2["E002_EXPECTED_TOKEN"] = "E002";
+  ErrorCode2["E003_UNCLOSED_STRING"] = "E003";
+  ErrorCode2["E004_UNCLOSED_COMMENT"] = "E004";
+  ErrorCode2["E005_UNCLOSED_DELIMITER"] = "E005";
+  ErrorCode2["E006_INVALID_IDENTIFIER"] = "E006";
+  ErrorCode2["E007_INVALID_NUMBER"] = "E007";
+  ErrorCode2["E008_INVALID_EXPRESSION"] = "E008";
+  ErrorCode2["E009_MISSING_END"] = "E009";
+  ErrorCode2["E010_UNDEFINED_VARIABLE"] = "E010";
+  ErrorCode2["E011_UNDEFINED_FUNCTION"] = "E011";
+  ErrorCode2["E012_TEMPLATE_NOT_FOUND"] = "E012";
+  ErrorCode2["E013_INVALID_ASSIGNMENT"] = "E013";
+  ErrorCode2["E014_INVALID_OPERATOR"] = "E014";
+  ErrorCode2["E015_MISSING_OPERATOR"] = "E015";
+  ErrorCode2["E016_INVALID_TYPE"] = "E016";
+  ErrorCode2["E017_CIRCULAR_REFERENCE"] = "E017";
+  ErrorCode2["E100_IO_ERROR"] = "E100";
+  ErrorCode2["E101_CONFIG_ERROR"] = "E101";
+  ErrorCode2["E102_FILE_NOT_FOUND"] = "E102";
+  return ErrorCode2;
+})(ErrorCode || {});
+var ParseError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    __publicField(this, "structured");
+    this.name = "ParseError";
+    this.structured = error;
+  }
+  /**
+   * 格式化为用户友好的字符串
+   */
+  toString() {
+    return formatError(this.structured);
+  }
+};
+var RuntimeError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    __publicField(this, "structured");
+    this.name = "RuntimeError";
+    this.structured = error;
+  }
+  toString() {
+    return formatError(this.structured);
+  }
+};
+var ConfigError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    __publicField(this, "structured");
+    this.name = "ConfigError";
+    this.structured = error;
+  }
+  toString() {
+    return formatError(this.structured);
+  }
+};
+var ErrorMessages = {
+  ["E001" /* E001_UNEXPECTED_TOKEN */]: {
+    title: "\u610F\u5916\u7684\u6807\u8BB0",
+    template: "\u610F\u5916\u7684\u6807\u8BB0 {token}\uFF0C\u671F\u671B {expected}",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u6B64\u5904\u662F\u5426\u6709\u8BED\u6CD5\u9519\u8BEF" },
+      { message: "\u786E\u8BA4\u662F\u5426\u9057\u6F0F\u4E86\u5FC5\u8981\u7684\u7B26\u53F7" }
+    ]
+  },
+  ["E002" /* E002_EXPECTED_TOKEN */]: {
+    title: "\u7F3A\u5C11\u6807\u8BB0",
+    template: "\u671F\u671B {expected}\uFF0C\u4F46\u53D1\u73B0 {found}",
+    defaultSuggestions: [
+      { message: "\u6DFB\u52A0\u7F3A\u5C11\u7684\u6807\u8BB0 {expected}" },
+      { message: "\u68C0\u67E5\u8BED\u6CD5\u662F\u5426\u6B63\u786E" }
+    ]
+  },
+  ["E003" /* E003_UNCLOSED_STRING */]: {
+    title: "\u672A\u95ED\u5408\u7684\u5B57\u7B26\u4E32",
+    template: "\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u672A\u95ED\u5408\uFF0C\u7F3A\u5C11\u7ED3\u675F\u5F15\u53F7",
+    defaultSuggestions: [
+      { message: '\u6DFB\u52A0\u7ED3\u675F\u5F15\u53F7 " \u6765\u95ED\u5408\u5B57\u7B26\u4E32' },
+      { message: "\u68C0\u67E5\u5B57\u7B26\u4E32\u4E2D\u662F\u5426\u6709\u672A\u8F6C\u4E49\u7684\u5F15\u53F7" },
+      { message: '\u5982\u9700\u5728\u5B57\u7B26\u4E32\u4E2D\u4F7F\u7528\u5F15\u53F7\uFF0C\u8BF7\u4F7F\u7528 \\" \u8FDB\u884C\u8F6C\u4E49' }
+    ]
+  },
+  ["E004" /* E004_UNCLOSED_COMMENT */]: {
+    title: "\u672A\u95ED\u5408\u7684\u6CE8\u91CA",
+    template: "\u6CE8\u91CA\u672A\u95ED\u5408\uFF0C\u7F3A\u5C11\u7ED3\u675F\u6807\u8BB0 {end}",
+    defaultSuggestions: [
+      { message: "\u6DFB\u52A0\u7ED3\u675F\u6807\u8BB0 {end} \u6765\u95ED\u5408\u6CE8\u91CA" },
+      { message: "\u68C0\u67E5\u6CE8\u91CA\u7684\u5F00\u59CB\u548C\u7ED3\u675F\u6807\u8BB0\u662F\u5426\u5339\u914D" }
+    ]
+  },
+  ["E005" /* E005_UNCLOSED_DELIMITER */]: {
+    title: "\u672A\u95ED\u5408\u7684\u5B9A\u754C\u7B26",
+    template: "\u6A21\u677F\u5B9A\u754C\u7B26\u672A\u95ED\u5408\uFF0C\u7F3A\u5C11\u7ED3\u675F\u6807\u8BB0 {end}",
+    defaultSuggestions: [
+      { message: "\u6DFB\u52A0\u7ED3\u675F\u6807\u8BB0 {end} \u6765\u95ED\u5408\u6A21\u677F\u4EE3\u7801\u5757" },
+      { message: "\u68C0\u67E5\u6A21\u677F\u8BED\u6CD5\u662F\u5426\u6B63\u786E" }
+    ]
+  },
+  ["E006" /* E006_INVALID_IDENTIFIER */]: {
+    title: "\u65E0\u6548\u7684\u6807\u8BC6\u7B26",
+    template: "\u65E0\u6548\u7684\u6807\u8BC6\u7B26 {identifier}",
+    defaultSuggestions: [
+      { message: "\u6807\u8BC6\u7B26\u5FC5\u987B\u4EE5\u5B57\u6BCD\u6216\u4E0B\u5212\u7EBF\u5F00\u5934" },
+      { message: "\u6807\u8BC6\u7B26\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E0B\u5212\u7EBF" },
+      { message: "\u68C0\u67E5\u662F\u5426\u8BEF\u7528\u4E86\u5173\u952E\u5B57\u4F5C\u4E3A\u6807\u8BC6\u7B26" }
+    ]
+  },
+  ["E007" /* E007_INVALID_NUMBER */]: {
+    title: "\u65E0\u6548\u7684\u6570\u5B57",
+    template: "\u65E0\u6548\u7684\u6570\u5B57\u5B57\u9762\u91CF {value}",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u6570\u5B57\u683C\u5F0F\u662F\u5426\u6B63\u786E" },
+      { message: "\u786E\u4FDD\u5C0F\u6570\u70B9\u540E\u6709\u6570\u5B57" }
+    ]
+  },
+  ["E008" /* E008_INVALID_EXPRESSION */]: {
+    title: "\u65E0\u6548\u7684\u8868\u8FBE\u5F0F",
+    template: "\u65E0\u6548\u7684\u8868\u8FBE\u5F0F: {detail}",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u8868\u8FBE\u5F0F\u8BED\u6CD5\u662F\u5426\u6B63\u786E" },
+      { message: "\u786E\u8BA4\u8FD0\u7B97\u7B26\u4F7F\u7528\u662F\u5426\u6B63\u786E" },
+      { message: "\u68C0\u67E5\u62EC\u53F7\u662F\u5426\u5339\u914D" }
+    ]
+  },
+  ["E009" /* E009_MISSING_END */]: {
+    title: "\u7F3A\u5C11\u7ED3\u675F\u8BED\u53E5",
+    template: "{construct} \u8BED\u53E5\u7F3A\u5C11\u5BF9\u5E94\u7684 end {construct}",
+    defaultSuggestions: [
+      { message: "\u6DFB\u52A0 end {construct} \u6765\u95ED\u5408\u8BED\u53E5\u5757" },
+      { message: "\u68C0\u67E5\u8BED\u53E5\u5757\u7684\u5D4C\u5957\u662F\u5426\u6B63\u786E" }
+    ]
+  },
+  ["E010" /* E010_UNDEFINED_VARIABLE */]: {
+    title: "\u672A\u5B9A\u4E49\u7684\u53D8\u91CF",
+    template: "\u53D8\u91CF {name} \u672A\u5B9A\u4E49",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u53D8\u91CF\u540D\u662F\u5426\u62FC\u5199\u6B63\u786E" },
+      { message: "\u786E\u4FDD\u53D8\u91CF\u5728\u4F7F\u7528\u524D\u5DF2\u58F0\u660E" },
+      { message: "\u4F7F\u7528 let \u5173\u952E\u5B57\u58F0\u660E\u53D8\u91CF: let {name} = value" }
+    ]
+  },
+  ["E011" /* E011_UNDEFINED_FUNCTION */]: {
+    title: "\u672A\u5B9A\u4E49\u7684\u51FD\u6570",
+    template: "\u51FD\u6570 {name} \u672A\u5B9A\u4E49",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u51FD\u6570\u540D\u662F\u5426\u62FC\u5199\u6B63\u786E" },
+      { message: "\u786E\u4FDD\u51FD\u6570\u5DF2\u5B9A\u4E49" },
+      { message: "\u4F7F\u7528 micro \u5173\u952E\u5B57\u5B9A\u4E49\u51FD\u6570" }
+    ]
+  },
+  ["E012" /* E012_TEMPLATE_NOT_FOUND */]: {
+    title: "\u6A21\u677F\u672A\u627E\u5230",
+    template: "\u6A21\u677F {name} \u672A\u627E\u5230",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u6A21\u677F\u540D\u79F0\u662F\u5426\u6B63\u786E" },
+      { message: "\u786E\u4FDD\u6A21\u677F\u6587\u4EF6\u5B58\u5728" },
+      { message: "\u68C0\u67E5\u6A21\u677F\u76EE\u5F55\u914D\u7F6E\u662F\u5426\u6B63\u786E" }
+    ]
+  },
+  ["E013" /* E013_INVALID_ASSIGNMENT */]: {
+    title: "\u65E0\u6548\u7684\u8D4B\u503C",
+    template: "\u65E0\u6CD5\u5BF9\u8868\u8FBE\u5F0F\u8FDB\u884C\u8D4B\u503C",
+    defaultSuggestions: [
+      { message: "\u53EA\u80FD\u5BF9\u53D8\u91CF\u8FDB\u884C\u8D4B\u503C" },
+      { message: "\u68C0\u67E5\u5DE6\u4FA7\u662F\u5426\u4E3A\u6709\u6548\u7684\u53D8\u91CF\u540D" }
+    ]
+  },
+  ["E014" /* E014_INVALID_OPERATOR */]: {
+    title: "\u65E0\u6548\u7684\u8FD0\u7B97\u7B26",
+    template: "\u8FD0\u7B97\u7B26 {operator} \u5728\u6B64\u4E0A\u4E0B\u6587\u4E2D\u65E0\u6548",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u8FD0\u7B97\u7B26\u4F7F\u7528\u662F\u5426\u6B63\u786E" },
+      { message: "\u786E\u8BA4\u64CD\u4F5C\u6570\u7C7B\u578B\u662F\u5426\u5339\u914D" }
+    ]
+  },
+  ["E015" /* E015_MISSING_OPERATOR */]: {
+    title: "\u7F3A\u5C11\u8FD0\u7B97\u7B26",
+    template: "\u8868\u8FBE\u5F0F\u7F3A\u5C11\u8FD0\u7B97\u7B26",
+    defaultSuggestions: [
+      { message: "\u5728\u4E24\u4E2A\u8868\u8FBE\u5F0F\u4E4B\u95F4\u6DFB\u52A0\u8FD0\u7B97\u7B26" },
+      { message: "\u68C0\u67E5\u662F\u5426\u9057\u6F0F\u4E86\u9017\u53F7\u5206\u9694\u7B26" }
+    ]
+  },
+  ["E016" /* E016_INVALID_TYPE */]: {
+    title: "\u7C7B\u578B\u9519\u8BEF",
+    template: "\u7C7B\u578B\u4E0D\u5339\u914D: {detail}",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u503C\u7684\u7C7B\u578B\u662F\u5426\u6B63\u786E" },
+      { message: "\u4F7F\u7528\u7C7B\u578B\u8F6C\u6362\u51FD\u6570\u8FDB\u884C\u8F6C\u6362" }
+    ]
+  },
+  ["E017" /* E017_CIRCULAR_REFERENCE */]: {
+    title: "\u5FAA\u73AF\u5F15\u7528",
+    template: "\u68C0\u6D4B\u5230\u5FAA\u73AF\u5F15\u7528: {chain}",
+    defaultSuggestions: [
+      { message: "\u79FB\u9664\u5FAA\u73AF\u4F9D\u8D56" },
+      { message: "\u68C0\u67E5\u6A21\u677F\u7EE7\u627F\u94FE\u662F\u5426\u5B58\u5728\u5FAA\u73AF" }
+    ]
+  },
+  ["E100" /* E100_IO_ERROR */]: {
+    title: "IO \u9519\u8BEF",
+    template: "\u6587\u4EF6\u64CD\u4F5C\u5931\u8D25: {detail}",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u6587\u4EF6\u6743\u9650" },
+      { message: "\u786E\u4FDD\u78C1\u76D8\u7A7A\u95F4\u5145\u8DB3" }
+    ]
+  },
+  ["E101" /* E101_CONFIG_ERROR */]: {
+    title: "\u914D\u7F6E\u9519\u8BEF",
+    template: "\u914D\u7F6E\u6587\u4EF6\u9519\u8BEF: {detail}",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u662F\u5426\u6B63\u786E" },
+      { message: "\u786E\u4FDD\u6240\u6709\u5FC5\u9700\u7684\u914D\u7F6E\u9879\u90FD\u5DF2\u8BBE\u7F6E" }
+    ]
+  },
+  ["E102" /* E102_FILE_NOT_FOUND */]: {
+    title: "\u6587\u4EF6\u672A\u627E\u5230",
+    template: "\u6587\u4EF6 {path} \u4E0D\u5B58\u5728",
+    defaultSuggestions: [
+      { message: "\u68C0\u67E5\u6587\u4EF6\u8DEF\u5F84\u662F\u5426\u6B63\u786E" },
+      { message: "\u786E\u4FDD\u6587\u4EF6\u5B58\u5728" }
+    ]
+  }
+};
+function createError(code, params = {}, options = {}) {
+  const template = ErrorMessages[code];
+  let message = template.template;
+  for (const [key, value] of Object.entries(params)) {
+    message = message.replace(`{${key}}`, value);
+  }
+  let suggestions = options.suggestions || [];
+  if (suggestions.length === 0 && template.defaultSuggestions) {
+    suggestions = template.defaultSuggestions.map((s) => ({
+      message: s.message.replace(/\{(\w+)\}/g, (_, key) => params[key] || `{${key}}`)
+    }));
+  }
+  return {
+    code,
+    severity: options.severity || "error",
+    title: template.title,
+    message,
+    range: options.range,
+    filePath: options.filePath,
+    sourceLine: options.sourceLine,
+    suggestions,
+    documentationUrl: options.documentationUrl
+  };
+}
+function formatError(error) {
+  const lines = [];
+  const severityIcon = {
+    error: "\u2717",
+    warning: "\u26A0",
+    hint: "\u2139"
+  };
+  const severityLabel = {
+    error: "\u9519\u8BEF",
+    warning: "\u8B66\u544A",
+    hint: "\u63D0\u793A"
+  };
+  lines.push(`${severityIcon[error.severity]} ${severityLabel[error.severity]} [${error.code}]: ${error.title}`);
+  lines.push(`  ${error.message}`);
+  if (error.filePath) {
+    let location = error.filePath;
+    if (error.range) {
+      location += `:${error.range.start.line}:${error.range.start.column}`;
+    }
+    lines.push(`  \u4F4D\u7F6E: ${location}`);
+  }
+  if (error.sourceLine && error.range) {
+    lines.push("");
+    lines.push(`  ${error.range.start.line.toString().padStart(4)} | ${error.sourceLine}`);
+    const pointer = " ".repeat(error.range.start.column - 1) + "^".repeat(Math.max(1, error.range.end.column - error.range.start.column));
+    lines.push(`      | ${pointer}`);
+  }
+  if (error.suggestions.length > 0) {
+    lines.push("");
+    lines.push("  \u5EFA\u8BAE:");
+    for (const suggestion of error.suggestions) {
+      lines.push(`    \u2022 ${suggestion.message}`);
+      if (suggestion.replacement) {
+        lines.push(`      \u66FF\u6362\u4E3A: ${suggestion.replacement}`);
+      }
+    }
+  }
+  if (error.documentationUrl) {
+    lines.push("");
+    lines.push(`  \u6587\u6863: ${error.documentationUrl}`);
+  }
+  return lines.join("\n");
+}
+function unexpectedTokenError(found, expected, range, sourceLine) {
+  return createError("E001" /* E001_UNEXPECTED_TOKEN */, { token: found, expected }, {
+    range,
+    sourceLine,
+    suggestions: [
+      { message: `\u68C0\u67E5\u6B64\u5904\u662F\u5426\u6709\u8BED\u6CD5\u9519\u8BEF\uFF0C\u671F\u671B ${expected}` }
+    ]
+  });
+}
+function missingEndError(construct, range, sourceLine) {
+  return createError("E009" /* E009_MISSING_END */, { construct }, {
+    range,
+    sourceLine,
+    suggestions: [
+      { message: `\u6DFB\u52A0 end ${construct} \u6765\u95ED\u5408\u6B64\u8BED\u53E5` }
+    ]
+  });
+}
+function undefinedVariableError(name, range, sourceLine) {
+  return createError("E010" /* E010_UNDEFINED_VARIABLE */, { name }, {
+    range,
+    sourceLine,
+    suggestions: [
+      { message: `\u68C0\u67E5\u53D8\u91CF\u540D\u662F\u5426\u62FC\u5199\u6B63\u786E` },
+      { message: `\u786E\u4FDD\u53D8\u91CF\u5728\u4F7F\u7528\u524D\u5DF2\u5B9A\u4E49` }
+    ]
+  });
+}
+function templateNotFoundError(name) {
+  return createError("E012" /* E012_TEMPLATE_NOT_FOUND */, { name }, {
+    suggestions: [
+      { message: `\u68C0\u67E5\u6A21\u677F\u540D\u79F0\u662F\u5426\u6B63\u786E` },
+      { message: `\u786E\u4FDD\u6A21\u677F\u5DF2\u6CE8\u518C` }
+    ]
+  });
+}
+function fileNotFoundError(path) {
+  return createError("E102" /* E102_FILE_NOT_FOUND */, { path }, {
+    suggestions: [
+      { message: `\u68C0\u67E5\u6587\u4EF6\u8DEF\u5F84\u662F\u5426\u6B63\u786E` },
+      { message: `\u786E\u4FDD\u6587\u4EF6\u5B58\u5728` }
+    ]
+  });
+}
+function configError(detail, suggestions) {
+  return createError("E101" /* E101_CONFIG_ERROR */, { detail }, {
+    suggestions: suggestions || [{ message: "\u68C0\u67E5\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u662F\u5426\u6B63\u786E" }]
+  });
+}
+
+// src/parser.ts
+var Parser = class {
+  /**
+   * 构造函数
+   * @param source 模板源代码
+   * @param language 语言配置
+   * @param filePath 文件路径（可选，用于错误报告）
+   */
+  constructor(source, language2, filePath) {
+    /** 词法分析器 */
+    __publicField(this, "lexer");
+    /** 当前词法单元 */
+    __publicField(this, "currentToken");
+    /** token 缓存（用于回溯） */
+    __publicField(this, "tokenBuffer", []);
+    /** 缓存索引（用于回溯） */
+    __publicField(this, "bufferIndex", -1);
+    /** 是否在模板模式 */
+    __publicField(this, "inTemplateMode");
+    /** 源代码 */
+    __publicField(this, "source");
+    /** 文件路径（用于错误报告） */
+    __publicField(this, "filePath");
+    const lang = language2 || language;
+    this.source = source;
+    this.filePath = filePath;
+    this.lexer = createLexer(source, lang);
+    this.currentToken = this.lexer.nextToken();
+    this.inTemplateMode = true;
+  }
+  /**
+   * 埥看下一个 token（不前进）
+   * @returns 下一个 token
+   */
+  peekToken() {
+    return this.lexer.nextToken();
+  }
+  /**
+   * 停止查看并前进
+   */
+  advance() {
+    if (this.bufferIndex >= 0 && this.bufferIndex < this.tokenBuffer.length - 1) {
+      this.currentToken = this.tokenBuffer[++this.bufferIndex];
+    } else {
+      this.tokenBuffer.push(this.currentToken);
+      this.bufferIndex = this.tokenBuffer.length - 1;
+      this.currentToken = this.lexer.nextToken();
+    }
+  }
+  /**
+   * 查看下一个 token（不前进）
+   * @returns 下一个 token
+   */
+  peekNextToken() {
+    return this.lexer.peekToken();
+  }
+  /**
+   * 开始缓存 token
+   */
+  startBuffering() {
+    this.tokenBuffer = [];
+    this.bufferIndex = -1;
+  }
+  /**
+   * 回退到上一个 token
+   */
+  backtrack() {
+    if (this.tokenBuffer.length > 0) {
+      this.currentToken = this.tokenBuffer[0];
+      this.bufferIndex = 0;
+    }
+  }
+  /**
+   * 解析模板，生成AST
+   * @returns 程序节点
+   */
+  parse() {
+    const body = [];
+    while (!this.isToken("EOF" /* EOF */)) {
+      if (this.isToken("TEXT" /* TEXT */)) {
+        body.push(this.parseText());
+      } else if (this.isToken("COMMENT" /* COMMENT */)) {
+        body.push(this.parseComment());
+      } else if (this.isToken("DELIMITER_START" /* DELIMITER_START */)) {
+        const node = this.parseTemplateExpression();
+        if (node !== null) {
+          body.push(node);
+        }
+      } else if (this.isToken("END" /* END */) || this.isToken("ELSE" /* ELSE */) || this.isToken("CASE" /* CASE */)) {
+        break;
+      } else {
+        break;
+      }
+    }
+    return createProgram(body);
+  }
+  /**
+   * 解析文本节点
+   * @returns 文本节点
+   */
+  parseText() {
+    const token = this.currentToken;
+    this.advance();
+    return createText(token.value, token.loc);
+  }
+  /**
+   * 解析注释节点
+   * @returns 注释节点
+   */
+  parseComment() {
+    const token = this.currentToken;
+    this.advance();
+    return createComment(token.value, true, token.loc);
+  }
+  /**
+   * 解析模板表达式
+   * @returns 语句或表达式节点，如果遇到结束标记则返回null
+   */
+  parseTemplateExpression() {
+    this.advance();
+    if (this.isToken("END" /* END */) || this.isToken("ELSE" /* ELSE */) || this.isToken("CASE" /* CASE */)) {
+      return null;
+    }
+    const statement = this.parseTemplateStatement();
+    if (statement === null) {
+      return null;
+    }
+    if (this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+      this.advance();
+    }
+    return statement;
+  }
+  /**
+   * 解析模板内的语句
+   * @returns 语句或表达式节点
+   */
+  parseTemplateStatement() {
+    const type = this.currentToken.type;
+    switch (type) {
+      case "END" /* END */:
+      case "ELSE" /* ELSE */:
+      case "CASE" /* CASE */:
+        return null;
+      case "LET" /* LET */:
+        return this.parseVariableDeclaration();
+      case "MICRO" /* MICRO */:
+        return this.parseMicroDeclaration();
+      case "NAMESPACE" /* NAMESPACE */:
+        return this.parseNamespaceDeclaration();
+      case "USING" /* USING */:
+        return this.parseUsingDeclaration();
+      case "IF" /* IF */:
+        return this.parseTemplateIfStatement();
+      case "LOOP" /* LOOP */:
+        return this.parseTemplateLoopStatement();
+      case "MATCH" /* MATCH */:
+        return this.parseTemplateMatchStatement();
+      case "BREAK" /* BREAK */:
+        return this.parseBreakStatement();
+      case "CONTINUE" /* CONTINUE */:
+        return this.parseContinueStatement();
+      case "EXTENDS" /* EXTENDS */:
+        return this.parseExtendsStatement();
+      case "BLOCK" /* BLOCK */:
+        return this.parseBlockDeclaration();
+      case "PREPEND" /* PREPEND */:
+        return this.parsePrependStatement();
+      case "APPEND" /* APPEND */:
+        return this.parseAppendStatement();
+      case "IDENTIFIER" /* IDENTIFIER */:
+        return this.parseTemplateExpressionOrAssignment();
+      case "NUMBER_LITERAL" /* NUMBER_LITERAL */:
+      case "STRING_LITERAL" /* STRING_LITERAL */:
+      case "BOOLEAN_LITERAL" /* BOOLEAN_LITERAL */:
+      case "CHARACTER_LITERAL" /* CHARACTER_LITERAL */:
+      case "LEFT_PAREN" /* LEFT_PAREN */:
+      case "LEFT_BRACKET" /* LEFT_BRACKET */:
+      case "LEFT_BRACE" /* LEFT_BRACE */:
+        return this.parseExpressionStatement();
+      case "DELIMITER_END" /* DELIMITER_END */:
+        return null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * 解析模板内的表达式或赋值语句
+   * @returns 表达式或赋值语句节点，如果遇到结束标记则返回null
+   */
+  parseTemplateExpressionOrAssignment() {
+    if (this.isToken("END" /* END */) || this.isToken("ELSE" /* ELSE */) || this.isToken("CASE" /* CASE */) || this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+      return null;
+    }
+    const startLoc = this.currentToken.loc;
+    const left = this.parseExpression();
+    if (this.isToken("ASSIGN" /* ASSIGN */)) {
+      this.advance();
+      const right = this.parseExpression();
+      this.consumeOptionalSemicolon();
+      return createAssignmentStatement(left, right, this.createLoc(startLoc));
+    }
+    this.consumeOptionalSemicolon();
+    return createExpressionStatement(left, this.createLoc(startLoc));
+  }
+  /**
+   * 解析模板内的if语句（支持else if和end if）
+   * @returns if语句节点
+   */
+  parseTemplateIfStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const test = this.parseExpression();
+    const consequent = this.parseTemplateBlock(["else", "end"]);
+    const elseIfs = [];
+    let alternate;
+    while (true) {
+      if (this.isToken("ELSE" /* ELSE */)) {
+        this.advance();
+        if (this.isToken("IF" /* IF */)) {
+          this.advance();
+          const elseIfTest = this.parseExpression();
+          const elseIfConsequent = this.parseTemplateBlock(["else", "end"]);
+          elseIfs.push(createElseIfClause(elseIfTest, elseIfConsequent));
+        } else {
+          alternate = this.parseTemplateBlock(["end"]);
+          break;
+        }
+      } else if (this.isToken("END" /* END */)) {
+        this.advance();
+        if (this.isToken("IF" /* IF */)) {
+          this.advance();
+        }
+        break;
+      } else if (this.isToken("DELIMITER_START" /* DELIMITER_START */)) {
+        this.advance();
+        if (this.isToken("ELSE" /* ELSE */)) {
+          this.advance();
+          if (this.isToken("IF" /* IF */)) {
+            this.advance();
+            const elseIfTest = this.parseExpression();
+            const elseIfConsequent = this.parseTemplateBlock(["else", "end"]);
+            elseIfs.push(createElseIfClause(elseIfTest, elseIfConsequent));
+          } else {
+            alternate = this.parseTemplateBlock(["end"]);
+            break;
+          }
+        } else if (this.isToken("END" /* END */)) {
+          this.advance();
+          if (this.isToken("IF" /* IF */)) {
+            this.advance();
+          }
+          break;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    if (this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+      this.advance();
+    }
+    return createIfStatement(test, consequent, elseIfs.length > 0 ? elseIfs : void 0, alternate, this.createLoc(startLoc));
+  }
+  /**
+   * 解析模板内的循环语句（支持loop item in list和end loop）
+   * @returns 循环语句节点
+   */
+  parseTemplateLoopStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    return this.parseForInLoop(startLoc);
+  }
+  /**
+   * 解析传统for循环
+   * @param startLoc 起始位置
+   * @returns for循环语句节点
+   */
+  parseTraditionalForLoop(startLoc) {
+    this.advance();
+    let init = null;
+    if (!this.isToken("SEMICOLON" /* SEMICOLON */)) {
+      if (this.isToken("LET" /* LET */)) {
+        init = this.parseVariableDeclaration();
+      } else {
+        init = this.parseExpression();
+      }
+    }
+    this.expectAndConsume("SEMICOLON" /* SEMICOLON */, ";");
+    let test = null;
+    if (!this.isToken("SEMICOLON" /* SEMICOLON */)) {
+      test = this.parseExpression();
+    }
+    this.expectAndConsume("SEMICOLON" /* SEMICOLON */, ";");
+    let update = null;
+    if (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      update = this.parseExpression();
+    }
+    this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+    const body = this.parseTemplateBlock(["end"]);
+    this.skipEndMarker("loop");
+    return createForStatement(init, test, update, body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析for-in遍历循环
+   * @param startLoc 起始位置
+   * @returns for-in循环语句节点
+   */
+  parseForInLoop(startLoc) {
+    let left;
+    if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+      this.advance();
+      const first = this.parseIdentifierNode();
+      left = first;
+      if (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+        const second = this.parseIdentifierNode();
+        left = [first, second];
+      }
+      this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+    } else if (this.isToken("IDENTIFIER" /* IDENTIFIER */)) {
+      left = this.parseIdentifierNode();
+    } else if (this.isToken("END" /* END */) || this.isToken("CASE" /* CASE */)) {
+      this.throwError(
+        "E008" /* E008_INVALID_EXPRESSION */,
+        { detail: `\u671F\u671B\u6807\u8BC6\u7B26\u6216 ( \u5728\u5FAA\u73AF\u8BED\u53E5\u4E2D\uFF0C\u4F46\u53D1\u73B0 ${this.currentToken.type}` },
+        this.currentToken.loc
+      );
+    }
+    this.expectAndConsume("IN" /* IN */, "in");
+    const right = this.parseExpression();
+    const body = this.parseTemplateBlock(["end"]);
+    this.skipEndMarker("loop");
+    return createForInStatement(left, right, body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析模板内的match语句
+   * @returns match语句节点
+   */
+  parseTemplateMatchStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const discriminant = this.parseExpression();
+    const cases = [];
+    while (true) {
+      if (this.isToken("CASE" /* CASE */)) {
+        this.advance();
+        let pattern = null;
+        if (this.isToken("IDENTIFIER" /* IDENTIFIER */) && this.currentToken.value === "_") {
+          this.advance();
+          pattern = null;
+        } else {
+          pattern = this.parseExpression();
+        }
+        const consequent = this.parseTemplateBlock(["case", "end"]);
+        cases.push(createMatchCase(pattern, consequent));
+      } else if (this.isToken("END" /* END */)) {
+        this.advance();
+        if (this.isToken("MATCH" /* MATCH */)) {
+          this.advance();
+        }
+        break;
+      } else if (this.isToken("DELIMITER_START" /* DELIMITER_START */)) {
+        this.advance();
+        if (this.isToken("CASE" /* CASE */)) {
+          this.advance();
+          let pattern = null;
+          if (this.isToken("IDENTIFIER" /* IDENTIFIER */) && this.currentToken.value === "_") {
+            this.advance();
+            pattern = null;
+          } else {
+            pattern = this.parseExpression();
+          }
+          const consequent = this.parseTemplateBlock(["case", "end"]);
+          cases.push(createMatchCase(pattern, consequent));
+        } else if (this.isToken("END" /* END */)) {
+          this.advance();
+          if (this.isToken("MATCH" /* MATCH */)) {
+            this.advance();
+          }
+          break;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    if (this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+      this.advance();
+    }
+    return createMatchStatement(discriminant, cases, this.createLoc(startLoc));
+  }
+  /**
+   * 解析微函数声明（支持end micro）
+   * @returns 函数声明节点
+   */
+  parseMicroDeclaration() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    this.expectAndConsume("LEFT_PAREN" /* LEFT_PAREN */, "(");
+    const params = [];
+    while (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      const param = this.parseTypedParameter();
+      params.push(param);
+      if (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+      } else if (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: ", \u6216 )", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+    }
+    this.advance();
+    const body = this.parseTemplateBlock(["end"]);
+    this.skipEndMarker("micro");
+    const paramIdentifiers = params.map((p) => p.name);
+    return createFunctionDeclaration(name, paramIdentifiers, body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析带类型注解的参数
+   * @returns 带类型注解的参数节点
+   */
+  parseTypedParameter() {
+    const name = this.parseIdentifierNode();
+    let typeAnnotation;
+    if (this.isToken("COLON" /* COLON */)) {
+      this.advance();
+      typeAnnotation = this.parseIdentifierNode();
+    }
+    return createTypedParameter(name, typeAnnotation);
+  }
+  /**
+   * 解析命名空间声明
+   * @returns 命名空间声明节点
+   */
+  parseNamespaceDeclaration() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    this.consumeOptionalSemicolon();
+    return createNamespaceDeclaration(name, this.createLoc(startLoc));
+  }
+  /**
+   * 解析using导入声明
+   * @returns using声明节点
+   */
+  parseUsingDeclaration() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const modulePath = [];
+    modulePath.push(this.parseIdentifierNode());
+    while (this.isToken("DOUBLE_COLON" /* DOUBLE_COLON */)) {
+      this.advance();
+      modulePath.push(this.parseIdentifierNode());
+    }
+    this.consumeOptionalSemicolon();
+    return createUsingDeclaration(modulePath, this.createLoc(startLoc));
+  }
+  /**
+   * 解析模板块（直到遇到指定的结束关键字）
+   * @param endKeywords 结束关键字列表
+   * @returns 块语句节点
+   */
+  parseTemplateBlock(endKeywords) {
+    const body = [];
+    while (!this.isToken("EOF" /* EOF */)) {
+      if (this.isToken("TEXT" /* TEXT */)) {
+        body.push(this.parseTextAsComment());
+      } else if (this.isToken("COMMENT" /* COMMENT */)) {
+        body.push(this.parseComment());
+      } else if (this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+        this.advance();
+      } else if (this.isToken("DELIMITER_START" /* DELIMITER_START */)) {
+        const nextToken = this.peekNextToken();
+        if (nextToken.type === "END" /* END */ || nextToken.type === "ELSE" /* ELSE */ || nextToken.type === "CASE" /* CASE */) {
+          break;
+        }
+        this.advance();
+        const statement = this.parseTemplateStatement();
+        if (statement !== null) {
+          body.push(statement);
+          if (this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+            this.advance();
+          }
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    return createBlockStatement(body);
+  }
+  /**
+   * 恢复前一个 token（用于回溯）
+   * @param type 要恢复的 token 类型
+   */
+  restoreToken(type) {
+    this.currentToken = {
+      type,
+      value: "",
+      loc: this.currentToken.loc
+    };
+  }
+  /**
+   * 将文本节点转换为注释节点（用于模板块内）
+   */
+  parseTextAsComment() {
+    const token = this.currentToken;
+    this.advance();
+    return createComment(token.value, false, token.loc);
+  }
+  /**
+   * 跳过结束标记
+   * @param keyword 关键字名称
+   */
+  skipEndMarker(keyword) {
+    if (this.isToken("END" /* END */)) {
+      this.advance();
+    }
+    if (this.isToken("IDENTIFIER" /* IDENTIFIER */) && this.currentToken.value === keyword) {
+      this.advance();
+    } else if (keyword === "loop" && this.isToken("LOOP" /* LOOP */) || keyword === "match" && this.isToken("MATCH" /* MATCH */) || keyword === "micro" && this.isToken("MICRO" /* MICRO */)) {
+      this.advance();
+    }
+    if (this.isToken("DELIMITER_END" /* DELIMITER_END */)) {
+      this.advance();
+    }
+  }
+  /**
+   * 解析break语句
+   * @returns break语句节点
+   */
+  parseBreakStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    this.consumeOptionalSemicolon();
+    return createBreakStatement(this.createLoc(startLoc));
+  }
+  /**
+   * 解析continue语句
+   * @returns continue语句节点
+   */
+  parseContinueStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    this.consumeOptionalSemicolon();
+    return createContinueStatement(this.createLoc(startLoc));
+  }
+  /**
+   * 解析extends语句
+   * @returns extends语句节点
+   */
+  parseExtendsStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const template = this.parseStringLiteral();
+    return createExtendsStatement(template, this.createLoc(startLoc));
+  }
+  /**
+   * 解析block声明
+   * @returns block声明节点
+   */
+  parseBlockDeclaration() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    const block = this.parseTemplateBlock(["end"]);
+    if (this.isToken("END" /* END */)) {
+      this.advance();
+      if (this.isToken("BLOCK" /* BLOCK */)) {
+        this.advance();
+      }
+    }
+    return createBlockDeclaration(name, block.body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析prepend语句
+   * @returns prepend语句节点
+   */
+  parsePrependStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    const block = this.parseTemplateBlock(["end"]);
+    if (this.isToken("END" /* END */)) {
+      this.advance();
+      if (this.isToken("BLOCK" /* BLOCK */)) {
+        this.advance();
+      }
+    }
+    return createPrependStatement(name, block.body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析append语句
+   * @returns append语句节点
+   */
+  parseAppendStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    const block = this.parseTemplateBlock(["end"]);
+    if (this.isToken("END" /* END */)) {
+      this.advance();
+      if (this.isToken("BLOCK" /* BLOCK */)) {
+        this.advance();
+      }
+    }
+    return createAppendStatement(name, block.body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析语句
+   * @returns 语句节点
+   */
+  parseStatement() {
+    const type = this.currentToken.type;
+    switch (type) {
+      case "LET" /* LET */:
+        return this.parseVariableDeclaration();
+      case "MICRO" /* MICRO */:
+        return this.parseFunctionDeclaration();
+      case "IF" /* IF */:
+        return this.parseIfStatement();
+      case "LOOP" /* LOOP */:
+        return this.parseLoopStatement();
+      case "LEFT_BRACE" /* LEFT_BRACE */:
+        return this.parseBlockStatement();
+      default:
+        if (this.isToken("IDENTIFIER" /* IDENTIFIER */)) {
+          const nextToken = this.lexer.nextToken();
+          if (nextToken.type === "ASSIGN" /* ASSIGN */) {
+            return this.parseAssignmentStatement();
+          }
+        }
+        return this.parseExpressionStatement();
+    }
+  }
+  /**
+   * 解析变量声明
+   * @returns 变量声明节点
+   */
+  parseVariableDeclaration() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    let typeAnnotation;
+    if (this.isToken("COLON" /* COLON */)) {
+      this.advance();
+      typeAnnotation = this.parseTypeAnnotation();
+    }
+    let init;
+    if (this.isToken("ASSIGN" /* ASSIGN */)) {
+      this.advance();
+      init = this.parseExpression();
+    }
+    this.consumeOptionalSemicolon();
+    return createVariableDeclaration(name, init, typeAnnotation, this.createLoc(startLoc));
+  }
+  /**
+   * 解析类型注解
+   * @returns 类型注解节点
+   */
+  parseTypeAnnotation() {
+    if (this.isToken("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+      return this.parseArrayTypeAnnotation();
+    }
+    if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+      return this.parseTupleTypeAnnotation();
+    }
+    return this.parseIdentifierNode();
+  }
+  /**
+   * 解析数组类型注解 [Type; N]
+   * @returns 数组类型注解节点
+   */
+  parseArrayTypeAnnotation() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const elementType = this.parseTypeAnnotation();
+    let size;
+    if (this.isToken("SEMICOLON" /* SEMICOLON */)) {
+      this.advance();
+      if (this.isToken("NUMBER_LITERAL" /* NUMBER_LITERAL */)) {
+        size = this.parseNumberLiteral();
+      }
+    }
+    this.expectAndConsume("RIGHT_BRACKET" /* RIGHT_BRACKET */, "]");
+    return createArrayTypeAnnotation(elementType, size, this.createLoc(startLoc));
+  }
+  /**
+   * 解析元组类型注解 (Type1, Type2, ...)
+   * @returns 元组类型注解节点
+   */
+  parseTupleTypeAnnotation() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const elementTypes = [];
+    while (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      elementTypes.push(this.parseTypeAnnotation());
+      if (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+      } else if (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: ", \u6216 )", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+    }
+    this.advance();
+    return createTupleTypeAnnotation(elementTypes, this.createLoc(startLoc));
+  }
+  /**
+   * 解析函数声明（传统模式）
+   * @returns 函数声明节点
+   */
+  parseFunctionDeclaration() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const name = this.parseIdentifierNode();
+    this.expectAndConsume("LEFT_PAREN" /* LEFT_PAREN */, "(");
+    const params = [];
+    while (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      if (this.isToken("IDENTIFIER" /* IDENTIFIER */)) {
+        params.push(this.parseIdentifierNode());
+        if (this.isToken("COLON" /* COLON */)) {
+          this.advance();
+          this.parseIdentifierNode();
+        }
+        if (this.isToken("COMMA" /* COMMA */)) {
+          this.advance();
+        }
+      } else {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: "\u6807\u8BC6\u7B26 \u6216 )", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+    }
+    this.advance();
+    const body = this.parseBlockStatement();
+    return createFunctionDeclaration(name, params, body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析if语句（传统模式）
+   * @returns if语句节点
+   */
+  parseIfStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    this.expectAndConsume("LEFT_PAREN" /* LEFT_PAREN */, "(");
+    const test = this.parseExpression();
+    this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+    const consequent = this.parseStatement();
+    const elseIfs = [];
+    let alternate;
+    while (this.isToken("ELSE" /* ELSE */)) {
+      this.advance();
+      if (this.isToken("IF" /* IF */)) {
+        this.advance();
+        this.expectAndConsume("LEFT_PAREN" /* LEFT_PAREN */, "(");
+        const elseIfTest = this.parseExpression();
+        this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+        const elseIfConsequent = this.parseStatement();
+        elseIfs.push(createElseIfClause(elseIfTest, elseIfConsequent));
+      } else {
+        alternate = this.parseStatement();
+        break;
+      }
+    }
+    return createIfStatement(test, consequent, elseIfs.length > 0 ? elseIfs : void 0, alternate, this.createLoc(startLoc));
+  }
+  /**
+   * 解析循环语句（传统模式）
+   * @returns 循环语句节点
+   */
+  parseLoopStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+      this.advance();
+      let init = null;
+      if (!this.isToken("SEMICOLON" /* SEMICOLON */)) {
+        if (this.isToken("LET" /* LET */)) {
+          init = this.parseVariableDeclaration();
+        } else {
+          init = this.parseExpression();
+        }
+      }
+      this.expectAndConsume("SEMICOLON" /* SEMICOLON */, ";");
+      let test = null;
+      if (!this.isToken("SEMICOLON" /* SEMICOLON */)) {
+        test = this.parseExpression();
+      }
+      this.expectAndConsume("SEMICOLON" /* SEMICOLON */, ";");
+      let update = null;
+      if (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+        update = this.parseExpression();
+      }
+      this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+      const body = this.parseStatement();
+      return createForStatement(init, test, update, body, this.createLoc(startLoc));
+    } else {
+      const test = this.parseExpression();
+      const body = this.parseStatement();
+      return createWhileStatement(test, body, this.createLoc(startLoc));
+    }
+  }
+  /**
+   * 解析块语句
+   * @returns 块语句节点
+   */
+  parseBlockStatement() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const body = [];
+    while (!this.isToken("RIGHT_BRACE" /* RIGHT_BRACE */) && !this.isToken("EOF" /* EOF */)) {
+      if (this.isToken("COMMENT" /* COMMENT */)) {
+        body.push(this.parseComment());
+      } else {
+        body.push(this.parseStatement());
+      }
+    }
+    if (this.isToken("RIGHT_BRACE" /* RIGHT_BRACE */)) {
+      this.advance();
+    }
+    return createBlockStatement(body, this.createLoc(startLoc));
+  }
+  /**
+   * 解析赋值语句
+   * @returns 赋值语句节点
+   */
+  parseAssignmentStatement() {
+    const startLoc = this.currentToken.loc;
+    const left = this.parseExpression();
+    this.expectAndConsume("ASSIGN" /* ASSIGN */, "=");
+    const right = this.parseExpression();
+    this.consumeOptionalSemicolon();
+    return createAssignmentStatement(left, right, this.createLoc(startLoc));
+  }
+  /**
+   * 解析表达式语句
+   * @returns 表达式语句节点
+   */
+  parseExpressionStatement() {
+    const startLoc = this.currentToken.loc;
+    const expression = this.parseExpression();
+    this.consumeOptionalSemicolon();
+    return createExpressionStatement(expression, this.createLoc(startLoc));
+  }
+  /**
+   * 解析表达式
+   * @returns 表达式节点
+   */
+  parseExpression() {
+    return this.parseAsExpression();
+  }
+  /**
+   * 解析逻辑或表达式
+   * @returns 表达式节点
+   */
+  parseLogicalOrExpression() {
+    let left = this.parseLogicalAndExpression();
+    while (this.isToken("LOGICAL_OR" /* LOGICAL_OR */)) {
+      const operator = this.currentToken.value;
+      this.advance();
+      const right = this.parseLogicalAndExpression();
+      left = createBinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * 解析逻辑与表达式
+   * @returns 表达式节点
+   */
+  parseLogicalAndExpression() {
+    let left = this.parseComparisonExpression();
+    while (this.isToken("LOGICAL_AND" /* LOGICAL_AND */)) {
+      const operator = this.currentToken.value;
+      this.advance();
+      const right = this.parseComparisonExpression();
+      left = createBinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * 解析比较表达式
+   * @returns 表达式节点
+   */
+  parseComparisonExpression() {
+    let left = this.parseAdditiveExpression();
+    while (this.isComparisonOperator(this.currentToken.type)) {
+      const operator = this.currentToken.value;
+      this.advance();
+      const right = this.parseAdditiveExpression();
+      left = createBinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * 检查是否为比较运算符
+   */
+  isComparisonOperator(type) {
+    return [
+      "EQUAL" /* EQUAL */,
+      "NOT_EQUAL" /* NOT_EQUAL */,
+      "LESS_THAN" /* LESS_THAN */,
+      "GREATER_THAN" /* GREATER_THAN */,
+      "LESS_THAN_OR_EQUAL" /* LESS_THAN_OR_EQUAL */,
+      "GREATER_THAN_OR_EQUAL" /* GREATER_THAN_OR_EQUAL */
+    ].includes(type);
+  }
+  /**
+   * 解析加法表达式
+   * @returns 表达式节点
+   */
+  parseAdditiveExpression() {
+    let left = this.parseMultiplicativeExpression();
+    while (this.isToken("PLUS" /* PLUS */) || this.isToken("MINUS" /* MINUS */)) {
+      const operator = this.currentToken.value;
+      this.advance();
+      const right = this.parseMultiplicativeExpression();
+      left = createBinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * 解析乘法表达式
+   * @returns 表达式节点
+   */
+  parseMultiplicativeExpression() {
+    let left = this.parseRangeExpression();
+    while (this.isToken("MULTIPLY" /* MULTIPLY */) || this.isToken("DIVIDE" /* DIVIDE */) || this.isToken("MODULO" /* MODULO */)) {
+      const operator = this.currentToken.value;
+      this.advance();
+      const right = this.parseRangeExpression();
+      left = createBinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * 解析范围表达式
+   * @returns 表达式节点
+   */
+  parseRangeExpression() {
+    let left = this.parseUnaryExpression();
+    if (this.isToken("RANGE" /* RANGE */)) {
+      this.advance();
+      const right = this.parseUnaryExpression();
+      left = createRangeExpression(left, right);
+    }
+    return left;
+  }
+  /**
+   * 解析类型转换表达式
+   * @returns 表达式节点
+   */
+  parseAsExpression() {
+    let left = this.parseLogicalOrExpression();
+    while (this.isToken("AS" /* AS */)) {
+      this.advance();
+      const typeAnnotation = this.parseIdentifierNode();
+      left = createAsExpression(left, typeAnnotation);
+    }
+    return left;
+  }
+  /**
+   * 解析一元表达式
+   * @returns 表达式节点
+   */
+  parseUnaryExpression() {
+    if (this.isToken("LOGICAL_NOT" /* LOGICAL_NOT */) || this.isToken("MINUS" /* MINUS */)) {
+      const operator = this.currentToken.value;
+      this.advance();
+      const argument = this.parseUnaryExpression();
+      return createUnaryExpression(operator, argument, true);
+    }
+    return this.parsePrimaryExpression();
+  }
+  /**
+   * 解析 primary 表达式
+   * @returns 表达式节点
+   */
+  parsePrimaryExpression() {
+    const type = this.currentToken.type;
+    switch (type) {
+      case "IDENTIFIER" /* IDENTIFIER */:
+        return this.parseIdentifierExpression();
+      case "NUMBER_LITERAL" /* NUMBER_LITERAL */:
+        return this.parseNumberLiteral();
+      case "STRING_LITERAL" /* STRING_LITERAL */:
+        return this.parseStringLiteral();
+      case "BOOLEAN_LITERAL" /* BOOLEAN_LITERAL */:
+        return this.parseBooleanLiteral();
+      case "CHARACTER_LITERAL" /* CHARACTER_LITERAL */:
+        return this.parseCharacterLiteral();
+      case "LEFT_PAREN" /* LEFT_PAREN */:
+        return this.parseParenthesizedExpression();
+      case "LEFT_BRACKET" /* LEFT_BRACKET */:
+        return this.parseArrayExpression();
+      case "LEFT_BRACE" /* LEFT_BRACE */:
+        return this.parseObjectExpression();
+      case "SUPER" /* SUPER */:
+        return this.parseSuperExpression();
+      default:
+        this.throwError(
+          "E001" /* E001_UNEXPECTED_TOKEN */,
+          { token: this.currentToken.type, expected: "\u8868\u8FBE\u5F0F" },
+          this.currentToken.loc,
+          [{ message: "\u68C0\u67E5\u6B64\u5904\u662F\u5426\u6709\u8BED\u6CD5\u9519\u8BEF" }]
+        );
+    }
+  }
+  /**
+   * 解析标识符节点（仅返回Identifier，不处理调用或成员访问）
+   */
+  parseIdentifierNode() {
+    if (!this.isToken("IDENTIFIER" /* IDENTIFIER */)) {
+      this.throwError(
+        "E006" /* E006_INVALID_IDENTIFIER */,
+        { identifier: this.currentToken.value || this.currentToken.type },
+        this.currentToken.loc,
+        [{ message: "\u6B64\u5904\u9700\u8981\u4E00\u4E2A\u6709\u6548\u7684\u6807\u8BC6\u7B26" }]
+      );
+    }
+    const token = this.currentToken;
+    this.advance();
+    return createIdentifier(token.value, token.loc);
+  }
+  /**
+   * 解析super表达式
+   * @returns super表达式节点
+   */
+  parseSuperExpression() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+      this.advance();
+      this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+    }
+    return createSuperExpression(this.createLoc(startLoc));
+  }
+  /**
+   * 解析标识符表达式（可能包含调用或成员访问）
+   */
+  parseIdentifierExpression() {
+    const token = this.currentToken;
+    const identifier = createIdentifier(token.value, token.loc);
+    this.advance();
+    if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+      return this.parseCallExpression(identifier);
+    }
+    if (this.isToken("DOT" /* DOT */) || this.isToken("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+      return this.parseMemberExpression(identifier);
+    }
+    return identifier;
+  }
+  /**
+   * 解析数字字面量
+   * @returns 字面量节点
+   */
+  parseNumberLiteral() {
+    const token = this.currentToken;
+    const value = parseFloat(token.value);
+    this.advance();
+    return createLiteral(value, token.value, token.loc);
+  }
+  /**
+   * 解析字符串字面量
+   * @returns 字面量节点
+   */
+  parseStringLiteral() {
+    const token = this.currentToken;
+    this.advance();
+    return createLiteral(token.value, `"${token.value}"`, token.loc);
+  }
+  /**
+   * 解析布尔字面量
+   * @returns 字面量节点
+   */
+  parseBooleanLiteral() {
+    const token = this.currentToken;
+    const value = token.value === "true";
+    this.advance();
+    return createLiteral(value, token.value, token.loc);
+  }
+  /**
+   * 解析字符字面量
+   * @returns 字面量节点
+   */
+  parseCharacterLiteral() {
+    const token = this.currentToken;
+    this.advance();
+    return createLiteral(token.value, `'${token.value}'`, token.loc);
+  }
+  /**
+   * 解析括号表达式或元组表达式
+   * @returns 表达式节点
+   */
+  parseParenthesizedExpression() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    if (this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      this.advance();
+      return createTupleExpression([], this.createLoc(startLoc));
+    }
+    const firstExpr = this.parseExpression();
+    if (this.isToken("COMMA" /* COMMA */)) {
+      const elements = [firstExpr];
+      while (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+        if (this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+          break;
+        }
+        elements.push(this.parseExpression());
+      }
+      this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+      return createTupleExpression(elements, this.createLoc(startLoc));
+    }
+    this.expectAndConsume("RIGHT_PAREN" /* RIGHT_PAREN */, ")");
+    return firstExpr;
+  }
+  /**
+   * 解析数组表达式
+   * @returns 数组表达式节点
+   */
+  parseArrayExpression() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const elements = [];
+    while (!this.isToken("RIGHT_BRACKET" /* RIGHT_BRACKET */)) {
+      elements.push(this.parseExpression());
+      if (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+      } else if (!this.isToken("RIGHT_BRACKET" /* RIGHT_BRACKET */)) {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: ", \u6216 ]", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+    }
+    this.advance();
+    return createArrayExpression(elements, this.createLoc(startLoc));
+  }
+  /**
+   * 解析对象表达式
+   * @returns 对象表达式节点
+   */
+  parseObjectExpression() {
+    const startLoc = this.currentToken.loc;
+    this.advance();
+    const properties = [];
+    while (!this.isToken("RIGHT_BRACE" /* RIGHT_BRACE */)) {
+      if (this.isToken("IDENTIFIER" /* IDENTIFIER */)) {
+        const key = this.parseIdentifierNode();
+        if (this.isToken("COLON" /* COLON */)) {
+          this.advance();
+          const value = this.parseExpression();
+          properties.push(createObjectProperty(key, value, false));
+        } else if (this.isToken("COMMA" /* COMMA */) || this.isToken("RIGHT_BRACE" /* RIGHT_BRACE */)) {
+          properties.push(createObjectProperty(key, key, true));
+        } else {
+          this.throwError(
+            "E002" /* E002_EXPECTED_TOKEN */,
+            { expected: ": \u6216 , \u6216 }", found: this.currentToken.type },
+            this.currentToken.loc
+          );
+        }
+      } else if (this.isToken("STRING_LITERAL" /* STRING_LITERAL */)) {
+        const key = createLiteral(this.currentToken.value, `"${this.currentToken.value}"`, this.currentToken.loc);
+        this.advance();
+        if (this.isToken("COLON" /* COLON */)) {
+          this.advance();
+          const value = this.parseExpression();
+          properties.push(createObjectProperty(key, value, false));
+        } else {
+          this.throwError(
+            "E002" /* E002_EXPECTED_TOKEN */,
+            { expected: ":", found: this.currentToken.type },
+            this.currentToken.loc
+          );
+        }
+      } else {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: "\u6807\u8BC6\u7B26 \u6216 \u5B57\u7B26\u4E32", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+      if (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+      } else if (!this.isToken("RIGHT_BRACE" /* RIGHT_BRACE */)) {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: ", \u6216 }", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+    }
+    this.advance();
+    return createObjectExpression(properties, this.createLoc(startLoc));
+  }
+  /**
+   * 解析函数调用表达式
+   * @param callee 被调用的函数
+   * @returns 函数调用表达式节点
+   */
+  parseCallExpression(callee) {
+    const startLoc = callee.loc;
+    this.advance();
+    const args = [];
+    while (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      args.push(this.parseExpression());
+      if (this.isToken("COMMA" /* COMMA */)) {
+        this.advance();
+      } else if (!this.isToken("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+        this.throwError(
+          "E002" /* E002_EXPECTED_TOKEN */,
+          { expected: ", \u6216 )", found: this.currentToken.type },
+          this.currentToken.loc
+        );
+      }
+    }
+    this.advance();
+    const callExpr = createCallExpression(callee, args, {
+      start: startLoc?.start || { line: 0, column: 0 },
+      end: this.currentToken.loc?.end || { line: 0, column: 0 }
+    });
+    const expr = this.parsePostfixExpression(callExpr);
+    return expr;
+  }
+  /**
+   * 解析成员访问表达式
+   * @param object 对象表达式
+   * @returns 成员访问表达式节点
+   */
+  parseMemberExpression(object) {
+    let memberExpr = object;
+    while (this.isToken("DOT" /* DOT */) || this.isToken("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+      if (this.isToken("DOT" /* DOT */)) {
+        this.advance();
+        let property;
+        if (this.isToken("NUMBER_LITERAL" /* NUMBER_LITERAL */)) {
+          property = this.parseNumberLiteral();
+        } else {
+          property = this.parseIdentifierNode();
+        }
+        memberExpr = createMemberExpression(memberExpr, property, false);
+        if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+          memberExpr = this.parseCallExpression(memberExpr);
+        }
+      } else {
+        this.advance();
+        const property = this.parseExpression();
+        this.expectAndConsume("RIGHT_BRACKET" /* RIGHT_BRACKET */, "]");
+        memberExpr = createMemberExpression(memberExpr, property, true);
+        if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+          memberExpr = this.parseCallExpression(memberExpr);
+        }
+      }
+    }
+    return memberExpr;
+  }
+  /**
+   * 解析后缀表达式（处理成员访问和链式调用）
+   */
+  parsePostfixExpression(expr) {
+    if (this.isToken("DOT" /* DOT */) || this.isToken("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+      return this.parseMemberExpression(expr);
+    }
+    if (this.isToken("LEFT_PAREN" /* LEFT_PAREN */)) {
+      return this.parseCallExpression(expr);
+    }
+    return expr;
+  }
+  /**
+   * 检查当前token是否为指定类型
+   */
+  isToken(type) {
+    return this.currentToken.type === type;
+  }
+  /**
+   * 期望并消费指定类型的token
+   */
+  expectAndConsume(type, expected) {
+    if (!this.isToken(type)) {
+      this.throwError(
+        "E002" /* E002_EXPECTED_TOKEN */,
+        { expected, found: this.currentToken.type },
+        this.currentToken.loc
+      );
+    }
+    this.advance();
+  }
+  /**
+   * 获取指定行的源代码
+   */
+  getSourceLine(line) {
+    const lines = this.source.split("\n");
+    if (line > 0 && line <= lines.length) {
+      return lines[line - 1];
+    }
+    return void 0;
+  }
+  /**
+   * 抛出结构化错误
+   */
+  throwError(code, params, range, suggestions) {
+    const sourceLine = range ? this.getSourceLine(range.start.line) : void 0;
+    const error = createError(code, params, {
+      range,
+      filePath: this.filePath,
+      sourceLine,
+      suggestions
+    });
+    throw new ParseError(error);
+  }
+  /**
+   * 消费可选的分号
+   */
+  consumeOptionalSemicolon() {
+    if (this.isToken("SEMICOLON" /* SEMICOLON */)) {
+      this.advance();
+    }
+  }
+  /**
+   * 创建位置信息
+   */
+  createLoc(startLoc) {
+    if (!startLoc) return void 0;
+    return {
+      start: startLoc.start,
+      end: this.currentToken.loc?.end || { line: 0, column: 0 }
+    };
+  }
+};
+function createParser(source, language2, filePath) {
+  return new Parser(source, language2, filePath);
+}
+function parse(source, language2, filePath) {
+  const parser = new Parser(source, language2, filePath);
+  return parser.parse();
+}
+
+// src/engine.ts
+var DejavuEngine = class {
+  constructor() {
+    __publicField(this, "templates", /* @__PURE__ */ new Map());
+  }
+  /**
+   * 注册模板
+   * @param name 模板名称
+   * @param source 模板源代码
+   * @param language 语言配置
+   */
+  registerTemplate(name, source, language2) {
+    const program = parse(source, language2);
+    this.templates.set(name, program);
+  }
+  /**
+   * 渲染已注册的模板
+   * @param name 模板名称
+   * @param context 模板上下文参数
+   * @returns 渲染结果
+   */
+  renderTemplate(name, context = {}) {
+    const program = this.templates.get(name);
+    if (!program) {
+      throw new Error(`Template "${name}" not found`);
+    }
+    return renderer.render(program, context);
+  }
+  /**
+   * 检查模板
+   * @param source 源代码路径
+   */
+  checkTemplate(source, language2) {
+    return parse(source, language2);
+  }
+};
+var engine = new DejavuEngine();
+
+// src/template.ts
+function registerTemplate(name, source, language2) {
+  engine.registerTemplate(name, source, language2);
+}
+function renderTemplate(name, context = {}) {
+  return engine.renderTemplate(name, context);
+}
+function checkTemplate(source, language2) {
+  engine.checkTemplate(source, language2);
+}
+export {
+  ConfigError,
+  DEFAULT_TEMPLATE_CONFIG,
+  DejavuEngine,
+  DejavuLanguage,
+  DejavuRenderer,
+  ErrorCode,
+  ErrorMessages,
+  Lexer,
+  NodeType,
+  ParseError,
+  Parser,
+  RuntimeError,
+  SyntaxMode,
+  TokenType,
+  checkTemplate,
+  configError,
+  createAppendStatement,
+  createArrayExpression,
+  createArrayTypeAnnotation,
+  createAsExpression,
+  createAssignmentStatement,
+  createBinaryExpression,
+  createBlockDeclaration,
+  createBlockStatement,
+  createBreakStatement,
+  createCallExpression,
+  createComment,
+  createContinueStatement,
+  createElseIfClause,
+  createError,
+  createExpressionStatement,
+  createExtendsStatement,
+  createForInStatement,
+  createForStatement,
+  createFunctionDeclaration,
+  createIdentifier,
+  createIfStatement,
+  createLexer,
+  createLiteral,
+  createMatchCase,
+  createMatchStatement,
+  createMemberExpression,
+  createNamespaceDeclaration,
+  createObjectExpression,
+  createObjectProperty,
+  createParser,
+  createPrependStatement,
+  createProgram,
+  createRangeExpression,
+  createSuperExpression,
+  createTemplateExpression,
+  createText,
+  createToken,
+  createTupleExpression,
+  createTupleTypeAnnotation,
+  createTypedParameter,
+  createUnaryExpression,
+  createUsingDeclaration,
+  createVariableDeclaration,
+  createWhileStatement,
+  engine,
+  fileNotFoundError,
+  formatError,
+  language,
+  missingEndError,
+  parse,
+  registerTemplate,
+  renderTemplate,
+  renderer,
+  templateNotFoundError,
+  undefinedVariableError,
+  unexpectedTokenError
+};