@codehz/json-expr 0.6.0 → 0.6.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-//#region src/ast-types.ts
+//#region src/types/ast-types.ts
 const PRECEDENCE = {
 	"||": 1,
 	"??": 1,
@@ -50,7 +50,7 @@ const BUILTIN_CONSTRUCTORS = new Set([
 ]);
 
 //#endregion
-//#region src/generate.ts
+//#region src/core/generate.ts
 /**
 * 创建新的生成上下文
 */
@@ -314,749 +314,463 @@ function transformPlaceholders(node, transform) {
 		default: return node;
 	}
 }
-
-//#endregion
-//#region src/proxy-metadata.ts
 /**
-* 全局 WeakMap 存储
+* 统计 AST 中各标识符名称的出现次数
+* 用于判断子表达式是否应该内联（引用次数 = 1 则内联，> 1 则推迟为独立编译）
 */
-const proxyMetadata = /* @__PURE__ */ new WeakMap();
+function countIdentifierReferences(node, counts) {
+	switch (node.type) {
+		case "Identifier":
+			counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
+			break;
+		case "Placeholder": break;
+		case "BinaryExpr":
+			countIdentifierReferences(node.left, counts);
+			countIdentifierReferences(node.right, counts);
+			break;
+		case "UnaryExpr":
+			countIdentifierReferences(node.argument, counts);
+			break;
+		case "ConditionalExpr":
+			countIdentifierReferences(node.test, counts);
+			countIdentifierReferences(node.consequent, counts);
+			countIdentifierReferences(node.alternate, counts);
+			break;
+		case "MemberExpr":
+			countIdentifierReferences(node.object, counts);
+			if (node.computed) countIdentifierReferences(node.property, counts);
+			break;
+		case "CallExpr":
+			countIdentifierReferences(node.callee, counts);
+			for (const arg of node.arguments) countIdentifierReferences(arg, counts);
+			break;
+		case "ArrayExpr":
+			for (const el of node.elements) countIdentifierReferences(el, counts);
+			break;
+		case "ObjectExpr":
+			for (const prop of node.properties) {
+				if (prop.computed) countIdentifierReferences(prop.key, counts);
+				countIdentifierReferences(prop.value, counts);
+			}
+			break;
+		case "ArrowFunctionExpr":
+			{
+				const paramNames = new Set(node.params.filter((p) => p.type === "Identifier").map((p) => p.name));
+				const bodyCounts = /* @__PURE__ */ new Map();
+				countIdentifierReferences(node.body, bodyCounts);
+				for (const [name, count] of bodyCounts) if (!paramNames.has(name)) counts.set(name, (counts.get(name) ?? 0) + count);
+			}
+			break;
+	}
+}
+
+//#endregion
+//#region src/core/parser/constants.ts
 /**
-* 设置 Proxy 元数据
+* 解析器常量定义
 */
-function setProxyMetadata(proxy, metadata) {
-	proxyMetadata.set(proxy, metadata);
-}
 /**
-* 获取 Proxy 元数据
+* 运算符列表，按长度排序（长的在前）以确保正确匹配
 */
