@doki-land/dejavu-engine 0.0.0 → 0.0.9

package/dist/index.d.ts

@@ -1,1445 +1,7 @@
 /**
- * DejaVu 模板引擎抽象语法树 (AST) 定义
+ * @doki-land/dejavu-engine —— 纯 TypeScript AOT 运行时库入口。
+ *
+ * 只包含 runtime helpers，供 dejavu-codegen AOT 产物 import。
+ * 不含 parser、模板编译器、loader、resolver 或 Node 文件系统依赖。
  */
-/**
- * AST 节点类型枚举
- */
-declare enum NodeType {
-    /** 程序节点 */
-    Program = "Program",
-    /** 表达式语句节点 */
-    ExpressionStatement = "ExpressionStatement",
-    /** 赋值语句节点 */
-    AssignmentStatement = "AssignmentStatement",
-    /** 变量声明节点 */
-    VariableDeclaration = "VariableDeclaration",
-    /** 函数声明节点 */
-    FunctionDeclaration = "FunctionDeclaration",
-    /** If 语句节点 */
-    IfStatement = "IfStatement",
-    /** Else If 分支节点 */
-    ElseIfClause = "ElseIfClause",
-    /** For 循环语句节点 */
-    ForStatement = "ForStatement",
-    /** For-In 遍历循环语句节点 */
-    ForInStatement = "ForInStatement",
-    /** While 循环语句节点 */
-    WhileStatement = "WhileStatement",
-    /** 匹配语句节点 */
-    MatchStatement = "MatchStatement",
-    /** 匹配分支节点 */
-    MatchCase = "MatchCase",
-    /** 命名空间声明节点 */
-    NamespaceDeclaration = "NamespaceDeclaration",
-    /** 导入声明节点 */
-    UsingDeclaration = "UsingDeclaration",
-    /** 块语句节点 */
-    BlockStatement = "BlockStatement",
-    /** 标识符节点 */
-    Identifier = "Identifier",
-    /** 字面量节点 */
-    Literal = "Literal",
-    /** 二元表达式节点 */
-    BinaryExpression = "BinaryExpression",
-    /** 一元表达式节点 */
-    UnaryExpression = "UnaryExpression",
-    /** 函数调用表达式节点 */
-    CallExpression = "CallExpression",
-    /** 成员访问表达式节点 */
-    MemberExpression = "MemberExpression",
-    /** 数组表达式节点 */
-    ArrayExpression = "ArrayExpression",
-    /** 对象表达式节点 */
-    ObjectExpression = "ObjectExpression",
-    /** 对象属性节点 */
-    ObjectProperty = "ObjectProperty",
-    /** 范围表达式节点 */
-    RangeExpression = "RangeExpression",
-    /** 带类型注解的参数节点 */
-    TypedParameter = "TypedParameter",
-    /** 模板字符串节点 */
-    TemplateLiteral = "TemplateLiteral",
-    /** 模板字符串表达式节点 */
-    TemplateExpression = "TemplateExpression",
-    /** 注释节点 */
-    Comment = "Comment",
-    /** 文本节点 */
-    Text = "Text"
-}
-/**
- * AST 节点基础接口
- */
-interface Node {
-    /** 节点类型 */
-    type: NodeType;
-    /** 节点位置信息 */
-    loc?: {
-        /** 开始位置 */
-        start: {
-            line: number;
-            column: number;
-        };
-        /** 结束位置 */
-        end: {
-            line: number;
-            column: number;
-        };
-    };
-}
-/**
- * 表达式节点接口
- */
-interface Expression extends Node {
-    /** 表达式类型 */
-    type: NodeType.Identifier | NodeType.Literal | NodeType.BinaryExpression | NodeType.UnaryExpression | NodeType.CallExpression | NodeType.MemberExpression | NodeType.ArrayExpression | NodeType.ObjectExpression | NodeType.RangeExpression | NodeType.TemplateLiteral | NodeType.TemplateExpression;
-}
-/**
- * 语句节点接口
- */
-interface Statement extends Node {
-    /** 语句类型 */
-    type: NodeType.ExpressionStatement | NodeType.AssignmentStatement | NodeType.VariableDeclaration | NodeType.FunctionDeclaration | NodeType.IfStatement | NodeType.ElseIfClause | NodeType.ForStatement | NodeType.ForInStatement | NodeType.WhileStatement | NodeType.MatchStatement | NodeType.MatchCase | NodeType.NamespaceDeclaration | NodeType.UsingDeclaration | NodeType.BlockStatement;
-}
-/**
- * 程序节点
- * 表示整个模板的根节点
- */
-interface Program extends Node {
-    type: NodeType.Program;
-    /** 程序体，包含所有语句 */
-    body: (Statement | Expression | Text | Comment)[];
-}
-/**
- * 表达式语句节点
- * 表示一个作为语句的表达式
- */
-interface ExpressionStatement extends Statement {
-    type: NodeType.ExpressionStatement;
-    /** 表达式 */
-    expression: Expression;
-}
-/**
- * 赋值语句节点
- * 表示变量赋值操作
- */
-interface AssignmentStatement extends Statement {
-    type: NodeType.AssignmentStatement;
-    /** 左值表达式 */
-    left: Expression;
-    /** 右值表达式 */
-    right: Expression;
-}
-/**
- * 变量声明节点
- * 表示变量声明语句
- */
-interface VariableDeclaration extends Statement {
-    type: NodeType.VariableDeclaration;
-    /** 变量名称 */
-    name: Identifier;
-    /** 变量初始化值 */
-    init?: Expression;
-}
-/**
- * 函数声明节点
- * 表示函数声明语句
- */
-interface FunctionDeclaration extends Statement {
-    type: NodeType.FunctionDeclaration;
-    /** 函数名称 */
-    name: Identifier;
-    /** 函数参数 */
-    params: Identifier[];
-    /** 函数体 */
-    body: BlockStatement;
-}
-/**
- * If 语句节点
- * 表示条件语句
- */
-interface IfStatement extends Statement {
-    type: NodeType.IfStatement;
-    /** 条件表达式 */
-    test: Expression;
-    /** 当条件为真时执行的语句 */
-    consequent: Statement;
-    /** else if 分支列表 */
-    elseIfs?: ElseIfClause[];
-    /** 当所有条件都为假时执行的语句 */
-    alternate?: Statement;
-}
-/**
- * Else If 分支节点
- * 表示 else if 分支
- */
-interface ElseIfClause extends Statement {
-    type: NodeType.ElseIfClause;
-    /** 条件表达式 */
-    test: Expression;
-    /** 当条件为真时执行的语句 */
-    consequent: Statement;
-}
-/**
- * For 循环语句节点
- * 表示 for 循环
- */
-interface ForStatement extends Statement {
-    type: NodeType.ForStatement;
-    /** 初始化表达式 */
-    init: VariableDeclaration | AssignmentStatement | Expression | null;
-    /** 条件表达式 */
-    test: Expression | null;
-    /** 增量表达式 */
-    update: Expression | null;
-    /** 循环体 */
-    body: Statement;
-}
-/**
- * For-In 遍历循环语句节点
- * 表示 loop item in list 遍历循环
- */
-interface ForInStatement extends Statement {
-    type: NodeType.ForInStatement;
-    /** 循环变量（单个变量或索引+元素元组） */
-    left: Identifier | [Identifier, Identifier];
-    /** 被遍历的表达式（数组或范围） */
-    right: Expression;
-    /** 循环体 */
-    body: Statement;
-}
-/**
- * While 循环语句节点
- * 表示 while 循环
- */
-interface WhileStatement extends Statement {
-    type: NodeType.WhileStatement;
-    /** 条件表达式 */
-    test: Expression;
-    /** 循环体 */
-    body: Statement;
-}
-/**
- * 匹配语句节点
- * 表示 match 匹配语句
- */
-interface MatchStatement extends Statement {
-    type: NodeType.MatchStatement;
-    /** 被匹配的表达式 */
-    discriminant: Expression;
-    /** 匹配分支列表 */
-    cases: MatchCase[];
-}
-/**
- * 匹配分支节点
- * 表示 match 语句中的 case 分支
- */
-interface MatchCase extends Statement {
-    type: NodeType.MatchCase;
-    /** 匹配模式（表达式或通配符 _） */
-    pattern: Expression | null;
-    /** 匹配成功时执行的语句 */
-    consequent: Statement;
-}
-/**
- * 命名空间声明节点
- * 表示 namespace 声明
- */
-interface NamespaceDeclaration extends Statement {
-    type: NodeType.NamespaceDeclaration;
-    /** 命名空间名称 */
-    name: Identifier;
-}
-/**
- * 导入声明节点
- * 表示 using 导入声明
- */
-interface UsingDeclaration extends Statement {
-    type: NodeType.UsingDeclaration;
-    /** 模块路径（如 header::render_header） */
-    modulePath: Identifier[];
-}
-/**
- * 块语句节点
- * 表示一组语句的集合
- */
-interface BlockStatement extends Statement {
-    type: NodeType.BlockStatement;
-    /** 块内的语句 */
-    body: (Statement | Expression | Comment)[];
-}
-/**
- * 标识符节点
- * 表示变量名、函数名等标识符
- */
-interface Identifier extends Expression {
-    type: NodeType.Identifier;
-    /** 标识符名称 */
-    name: string;
-}
-/**
- * 字面量节点
- * 表示字符串、数字、布尔值等字面量
- */
-interface Literal extends Expression {
-    type: NodeType.Literal;
-    /** 字面量值 */
-    value: string | number | boolean | null | undefined;
-    /** 原始字符串表示 */
-    raw?: string;
-}
-/**
- * 二元表达式节点
- * 表示二元运算表达式
- */
-interface BinaryExpression extends Expression {
-    type: NodeType.BinaryExpression;
-    /** 运算符 */
-    operator: string;
-    /** 左操作数 */
-    left: Expression;
-    /** 右操作数 */
-    right: Expression;
-}
-/**
- * 一元表达式节点
- * 表示一元运算表达式
- */
-interface UnaryExpression extends Expression {
-    type: NodeType.UnaryExpression;
-    /** 运算符 */
-    operator: string;
-    /** 操作数 */
-    argument: Expression;
-    /** 是否为前缀运算符 */
-    prefix: boolean;
-}
-/**
- * 函数调用表达式节点
- * 表示函数调用
- */
-interface CallExpression extends Expression {
-    type: NodeType.CallExpression;
-    /** 被调用的函数表达式 */
-    callee: Expression;
-    /** 函数参数 */
-    arguments: Expression[];
-}
-/**
- * 成员访问表达式节点
- * 表示对象成员访问
- */
-interface MemberExpression extends Expression {
-    type: NodeType.MemberExpression;
-    /** 对象表达式 */
-    object: Expression;
-    /** 成员表达式 */
-    property: Expression;
-    /** 是否使用点号访问 */
-    computed: boolean;
-}
-/**
- * 数组表达式节点
- * 表示数组字面量
- */
-interface ArrayExpression extends Expression {
-    type: NodeType.ArrayExpression;
-    /** 数组元素 */
-    elements: Expression[];
-}
-/**
- * 对象表达式节点
- * 表示对象字面量
- */
-interface ObjectExpression extends Expression {
-    type: NodeType.ObjectExpression;
-    /** 对象属性 */
-    properties: ObjectProperty[];
-}
-/**
- * 对象属性节点
- * 表示对象的属性
- */
-interface ObjectProperty extends Node {
-    type: NodeType.ObjectProperty;
-    /** 属性键 */
-    key: Identifier | Literal;
-    /** 属性值 */
-    value: Expression;
-    /** 是否为简写属性 */
-    shorthand: boolean;
-}
-/**
- * 范围表达式节点
- * 表示 start..end 范围表达式
- */
-interface RangeExpression extends Expression {
-    type: NodeType.RangeExpression;
-    /** 范围起始值 */
-    start: Expression;
-    /** 范围结束值 */
-    end: Expression;
-}
-/**
- * 带类型注解的参数节点
- * 表示函数参数带类型注解
- */
-interface TypedParameter extends Node {
-    type: NodeType.TypedParameter;
-    /** 参数名称 */
-    name: Identifier;
-    /** 参数类型 */
-    typeAnnotation?: Identifier;
-}
-/**
- * 模板字符串节点
- * 表示模板字符串
- */
-interface TemplateLiteral extends Expression {
-    type: NodeType.TemplateLiteral;
-    /** 模板字符串片段 */
-    quasis: {
-        value: {
-            raw: string;
-            cooked: string;
-        };
-    }[];
-    /** 模板字符串中的表达式 */
-    expressions: Expression[];
-}
-/**
- * 模板表达式节点
- * 表示 DejaVu 模板表达式
- */
-interface TemplateExpression extends Expression {
-    type: NodeType.TemplateExpression;
-    /** 模板内容 */
-    content: string;
-}
-/**
- * 注释节点
- * 表示注释
- */
-interface Comment extends Node {
-    type: NodeType.Comment;
-    /** 注释内容 */
-    value: string;
-    /** 是否为块注释 */
-    block: boolean;
-}
-/**
- * 文本节点
- * 表示模板中的普通文本
- */
-interface Text extends Node {
-    type: NodeType.Text;
-    /** 文本内容 */
-    value: string;
-}
-/**
- * 创建标识符节点
- * @param name 标识符名称
- * @param loc 位置信息
- * @returns 标识符节点
- */
-declare function createIdentifier(name: string, loc?: Node['loc']): Identifier;
-/**
- * 创建字面量节点
- * @param value 字面量值
- * @param raw 原始字符串表示
- * @param loc 位置信息
- * @returns 字面量节点
- */
-declare function createLiteral(value: Literal['value'], raw?: string, loc?: Node['loc']): Literal;
-/**
- * 创建程序节点
- * @param body 程序体
- * @param loc 位置信息
- * @returns 程序节点
- */
-declare function createProgram(body: Program['body'], loc?: Node['loc']): Program;
-/**
- * 创建表达式语句节点
- * @param expression 表达式
- * @param loc 位置信息
- * @returns 表达式语句节点
- */
-declare function createExpressionStatement(expression: Expression, loc?: Node['loc']): ExpressionStatement;
-/**
- * 创建变量声明节点
- * @param name 变量名称
- * @param init 初始化值
- * @param loc 位置信息
- * @returns 变量声明节点
- */
-declare function createVariableDeclaration(name: Identifier, init?: Expression, loc?: Node['loc']): VariableDeclaration;
-/**
- * 创建块语句节点
- * @param body 块内语句
- * @param loc 位置信息
- * @returns 块语句节点
- */
-declare function createBlockStatement(body: BlockStatement['body'], loc?: Node['loc']): BlockStatement;
-/**
- * 创建二元表达式节点
- * @param operator 运算符
- * @param left 左操作数
- * @param right 右操作数
- * @param loc 位置信息
- * @returns 二元表达式节点
- */
-declare function createBinaryExpression(operator: string, left: Expression, right: Expression, loc?: Node['loc']): BinaryExpression;
-/**
- * 创建函数调用表达式节点
- * @param callee 被调用的函数
- * @param args 函数参数
- * @param loc 位置信息
- * @returns 函数调用表达式节点
- */
-declare function createCallExpression(callee: Expression, args: Expression[], loc?: Node['loc']): CallExpression;
-/**
- * 创建文本节点
- * @param value 文本内容
- * @param loc 位置信息
- * @returns 文本节点
- */
-declare function createText(value: string, loc?: Node['loc']): Text;
-/**
- * 创建模板表达式节点
- * @param content 模板内容
- * @param loc 位置信息
- * @returns 模板表达式节点
- */
-declare function createTemplateExpression(content: string, loc?: Node['loc']): TemplateExpression;
-/**
- * 创建一元表达式节点
- * @param operator 运算符
- * @param argument 操作数
- * @param prefix 是否为前缀运算符
- * @param loc 位置信息
- * @returns 一元表达式节点
- */
-declare function createUnaryExpression(operator: string, argument: Expression, prefix: boolean, loc?: Node['loc']): UnaryExpression;
-/**
- * 创建成员访问表达式节点
- * @param object 对象表达式
- * @param property 成员表达式
- * @param computed 是否使用计算访问
- * @param loc 位置信息
- * @returns 成员访问表达式节点
- */
-declare function createMemberExpression(object: Expression, property: Expression, computed: boolean, loc?: Node['loc']): MemberExpression;
-/**
- * 创建数组表达式节点
- * @param elements 数组元素
- * @param loc 位置信息
- * @returns 数组表达式节点
- */
-declare function createArrayExpression(elements: Expression[], loc?: Node['loc']): ArrayExpression;
-/**
- * 创建对象表达式节点
- * @param properties 对象属性
- * @param loc 位置信息
- * @returns 对象表达式节点
- */
-declare function createObjectExpression(properties: ObjectProperty[], loc?: Node['loc']): ObjectExpression;
-/**
- * 创建对象属性节点
- * @param key 属性键
- * @param value 属性值
- * @param shorthand 是否为简写属性
- * @param loc 位置信息
- * @returns 对象属性节点
- */
-declare function createObjectProperty(key: Identifier | Literal, value: Expression, shorthand: boolean, loc?: Node['loc']): ObjectProperty;
-/**
- * 创建If语句节点
- * @param test 条件表达式
- * @param consequent 当条件为真时执行的语句
- * @param elseIfs else if 分支列表
- * @param alternate 当所有条件都为假时执行的语句
- * @param loc 位置信息
- * @returns If语句节点
- */
-declare function createIfStatement(test: Expression, consequent: Statement, elseIfs?: ElseIfClause[], alternate?: Statement, loc?: Node['loc']): IfStatement;
-/**
- * 创建Else If分支节点
- * @param test 条件表达式
- * @param consequent 当条件为真时执行的语句
- * @param loc 位置信息
- * @returns Else If分支节点
- */
-declare function createElseIfClause(test: Expression, consequent: Statement, loc?: Node['loc']): ElseIfClause;
-/**
- * 创建For循环语句节点
- * @param init 初始化表达式
- * @param test 条件表达式
- * @param update 增量表达式
- * @param body 循环体
- * @param loc 位置信息
- * @returns For循环语句节点
- */
-declare function createForStatement(init: VariableDeclaration | AssignmentStatement | Expression | null, test: Expression | null, update: Expression | null, body: Statement, loc?: Node['loc']): ForStatement;
-/**
- * 创建While循环语句节点
- * @param test 条件表达式
- * @param body 循环体
- * @param loc 位置信息
- * @returns While循环语句节点
- */
-declare function createWhileStatement(test: Expression, body: Statement, loc?: Node['loc']): WhileStatement;
-/**
- * 创建For-In遍历循环语句节点
- * @param left 循环变量
- * @param right 被遍历的表达式
- * @param body 循环体
- * @param loc 位置信息
- * @returns For-In遍历循环语句节点
- */
-declare function createForInStatement(left: Identifier | [Identifier, Identifier], right: Expression, body: Statement, loc?: Node['loc']): ForInStatement;
-/**
- * 创建匹配语句节点
- * @param discriminant 被匹配的表达式
- * @param cases 匹配分支列表
- * @param loc 位置信息
- * @returns 匹配语句节点
- */
-declare function createMatchStatement(discriminant: Expression, cases: MatchCase[], loc?: Node['loc']): MatchStatement;
-/**
- * 创建匹配分支节点
- * @param pattern 匹配模式
- * @param consequent 匹配成功时执行的语句
- * @param loc 位置信息
- * @returns 匹配分支节点
- */
-declare function createMatchCase(pattern: Expression | null, consequent: Statement, loc?: Node['loc']): MatchCase;
-/**
- * 创建命名空间声明节点
- * @param name 命名空间名称
- * @param loc 位置信息
- * @returns 命名空间声明节点
- */
-declare function createNamespaceDeclaration(name: Identifier, loc?: Node['loc']): NamespaceDeclaration;
-/**
- * 创建导入声明节点
- * @param modulePath 模块路径
- * @param loc 位置信息
- * @returns 导入声明节点
- */
-declare function createUsingDeclaration(modulePath: Identifier[], loc?: Node['loc']): UsingDeclaration;
-/**
- * 创建范围表达式节点
- * @param start 范围起始值
- * @param end 范围结束值
- * @param loc 位置信息
- * @returns 范围表达式节点
- */
-declare function createRangeExpression(start: Expression, end: Expression, loc?: Node['loc']): RangeExpression;
-/**
- * 创建带类型注解的参数节点
- * @param name 参数名称
- * @param typeAnnotation 参数类型
- * @param loc 位置信息
- * @returns 带类型注解的参数节点
- */
-declare function createTypedParameter(name: Identifier, typeAnnotation?: Identifier, loc?: Node['loc']): TypedParameter;
-/**
- * 创建函数声明节点
- * @param name 函数名称
- * @param params 函数参数
- * @param body 函数体
- * @param loc 位置信息
- * @returns 函数声明节点
- */
-declare function createFunctionDeclaration(name: Identifier, params: Identifier[], body: BlockStatement, loc?: Node['loc']): FunctionDeclaration;
-/**
- * 创建赋值语句节点
- * @param left 左值表达式
- * @param right 右值表达式
- * @param loc 位置信息
- * @returns 赋值语句节点
- */
-declare function createAssignmentStatement(left: Expression, right: Expression, loc?: Node['loc']): AssignmentStatement;
-/**
- * 创建注释节点
- * @param value 注释内容
- * @param block 是否为块注释
- * @param loc 位置信息
- * @returns 注释节点
- */
-declare function createComment(value: string, block: boolean, loc?: Node['loc']): Comment;
-
-/**
- * DejaVu 模板引擎语言配置
- */
-/**
- * 语法模式枚举
- */
-declare enum SyntaxMode {
-    /** 编程模式（纯代码） */
-    Programming = "Programming",
-    /** 模板模式（带插值的文本） */
-    Template = "Template"
-}
-/**
- * 模板配置接口
- */
-interface TemplateConfig {
-    /** 代码开始定界符 */
-    codeStart: string;
-    /** 代码结束定界符 */
-    codeEnd: string;
-    /** 注释开始定界符 */
-    commentStart: string;
-    /** 注释结束定界符 */
-    commentEnd: string;
-    /** 是否支持过滤器管道语法 `a |> b |> c` */
-    supportFilterPipe: boolean;
-    /** 是否支持遗留的 `for` 语法（否则只允许 `loop`） */
-    legacyFor: boolean;
-}
-/**
- * 默认模板配置
- */
-declare const DEFAULT_TEMPLATE_CONFIG: TemplateConfig;
-/**
- * DejaVu 语言配置类
- */
-declare class DejavuLanguage {
-    /** 语法模式 */
-    syntaxMode: SyntaxMode;
-    /** 模板配置 */
-    template: TemplateConfig;
-    /**
-     * 创建新的 DejaVu 语言配置
-     */
-    constructor();
-    /**
-     * 设置语法模式
-     * @param mode 语法模式
-     * @returns 当前实例
-     */
-    withMode(mode: SyntaxMode): this;
-    /**
-     * 设置模板配置
-     * @param template 模板配置
-     * @returns 当前实例
-     */
-    withTemplate(template: Partial<TemplateConfig>): this;
-}
-/**
- * 默认 DejaVu 语言配置
- */
-declare const language: DejavuLanguage;
-
-declare class DejavuEngine {
-    private readonly templates;
-    /**
-     * 注册模板
-     * @param name 模板名称
-     * @param source 模板源代码
-     * @param language 语言配置
-     */
-    registerTemplate(name: string, source: string, language?: DejavuLanguage): void;
-    /**
-     * 渲染已注册的模板
-     * @param name 模板名称
-     * @param context 模板上下文参数
-     * @returns 渲染结果
-     */
-    renderTemplate(name: string, context?: Record<string, any>): string;
-    /**
-     * 检查模板
-     * @param source 源代码路径
-     */
-    checkTemplate(source: string, language?: DejavuLanguage): Program;
-}
-/**
- * 引擎单例实例
- */
-declare const engine: DejavuEngine;
-
-/** 注册模板 */
-declare function registerTemplate(name: string, source: string, language?: DejavuLanguage): void;
-/** 渲染模板 */
-declare function renderTemplate(name: string, context?: Record<string, unknown>): string;
-/** 检查模板 */
-declare function checkTemplate(source: string, language?: DejavuLanguage): void;
-
-/**
- * DejaVu 模板引擎渲染器
- * 负责将 AST 转换为最终输出
- */
-
-/**
- * 渲染上下文接口
- */
-interface RenderContext {
-    /** 变量作用域 */
-    scope: Record<string, any>;
-    /** 父上下文 */
-    parent?: RenderContext;
-}
-/**
- * DejaVu 渲染器类
- */
-declare class DejavuRenderer {
-    /**
-     * 创建渲染上下文
-     * @param initialScope 初始作用域
-     * @returns 渲染上下文
-     */
-    private createContext;
-    /**
-     * 查找变量
-     * @param context 渲染上下文
-     * @param name 变量名
-     * @returns 变量值
-     */
-    private findVariable;
-    /**
-     * 设置变量
-     * @param context 渲染上下文
-     * @param name 变量名
-     * @param value 变量值
-     */
-    private setVariable;
-    /**
-     * 执行二元运算
-     * @param left 左操作数
-     * @param operator 运算符
-     * @param right 右操作数
-     * @returns 运算结果
-     */
-    private executeBinaryOperation;
-    /**
-     * 执行一元运算
-     * @param operator 运算符
-     * @param argument 操作数
-     * @returns 运算结果
-     */
-    private executeUnaryOperation;
-    /**
-     * 评估表达式
-     * @param node 表达式节点
-     * @param context 渲染上下文
-     * @returns 表达式结果
-     */
-    private evaluateExpression;
-    /**
-     * 渲染语句
-     * @param node 语句节点
-     * @param context 渲染上下文
-     * @returns 渲染结果
-     */
-    private renderStatement;
-    /**
-     * 渲染块语句
-     * @param node 块语句节点
-     * @param context 渲染上下文
-     * @returns 渲染结果
-     */
-    private renderBlockStatement;
-    /**
-     * 渲染程序
-     * @param node 程序节点
-     * @param context 渲染上下文
-     * @returns 渲染结果
-     */
-    private renderProgram;
-    /**
-     * 渲染 AST
-     * @param ast 抽象语法树
-     * @param initialScope 初始作用域
-     * @returns 渲染结果
-     */
-    render(ast: Program, initialScope?: Record<string, any>): string;
-}
-/**
- * 渲染器实例
- */
-declare const renderer: DejavuRenderer;
-
-/**
- * DejaVu 模板引擎词法单元定义
- */
-/**
- * 词法单元类型枚举
- */
-declare enum TokenType {
-    /** 插值开始定界符 */
-    DELIMITER_START = "DELIMITER_START",
-    /** 插值结束定界符 */
-    DELIMITER_END = "DELIMITER_END",
-    /** 注释开始定界符 */
-    COMMENT_START = "COMMENT_START",
-    /** 注释结束定界符 */
-    COMMENT_END = "COMMENT_END",
-    /** 变量声明关键字 */
-    LET = "LET",
-    /** 微函数关键字 */
-    MICRO = "MICRO",
-    /** 命名空间关键字 */
-    NAMESPACE = "NAMESPACE",
-    /** 导入关键字 */
-    USING = "USING",
-    /** 条件语句关键字 */
-    IF = "IF",
-    /** 条件语句关键字 */
-    ELSE = "ELSE",
-    /** 循环语句关键字 */
-    LOOP = "LOOP",
-    /** 遍历关键字 */
-    IN = "IN",
-    /** 跳出循环关键字 */
-    BREAK = "BREAK",
-    /** 继续循环关键字 */
-    CONTINUE = "CONTINUE",
-    /** 匹配语句关键字 */
-    MATCH = "MATCH",
-    /** 匹配分支关键字 */
-    CASE = "CASE",
-    /** 结束语句关键字 */
-    END = "END",
-    /** 标识符 */
-    IDENTIFIER = "IDENTIFIER",
-    /** 布尔字面量 */
-    BOOLEAN_LITERAL = "BOOLEAN_LITERAL",
-    /** 数字字面量 */
-    NUMBER_LITERAL = "NUMBER_LITERAL",
-    /** 字符字面量 */
-    CHARACTER_LITERAL = "CHARACTER_LITERAL",
-    /** 字符串字面量 */
-    STRING_LITERAL = "STRING_LITERAL",
-    /** 原始标识符字面量 */
-    RAW_IDENTIFIER = "RAW_IDENTIFIER",
-    /** 赋值运算符 */
-    ASSIGN = "ASSIGN",
-    /** 加法运算符 */
-    PLUS = "PLUS",
-    /** 减法运算符 */
-    MINUS = "MINUS",
-    /** 乘法运算符 */
-    MULTIPLY = "MULTIPLY",
-    /** 除法运算符 */
-    DIVIDE = "DIVIDE",
-    /** 取模运算符 */
-    MODULO = "MODULO",
-    /** 逻辑与运算符 */
-    LOGICAL_AND = "LOGICAL_AND",
-    /** 逻辑或运算符 */
-    LOGICAL_OR = "LOGICAL_OR",
-    /** 逻辑非运算符 */
-    LOGICAL_NOT = "LOGICAL_NOT",
-    /** 等于运算符 */
-    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",
-    /** 左括号 */
-    LEFT_PAREN = "LEFT_PAREN",
-    /** 右括号 */
-    RIGHT_PAREN = "RIGHT_PAREN",
-    /** 左方括号 */
-    LEFT_BRACKET = "LEFT_BRACKET",
-    /** 右方括号 */
-    RIGHT_BRACKET = "RIGHT_BRACKET",
-    /** 左花括号 */
-    LEFT_BRACE = "LEFT_BRACE",
-    /** 右花括号 */
-    RIGHT_BRACE = "RIGHT_BRACE",
-    /** 分号 */
-    SEMICOLON = "SEMICOLON",
-    /** 逗号 */
-    COMMA = "COMMA",
-    /** 点号 */
-    DOT = "DOT",
-    /** 冒号 */
-    COLON = "COLON",
-    /** 双冒号 */
-    DOUBLE_COLON = "DOUBLE_COLON",
-    /** 范围运算符 */
-    RANGE = "RANGE",
-    /** 文本 */
-    TEXT = "TEXT",
-    /** 注释 */
-    COMMENT = "COMMENT",
-    /** 结束标记 */
-    EOF = "EOF"
-}
-/**
- * 词法单元接口
- */
-interface Token {
-    /** 词法单元类型 */
-    type: TokenType;
-    /** 词法单元值 */
-    value: string;
-    /** 位置信息 */
-    loc: {
-        /** 开始位置 */
-        start: {
-            line: number;
-            column: number;
-        };
-        /** 结束位置 */
-        end: {
-            line: number;
-            column: number;
-        };
-    };
-}
-/**
- * 创建词法单元
- * @param type 词法单元类型
- * @param value 词法单元值
- * @param startLine 开始行号
- * @param startColumn 开始列号
- * @param endLine 结束行号
- * @param endColumn 结束列号
- * @returns 词法单元
- */
-declare function createToken(type: TokenType, value: string, startLine: number, startColumn: number, endLine: number, endColumn: number): Token;
-
-/**
- * DejaVu 模板引擎词法分析器
- */
-
-/**
- * 词法分析器类
- */
-declare class Lexer {
-    /** 模板源代码 */
-    readonly source: string;
-    /** 当前位置 */
-    private position;
-    /** 当前行号 */
-    private line;
-    /** 当前列号 */
-    private column;
-    /** 定界符配置 */
-    private delimiters;
-    /**
-     * 构造函数
-     * @param source 模板源代码
-     * @param language 语言配置
-     */
-    constructor(source: string, language?: DejavuLanguage);
-    /**
-     * 获取下一个词法单元
-     * @returns 词法单元
-     */
-    nextToken(): Token;
-    /**
-     * 跳过空白字符
-     */
-    private skipWhitespace;
-    /**
-     * 检查定界符
-     * @returns 词法单元，如果不是定界符则返回null
-     */
-    private checkDelimiters;
-    /**
-     * 检查注释
-     * @returns 词法单元，如果不是注释则返回null
-     */
-    private checkComment;
-    /**
-     * 检查标识符和关键字
-     * @returns 词法单元，如果不是标识符或关键字则返回null
-     */
-    private checkIdentifier;
-    /**
-     * 检查是否为标识符的开始字符
-     * @param char 字符
-     * @returns 是否为标识符的开始字符
-     */
-    private isIdentifierStart;
-    /**
-     * 检查是否为标识符的组成字符
-     * @param char 字符
-     * @returns 是否为标识符的组成字符
-     */
-    private isIdentifierPart;
-    /**
-     * 检查是否为关键字
-     * @param identifier 标识符
-     * @param startLine 开始行号
-     * @param startColumn 开始列号
-     * @returns 词法单元，如果不是关键字则返回null
-     */
-    private checkKeyword;
-    /**
-     * 检查字面量
-     * @returns 词法单元，如果不是字面量则返回null
-     */
-    private checkLiteral;
-    /**
-     * 检查数字字面量
-     * @returns 词法单元，如果不是数字字面量则返回null
-     */
-    private checkNumberLiteral;
-    /**
-     * 检查字符是否为数字
-     * @param char 字符
-     * @returns 是否为数字
-     */
-    private isDigit;
-    /**
-     * 检查字符字面量
-     * @returns 词法单元，如果不是字符字面量则返回null
-     */
-    private checkCharacterLiteral;
-    /**
-     * 检查字符串字面量
-     * @returns 词法单元，如果不是字符串字面量则返回null
-     */
-    private checkStringLiteral;
-    /**
-     * 检查原始标识符字面量
-     * @returns 词法单元，如果不是原始标识符字面量则返回null
-     */
-    private checkRawIdentifier;
-    /**
-     * 检查运算符和标点符号
-     * @returns 词法单元，如果不是运算符或标点符号则返回null
-     */
-    private checkOperator;
-    /**
-     * 检查文本
-     * @returns 词法单元，如果不是文本则返回null
-     */
-    private checkText;
-    /**
-     * 创建词法单元
-     * @param type 词法单元类型
-     * @param value 词法单元值
-     * @param startLine 开始行号
-     * @param startColumn 开始列号
-     * @param endLine 结束行号
-     * @param endColumn 结束列号
-     * @returns 词法单元
-     */
-    private createToken;
-}
-/**
- * 创建词法分析器
- * @param source 模板源代码
- * @param language 语言配置
- * @returns 词法分析器实例
- */
-declare function createLexer(source: string, language?: DejavuLanguage): Lexer;
-
-/**
- * DejaVu 模板引擎语法分析器
- */
-
-/**
- * 语法分析器类
- */
-declare class Parser {
-    /** 词法分析器 */
-    private lexer;
-    /** 当前词法单元 */
-    private currentToken;
-    /** 是否在模板模式 */
-    private inTemplateMode;
-    /**
-     * 构造函数
-     * @param source 模板源代码
-     * @param language 语言配置
-     */
-    constructor(source: string, language?: DejavuLanguage);
-    /**
-     * 解析模板，生成AST
-     * @returns 程序节点
-     */
-    parse(): Program;
-    /**
-     * 解析文本节点
-     * @returns 文本节点
-     */
-    private parseText;
-    /**
-     * 解析注释节点
-     * @returns 注释节点
-     */
-    private parseComment;
-    /**
-     * 解析模板表达式
-     * @returns 语句或表达式节点，如果遇到结束标记则返回null
-     */
-    private parseTemplateExpression;
-    /**
-     * 解析模板内的语句
-     * @returns 语句或表达式节点
-     */
-    private parseTemplateStatement;
-    /**
-     * 解析模板内的表达式或赋值语句
-     * @returns 表达式或赋值语句节点
-     */
-    private parseTemplateExpressionOrAssignment;
-    /**
-     * 解析模板内的if语句（支持else if和end if）
-     * @returns if语句节点
-     */
-    private parseTemplateIfStatement;
-    /**
-     * 解析模板内的循环语句（支持loop item in list和end loop）
-     * @returns 循环语句节点
-     */
-    private parseTemplateLoopStatement;
-    /**
-     * 解析传统for循环
-     * @param startLoc 起始位置
-     * @returns for循环语句节点
-     */
-    private parseTraditionalForLoop;
-    /**
-     * 解析for-in遍历循环
-     * @param startLoc 起始位置
-     * @returns for-in循环语句节点
-     */
-    private parseForInLoop;
-    /**
-     * 解析模板内的match语句
-     * @returns match语句节点
-     */
-    private parseTemplateMatchStatement;
-    /**
-     * 解析微函数声明（支持end micro）
-     * @returns 函数声明节点
-     */
-    private parseMicroDeclaration;
-    /**
-     * 解析带类型注解的参数
-     * @returns 带类型注解的参数节点
-     */
-    private parseTypedParameter;
-    /**
-     * 解析命名空间声明
-     * @returns 命名空间声明节点
-     */
-    private parseNamespaceDeclaration;
-    /**
-     * 解析using导入声明
-     * @returns using声明节点
-     */
-    private parseUsingDeclaration;
-    /**
-     * 解析模板块（直到遇到指定的结束关键字）
-     * @param endKeywords 结束关键字列表
-     * @returns 块语句节点
-     */
-    private parseTemplateBlock;
-    /**
-     * 将文本节点转换为注释节点（用于模板块内）
-     */
-    private parseTextAsComment;
-    /**
-     * 跳过结束标记
-     * @param keyword 关键字名称
-     */
-    private skipEndMarker;
-    /**
-     * 解析break语句
-     * @returns 表达式语句节点
-     */
-    private parseBreakStatement;
-    /**
-     * 解析continue语句
-     * @returns 表达式语句节点
-     */
-    private parseContinueStatement;
-    /**
-     * 解析语句
-     * @returns 语句节点
-     */
-    private parseStatement;
-    /**
-     * 解析变量声明
-     * @returns 变量声明节点
-     */
-    private parseVariableDeclaration;
-    /**
-     * 解析函数声明（传统模式）
-     * @returns 函数声明节点
-     */
-    private parseFunctionDeclaration;
-    /**
-     * 解析if语句（传统模式）
-     * @returns if语句节点
-     */
-    private parseIfStatement;
-    /**
-     * 解析循环语句（传统模式）
-     * @returns 循环语句节点
-     */
-    private parseLoopStatement;
-    /**
-     * 解析块语句
-     * @returns 块语句节点
-     */
-    private parseBlockStatement;
-    /**
-     * 解析赋值语句
-     * @returns 赋值语句节点
-     */
-    private parseAssignmentStatement;
-    /**
-     * 解析表达式语句
-     * @returns 表达式语句节点
-     */
-    private parseExpressionStatement;
-    /**
-     * 解析表达式
-     * @returns 表达式节点
-     */
-    private parseExpression;
-    /**
-     * 解析逻辑或表达式
-     * @returns 表达式节点
-     */
-    private parseLogicalOrExpression;
-    /**
-     * 解析逻辑与表达式
-     * @returns 表达式节点
-     */
-    private parseLogicalAndExpression;
-    /**
-     * 解析比较表达式
-     * @returns 表达式节点
-     */
-    private parseComparisonExpression;
-    /**
-     * 检查是否为比较运算符
-     */
-    private isComparisonOperator;
-    /**
-     * 解析加法表达式
-     * @returns 表达式节点
-     */
-    private parseAdditiveExpression;
-    /**
-     * 解析乘法表达式
-     * @returns 表达式节点
-     */
-    private parseMultiplicativeExpression;
-    /**
-     * 解析范围表达式
-     * @returns 表达式节点
-     */
-    private parseRangeExpression;
-    /**
-     * 解析一元表达式
-     * @returns 表达式节点
-     */
-    private parseUnaryExpression;
-    /**
-     * 解析 primary 表达式
-     * @returns 表达式节点
-     */
-    private parsePrimaryExpression;
-    /**
-     * 解析标识符节点（仅返回Identifier，不处理调用或成员访问）
-     */
-    private parseIdentifierNode;
-    /**
-     * 解析标识符表达式（可能包含调用或成员访问）
-     */
-    private parseIdentifierExpression;
-    /**
-     * 解析数字字面量
-     * @returns 字面量节点
-     */
-    private parseNumberLiteral;
-    /**
-     * 解析字符串字面量
-     * @returns 字面量节点
-     */
-    private parseStringLiteral;
-    /**
-     * 解析布尔字面量
-     * @returns 字面量节点
-     */
-    private parseBooleanLiteral;
-    /**
-     * 解析字符字面量
-     * @returns 字面量节点
-     */
-    private parseCharacterLiteral;
-    /**
-     * 解析括号表达式
-     * @returns 表达式节点
-     */
-    private parseParenthesizedExpression;
-    /**
-     * 解析数组表达式
-     * @returns 数组表达式节点
-     */
-    private parseArrayExpression;
-    /**
-     * 解析对象表达式
-     * @returns 对象表达式节点
-     */
-    private parseObjectExpression;
-    /**
-     * 解析函数调用表达式
-     * @param callee 被调用的函数
-     * @returns 函数调用表达式节点
-     */
-    private parseCallExpression;
-    /**
-     * 解析成员访问表达式
-     * @param object 对象表达式
-     * @returns 成员访问表达式节点
-     */
-    private parseMemberExpression;
-    /**
-     * 解析后缀表达式（处理成员访问和链式调用）
-     */
-    private parsePostfixExpression;
-    /**
-     * 检查当前token是否为指定类型
-     */
-    private isToken;
-    /**
-     * 期望并消费指定类型的token
-     */
-    private expectAndConsume;
-    /**
-     * 消费可选的分号
-     */
-    private consumeOptionalSemicolon;
-    /**
-     * 创建位置信息
-     */
-    private createLoc;
-    /**
-     * 前进到下一个词法单元
-     */
-    private advance;
-}
-/**
- * 创建解析器
- * @param source 模板源代码
- * @param language 语言配置
- * @returns 解析器实例
- */
-declare function createParser(source: string, language?: DejavuLanguage): Parser;
-/**
- * 解析模板，生成AST
- * @param source 模板源代码
- * @param language 语言配置
- * @returns 程序节点
- */
-declare function parse(source: string, language?: DejavuLanguage): Program;
-
-export { type ArrayExpression, type AssignmentStatement, type BinaryExpression, type BlockStatement, type CallExpression, type Comment, DEFAULT_TEMPLATE_CONFIG, DejavuEngine, DejavuLanguage, DejavuRenderer, type ElseIfClause, type Expression, type ExpressionStatement, type ForInStatement, type ForStatement, type FunctionDeclaration, type Identifier, type IfStatement, Lexer, type Literal, type MatchCase, type MatchStatement, type MemberExpression, type NamespaceDeclaration, type Node, NodeType, type ObjectExpression, type ObjectProperty, Parser, type Program, type RangeExpression, type RenderContext, type Statement, SyntaxMode, type TemplateConfig, type TemplateExpression, type TemplateLiteral, type Text, type Token, TokenType, type TypedParameter, type UnaryExpression, type UsingDeclaration, type VariableDeclaration, type WhileStatement, checkTemplate, createArrayExpression, createAssignmentStatement, createBinaryExpression, createBlockStatement, createCallExpression, createComment, createElseIfClause, createExpressionStatement, createForInStatement, createForStatement, createFunctionDeclaration, createIdentifier, createIfStatement, createLexer, createLiteral, createMatchCase, createMatchStatement, createMemberExpression, createNamespaceDeclaration, createObjectExpression, createObjectProperty, createParser, createProgram, createRangeExpression, createTemplateExpression, createText, createToken, createTypedParameter, createUnaryExpression, createUsingDeclaration, createVariableDeclaration, createWhileStatement, engine, language, parse, registerTemplate, renderTemplate, renderer };
+export { htmlEscape, valueToString, isTruthy, applyFilter, binary, unary, exprMember, exprIndex, } from "./runtime/index.js";