@codehz/json-expr 0.5.6 → 0.6.1

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
 /**
 * 创建新的生成上下文
 */
@@ -316,586 +316,412 @@ function transformPlaceholders(node, transform) {
 }
 
 //#endregion
-//#region src/proxy-metadata.ts
+//#region src/core/parser/constants.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-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 { shortCircuit = true } = 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);
+	/**
+	* 解析数组字面量
+	*/
+	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;
 		}
-		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;
-		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(", ")}`);
+		this.expect("]");
+		return {
+			type: "ArrayExpr",
+			elements
+		};
 	}
-	const expressions = [];
-	if (shortCircuit) {
-		let nextIndex = variableOrder.length;
-		function compileAst(node) {
-			if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node);
-			if (node.type === "ConditionalExpr") return compileConditional(node);
-			const exprStr = generate(node);
-			expressions.push(exprStr);
-			return nextIndex++;
+	/**
+	* 解析对象字面量
+	*/
+	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;
 		}
-		function compileShortCircuit(node) {
-			const leftIdx = compileAst(node.left);
-			const branchConditions = {
-				"||": `$${leftIdx}`,
-				"&&": `!$${leftIdx}`,
-				"??": `$${leftIdx}!=null`
+		this.expect("}");
+		return {
+			type: "ObjectExpr",
+			properties
+		};
+	}
+	/**
+	* 解析对象属性
+	*/
+	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
 			};
-			const branchIdx = expressions.length;
-			expressions.push([
-				"br",
-				branchConditions[node.operator],
-				0
-			]);
-			nextIndex++;
-			compileAst(node.right);
-			const skipCount = expressions.length - branchIdx - 1;
-			expressions[branchIdx][2] = skipCount;
-			const phiIdx = nextIndex++;
-			expressions.push(["phi"]);
-			return phiIdx;
 		}
-		function compileConditional(node) {
-			const testIdx = compileAst(node.test);
-			const branchIdx = expressions.length;
-			expressions.push([
-				"br",
-				`$${testIdx}`,
-				0
-			]);
-			nextIndex++;
-			compileAst(node.alternate);
-			const jmpIdx = expressions.length;
-			expressions.push(["jmp", 0]);
-			nextIndex++;
-			compileAst(node.consequent);
-			const thenEndIdx = expressions.length;
-			expressions[branchIdx][2] = jmpIdx - branchIdx;
-			expressions[jmpIdx][1] = thenEndIdx - jmpIdx - 1;
-			const phiIdx = nextIndex++;
-			expressions.push(["phi"]);
-			return phiIdx;
-		}
-		compileAst(transformed);
-	} else expressions.push(generate(transformed));
-	return [variableOrder, ...expressions];
-}
-
-//#endregion
-//#region src/evaluate.ts
-/**
-* 缓存已构造的求值函数，以提升重复执行性能
-*/
-const evaluatorCache = /* @__PURE__ */ new Map();
-/**
-* 检测编译数据是否包含控制流节点（V2 格式）
-*/
-function isV2Format(expressions) {
-	return expressions.some((expr) => Array.isArray(expr));
-}
-/**
-* 执行编译后的表达式
-*
-* @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)
-* ```
-*/
-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}`);
+		if (key.type !== "Identifier") throw new Error("Shorthand property must be an identifier");
+		return {
+			key,
+			value: key,
+			computed: false,
+			shorthand: true
+		};
 	}
-	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 = isV2Format(expressions) ? buildEvaluatorFunctionBodyV2(expressions, variableNames.length) : buildEvaluatorFunctionBody(expressions, variableNames.length);
-		evaluator = new Function("$values", functionBody);
-		evaluatorCache.set(cacheKey, evaluator);
+	/**
+	* 解析标识符
+	*/
+	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
+		};
 	}
-	try {
-		return evaluator(valueArray);
-	} catch (error) {
-		throw new Error(`Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`);
+	/**
+	* 解析表达式 - 需要在子类中实现
+	*/
+	parseExpression() {
+		throw new Error("parseExpression must be implemented in subclass");
 	}
-}
-/**
-* 构造求值函数体
-*
-* @param expressions - 表达式列表
-* @param variableCount - 变量数量
-* @returns 函数体字符串
-*
-* @example
-* ```ts
-* buildEvaluatorFunctionBody(["$0+$1", "$2*2"], 2)
-* // 返回执行 $0+$1 并存储到 $values[2]，然后执行 $2*2 的函数体
-* ```
-*/
-function buildEvaluatorFunctionBody(expressions, variableCount) {
-	if (expressions.length === 0) throw new Error("No expressions to evaluate");
-	return [
-		...Array.from({ length: variableCount }, (_, i) => `const $${i} = $values[${i}];`),
-		...expressions.map((expr, i) => {
-			const idx = variableCount + i;
-			return `const $${idx} = ${expr}; $values[${idx}] = $${idx};`;
-		}),
-		`return $values[$values.length - 1];`
-	].join("\n");
-}
+};
+
+//#endregion
+//#region src/core/parser/arrow-function-parser.ts
 /**
-* 构造带控制流支持的求值函数体（V2 格式）
-*
-* @param expressions - 表达式列表（可包含控制流节点）
-* @param variableCount - 变量数量
-* @returns 函数体字符串
+* ArrowFunctionParser 类 - 继承 PrimaryParser，添加箭头函数解析功能
 */
-function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
-	if (expressions.length === 0) throw new Error("No expressions to evaluate");
-	const lines = [
-		...Array.from({ length: variableCount }, (_, i) => `const $${i} = $values[${i}];`),
-		"let $pc = 0;",
-		"let $lastValue;",
-		...expressions.map((_, i) => `let $${variableCount + i};`),
-		`while ($pc < ${expressions.length}) {`,
-		"  switch ($pc) {"
-	];
-	expressions.forEach((expr, i) => {
-		const idx = variableCount + i;
-		lines.push(`    case ${i}: {`);
-		if (typeof expr === "string") {
-			lines.push(`      $${idx} = $lastValue = ${expr};`);
-			lines.push(`      $values[${idx}] = $${idx};`);
-			lines.push("      $pc++; break;");
-		} else {
-			const [type] = expr;
-			switch (type) {
-				case "br":
-					lines.push(`      if (${expr[1]}) { $pc += ${expr[2] + 1}; } else { $pc++; } break;`);
-					break;
-				case "jmp":
-					lines.push(`      $pc += ${expr[1] + 1}; break;`);
-					break;
-				case "phi":
-					lines.push(`      $${idx} = $values[${idx}] = $lastValue; $pc++; break;`);
-					break;
+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;
 		}
-		lines.push("    }");
-	});
-	lines.push("  }", "}", "return $values[$values.length - 1];");
-	return lines.join("\n");
-}
+	}
+	/**
+	* 尝试解析单参数无括号的箭头函数: 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;
+		}
+	}
+};
 
 //#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();
@@ -916,6 +742,9 @@ var Parser = class Parser {
 		}
 		return node;
 	}
+	/**
+	* 解析二元表达式，使用优先级爬升算法
+	*/
 	parseBinary(minPrec) {
 		let left = this.parseUnary();
 		while (true) {
@@ -935,6 +764,9 @@ var Parser = class Parser {
 		}
 		return left;
 	}
+	/**
+	* 解析一元表达式
+	*/
 	parseUnary() {
 		this.skipWhitespace();
 		const ch = this.peek();
@@ -959,6 +791,9 @@ var Parser = class Parser {
 		}
 		return this.parsePostfix();
 	}
+	/**
+	* 解析后缀表达式（成员访问、函数调用、可选链等）
+	*/
 	parsePostfix() {
 		let node = this.parsePrimary();
 		while (true) {
@@ -1039,10 +874,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();
@@ -1069,316 +907,354 @@ 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 = [];
-		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
-		};
-	}
-	parseObject() {
-		this.expect("{");
-		const properties = [];
+	/**
+	* 解析函数调用参数列表
+	*/
+	parseArguments() {
+		const args = [];
 		this.skipWhitespace();
-		while (this.peek() !== "}") {
-			const prop = this.parseObjectProperty();
-			properties.push(prop);
+		while (this.peek() !== ")") {
+			args.push(this.parseExpression());
 			this.skipWhitespace();
 			if (this.peek() === ",") {
 				this.advance();
 				this.skipWhitespace();
 			} else break;
 		}
-		this.expect("}");
-		return {
-			type: "ObjectExpr",
-			properties
-		};
+		return args;
 	}
-	parseObjectProperty() {
+};
+
+//#endregion
+//#region src/core/parser/parser.ts
+/**
+* Parser 类 - 完整的 JavaScript 表达式解析器
+*/
+var Parser = class extends ExpressionParser {
+	/**
+	* 解析表达式字符串为 AST
+	*/
+	parse() {
 		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();
+		const node = this.parseExpression();
 		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
-		};
+		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;
 	}
-	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
-		};
+};
+
+//#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;
 	}
-	/**
-	* 尝试解析带括号的箭头函数: (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;
+	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);
 		}
 	}
-	/**
-	* 尝试解析单参数无括号的箭头函数: 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 (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);
 		}
-	}
-	parseArguments() {
-		const args = [];
-		this.skipWhitespace();
-		while (this.peek() !== ")") {
-			args.push(this.parseExpression());
-			this.skipWhitespace();
-			if (this.peek() === ",") {
-				this.advance();
-				this.skipWhitespace();
-			} else break;
+		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 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 Map) {
+			const entries = [];
+			arg.forEach((value, key) => {
+				entries.push(arrayExpr([serializeArgumentToAST(key), serializeArgumentToAST(value)]));
+			});
+			return callExpr(identifier("Map"), [arrayExpr(entries)]);
 		}
-		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;
-			}
+		if (arg instanceof Set) {
+			const values = [];
+			arg.forEach((value) => values.push(serializeArgumentToAST(value)));
+			return callExpr(identifier("Set"), [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;
+		const typedArrayConstructor = getTypedArrayConstructor(arg);
+		if (typedArrayConstructor) {
+			const values = [...arg].map(serializeArgumentToAST);
+			const constructorName = typedArrayConstructor.name;
+			return callExpr(identifier(constructorName), [arrayExpr(values)]);
+		}
+		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);
+		}
+	};
+}
+/**
+* 创建根 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/api/variable.ts
 /**
-* 解析 JavaScript 表达式为 AST
+* 跟踪每个 variable 的唯一 Symbol ID
 */
-function parse(source) {
-	return new Parser(source).parse();
+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，可以继续链式调用
@@ -1444,7 +1320,7 @@ function expr(context) {
 }
 
 //#endregion
-//#region src/lambda.ts
+//#region src/api/lambda.ts
 /**
 * Lambda 参数计数器，用于生成唯一 ID
 */
@@ -1555,7 +1431,7 @@ function filterClosureDeps(bodyDeps, paramSymbols) {
 }
 
 //#endregion
-//#region src/template.ts
+//#region src/api/template.ts
 /**
 * Tagged template 函数，用于创建包含变量的字符串表达式
 *
@@ -1604,34 +1480,7 @@ function t(strings, ...values) {
 }
 
 //#endregion
-//#region src/test-helper.ts
-/**
-* 编译并求值表达式
-* 自动推导变量类型和返回类型
-*
-* @template TResult - 表达式求值结果类型
-* @template TVars - 变量映射类型
-* @param expr - 要编译的表达式
-* @param variables - 变量定义映射
-* @param values - 变量值映射
-* @returns 表达式求值结果
-*
-* @example
-* ```ts
-* const callback = variable<(f: (x: number) => number) => number>();
-* const result = compileAndEvaluate(
-*   myExpr,
-*   { callback },
-*   { callback: (fn) => fn(5) }
-* );
-* ```
-*/
-function compileAndEvaluate(expr, variables, values, options) {
-	return evaluate(compile(expr, variables, options), values);
-}
-
-//#endregion
-//#region src/wrap.ts
+//#region src/api/wrap.ts
 /**
 * 将静态值包装为 Proxy Expression
 * 返回的 Proxy 可以像 Variable 一样调用方法和访问属性
@@ -1661,5 +1510,434 @@ function wrap(value) {
 }
 
 //#endregion
-export { compile, compileAndEvaluate, evaluate, expr, lambda, t, variable, wrap };
+//#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 BRANCH_CONDITIONS = {
+	"||": (idx) => `$[${idx}]`,
+	"&&": (idx) => `!$[${idx}]`,
+	"??": (idx) => `$[${idx}]!=null`
+};
+/**
+* 将 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)) {
+			const index = variableOrder.length;
+			variableToIndex.set(name, index);
+			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);
+		return index !== void 0 ? `$[${index}]` : null;
+	});
+	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}]`;
+		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
+		return name;
+	});
+	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].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 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();
+/**
+* 判断是否是 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}`);
+			}
+		}
+	}
+	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 });
+}
+/**
+* 执行编译后的表达式
+*
+* @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)
+* ```
+*/
+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)}`);
+	}
+}
+/**
+* 构造求值函数体
+*
+* @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
+export { compile, evaluate, expr, lambda, t, variable, wrap };
 //# sourceMappingURL=index.mjs.map