-function getProxyMetadata(proxy) {
-	return proxyMetadata.get(proxy);
-}
-
-//#endregion
-//#region src/proxy-variable.ts
-const typedArrayConstructors = [
-	"Int8Array",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Int16Array",
-	"Uint16Array",
-	"Int32Array",
-	"Uint32Array",
-	"Float32Array",
-	"Float64Array",
-	"BigInt64Array",
-	"BigUint64Array"
+const OPERATORS = [
+	"instanceof",
+	">>>",
+	"===",
+	"!==",
+	"&&",
+	"||",
+	"??",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"<<",
+	">>",
+	"**",
+	"in",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"<",
+	">",
+	"&",
+	"|",
+	"^"
 ];
 /**
-* 创建占位符 AST 节点
+* 关键字运算符（需要后面不能跟标识符字符）
 */
-function placeholder(id) {
-	return {
-		type: "Placeholder",
-		id
-	};
-}
+const KEYWORD_OPERATORS = new Set(["in", "instanceof"]);
 /**
-* 创建标识符 AST 节点
+* 转义字符映射
 */
-function identifier(name) {
-	return {
-		type: "Identifier",
-		name
-	};
-}
+const ESCAPE_CHARS = {
+	n: "\n",
+	r: "\r",
+	t: "	",
+	"\\": "\\",
+	"'": "'",
+	"\"": "\"",
+	"`": "`"
+};
+
+//#endregion
+//#region src/core/parser/utils.ts
 /**
-* 创建数字字面量 AST 节点
+* 解析器工具函数
 */
-function numberLiteral(value) {
-	return {
-		type: "NumberLiteral",
-		value,
-		raw: String(value)
-	};
-}
 /**
-* 创建字符串字面量 AST 节点
+* 判断字符是否为数字 0-9
 */
-function stringLiteral(value, quote = "\"") {
-	return {
-		type: "StringLiteral",
-		value,
-		quote
-	};
+function isDigit(ch) {
+	const code = ch.charCodeAt(0);
+	return code >= 48 && code <= 57;
 }
 /**
-* 创建成员表达式 AST 节点
+* 判断字符是否为十六进制数字 0-9, A-F, a-f
 */
-function memberExpr(object, property) {
-	return {
-		type: "MemberExpr",
-		object,
-		property,
-		computed: false,
-		optional: false
-	};
+function isHexDigit(ch) {
+	const code = ch.charCodeAt(0);
+	return code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
 }
 /**
-* 创建调用表达式 AST 节点
+* 判断字符是否可以作为标识符的开头（字母、下划线、$）
 */
-function callExpr(callee, arguments_) {
-	return {
-		type: "CallExpr",
-		callee,
-		arguments: arguments_,
-		optional: false
-	};
+function isIdentifierStart(ch) {
+	const code = ch.charCodeAt(0);
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 36;
 }
 /**
-* 创建数组表达式 AST 节点
+* 判断字符是否可以作为标识符的一部分（字母、数字、下划线、$）
 */
-function arrayExpr(elements) {
-	return {
-		type: "ArrayExpr",
-		elements
-	};
+function isIdentifierPart(ch) {
+	const code = ch.charCodeAt(0);
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95 || code === 36;
 }
+
+//#endregion
+//#region src/core/parser/tokenizer.ts
 /**
-* 检查对象是否为 TypedArray 实例
+* 词法分析器 - 负责源代码的逐字符扫描和标记识别
 */
-function getTypedArrayConstructor(value) {
-	for (const constructorName of typedArrayConstructors) {
-		const Constructor = globalThis[constructorName];
-		if (Constructor && value instanceof Constructor) return Constructor;
-	}
-	return null;
-}
 /**
-* 序列化参数为 AST 节点
-* - Proxy Variable/Expression：使用 ast 或占位符标识符
-* - 数组：返回 ArrayExpr 节点
-* - 对象：返回 ObjectExpr 节点
-* - 原始值：返回对应的字面量节点
-* - Date, RegExp, BigInt, URL, URLSearchParams, Map, Set, TypedArray, DataView: 构造函数调用
+* Tokenizer 类 - 提供词法分析的基础功能
 */
-function serializeArgumentToAST(arg) {
-	if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
-		const meta = getProxyMetadata(arg);
-		if (meta) {
-			if (meta.ast) return meta.ast;
-			if (meta.rootVariable) return placeholder(meta.rootVariable);
-		}
+var Tokenizer = class {
+	pos = 0;
+	source;
+	constructor(source) {
+		this.source = source;
 	}
-	if (Array.isArray(arg)) return arrayExpr(arg.map(serializeArgumentToAST));
-	if (typeof arg === "object" && arg !== null) {
-		if (arg instanceof Date) return callExpr(identifier("Date"), [numberLiteral(arg.getTime())]);
-		if (arg instanceof RegExp) {
-			const args = [stringLiteral(arg.source)];
-			if (arg.flags) args.push(stringLiteral(arg.flags));
-			return callExpr(identifier("RegExp"), args);
+	/**
+	* 查看当前位置的字符，不移动位置
+	*/
+	peek() {
+		return this.source[this.pos] || "";
+	}
+	/**
+	* 查看指定偏移量位置的字符，不移动位置
+	*/
+	peekAt(offset) {
+		return this.source[this.pos + offset] || "";
+	}
+	/**
+	* 前进一个字符并返回该字符
+	*/
+	advance() {
+		return this.source[this.pos++] || "";
+	}
+	/**
+	* 期望当前字符是指定字符，否则抛出错误
+	*/
+	expect(ch) {
+		if (this.peek() !== ch) throw new Error(`Expected '${ch}' at position ${this.pos}, got '${this.peek()}'`);
+		this.advance();
+	}
+	/**
+	* 跳过空白字符
+	*/
+	skipWhitespace() {
+		while (/\s/.test(this.peek())) this.advance();
+	}
+	/**
+	* 尝试匹配并消费运算符
+	* 返回匹配到的运算符，如果没有匹配则返回 null
+	*/
+	peekOperator() {
+		for (const op of OPERATORS) {
+			if (!this.source.startsWith(op, this.pos)) continue;
+			if (KEYWORD_OPERATORS.has(op)) {
+				const nextChar = this.source[this.pos + op.length];
+				if (nextChar && isIdentifierPart(nextChar)) continue;
+			}
+			return op;
 		}
-		if (typeof URL !== "undefined" && arg instanceof URL) return callExpr(identifier("URL"), [stringLiteral(arg.href)]);
-		if (typeof URLSearchParams !== "undefined" && arg instanceof URLSearchParams) {
-			const entries = [];
-			arg.forEach((value, key) => {
-				entries.push(arrayExpr([stringLiteral(key), stringLiteral(value)]));
-			});
-			return callExpr(identifier("URLSearchParams"), [arrayExpr(entries)]);
+		return null;
+	}
+	/**
+	* 尝试匹配并消费关键字
+	* 如果匹配成功则移动位置并返回 true，否则返回 false
+	*/
+	matchKeyword(keyword) {
+		if (this.source.startsWith(keyword, this.pos)) {
+			const nextChar = this.source[this.pos + keyword.length];
+			if (!nextChar || !isIdentifierPart(nextChar)) {
+				this.pos += keyword.length;
+				return true;
+			}
 		}
-		if (arg instanceof Map) {
-			const entries = [];
-			arg.forEach((value, key) => {
-				entries.push(arrayExpr([serializeArgumentToAST(key), serializeArgumentToAST(value)]));
-			});
-			return callExpr(identifier("Map"), [arrayExpr(entries)]);
+		return false;
+	}
+};
+
+//#endregion
+//#region src/core/parser/primary-parser.ts
+/**
+* PrimaryParser 类 - 继承 Tokenizer，提供基本类型的解析功能
+*/
+var PrimaryParser = class extends Tokenizer {
+	/**
+	* 解析数字字面量
+	*/
+	parseNumber() {
+		const start = this.pos;
+		if (this.peek() === "0") {
+			const next = this.peekAt(1)?.toLowerCase();
+			if (next === "x" || next === "o" || next === "b") {
+				this.advance();
+				this.advance();
+				while (isHexDigit(this.peek())) this.advance();
+				const raw = this.source.slice(start, this.pos);
+				return {
+					type: "NumberLiteral",
+					value: Number(raw),
+					raw
+				};
+			}
 		}
-		if (arg instanceof Set) {
-			const values = [];
-			arg.forEach((value) => values.push(serializeArgumentToAST(value)));
-			return callExpr(identifier("Set"), [arrayExpr(values)]);
+		while (isDigit(this.peek())) this.advance();
+		if (this.peek() === "." && isDigit(this.peekAt(1))) {
+			this.advance();
+			while (isDigit(this.peek())) this.advance();
 		}
-		const typedArrayConstructor = getTypedArrayConstructor(arg);
-		if (typedArrayConstructor) {
-			const values = [...arg].map(serializeArgumentToAST);
-			const constructorName = typedArrayConstructor.name;
-			return callExpr(identifier(constructorName), [arrayExpr(values)]);
+		if (this.peek()?.toLowerCase() === "e") {
+			this.advance();
+			if (this.peek() === "+" || this.peek() === "-") this.advance();
+			while (isDigit(this.peek())) this.advance();
 		}
-		if (arg instanceof ArrayBuffer) {
-			const uint8Array = new Uint8Array(arg);
-			const values = Array.from(uint8Array).map(numberLiteral);
-			return memberExpr(callExpr(identifier("Uint8Array"), [arrayExpr(values)]), identifier("buffer"));
+		const raw = this.source.slice(start, this.pos);
+		return {
+			type: "NumberLiteral",
+			value: Number(raw),
+			raw
+		};
+	}
+	/**
+	* 解析字符串字面量
+	*/
+	parseString() {
+		const quote = this.peek();
+		this.advance();
+		let value = "";
+		while (this.pos < this.source.length && this.peek() !== quote) if (this.peek() === "\\") {
+			this.advance();
+			const escaped = this.peek();
+			value += ESCAPE_CHARS[escaped] ?? escaped;
+			this.advance();
+		} else {
+			value += this.peek();
+			this.advance();
 		}
-		if (arg instanceof DataView) return callExpr(identifier("DataView"), [serializeArgumentToAST(arg.buffer)]);
+		this.expect(quote);
 		return {
-			type: "ObjectExpr",
-			properties: Object.entries(arg).map(([k, v]) => {
-				return {
-					key: /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? identifier(k) : stringLiteral(k),
-					value: serializeArgumentToAST(v),
-					computed: false,
-					shorthand: false
-				};
-			})
+			type: "StringLiteral",
+			value,
+			quote
 		};
 	}
-	if (arg === null) return { type: "NullLiteral" };
-	if (arg === void 0) return identifier("undefined");
-	if (typeof arg === "boolean") return {
-		type: "BooleanLiteral",
-		value: arg
-	};
-	if (typeof arg === "number") return numberLiteral(arg);
-	if (typeof arg === "string") return stringLiteral(arg);
-	if (typeof arg === "bigint") return callExpr(identifier("BigInt"), [stringLiteral(arg.toString())]);
-	throw new Error(`Unsupported argument type: ${typeof arg}`);
-}
-/**
-* 从参数中收集依赖的 Symbol
-* 递归遍历数组和对象，收集所有 Proxy 的依赖
-*/
-function collectDepsFromArgs(args, deps) {
-	for (const arg of args) if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
-		const meta = getProxyMetadata(arg);
-		if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
-		else if (Array.isArray(arg)) collectDepsFromArgs(arg, deps);
-		else if (typeof arg === "object") collectDepsFromArgs(Object.values(arg), deps);
-	}
-}
-/**
-* 创建 Proxy 的公共 handler
-*/
-function createProxyHandler(ast, deps) {
-	return {
-		get(_target, prop) {
-			if (typeof prop === "symbol") return void 0;
-			return createProxyExpressionWithAST(memberExpr(ast, identifier(String(prop))), deps);
-		},
-		apply(_target, _thisArg, args) {
-			const callAst = callExpr(ast, args.map(serializeArgumentToAST));
-			const newDeps = new Set(deps);
-			collectDepsFromArgs(args, newDeps);
-			return createProxyExpressionWithAST(callAst, newDeps);
-		}
-	};
-}
-/**
-* 创建根 Variable Proxy
-* 拦截属性访问，返回新的 expression proxy
-* 不可直接调用（apply 应该只在链式调用后可用）
-*
-* @param id - 变量的唯一标识 Symbol
-* @returns Proxy 包装的 Variable
-*/
-function createProxyVariable(id) {
-	const deps = new Set([id]);
-	const ast = placeholder(id);
-	const proxy = new Proxy(function() {}, createProxyHandler(ast, deps));
-	setProxyMetadata(proxy, {
-		type: "variable",
-		rootVariable: id,
-		dependencies: deps
-	});
-	return proxy;
-}
-/**
-* 创建带完整 AST 的 Proxy（方法调用后）
-* 可以继续链式访问和调用
-*
-* @param ast - 完整的表达式 AST
-* @param deps - 依赖集合
-* @returns Proxy 包装的 Expression
-*/
-function createProxyExpressionWithAST(ast, deps) {
-	const proxy = new Proxy(function() {}, createProxyHandler(ast, deps));
-	setProxyMetadata(proxy, {
-		type: "expression",
-		ast,
-		dependencies: deps
-	});
-	return proxy;
-}
-
-//#endregion
-//#region src/variable.ts
-/**
-* 跟踪每个 variable 的唯一 Symbol ID
-*/
-const variableIds = /* @__PURE__ */ new WeakMap();
-/**
-* 计数器用于生成唯一变量 ID
-*/
-let variableCounter = 0;
-/**
-* 创建一个类型化变量
-* 返回 Proxy 对象，支持链式属性访问和方法调用
-*
-* @example
-* ```ts
-* const x = variable<number>();
-* const config = variable<{ timeout: number }>();
-* const timeout = config.timeout; // Proxy expression
-* ```
-*/
-function variable() {
-	const id = Symbol(`var_${variableCounter++}`);
-	const proxy = createProxyVariable(id);
-	variableIds.set(proxy, id);
-	return proxy;
-}
-/**
-* 获取 variable 的唯一 Symbol ID
-*/
-function getVariableId(variable) {
-	if (typeof variable !== "object" && typeof variable !== "function" || variable === null) return void 0;
-	return variableIds.get(variable);
-}
-
-//#endregion
-//#region src/compile.ts
-const ALLOWED_GLOBALS = new Set([
-	"Math",
-	"JSON",
-	"Date",
-	"RegExp",
-	"Number",
-	"String",
-	"Boolean",
-	"Array",
-	"Object",
-	"undefined",
-	"NaN",
-	"Infinity",
-	"isNaN",
-	"isFinite",
-	"parseInt",
-	"parseFloat",
-	"BigInt",
-	"URL",
-	"URLSearchParams",
-	"Map",
-	"Set",
-	"Int8Array",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Int16Array",
-	"Uint16Array",
-	"Int32Array",
-	"Uint32Array",
-	"Float32Array",
-	"Float64Array",
-	"BigInt64Array",
-	"BigUint64Array",
-	"ArrayBuffer",
-	"DataView"
-]);
-/**
-* 将 Proxy Expression 编译为可序列化的 JSON 结构
-*
-* @template TResult - 表达式结果类型
-* @param expression - Proxy Expression，或包含 Proxy 的对象/数组/原始值
-* @param variables - 所有使用的变量定义
-* @param options - 编译选项
-* @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
-*
-* @throws 如果传入无效的表达式或未定义的变量引用
-*
-* @example
-* ```ts
-* const x = variable<number>()
-* const y = variable<number>()
-* const sum = expr({ x, y })("x + y")
-* const result = expr({ sum, x })("sum * x")
-* const compiled = compile(result, { x, y })
-* // => [["x", "y"], "($[0]+$[1])*$[0]"]
-* ```
-*/
-function compile(expression, variables, _options = {}) {
-	const ast = serializeArgumentToAST(expression);
-	const variableOrder = [];
-	const variableToIndex = /* @__PURE__ */ new Map();
-	const symbolToName = /* @__PURE__ */ new Map();
-	for (const [name, value] of Object.entries(variables)) {
-		if (!variableToIndex.has(name)) {
-			variableToIndex.set(name, variableOrder.length);
-			variableOrder.push(name);
-		}
-		const id = getVariableId(value);
-		if (id) symbolToName.set(id, name);
-	}
-	const placeholderTransformed = transformPlaceholders(ast, (id) => {
-		const name = symbolToName.get(id);
-		if (!name) return null;
-		const index = variableToIndex.get(name);
-		if (index === void 0) return null;
-		return `$[${index}]`;
-	});
-	const undefinedVars = [];
-	const transformed = transformIdentifiers(placeholderTransformed, (name) => {
-		if (name.startsWith("$[") && /^\$\[\d+\]$/.test(name)) return name;
-		if (/^_\d+$/.test(name)) return name;
-		const index = variableToIndex.get(name);
-		if (index !== void 0) return `$[${index}]`;
-		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
-		return name;
-	});
-	if (undefinedVars.length > 0) {
-		const uniqueVars = [...new Set(undefinedVars)];
-		throw new Error(`Undefined variable(s): ${uniqueVars.join(", ")}`);
-	}
-	const topLevelExprs = [];
-	compileAst(transformed, {
-		nextParamIndex: 0,
-		expressionStack: [topLevelExprs],
-		nextIndex: variableOrder.length,
-		variableCount: variableOrder.length
-	});
-	return [variableOrder, ...topLevelExprs];
-}
-function currentExprs(ctx) {
-	return ctx.expressionStack[ctx.expressionStack.length - 1];
-}
-/**
-* 提取 AST 中所有 ArrowFunctionExpr 节点，编译为 FnNode，
-* 并将原始位置替换为 $[N] 标识符引用。
-*/
-function extractAndCompileArrowFunctions(node, ctx) {
-	switch (node.type) {
-		case "ArrowFunctionExpr": return {
-			type: "Identifier",
-			name: `$[${compileArrowFunction(node, ctx)}]`
-		};
-		case "BinaryExpr": return {
-			...node,
-			left: extractAndCompileArrowFunctions(node.left, ctx),
-			right: extractAndCompileArrowFunctions(node.right, ctx)
-		};
-		case "UnaryExpr": return {
-			...node,
-			argument: extractAndCompileArrowFunctions(node.argument, ctx)
-		};
-		case "ConditionalExpr": return {
-			...node,
-			test: extractAndCompileArrowFunctions(node.test, ctx),
-			consequent: extractAndCompileArrowFunctions(node.consequent, ctx),
-			alternate: extractAndCompileArrowFunctions(node.alternate, ctx)
-		};
-		case "MemberExpr": return {
-			...node,
-			object: extractAndCompileArrowFunctions(node.object, ctx),
-			property: node.computed ? extractAndCompileArrowFunctions(node.property, ctx) : node.property
-		};
-		case "CallExpr": return {
-			...node,
-			callee: extractAndCompileArrowFunctions(node.callee, ctx),
-			arguments: node.arguments.map((arg) => extractAndCompileArrowFunctions(arg, ctx))
-		};
-		case "ArrayExpr": return {
-			...node,
-			elements: node.elements.map((el) => extractAndCompileArrowFunctions(el, ctx))
-		};
-		case "ObjectExpr": return {
-			...node,
-			properties: node.properties.map((prop) => ({
-				...prop,
-				key: prop.computed ? extractAndCompileArrowFunctions(prop.key, ctx) : prop.key,
-				value: extractAndCompileArrowFunctions(prop.value, ctx)
-			}))
-		};
-		default: return node;
-	}
-}
-function compileAst(node, ctx) {
-	if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node, ctx);
-	if (node.type === "ConditionalExpr") return compileConditional(node, ctx);
-	if (node.type === "ArrowFunctionExpr") return compileArrowFunction(node, ctx);
-	const exprStr = generate(extractAndCompileArrowFunctions(node, ctx));
-	currentExprs(ctx).push(exprStr);
-	return ctx.nextIndex++;
-}
-function compileShortCircuit(node, ctx) {
-	const exprs = currentExprs(ctx);
-	const leftIdx = compileAst(node.left, ctx);
-	const branchConditions = {
-		"||": `$[${leftIdx}]`,
-		"&&": `!$[${leftIdx}]`,
-		"??": `$[${leftIdx}]!=null`
-	};
-	const branchIdx = exprs.length;
-	exprs.push([
-		"br",
-		branchConditions[node.operator],
-		0
-	]);
-	ctx.nextIndex++;
-	compileAst(node.right, ctx);
-	const skipCount = exprs.length - branchIdx - 1;
-	exprs[branchIdx][2] = skipCount;
-	const phiIdx = ctx.nextIndex++;
-	exprs.push(["phi"]);
-	return phiIdx;
-}
-function compileConditional(node, ctx) {
-	const exprs = currentExprs(ctx);
-	const testIdx = compileAst(node.test, ctx);
-	const branchIdx = exprs.length;
-	exprs.push([
-		"br",
-		`$[${testIdx}]`,
-		0
-	]);
-	ctx.nextIndex++;
-	compileAst(node.alternate, ctx);
-	const jmpIdx = exprs.length;
-	exprs.push(["jmp", 0]);
-	ctx.nextIndex++;
-	compileAst(node.consequent, ctx);
-	const thenEndIdx = exprs.length;
-	exprs[branchIdx][2] = jmpIdx - branchIdx;
-	exprs[jmpIdx][1] = thenEndIdx - jmpIdx - 1;
-	const phiIdx = ctx.nextIndex++;
-	exprs.push(["phi"]);
-	return phiIdx;
-}
-function compileArrowFunction(node, ctx) {
-	const paramCount = node.params.length;
-	const fnIndex = ctx.nextIndex++;
-	const paramMapping = /* @__PURE__ */ new Map();
-	for (const param of node.params) if (param.type === "Placeholder") {
-		const paramName = `_${ctx.nextParamIndex++}`;
-		paramMapping.set(param.id, paramName);
-	}
-	const transformedBody = transformPlaceholders(node.body, (id) => {
-		return paramMapping.get(id) ?? null;
-	});
-	const lambdaStmts = [];
-	ctx.expressionStack.push(lambdaStmts);
-	compileAst(transformedBody, ctx);
-	ctx.expressionStack.pop();
-	const fnNode = [
-		"fn",
-		paramCount,
-		...lambdaStmts
-	];
-	currentExprs(ctx).push(fnNode);
-	return fnIndex;
-}
-
-//#endregion
-//#region src/evaluate.ts
-/**
-* 缓存已构造的求值函数，以提升重复执行性能
-*/
-const evaluatorCache = /* @__PURE__ */ new Map();
-/**
-* 判断是否是 FnNode
-*/
-function isFnNode(expr) {
-	return Array.isArray(expr) && expr[0] === "fn" && typeof expr[1] === "number";
-}
-/**
-* 判断是否是控制流节点
-*/
-function isControlFlowNode(expr) {
-	return Array.isArray(expr) && (expr[0] === "br" || expr[0] === "jmp" || expr[0] === "phi");
-}
-/**
-* 生成 lambda 函数代码
-*
-* @param fnNode - FnNode 节点
-* @param indexCounter - 全局索引计数器
-* @param paramCounter - 参数计数器
-* @returns lambda 函数代码字符串
-*/
-function generateLambdaCode(fnNode, indexCounter, paramCounter) {
-	const [, paramCount, ...stmts] = fnNode;
-	const paramStartIndex = paramCounter.value;
-	paramCounter.value += paramCount;
-	return `(${Array.from({ length: paramCount }, (_, i) => `_${paramStartIndex + i}`).join(",")})=>{${translateStmts(stmts, indexCounter, paramCounter)}}`;
-}
-/**
-* 翻译表达式列表为 JavaScript 代码
-* 使用全局索引计数器分配 $[N] 槽位
-*/
-function translateStmts(expressions, indexCounter, paramCounter) {
-	for (let i = 0; i < expressions.length; i++) {
-		const expr = expressions[i];
-		if (!expr) continue;
-		if (isControlFlowNode(expr)) {
-			const [type, , offset] = expr;
-			if ((type === "br" || type === "jmp") && offset !== void 0) {
-				const target = i + offset + 1;
-				if (target < 0 || target > expressions.length) throw new Error(`Unable to translate: invalid jump target at index ${i}. Target would be ${target}, but expression length is ${expressions.length}`);
-			}
+	/**
+	* 解析数组字面量
+	*/
+	parseArray() {
+		this.expect("[");
+		const elements = [];
+		this.skipWhitespace();
+		while (this.peek() !== "]") {
+			elements.push(this.parseExpression());
+			this.skipWhitespace();
+			if (this.peek() === ",") {
+				this.advance();
+				this.skipWhitespace();
+			} else break;
 		}
+		this.expect("]");
+		return {
+			type: "ArrayExpr",
+			elements
+		};
 	}
-	const lines = ["let $lastValue;"];
-	const indexMap = [];
-	const savedStart = indexCounter.value;
-	for (let i = 0; i < expressions.length; i++) {
-		indexMap.push(indexCounter.value);
-		const expr = expressions[i];
-		if (isFnNode(expr)) {
-			indexCounter.value++;
-			countFnNodeIndices(expr, indexCounter);
-		} else indexCounter.value++;
+	/**
+	* 解析对象字面量
+	*/
+	parseObject() {
+		this.expect("{");
+		const properties = [];
+		this.skipWhitespace();
+		while (this.peek() !== "}") {
+			const prop = this.parseObjectProperty();
+			properties.push(prop);
+			this.skipWhitespace();
+			if (this.peek() === ",") {
+				this.advance();
+				this.skipWhitespace();
+			} else break;
+		}
+		this.expect("}");
+		return {
+			type: "ObjectExpr",
+			properties
+		};
 	}
-	indexCounter.value = savedStart;
-	const processed = /* @__PURE__ */ new Set();
-	function translateRange(start, end, indent = "") {
-		let i = start;
-		while (i < end) {
-			if (processed.has(i)) {
-				i++;
-				continue;
-			}
-			const expr = expressions[i];
-			if (!expr) {
-				i++;
-				continue;
-			}
-			const varIdx = indexMap[i];
-			if (isFnNode(expr)) {
-				processed.add(i);
-				indexCounter.value++;
-				const lambdaCode = generateLambdaCode(expr, indexCounter, paramCounter);
-				lines.push(`${indent}$[${varIdx}] = $lastValue = ${lambdaCode};`);
-				i++;
-			} else if (typeof expr === "string") {
-				processed.add(i);
-				indexCounter.value++;
-				lines.push(`${indent}$[${varIdx}] = $lastValue = ${expr};`);
-				i++;
-			} else if (!Array.isArray(expr)) i++;
-			else {
-				const [type] = expr;
-				if (type === "br") {
-					processed.add(i);
-					indexCounter.value++;
-					const [, condition, skipCount] = expr;
-					const falseBlockEnd = i + skipCount;
-					let jmpIdx = -1;
-					let trueBlockEnd = falseBlockEnd + 1;
-					if (falseBlockEnd < expressions.length) {
-						const lastInFalseBranch = expressions[falseBlockEnd];
-						if (Array.isArray(lastInFalseBranch) && lastInFalseBranch[0] === "jmp") {
-							jmpIdx = falseBlockEnd;
-							const jmpOffset = lastInFalseBranch[1];
-							trueBlockEnd = jmpIdx + jmpOffset;
-							processed.add(jmpIdx);
-						}
-					}
-					const hasElse = jmpIdx >= 0;
-					lines.push(`${indent}if (!(${condition})) {`);
-					translateRange(i + 1, falseBlockEnd + 1, indent + "  ");
-					if (hasElse) {
-						lines.push(`${indent}} else {`);
-						translateRange(jmpIdx + 1, trueBlockEnd + 1, indent + "  ");
-						lines.push(`${indent}}`);
-						i = trueBlockEnd + 1;
-					} else {
-						lines.push(`${indent}}`);
-						i = falseBlockEnd + 1;
-					}
-				} else if (type === "phi") {
-					processed.add(i);
-					indexCounter.value++;
-					lines.push(`${indent}$[${varIdx}] = $lastValue;`);
-					i++;
-				} else if (type === "jmp") {
-					indexCounter.value++;
-					throw new Error(`Unable to translate: unexpected jmp at index ${i}. This should have been paired with a preceding br. Unsupported control flow structure.`);
-				} else throw new Error(`Unable to translate: unknown control flow node type.`);
-			}
+	/**
+	* 解析对象属性
+	*/
+	parseObjectProperty() {
+		this.skipWhitespace();
+		let key;
+		let computed = false;
+		if (this.peek() === "[") {
+			this.advance();
+			this.skipWhitespace();
+			key = this.parseExpression();
+			this.skipWhitespace();
+			this.expect("]");
+			computed = true;
+		} else if (this.peek() === "\"" || this.peek() === "'") key = this.parseString();
+		else key = this.parseIdentifier();
+		this.skipWhitespace();
+		if (this.peek() === ":") {
+			this.advance();
+			this.skipWhitespace();
+			const value = this.parseExpression();
+			return {
+				key,
+				value,
+				computed,
+				shorthand: false
+			};
 		}
+		if (key.type !== "Identifier") throw new Error("Shorthand property must be an identifier");
+		return {
+			key,
+			value: key,
+			computed: false,
+			shorthand: true
+		};
 	}
-	translateRange(0, expressions.length);
-	lines.push("return $lastValue;");
-	return lines.join("\n");
-}
-/**
-* 计算 FnNode 内部 stmts 占用的索引数量（递归）
-*/
-function countFnNodeIndices(fnNode, indexCounter) {
-	const [, , ...stmts] = fnNode;
-	for (const stmt of stmts) if (isFnNode(stmt)) {
-		indexCounter.value++;
-		countFnNodeIndices(stmt, indexCounter);
-	} else indexCounter.value++;
-}
-/**
-* 分析并验证控制流结构，将 br/jmp/phi 翻译为 if-else 语句
-*/
-function translateControlFlow(expressions, variableCount) {
-	return translateStmts(expressions, { value: variableCount }, { value: 0 });
-}
+	/**
+	* 解析标识符
+	*/
+	parseIdentifier() {
+		const start = this.pos;
+		while (isIdentifierPart(this.peek())) this.advance();
+		const name = this.source.slice(start, this.pos);
+		if (!name) throw new Error(`Expected identifier at position ${this.pos}`);
+		return {
+			type: "Identifier",
+			name
+		};
+	}
+	/**
+	* 解析表达式 - 需要在子类中实现
+	*/
+	parseExpression() {
+		throw new Error("parseExpression must be implemented in subclass");
+	}
+};
+
+//#endregion
+//#region src/core/parser/arrow-function-parser.ts
 /**
-* 执行编译后的表达式
-*
-* @template TResult - 表达式结果类型
-* @param data - 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
-* @param values - 变量值映射，按变量名提供值
-* @returns 最后一个表达式的求值结果
-*
-* @throws 如果运行时类型验证失败或表达式执行出错
-*
-* @example
-* ```ts
-* const compiled = [["x", "y"], "$[0]+$[1]", "$[1]*2"]
-* const result = evaluate<number>(compiled, { x: 2, y: 3 })
-* // => 6  (3 * 2)
-* ```
+* ArrowFunctionParser 类 - 继承 PrimaryParser，添加箭头函数解析功能
 */
-function evaluate(data, values) {
-	if (data.length < 1) throw new Error("Invalid compiled data: must have at least variable names");
-	const [variableNames, ...expressions] = data;
-	if (!Array.isArray(variableNames)) throw new Error("Invalid compiled data: first element must be variable names array");
-	for (const varName of variableNames) {
-		if (typeof varName !== "string") throw new Error("Invalid compiled data: variable names must be strings");
-		if (!(varName in values)) throw new Error(`Missing required variable: ${varName}`);
-	}
-	const valueArray = [];
-	for (const varName of variableNames) valueArray.push(values[varName]);
-	const cacheKey = JSON.stringify(data);
-	let evaluator = evaluatorCache.get(cacheKey);
-	if (!evaluator) {
-		const functionBody = buildEvaluatorFunctionBody(expressions, variableNames.length);
-		evaluator = new Function("$", functionBody);
-		evaluatorCache.set(cacheKey, evaluator);
+var ArrowFunctionParser = class extends PrimaryParser {
+	/**
+	* 尝试解析带括号的箭头函数: (a, b) => expr
+	* 使用回溯机制
+	*/
+	tryParseArrowFunction() {
+		const savedPos = this.pos;
+		try {
+			this.expect("(");
+			this.skipWhitespace();
+			const params = [];
+			while (this.peek() !== ")") {
+				if (!isIdentifierStart(this.peek())) throw new Error("Expected identifier");
+				params.push(this.parseIdentifier());
+				this.skipWhitespace();
+				if (this.peek() === ",") {
+					this.advance();
+					this.skipWhitespace();
+				} else break;
+			}
+			this.expect(")");
+			this.skipWhitespace();
+			if (this.source.slice(this.pos, this.pos + 2) !== "=>") throw new Error("Expected =>");
+			this.pos += 2;
+			this.skipWhitespace();
+			return {
+				type: "ArrowFunctionExpr",
+				params,
+				body: this.parseExpression()
+			};
+		} catch {
+			this.pos = savedPos;
+			return null;
+		}
 	}
-	try {
-		return evaluator(valueArray);
-	} catch (error) {
-		throw new Error(`Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`);
+	/**
+	* 尝试解析单参数无括号的箭头函数: a => expr
+	* 使用回溯机制
+	*/
+	tryParseSingleParamArrowFunction() {
+		const savedPos = this.pos;
+		try {
+			const param = this.parseIdentifier();
+			this.skipWhitespace();
+			if (this.source.slice(this.pos, this.pos + 2) !== "=>") throw new Error("Expected =>");
+			this.pos += 2;
+			this.skipWhitespace();
+			const body = this.parseExpression();
+			return {
+				type: "ArrowFunctionExpr",
+				params: [param],
+				body
+			};
+		} catch {
+			this.pos = savedPos;
+			return null;
+		}
 	}
-}
-/**
-* 构造求值函数体
-*
-* @param expressions - 表达式列表（可包含控制流节点和 FnNode）
-* @param variableCount - 变量数量
-* @returns 函数体字符串
-*/
-function buildEvaluatorFunctionBody(expressions, variableCount) {
-	if (expressions.length === 0) throw new Error("No expressions to evaluate");
-	return translateControlFlow(expressions, variableCount);
-}
+};
 
 //#endregion
-//#region src/parser.ts
-var Parser = class Parser {
-	pos = 0;
-	source;
-	constructor(source) {
-		this.source = source;
-	}
-	parse() {
-		this.skipWhitespace();
-		const node = this.parseExpression();
-		this.skipWhitespace();
-		if (this.pos < this.source.length) throw new Error(`Unexpected token at position ${this.pos}: ${this.source.slice(this.pos, this.pos + 10)}`);
-		return node;
-	}
+//#region src/core/parser/expression-parser.ts
+/**
+* ExpressionParser 类 - 继承 ArrowFunctionParser，实现完整的表达式解析功能
+*/
+var ExpressionParser = class extends ArrowFunctionParser {
+	/**
+	* 解析表达式的入口
+	*/
 	parseExpression() {
 		return this.parseConditional();
 	}
+	/**
+	* 解析条件（三元）表达式: test ? consequent : alternate
+	*/
 	parseConditional() {
 		let node = this.parseBinary(0);
 		this.skipWhitespace();
@@ -1077,6 +791,9 @@ var Parser = class Parser {
 		}
 		return node;
 	}
+	/**
+	* 解析二元表达式，使用优先级爬升算法
+	*/
 	parseBinary(minPrec) {
 		let left = this.parseUnary();
 		while (true) {
@@ -1096,6 +813,9 @@ var Parser = class Parser {
 		}
 		return left;
 	}
+	/**
+	* 解析一元表达式
+	*/
 	parseUnary() {
 		this.skipWhitespace();
 		const ch = this.peek();
@@ -1120,6 +840,9 @@ var Parser = class Parser {
 		}
 		return this.parsePostfix();
 	}
+	/**
+	* 解析后缀表达式（成员访问、函数调用、可选链等）
+	*/
 	parsePostfix() {
 		let node = this.parsePrimary();
 		while (true) {
@@ -1200,10 +923,13 @@ var Parser = class Parser {
 		}
 		return node;
 	}
+	/**
+	* 解析基本表达式（字面量、标识符、括号表达式、箭头函数等）
+	*/
 	parsePrimary() {
 		this.skipWhitespace();
 		const ch = this.peek();
-		if (this.isDigit(ch) || ch === "." && this.isDigit(this.peekAt(1))) return this.parseNumber();
+		if (isDigit(ch) || ch === "." && isDigit(this.peekAt(1))) return this.parseNumber();
 		if (ch === "\"" || ch === "'" || ch === "`") return this.parseString();
 		if (ch === "[") return this.parseArray();
 		if (ch === "{") return this.parseObject();
@@ -1230,316 +956,355 @@ var Parser = class Parser {
 			type: "Identifier",
 			name: "undefined"
 		};
-		if (this.isIdentifierStart(ch)) {
+		if (isIdentifierStart(ch)) {
 			const arrowFunc = this.tryParseSingleParamArrowFunction();
 			if (arrowFunc) return arrowFunc;
 			return this.parseIdentifier();
 		}
 		throw new Error(`Unexpected character at position ${this.pos}: ${ch}`);
 	}
-	parseNumber() {
-		const start = this.pos;
-		if (this.peek() === "0") {
-			const next = this.peekAt(1)?.toLowerCase();
-			if (next === "x" || next === "o" || next === "b") {
-				this.advance();
-				this.advance();
-				while (this.isHexDigit(this.peek())) this.advance();
-				const raw = this.source.slice(start, this.pos);
-				return {
-					type: "NumberLiteral",
-					value: Number(raw),
-					raw
-				};
-			}
-		}
-		while (this.isDigit(this.peek())) this.advance();
-		if (this.peek() === "." && this.isDigit(this.peekAt(1))) {
-			this.advance();
-			while (this.isDigit(this.peek())) this.advance();
-		}
-		if (this.peek()?.toLowerCase() === "e") {
-			this.advance();
-			if (this.peek() === "+" || this.peek() === "-") this.advance();
-			while (this.isDigit(this.peek())) this.advance();
-		}
-		const raw = this.source.slice(start, this.pos);
-		return {
-			type: "NumberLiteral",
-			value: Number(raw),
-			raw
-		};
-	}
-	static ESCAPE_CHARS = {
-		n: "\n",
-		r: "\r",
-		t: "	",
-		"\\": "\\",
-		"'": "'",
-		"\"": "\"",
-		"`": "`"
-	};
-	parseString() {
-		const quote = this.peek();
-		this.advance();
-		let value = "";
-		while (this.pos < this.source.length && this.peek() !== quote) if (this.peek() === "\\") {
-			this.advance();
-			const escaped = this.peek();
-			value += Parser.ESCAPE_CHARS[escaped] ?? escaped;
-			this.advance();
-		} else {
-			value += this.peek();
-			this.advance();
-		}
-		this.expect(quote);
-		return {
-			type: "StringLiteral",
-			value,
-			quote
-		};
-	}
-	parseArray() {
-		this.expect("[");
-		const elements = [];
+	/**
+	* 解析函数调用参数列表
+	*/
+	parseArguments() {
+		const args = [];
 		this.skipWhitespace();
-		while (this.peek() !== "]") {
-			elements.push(this.parseExpression());
+		while (this.peek() !== ")") {
+			args.push(this.parseExpression());
 			this.skipWhitespace();
 			if (this.peek() === ",") {
 				this.advance();
 				this.skipWhitespace();
 			} else break;
 		}
-		this.expect("]");
-		return {
-			type: "ArrayExpr",
-			elements
-		};
+		return args;
 	}
-	parseObject() {
-		this.expect("{");
-		const properties = [];
+};
+
+//#endregion
+//#region src/core/parser/parser.ts
+/**
+* Parser 类 - 完整的 JavaScript 表达式解析器
+*/
+var Parser = class extends ExpressionParser {
+	/**
+	* 解析表达式字符串为 AST
+	*/
+	parse() {
 		this.skipWhitespace();
-		while (this.peek() !== "}") {
-			const prop = this.parseObjectProperty();
-			properties.push(prop);
-			this.skipWhitespace();
-			if (this.peek() === ",") {
-				this.advance();
-				this.skipWhitespace();
-			} else break;
-		}
-		this.expect("}");
-		return {
-			type: "ObjectExpr",
-			properties
-		};
+		const node = this.parseExpression();
+		this.skipWhitespace();
+		if (this.pos < this.source.length) throw new Error(`Unexpected token at position ${this.pos}: ${this.source.slice(this.pos, this.pos + 10)}`);
+		return node;
+	}
+};
+
+//#endregion
+//#region src/core/parser/index.ts
+/**
+* 解析 JavaScript 表达式为 AST
+*/
+function parse(source) {
+	return new Parser(source).parse();
+}
+
+//#endregion
+//#region src/proxy/proxy-metadata.ts
+/**
+* 全局 WeakMap 存储
+*/
+const proxyMetadata = /* @__PURE__ */ new WeakMap();
+/**
+* 设置 Proxy 元数据
+*/
+function setProxyMetadata(proxy, metadata) {
+	proxyMetadata.set(proxy, metadata);
+}
+/**
+* 获取 Proxy 元数据
+*/
+function getProxyMetadata(proxy) {
+	return proxyMetadata.get(proxy);
+}
+
+//#endregion
+//#region src/proxy/proxy-variable.ts
+const typedArrayConstructors = [
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+];
+/**
+* 创建占位符 AST 节点
+*/
+function placeholder(id) {
+	return {
+		type: "Placeholder",
+		id
+	};
+}
+/**
+* 创建标识符 AST 节点
+*/
+function identifier(name) {
+	return {
+		type: "Identifier",
+		name
+	};
+}
+/**
+* 创建数字字面量 AST 节点
+*/
+function numberLiteral(value) {
+	return {
+		type: "NumberLiteral",
+		value,
+		raw: String(value)
+	};
+}
+/**
+* 创建字符串字面量 AST 节点
+*/
+function stringLiteral(value, quote = "\"") {
+	return {
+		type: "StringLiteral",
+		value,
+		quote
+	};
+}
+/**
+* 创建成员表达式 AST 节点
+*/
+function memberExpr(object, property) {
+	return {
+		type: "MemberExpr",
+		object,
+		property,
+		computed: false,
+		optional: false
+	};
+}
+/**
+* 创建调用表达式 AST 节点
+*/
+function callExpr(callee, arguments_) {
+	return {
+		type: "CallExpr",
+		callee,
+		arguments: arguments_,
+		optional: false
+	};
+}
+/**
+* 创建数组表达式 AST 节点
+*/
+function arrayExpr(elements) {
+	return {
+		type: "ArrayExpr",
+		elements
+	};
+}
+/**
+* 检查对象是否为 TypedArray 实例
+*/
+function getTypedArrayConstructor(value) {
+	for (const constructorName of typedArrayConstructors) {
+		const Constructor = globalThis[constructorName];
+		if (Constructor && value instanceof Constructor) return Constructor;
 	}
-	parseObjectProperty() {
-		this.skipWhitespace();
-		let key;
-		let computed = false;
-		if (this.peek() === "[") {
-			this.advance();
-			this.skipWhitespace();
-			key = this.parseExpression();
-			this.skipWhitespace();
-			this.expect("]");
-			computed = true;
-		} else if (this.peek() === "\"" || this.peek() === "'") key = this.parseString();
-		else key = this.parseIdentifier();
-		this.skipWhitespace();
-		if (this.peek() === ":") {
-			this.advance();
-			this.skipWhitespace();
-			const value = this.parseExpression();
-			return {
-				key,
-				value,
-				computed,
-				shorthand: false
-			};
+	return null;
+}
+/**
+* 序列化参数为 AST 节点
+* - Proxy Variable/Expression：使用 ast 或占位符标识符
+* - 数组：返回 ArrayExpr 节点
+* - 对象：返回 ObjectExpr 节点
+* - 原始值：返回对应的字面量节点
+* - Date, RegExp, BigInt, URL, URLSearchParams, Map, Set, TypedArray, DataView: 构造函数调用
+*/
+function serializeArgumentToAST(arg) {
+	if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
+		const meta = getProxyMetadata(arg);
+		if (meta) {
+			if (meta.ast) return meta.ast;
+			if (meta.rootVariable) return placeholder(meta.rootVariable);
 		}
-		if (key.type !== "Identifier") throw new Error("Shorthand property must be an identifier");
-		return {
-			key,
-			value: key,
-			computed: false,
-			shorthand: true
-		};
-	}
-	parseIdentifier() {
-		const start = this.pos;
-		while (this.isIdentifierPart(this.peek())) this.advance();
-		const name = this.source.slice(start, this.pos);
-		if (!name) throw new Error(`Expected identifier at position ${this.pos}`);
-		return {
-			type: "Identifier",
-			name
-		};
 	}
-	/**
-	* 尝试解析带括号的箭头函数: (a, b) => expr
-	* 使用回溯机制
-	*/
-	tryParseArrowFunction() {
-		const savedPos = this.pos;
-		try {
-			this.expect("(");
-			this.skipWhitespace();
-			const params = [];
-			while (this.peek() !== ")") {
-				if (!this.isIdentifierStart(this.peek())) throw new Error("Expected identifier");
-				params.push(this.parseIdentifier());
-				this.skipWhitespace();
-				if (this.peek() === ",") {
-					this.advance();
-					this.skipWhitespace();
-				} else break;
-			}
-			this.expect(")");
-			this.skipWhitespace();
-			if (this.source.slice(this.pos, this.pos + 2) !== "=>") throw new Error("Expected =>");
-			this.pos += 2;
-			this.skipWhitespace();
-			return {
-				type: "ArrowFunctionExpr",
-				params,
-				body: this.parseExpression()
-			};
-		} catch {
-			this.pos = savedPos;
-			return null;
+	if (Array.isArray(arg)) return arrayExpr(arg.map(serializeArgumentToAST));
+	if (typeof arg === "object" && arg !== null) {
+		if (arg instanceof Date) return callExpr(identifier("Date"), [numberLiteral(arg.getTime())]);
+		if (arg instanceof RegExp) {
+			const args = [stringLiteral(arg.source)];
+			if (arg.flags) args.push(stringLiteral(arg.flags));
+			return callExpr(identifier("RegExp"), args);
 		}
-	}
-	/**
-	* 尝试解析单参数无括号的箭头函数: a => expr
-	* 使用回溯机制
-	*/
-	tryParseSingleParamArrowFunction() {
-		const savedPos = this.pos;
-		try {
-			const param = this.parseIdentifier();
-			this.skipWhitespace();
-			if (this.source.slice(this.pos, this.pos + 2) !== "=>") throw new Error("Expected =>");
-			this.pos += 2;
-			this.skipWhitespace();
-			const body = this.parseExpression();
-			return {
-				type: "ArrowFunctionExpr",
-				params: [param],
-				body
-			};
-		} catch {
-			this.pos = savedPos;
-			return null;
+		if (typeof URL !== "undefined" && arg instanceof URL) return callExpr(identifier("URL"), [stringLiteral(arg.href)]);
+		if (typeof URLSearchParams !== "undefined" && arg instanceof URLSearchParams) {
+			const entries = [];
+			arg.forEach((value, key) => {
+				entries.push(arrayExpr([stringLiteral(key), stringLiteral(value)]));
+			});
+			return callExpr(identifier("URLSearchParams"), [arrayExpr(entries)]);
 		}
-	}
-	parseArguments() {
-		const args = [];
-		this.skipWhitespace();
-		while (this.peek() !== ")") {
-			args.push(this.parseExpression());
-			this.skipWhitespace();
-			if (this.peek() === ",") {
-				this.advance();
-				this.skipWhitespace();
-			} else break;
+		if (arg instanceof Map) {
+			const entries = [];
+			arg.forEach((value, key) => {
+				entries.push(arrayExpr([serializeArgumentToAST(key), serializeArgumentToAST(value)]));
+			});
+			return callExpr(identifier("Map"), [arrayExpr(entries)]);
 		}
-		return args;
-	}
-	static OPERATORS = [
-		"instanceof",
-		">>>",
-		"===",
-		"!==",
-		"&&",
-		"||",
-		"??",
-		"==",
-		"!=",
-		"<=",
-		">=",
-		"<<",
-		">>",
-		"**",
-		"in",
-		"+",
-		"-",
-		"*",
-		"/",
-		"%",
-		"<",
-		">",
-		"&",
-		"|",
-		"^"
-	];
-	static KEYWORD_OPERATORS = new Set(["in", "instanceof"]);
-	peekOperator() {
-		for (const op of Parser.OPERATORS) {
-			if (!this.source.startsWith(op, this.pos)) continue;
-			if (Parser.KEYWORD_OPERATORS.has(op)) {
-				const nextChar = this.source[this.pos + op.length];
-				if (nextChar && this.isIdentifierPart(nextChar)) continue;
-			}
-			return op;
+		if (arg instanceof Set) {
+			const values = [];
+			arg.forEach((value) => values.push(serializeArgumentToAST(value)));
+			return callExpr(identifier("Set"), [arrayExpr(values)]);
 		}
-		return null;
-	}
-	matchKeyword(keyword) {
-		if (this.source.startsWith(keyword, this.pos)) {
-			const nextChar = this.source[this.pos + keyword.length];
-			if (!nextChar || !this.isIdentifierPart(nextChar)) {
-				this.pos += keyword.length;
-				return true;
-			}
+		const typedArrayConstructor = getTypedArrayConstructor(arg);
+		if (typedArrayConstructor) {
+			const values = [...arg].map(serializeArgumentToAST);
+			const constructorName = typedArrayConstructor.name;
+			return callExpr(identifier(constructorName), [arrayExpr(values)]);
 		}
-		return false;
-	}
-	peek() {
-		return this.source[this.pos] || "";
-	}
-	peekAt(offset) {
-		return this.source[this.pos + offset] || "";
-	}
-	advance() {
-		return this.source[this.pos++] || "";
-	}
-	expect(ch) {
-		if (this.peek() !== ch) throw new Error(`Expected '${ch}' at position ${this.pos}, got '${this.peek()}'`);
-		this.advance();
-	}
-	skipWhitespace() {
-		while (/\s/.test(this.peek())) this.advance();
-	}
-	isDigit(ch) {
-		const code = ch.charCodeAt(0);
-		return code >= 48 && code <= 57;
-	}
-	isHexDigit(ch) {
-		const code = ch.charCodeAt(0);
-		return code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
-	}
-	isIdentifierStart(ch) {
-		const code = ch.charCodeAt(0);
-		return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 36;
+		if (arg instanceof ArrayBuffer) {
+			const uint8Array = new Uint8Array(arg);
+			const values = Array.from(uint8Array).map(numberLiteral);
+			return memberExpr(callExpr(identifier("Uint8Array"), [arrayExpr(values)]), identifier("buffer"));
+		}
+		if (arg instanceof DataView) return callExpr(identifier("DataView"), [serializeArgumentToAST(arg.buffer)]);
+		return {
+			type: "ObjectExpr",
+			properties: Object.entries(arg).map(([k, v]) => {
+				return {
+					key: /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? identifier(k) : stringLiteral(k),
+					value: serializeArgumentToAST(v),
+					computed: false,
+					shorthand: false
+				};
+			})
+		};
 	}
-	isIdentifierPart(ch) {
-		const code = ch.charCodeAt(0);
-		return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95 || code === 36;
+	if (arg === null) return { type: "NullLiteral" };
+	if (arg === void 0) return identifier("undefined");
+	if (typeof arg === "boolean") return {
+		type: "BooleanLiteral",
+		value: arg
+	};
+	if (typeof arg === "number") return numberLiteral(arg);
+	if (typeof arg === "string") return stringLiteral(arg);
+	if (typeof arg === "bigint") return callExpr(identifier("BigInt"), [stringLiteral(arg.toString())]);
+	throw new Error(`Unsupported argument type: ${typeof arg}`);
+}
+/**
+* 从参数中收集依赖的 Symbol
+* 递归遍历数组和对象，收集所有 Proxy 的依赖
+*/
+function collectDepsFromArgs(args, deps) {
+	for (const arg of args) if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
+		const meta = getProxyMetadata(arg);
+		if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
+		else if (Array.isArray(arg)) collectDepsFromArgs(arg, deps);
+		else if (typeof arg === "object") collectDepsFromArgs(Object.values(arg), deps);
 	}
-};
+}
+/**
+* 创建 Proxy 的公共 handler
+*/
+function createProxyHandler(ast, deps) {
+	return {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpressionWithAST(memberExpr(ast, identifier(String(prop))), deps);
+		},
+		apply(_target, _thisArg, args) {
+			const callAst = callExpr(ast, args.map(serializeArgumentToAST));
+			const newDeps = new Set(deps);
+			collectDepsFromArgs(args, newDeps);
+			return createProxyExpressionWithAST(callAst, newDeps);
+		}
+	};
+}
 /**
-* 解析 JavaScript 表达式为 AST
+* 创建根 Variable Proxy
+* 拦截属性访问，返回新的 expression proxy
+* 不可直接调用（apply 应该只在链式调用后可用）
+*
+* @param id - 变量的唯一标识 Symbol
+* @returns Proxy 包装的 Variable
 */
-function parse(source) {
-	return new Parser(source).parse();
+function createProxyVariable(id) {
+	const deps = new Set([id]);
+	const ast = placeholder(id);
+	const proxy = new Proxy(function() {}, createProxyHandler(ast, deps));
+	setProxyMetadata(proxy, {
+		type: "variable",
+		rootVariable: id,
+		dependencies: deps
+	});
+	return proxy;
+}
+/**
+* 创建带完整 AST 的 Proxy（方法调用后）
+* 可以继续链式访问和调用
+*
+* @param ast - 完整的表达式 AST
+* @param deps - 依赖集合
+* @returns Proxy 包装的 Expression
+*/
+function createProxyExpressionWithAST(ast, deps, deferredAsts) {
+	const proxy = new Proxy(function() {}, createProxyHandler(ast, deps));
+	setProxyMetadata(proxy, {
+		type: "expression",
+		ast,
+		dependencies: deps,
+		deferredAsts
+	});
+	return proxy;
+}
+
+//#endregion
+//#region src/api/variable.ts
+/**
+* 跟踪每个 variable 的唯一 Symbol ID
+*/
+const variableIds = /* @__PURE__ */ new WeakMap();
+/**
+* 计数器用于生成唯一变量 ID
+*/
+let variableCounter = 0;
+/**
+* 创建一个类型化变量
+* 返回 Proxy 对象，支持链式属性访问和方法调用
+*
+* @example
+* ```ts
+* const x = variable<number>();
+* const config = variable<{ timeout: number }>();
+* const timeout = config.timeout; // Proxy expression
+* ```
+*/
+function variable() {
+	const id = Symbol(`var_${variableCounter++}`);
+	const proxy = createProxyVariable(id);
+	variableIds.set(proxy, id);
+	return proxy;
+}
+/**
+* 获取 variable 的唯一 Symbol ID
+*/
+function getVariableId(variable) {
+	if (typeof variable !== "object" && typeof variable !== "function" || variable === null) return void 0;
+	return variableIds.get(variable);
 }
 
 //#endregion
-//#region src/expr.ts
+//#region src/api/expr.ts
 /**
 * 创建表达式
 * 返回 Proxy Expression，可以继续链式调用
@@ -1591,236 +1356,690 @@ function expr(context) {
 			const meta = getProxyMetadata(value);
 			if (meta?.ast) nameToExprAST.set(name, meta.ast);
 		}
-		return createProxyExpressionWithAST(transformIdentifiers(parse(source), (name) => {
+		const ast = parse(source);
+		const refCounts = /* @__PURE__ */ new Map();
+		countIdentifierReferences(ast, refCounts);
+		const deferredAsts = /* @__PURE__ */ new Map();
+		return createProxyExpressionWithAST(transformIdentifiers(ast, (name) => {
 			const id = nameToId.get(name);
 			if (id) return {
 				type: "Placeholder",
 				id
 			};
 			const exprAST = nameToExprAST.get(name);
-			if (exprAST) return exprAST;
+			if (exprAST) {
+				if ((refCounts.get(name) ?? 0) <= 1) return exprAST;
+				deferredAsts.set(name, exprAST);
+				return name;
+			}
 			return name;
-		}), deps);
+		}), deps, deferredAsts.size > 0 ? deferredAsts : void 0);
 	};
 }
 
 //#endregion
-//#region src/lambda.ts
+//#region src/api/lambda.ts
 /**
 * Lambda 参数计数器，用于生成唯一 ID
 */
 let lambdaParamCounter = 0;
 /**
-* Lambda 参数到索引的映射
-* 用于编译时确定参数位置
+* Lambda 参数到索引的映射
+* 用于编译时确定参数位置
+*/
+const lambdaParamIndices = /* @__PURE__ */ new WeakMap();
+/**
+* 创建 lambda 参数代理
+* 生成带特殊标记的 Proxy，用于在表达式中追踪参数
+*
+* @param index - 参数索引（0, 1, 2...）
+* @returns Lambda 参数代理
+*/
+function createLambdaParam(index) {
+	const proxy = createProxyVariable(Symbol(`lambda_param_${lambdaParamCounter++}_${index}`));
+	lambdaParamIndices.set(proxy, index);
+	return proxy;
+}
+/**
+* 创建类型安全的 lambda 表达式
+*
+* @template Args - 参数类型元组
+* @template R - 返回值类型
+* @param builder - Lambda 构建函数，接收参数代理，返回函数体表达式
+* @returns Lambda 表达式代理
+*
+* @example
+* ```ts
+* const add = lambda<[number, number], number>(
+*   (a, b) => expr({ a, b })("a + b")
+* );
+*
+* const numbers = variable<number[]>();
+* const sum = numbers.reduce(add, 0);
+* ```
+*/
+function lambda(builder) {
+	const paramCount = builder.length;
+	const { params, paramSymbols } = createLambdaParams(paramCount);
+	const { bodyAst, bodyDeps } = extractBodyAstAndDeps(builder(...params));
+	const lambdaProxy = createProxyExpressionWithAST(createArrowFunctionAst(bodyAst, paramCount, paramSymbols), filterClosureDeps(bodyDeps, paramSymbols));
+	const existingMeta = getProxyMetadata(lambdaProxy);
+	if (existingMeta) setProxyMetadata(lambdaProxy, {
+		...existingMeta,
+		type: "expression"
+	});
+	return lambdaProxy;
+}
+/**
+* 创建 lambda 参数和符号映射
+*/
+function createLambdaParams(paramCount) {
+	const params = [];
+	const paramSymbols = [];
+	for (let i = 0; i < paramCount; i++) {
+		const param = createLambdaParam(i);
+		params.push(param);
+		const meta = getProxyMetadata(param);
+		if (meta?.rootVariable) paramSymbols.push(meta.rootVariable);
+	}
+	return {
+		params,
+		paramSymbols
+	};
+}
+/**
+* 从表达式中提取 AST 和依赖
+*/
+function extractBodyAstAndDeps(bodyExpr) {
+	const meta = (typeof bodyExpr === "object" || typeof bodyExpr === "function") && bodyExpr !== null ? getProxyMetadata(bodyExpr) : void 0;
+	if (meta?.ast) return {
+		bodyAst: meta.ast,
+		bodyDeps: meta.dependencies ?? /* @__PURE__ */ new Set()
+	};
+	else {
+		const bodyDeps = /* @__PURE__ */ new Set();
+		collectDepsFromArgs([bodyExpr], bodyDeps);
+		return {
+			bodyAst: serializeArgumentToAST(bodyExpr),
+			bodyDeps
+		};
+	}
+}
+/**
+* 创建箭头函数 AST
+* 使用 Placeholder 节点作为参数，在代码生成时再分配实际参数名
+*/
+function createArrowFunctionAst(bodyAst, paramCount, paramSymbols) {
+	return {
+		type: "ArrowFunctionExpr",
+		params: Array.from({ length: paramCount }, (_, i) => ({
+			type: "Placeholder",
+			id: paramSymbols[i]
+		})),
+		body: bodyAst
+	};
+}
+/**
+* 过滤掉 lambda 参数依赖，只保留外部闭包变量
+*/
+function filterClosureDeps(bodyDeps, paramSymbols) {
+	const closureDeps = /* @__PURE__ */ new Set();
+	for (const dep of bodyDeps) if (!paramSymbols.includes(dep)) closureDeps.add(dep);
+	return closureDeps;
+}
+
+//#endregion
+//#region src/api/template.ts
+/**
+* Tagged template 函数，用于创建包含变量的字符串表达式
+*
+* @example
+* ```ts
+* const name = variable<string>();
+* const count = variable<number>();
+*
+* const greeting = t`Hello, ${name}!`;
+* const message = t`You have ${count} items.`;
+*
+* const compiled = compile(greeting, { name });
+* const result = evaluate(compiled, { name: "Alice" }); // => "Hello, Alice!"
+* ```
+*/
+function t(strings, ...values) {
+	const deps = /* @__PURE__ */ new Set();
+	collectDepsFromArgs(values, deps);
+	const parts = [];
+	for (let i = 0; i < strings.length; i++) {
+		const str = strings[i];
+		if (str.length > 0) parts.push({
+			type: "StringLiteral",
+			value: str,
+			quote: "\""
+		});
+		if (i < values.length) {
+			const ast = serializeArgumentToAST(values[i]);
+			parts.push(ast);
+		}
+	}
+	if (parts.length === 0) return createProxyExpressionWithAST({
+		type: "StringLiteral",
+		value: "",
+		quote: "\""
+	}, deps);
+	if (parts.length === 1) return createProxyExpressionWithAST(parts[0], deps);
+	let resultAst = parts[0];
+	for (let i = 1; i < parts.length; i++) resultAst = {
+		type: "BinaryExpr",
+		operator: "+",
+		left: resultAst,
+		right: parts[i]
+	};
+	return createProxyExpressionWithAST(resultAst, deps);
+}
+
+//#endregion
+//#region src/api/wrap.ts
+/**
+* 将静态值包装为 Proxy Expression
+* 返回的 Proxy 可以像 Variable 一样调用方法和访问属性
+*
+* @template T - 值的类型
+* @param value - 要包装的静态值（支持原始值、对象、数组、Date、RegExp 等）
+* @returns Proxy Expression，可以继续链式调用
+*
+* @example
+* ```ts
+* // 包装 RegExp
+* const pattern = wrap(/^[a-z]+$/i);
+* const input = variable<string>();
+* const result = pattern.match(input);
+*
+* // 包装 Date
+* const now = wrap(new Date());
+* const year = now.getFullYear();
+*
+* // 包装数组
+* const numbers = wrap([1, 2, 3, 4, 5]);
+* const doubled = numbers.map((x) => x * 2);
+* ```
+*/
+function wrap(value) {
+	return createProxyExpressionWithAST(serializeArgumentToAST(value), /* @__PURE__ */ new Set());
+}
+
+//#endregion
+//#region src/core/compile.ts
+const ALLOWED_GLOBALS = new Set([
+	"Math",
+	"JSON",
+	"Date",
+	"RegExp",
+	"Number",
+	"String",
+	"Boolean",
+	"Array",
+	"Object",
+	"undefined",
+	"NaN",
+	"Infinity",
+	"isNaN",
+	"isFinite",
+	"parseInt",
+	"parseFloat",
+	"BigInt",
+	"URL",
+	"URLSearchParams",
+	"Map",
+	"Set",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"ArrayBuffer",
+	"DataView"
+]);
+/**
+* 短路运算符对应的分支条件
 */
-const lambdaParamIndices = /* @__PURE__ */ new WeakMap();
+const BRANCH_CONDITIONS = {
+	"||": (idx) => `$[${idx}]`,
+	"&&": (idx) => `!$[${idx}]`,
+	"??": (idx) => `$[${idx}]!=null`
+};
 /**
-* 创建 lambda 参数代理
-* 生成带特殊标记的 Proxy，用于在表达式中追踪参数
+* 将 Proxy Expression 编译为可序列化的 JSON 结构
 *
-* @param index - 参数索引（0, 1, 2...）
-* @returns Lambda 参数代理
-*/
-function createLambdaParam(index) {
-	const proxy = createProxyVariable(Symbol(`lambda_param_${lambdaParamCounter++}_${index}`));
-	lambdaParamIndices.set(proxy, index);
-	return proxy;
-}
-/**
-* 创建类型安全的 lambda 表达式
+* @template TResult - 表达式结果类型
+* @param expression - Proxy Expression，或包含 Proxy 的对象/数组/原始值
+* @param variables - 所有使用的变量定义
+* @param options - 编译选项
+* @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
 *
-* @template Args - 参数类型元组
-* @template R - 返回值类型
-* @param builder - Lambda 构建函数，接收参数代理，返回函数体表达式
-* @returns Lambda 表达式代理
+* @throws 如果传入无效的表达式或未定义的变量引用
 *
 * @example
 * ```ts
-* const add = lambda<[number, number], number>(
-*   (a, b) => expr({ a, b })("a + b")
-* );
-*
-* const numbers = variable<number[]>();
-* const sum = numbers.reduce(add, 0);
+* const x = variable<number>()
+* const y = variable<number>()
+* const sum = expr({ x, y })("x + y")
+* const result = expr({ sum, x })("sum * x")
+* const compiled = compile(result, { x, y })
+* // => [["x", "y"], "($[0]+$[1])*$[0]"]
 * ```
 */
-function lambda(builder) {
-	const paramCount = builder.length;
-	const { params, paramSymbols } = createLambdaParams(paramCount);
-	const { bodyAst, bodyDeps } = extractBodyAstAndDeps(builder(...params));
-	const lambdaProxy = createProxyExpressionWithAST(createArrowFunctionAst(bodyAst, paramCount, paramSymbols), filterClosureDeps(bodyDeps, paramSymbols));
-	const existingMeta = getProxyMetadata(lambdaProxy);
-	if (existingMeta) setProxyMetadata(lambdaProxy, {
-		...existingMeta,
-		type: "expression"
+function compile(expression, variables, _options = {}) {
+	let deferredAsts;
+	if ((typeof expression === "object" || typeof expression === "function") && expression !== null) deferredAsts = getProxyMetadata(expression)?.deferredAsts;
+	const ast = serializeArgumentToAST(expression);
+	const variableOrder = [];
+	const variableToIndex = /* @__PURE__ */ new Map();
+	const symbolToName = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(variables)) {
+		if (!variableToIndex.has(name)) {
+			const index = variableOrder.length;
+			variableToIndex.set(name, index);
+			variableOrder.push(name);
+		}
+		const id = getVariableId(value);
+		if (id) symbolToName.set(id, name);
+	}
+	const topLevelExprs = [];
+	const ctx = {
+		nextParamIndex: 0,
+		expressionStack: [topLevelExprs],
+		nextIndex: variableOrder.length,
+		variableCount: variableOrder.length
+	};
+	const deferredIndexMap = /* @__PURE__ */ new Map();
+	if (deferredAsts && deferredAsts.size > 0) compileDeferredExprs(deferredAsts, ctx, symbolToName, variableToIndex, deferredIndexMap);
+	const placeholderTransformed = transformPlaceholders(ast, (id) => {
+		const name = symbolToName.get(id);
+		if (!name) return null;
+		const index = variableToIndex.get(name);
+		return index !== void 0 ? `$[${index}]` : null;
 	});
-	return lambdaProxy;
+	const undefinedVars = [];
+	const transformed = transformIdentifiers(placeholderTransformed, (name) => {
+		if (/^\$\[\d+\]$/.test(name)) return name;
+		if (/^_\d+$/.test(name)) return name;
+		const index = variableToIndex.get(name);
+		if (index !== void 0) return `$[${index}]`;
+		const deferredIdx = deferredIndexMap.get(name);
+		if (deferredIdx !== void 0) return `$[${deferredIdx}]`;
+		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
+		return name;
+	});
+	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
+	compileAst(transformed, ctx);
+	return [variableOrder, ...topLevelExprs];
 }
 /**
-* 创建 lambda 参数和符号映射
+* 获取当前表达式列表
 */
-function createLambdaParams(paramCount) {
-	const params = [];
-	const paramSymbols = [];
-	for (let i = 0; i < paramCount; i++) {
-		const param = createLambdaParam(i);
-		params.push(param);
-		const meta = getProxyMetadata(param);
-		if (meta?.rootVariable) paramSymbols.push(meta.rootVariable);
+function currentExprs(ctx) {
+	return ctx.expressionStack[ctx.expressionStack.length - 1];
+}
+/**
+* 编译推迟的子表达式（因引用计数 >1 未内联）
+* 使用递归处理，自动按依赖拓扑顺序编译
+*/
+function compileDeferredExprs(deferredAsts, ctx, symbolToName, variableToIndex, deferredIndexMap) {
+	const processing = /* @__PURE__ */ new Set();
+	function compileOne(name) {
+		if (processing.has(name)) throw new Error(`Circular reference in deferred expressions: ${name}`);
+		const existing = deferredIndexMap.get(name);
+		if (existing !== void 0) return existing;
+		const ast = deferredAsts.get(name);
+		if (!ast) throw new Error(`Unknown deferred expression: ${name}`);
+		processing.add(name);
+		const t1 = transformPlaceholders(ast, (id) => {
+			const vName = symbolToName.get(id);
+			if (!vName) return null;
+			const idx = variableToIndex.get(vName);
+			return idx !== void 0 ? `$[${idx}]` : null;
+		});
+		const undefinedVars = [];
+		const t2 = transformIdentifiers(t1, (n) => {
+			if (/^\$\[\d+\]$/.test(n)) return n;
+			if (/^_\d+$/.test(n)) return n;
+			const varIdx = variableToIndex.get(n);
+			if (varIdx !== void 0) return `$[${varIdx}]`;
+			if (deferredAsts.has(n)) return `$[${compileOne(n)}]`;
+			if (!ALLOWED_GLOBALS.has(n)) undefinedVars.push(n);
+			return n;
+		});
+		if (undefinedVars.length > 0) throw new Error(`Undefined variable(s) in deferred expression "${name}": ${[...new Set(undefinedVars)].join(", ")}`);
+		const idx = compileAst(t2, ctx);
+		deferredIndexMap.set(name, idx);
+		processing.delete(name);
+		return idx;
 	}
-	return {
-		params,
-		paramSymbols
-	};
+	for (const name of deferredAsts.keys()) compileOne(name);
 }
 /**
-* 从表达式中提取 AST 和依赖
+* 提取 AST 中所有 ArrowFunctionExpr 节点，编译为 FnNode，
+* 并将原始位置替换为 $[N] 标识符引用。
 */
-function extractBodyAstAndDeps(bodyExpr) {
-	const meta = (typeof bodyExpr === "object" || typeof bodyExpr === "function") && bodyExpr !== null ? getProxyMetadata(bodyExpr) : void 0;
-	if (meta?.ast) return {
-		bodyAst: meta.ast,
-		bodyDeps: meta.dependencies ?? /* @__PURE__ */ new Set()
-	};
-	else {
-		const bodyDeps = /* @__PURE__ */ new Set();
-		collectDepsFromArgs([bodyExpr], bodyDeps);
-		return {
-			bodyAst: serializeArgumentToAST(bodyExpr),
-			bodyDeps
+function extractAndCompileArrowFunctions(node, ctx) {
+	switch (node.type) {
+		case "ArrowFunctionExpr": return {
+			type: "Identifier",
+			name: `$[${compileArrowFunction(node, ctx)}]`
+		};
+		case "BinaryExpr": return {
+			...node,
+			left: extractAndCompileArrowFunctions(node.left, ctx),
+			right: extractAndCompileArrowFunctions(node.right, ctx)
+		};
+		case "UnaryExpr": return {
+			...node,
+			argument: extractAndCompileArrowFunctions(node.argument, ctx)
+		};
+		case "ConditionalExpr": return {
+			...node,
+			test: extractAndCompileArrowFunctions(node.test, ctx),
+			consequent: extractAndCompileArrowFunctions(node.consequent, ctx),
+			alternate: extractAndCompileArrowFunctions(node.alternate, ctx)
+		};
+		case "MemberExpr": return {
+			...node,
+			object: extractAndCompileArrowFunctions(node.object, ctx),
+			property: node.computed ? extractAndCompileArrowFunctions(node.property, ctx) : node.property
+		};
+		case "CallExpr": return {
+			...node,
+			callee: extractAndCompileArrowFunctions(node.callee, ctx),
+			arguments: node.arguments.map((arg) => extractAndCompileArrowFunctions(arg, ctx))
+		};
+		case "ArrayExpr": return {
+			...node,
+			elements: node.elements.map((el) => extractAndCompileArrowFunctions(el, ctx))
+		};
+		case "ObjectExpr": return {
+			...node,
+			properties: node.properties.map((prop) => ({
+				...prop,
+				key: prop.computed ? extractAndCompileArrowFunctions(prop.key, ctx) : prop.key,
+				value: extractAndCompileArrowFunctions(prop.value, ctx)
+			}))
 		};
+		default: return node;
 	}
 }
+function compileAst(node, ctx) {
+	if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node, ctx);
+	if (node.type === "ConditionalExpr") return compileConditional(node, ctx);
+	if (node.type === "ArrowFunctionExpr") return compileArrowFunction(node, ctx);
+	const exprStr = generate(extractAndCompileArrowFunctions(node, ctx));
+	currentExprs(ctx).push(exprStr);
+	return ctx.nextIndex++;
+}
+function compileShortCircuit(node, ctx) {
+	const exprs = currentExprs(ctx);
+	const leftIdx = compileAst(node.left, ctx);
+	const condition = BRANCH_CONDITIONS[node.operator]?.(leftIdx);
+	if (!condition) throw new Error(`Unexpected operator: ${node.operator}`);
+	const branchIdx = exprs.length;
+	exprs.push([
+		"br",
+		condition,
+		0
+	]);
+	ctx.nextIndex++;
+	compileAst(node.right, ctx);
+	const skipCount = exprs.length - branchIdx - 1;
+	exprs[branchIdx][2] = skipCount;
+	const phiIdx = ctx.nextIndex++;
+	exprs.push(["phi"]);
+	return phiIdx;
+}
+function compileConditional(node, ctx) {
+	const exprs = currentExprs(ctx);
+	const testIdx = compileAst(node.test, ctx);
+	const branchIdx = exprs.length;
+	exprs.push([
+		"br",
+		`$[${testIdx}]`,
+		0
+	]);
+	ctx.nextIndex++;
+	compileAst(node.alternate, ctx);
+	const jmpIdx = exprs.length;
+	exprs.push(["jmp", 0]);
+	ctx.nextIndex++;
+	compileAst(node.consequent, ctx);
+	const thenEndIdx = exprs.length;
+	exprs[branchIdx][2] = jmpIdx - branchIdx;
+	exprs[jmpIdx][1] = thenEndIdx - jmpIdx - 1;
+	const phiIdx = ctx.nextIndex++;
+	exprs.push(["phi"]);
+	return phiIdx;
+}
+function compileArrowFunction(node, ctx) {
+	const fnIndex = ctx.nextIndex++;
+	const paramMapping = /* @__PURE__ */ new Map();
+	for (const param of node.params) if (param.type === "Placeholder") paramMapping.set(param.id, `_${ctx.nextParamIndex++}`);
+	const transformedBody = transformPlaceholders(node.body, (id) => paramMapping.get(id) ?? null);
+	const lambdaStmts = [];
+	ctx.expressionStack.push(lambdaStmts);
+	compileAst(transformedBody, ctx);
+	ctx.expressionStack.pop();
+	const fnNode = [
+		"fn",
+		node.params.length,
+		...lambdaStmts
+	];
+	currentExprs(ctx).push(fnNode);
+	return fnIndex;
+}
+
+//#endregion
+//#region src/core/evaluate.ts
+/**
+* 缓存已构造的求值函数，以提升重复执行性能
+*/
+const evaluatorCache = /* @__PURE__ */ new Map();
 /**
-* 创建箭头函数 AST
-* 使用 Placeholder 节点作为参数，在代码生成时再分配实际参数名
+* 判断是否是 FnNode
 */
-function createArrowFunctionAst(bodyAst, paramCount, paramSymbols) {
-	return {
-		type: "ArrowFunctionExpr",
-		params: Array.from({ length: paramCount }, (_, i) => ({
-			type: "Placeholder",
-			id: paramSymbols[i]
-		})),
-		body: bodyAst
-	};
+function isFnNode(expr) {
+	return Array.isArray(expr) && expr[0] === "fn" && typeof expr[1] === "number";
 }
 /**
-* 过滤掉 lambda 参数依赖，只保留外部闭包变量
+* 判断是否是控制流节点
 */
-function filterClosureDeps(bodyDeps, paramSymbols) {
-	const closureDeps = /* @__PURE__ */ new Set();
-	for (const dep of bodyDeps) if (!paramSymbols.includes(dep)) closureDeps.add(dep);
-	return closureDeps;
+function isControlFlowNode(expr) {
+	return Array.isArray(expr) && (expr[0] === "br" || expr[0] === "jmp" || expr[0] === "phi");
 }
-
-//#endregion
-//#region src/template.ts
 /**
-* Tagged template 函数，用于创建包含变量的字符串表达式
-*
-* @example
-* ```ts
-* const name = variable<string>();
-* const count = variable<number>();
-*
-* const greeting = t`Hello, ${name}!`;
-* const message = t`You have ${count} items.`;
+* 生成 lambda 函数代码
 *
-* const compiled = compile(greeting, { name });
-* const result = evaluate(compiled, { name: "Alice" }); // => "Hello, Alice!"
-* ```
+* @param fnNode - FnNode 节点
+* @param indexCounter - 全局索引计数器
+* @param paramCounter - 参数计数器
+* @returns lambda 函数代码字符串
 */
-function t(strings, ...values) {
-	const deps = /* @__PURE__ */ new Set();
-	collectDepsFromArgs(values, deps);
-	const parts = [];
-	for (let i = 0; i < strings.length; i++) {
-		const str = strings[i];
-		if (str.length > 0) parts.push({
-			type: "StringLiteral",
-			value: str,
-			quote: "\""
-		});
-		if (i < values.length) {
-			const ast = serializeArgumentToAST(values[i]);
-			parts.push(ast);
+function generateLambdaCode(fnNode, indexCounter, paramCounter) {
+	const [, paramCount, ...stmts] = fnNode;
+	const paramStartIndex = paramCounter.value;
+	paramCounter.value += paramCount;
+	return `(${Array.from({ length: paramCount }, (_, i) => `_${paramStartIndex + i}`).join(",")})=>{${translateStmts(stmts, indexCounter, paramCounter)}}`;
+}
+/**
+* 翻译表达式列表为 JavaScript 代码
+* 使用全局索引计数器分配 $[N] 槽位
+*/
+function translateStmts(expressions, indexCounter, paramCounter) {
+	for (let i = 0; i < expressions.length; i++) {
+		const expr = expressions[i];
+		if (!expr) continue;
+		if (isControlFlowNode(expr)) {
+			const [type, , offset] = expr;
+			if ((type === "br" || type === "jmp") && offset !== void 0) {
+				const target = i + offset + 1;
+				if (target < 0 || target > expressions.length) throw new Error(`Unable to translate: invalid jump target at index ${i}. Target would be ${target}, but expression length is ${expressions.length}`);
+			}
 		}
 	}
-	if (parts.length === 0) return createProxyExpressionWithAST({
-		type: "StringLiteral",
-		value: "",
-		quote: "\""
-	}, deps);
-	if (parts.length === 1) return createProxyExpressionWithAST(parts[0], deps);
-	let resultAst = parts[0];
-	for (let i = 1; i < parts.length; i++) resultAst = {
-		type: "BinaryExpr",
-		operator: "+",
-		left: resultAst,
-		right: parts[i]
-	};
-	return createProxyExpressionWithAST(resultAst, deps);
+	const lines = ["let $lastValue;"];
+	const indexMap = [];
+	const savedStart = indexCounter.value;
+	for (let i = 0; i < expressions.length; i++) {
+		indexMap.push(indexCounter.value);
+		const expr = expressions[i];
+		if (isFnNode(expr)) {
+			indexCounter.value++;
+			countFnNodeIndices(expr, indexCounter);
+		} else indexCounter.value++;
+	}
+	indexCounter.value = savedStart;
+	const processed = /* @__PURE__ */ new Set();
+	function translateRange(start, end, indent = "") {
+		let i = start;
+		while (i < end) {
+			if (processed.has(i)) {
+				i++;
+				continue;
+			}
+			const expr = expressions[i];
+			if (!expr) {
+				i++;
+				continue;
+			}
+			const varIdx = indexMap[i];
+			if (isFnNode(expr)) {
+				processed.add(i);
+				indexCounter.value++;
+				const lambdaCode = generateLambdaCode(expr, indexCounter, paramCounter);
+				lines.push(`${indent}$[${varIdx}] = $lastValue = ${lambdaCode};`);
+				i++;
+			} else if (typeof expr === "string") {
+				processed.add(i);
+				indexCounter.value++;
+				lines.push(`${indent}$[${varIdx}] = $lastValue = ${expr};`);
+				i++;
+			} else if (!Array.isArray(expr)) i++;
+			else {
+				const [type] = expr;
+				if (type === "br") {
+					processed.add(i);
+					indexCounter.value++;
+					const [, condition, skipCount] = expr;
+					const falseBlockEnd = i + skipCount;
+					let jmpIdx = -1;
+					let trueBlockEnd = falseBlockEnd + 1;
+					if (falseBlockEnd < expressions.length) {
+						const lastInFalseBranch = expressions[falseBlockEnd];
+						if (Array.isArray(lastInFalseBranch) && lastInFalseBranch[0] === "jmp") {
+							jmpIdx = falseBlockEnd;
+							const jmpOffset = lastInFalseBranch[1];
+							trueBlockEnd = jmpIdx + jmpOffset;
+							processed.add(jmpIdx);
+						}
+					}
+					const hasElse = jmpIdx >= 0;
+					lines.push(`${indent}if (!(${condition})) {`);
+					translateRange(i + 1, falseBlockEnd + 1, indent + "  ");
+					if (hasElse) {
+						lines.push(`${indent}} else {`);
+						translateRange(jmpIdx + 1, trueBlockEnd + 1, indent + "  ");
+						lines.push(`${indent}}`);
+						i = trueBlockEnd + 1;
+					} else {
+						lines.push(`${indent}}`);
+						i = falseBlockEnd + 1;
+					}
+				} else if (type === "phi") {
+					processed.add(i);
+					indexCounter.value++;
+					lines.push(`${indent}$[${varIdx}] = $lastValue;`);
+					i++;
+				} else if (type === "jmp") {
+					indexCounter.value++;
+					throw new Error(`Unable to translate: unexpected jmp at index ${i}. This should have been paired with a preceding br. Unsupported control flow structure.`);
+				} else throw new Error(`Unable to translate: unknown control flow node type.`);
+			}
+		}
+	}
+	translateRange(0, expressions.length);
+	lines.push("return $lastValue;");
+	return lines.join("\n");
+}
+/**
+* 计算 FnNode 内部 stmts 占用的索引数量（递归）
+*/
+function countFnNodeIndices(fnNode, indexCounter) {
+	const [, , ...stmts] = fnNode;
+	for (const stmt of stmts) if (isFnNode(stmt)) {
+		indexCounter.value++;
+		countFnNodeIndices(stmt, indexCounter);
+	} else indexCounter.value++;
+}
+/**
+* 分析并验证控制流结构，将 br/jmp/phi 翻译为 if-else 语句
+*/
+function translateControlFlow(expressions, variableCount) {
+	return translateStmts(expressions, { value: variableCount }, { value: 0 });
 }
-
-//#endregion
-//#region src/test-helper.ts
 /**
-* 编译并求值表达式
-* 自动推导变量类型和返回类型
+* 执行编译后的表达式
 *
-* @template TResult - 表达式求值结果类型
-* @template TVars - 变量映射类型
-* @param expr - 要编译的表达式
-* @param variables - 变量定义映射
-* @param values - 变量值映射
-* @returns 表达式求值结果
+* @template TResult - 表达式结果类型
+* @param data - 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
+* @param values - 变量值映射，按变量名提供值
+* @returns 最后一个表达式的求值结果
+*
+* @throws 如果运行时类型验证失败或表达式执行出错
 *
 * @example
 * ```ts
-* const callback = variable<(f: (x: number) => number) => number>();
-* const result = compileAndEvaluate(
-*   myExpr,
-*   { callback },
-*   { callback: (fn) => fn(5) }
-* );
+* const compiled = [["x", "y"], "$[0]+$[1]", "$[1]*2"]
+* const result = evaluate<number>(compiled, { x: 2, y: 3 })
+* // => 6  (3 * 2)
 * ```
 */
-function compileAndEvaluate(expr, variables, values, options) {
-	return evaluate(compile(expr, variables, options), values);
+function evaluate(data, values) {
+	if (data.length < 1) throw new Error("Invalid compiled data: must have at least variable names");
+	const [variableNames, ...expressions] = data;
+	if (!Array.isArray(variableNames)) throw new Error("Invalid compiled data: first element must be variable names array");
+	for (const varName of variableNames) {
+		if (typeof varName !== "string") throw new Error("Invalid compiled data: variable names must be strings");
+		if (!(varName in values)) throw new Error(`Missing required variable: ${varName}`);
+	}
+	const valueArray = [];
+	for (const varName of variableNames) valueArray.push(values[varName]);
+	const cacheKey = JSON.stringify(data);
+	let evaluator = evaluatorCache.get(cacheKey);
+	if (!evaluator) {
+		const functionBody = buildEvaluatorFunctionBody(expressions, variableNames.length);
+		evaluator = new Function("$", functionBody);
+		evaluatorCache.set(cacheKey, evaluator);
+	}
+	try {
+		return evaluator(valueArray);
+	} catch (error) {
+		throw new Error(`Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
-
-//#endregion
-//#region src/wrap.ts
 /**
-* 将静态值包装为 Proxy Expression
-* 返回的 Proxy 可以像 Variable 一样调用方法和访问属性
-*
-* @template T - 值的类型
-* @param value - 要包装的静态值（支持原始值、对象、数组、Date、RegExp 等）
-* @returns Proxy Expression，可以继续链式调用
-*
-* @example
-* ```ts
-* // 包装 RegExp
-* const pattern = wrap(/^[a-z]+$/i);
-* const input = variable<string>();
-* const result = pattern.match(input);
-*
-* // 包装 Date
-* const now = wrap(new Date());
-* const year = now.getFullYear();
+* 构造求值函数体
 *
-* // 包装数组
-* const numbers = wrap([1, 2, 3, 4, 5]);
-* const doubled = numbers.map((x) => x * 2);
-* ```
+* @param expressions - 表达式列表（可包含控制流节点和 FnNode）
+* @param variableCount - 变量数量
+* @returns 函数体字符串
 */
-function wrap(value) {
-	return createProxyExpressionWithAST(serializeArgumentToAST(value), /* @__PURE__ */ new Set());
+function buildEvaluatorFunctionBody(expressions, variableCount) {
+	if (expressions.length === 0) throw new Error("No expressions to evaluate");
+	return translateControlFlow(expressions, variableCount);
 }
 
 //#endregion
-export { compile, compileAndEvaluate, evaluate, expr, lambda, t, variable, wrap };
+export { compile, evaluate, expr, lambda, t, variable, wrap };
 //# sourceMappingURL=index.mjs.map