@codehz/json-expr 0.5.1 → 0.5.3

package/dist/index.mjs

@@ -1,4 +1,4 @@
-//#region src/parser.ts
+//#region src/ast-types.ts
 const PRECEDENCE = {
 	"||": 1,
 	"??": 1,
@@ -27,1421 +27,1372 @@ const PRECEDENCE = {
 	"**": 11
 };
 const RIGHT_ASSOCIATIVE = new Set(["**"]);
-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;
+const BUILTIN_CONSTRUCTORS = new Set([
+	"Date",
+	"RegExp",
+	"URL",
+	"URLSearchParams",
+	"Map",
+	"Set",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"ArrayBuffer",
+	"DataView"
+]);
+
+//#endregion
+//#region src/generate.ts
+/**
+* 创建新的生成上下文
+*/
+function createGenerateContext() {
+	return {
+		lambdaParamCounter: 0,
+		paramMapping: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* 从 AST 生成规范化的代码
+*/
+function generate(node) {
+	return generateWithContext(node, createGenerateContext());
+}
+/**
+* 带上下文的代码生成
+*/
+function generateWithContext(node, ctx) {
+	switch (node.type) {
+		case "NumberLiteral": return node.raw;
+		case "StringLiteral": return JSON.stringify(node.value);
+		case "BooleanLiteral": return node.value ? "true" : "false";
+		case "NullLiteral": return "null";
+		case "Identifier": return node.name;
+		case "Placeholder": {
+			const mappedName = ctx.paramMapping.get(node.id);
+			if (mappedName) return mappedName;
+			return `$$${node.id.description}$$`;
+		}
+		case "BinaryExpr": {
+			const left = wrapIfNeededWithContext(node.left, node, "left", ctx);
+			const right = wrapIfNeededWithContext(node.right, node, "right", ctx);
+			if (node.operator === "in" || node.operator === "instanceof") return `${left} ${node.operator} ${right}`;
+			return `${left}${node.operator}${right}`;
+		}
+		case "UnaryExpr":
+			if (node.prefix) {
+				const arg = wrapIfNeededWithContext(node.argument, node, "argument", ctx);
+				if (node.operator === "typeof" || node.operator === "void") return `${node.operator} ${arg}`;
+				return `${node.operator}${arg}`;
+			}
+			return generateWithContext(node.argument, ctx) + node.operator;
+		case "ConditionalExpr": return `${wrapIfNeededWithContext(node.test, node, "test", ctx)}?${wrapIfNeededWithContext(node.consequent, node, "consequent", ctx)}:${wrapIfNeededWithContext(node.alternate, node, "alternate", ctx)}`;
+		case "MemberExpr": {
+			const object = wrapIfNeededWithContext(node.object, node, "object", ctx);
+			const property = generateWithContext(node.property, ctx);
+			return node.computed ? `${object}${node.optional ? "?." : ""}[${property}]` : `${object}${node.optional ? "?." : "."}${property}`;
+		}
+		case "CallExpr": {
+			const callee = wrapIfNeededWithContext(node.callee, node, "callee", ctx);
+			const args = node.arguments.map((arg) => generateWithContext(arg, ctx)).join(",");
+			return `${node.callee.type === "Identifier" && BUILTIN_CONSTRUCTORS.has(node.callee.name) ? "new " : ""}${callee}${node.optional ? "?." : ""}(${args})`;
+		}
+		case "ArrayExpr": return `[${node.elements.map((el) => generateWithContext(el, ctx)).join(",")}]`;
+		case "ObjectExpr": return `{${node.properties.map((prop) => {
+			if (prop.shorthand) return generateWithContext(prop.key, ctx);
+			return `${prop.computed ? `[${generateWithContext(prop.key, ctx)}]` : generateWithContext(prop.key, ctx)}:${generateWithContext(prop.value, ctx)}`;
+		}).join(",")}}`;
+		case "ArrowFunctionExpr": {
+			const paramNames = [];
+			const placeholderIds = [];
+			for (const param of node.params) if (param.type === "Placeholder") {
+				const uniqueName = `_${ctx.lambdaParamCounter++}`;
+				paramNames.push(uniqueName);
+				placeholderIds.push(param.id);
+				ctx.paramMapping.set(param.id, uniqueName);
+			} else paramNames.push(param.name);
+			const paramsStr = paramNames.length === 1 ? paramNames[0] : `(${paramNames.join(",")})`;
+			const body = node.body.type === "ObjectExpr" ? `(${generateWithContext(node.body, ctx)})` : generateWithContext(node.body, ctx);
+			for (const id of placeholderIds) ctx.paramMapping.delete(id);
+			return `${paramsStr}=>${body}`;
+		}
+		default: {
+			const nodeType = node.type ?? "unknown";
+			throw new Error(`Unknown node type: ${nodeType}`);
+		}
 	}
-	parseExpression() {
-		return this.parseConditional();
+}
+/**
+* 判断是否需要括号包裹，并生成代码（带上下文版本）
+*/
+function wrapIfNeededWithContext(child, parent, position, ctx) {
+	const code = generateWithContext(child, ctx);
+	if (needsParens(child, parent, position)) return `(${code})`;
+	return code;
+}
+/**
+* 判断子节点是否需要括号
+*/
+function needsParens(child, parent, position) {
+	switch (parent.type) {
+		case "BinaryExpr":
+			if (child.type === "ConditionalExpr" || child.type === "UnaryExpr") return true;
+			if (child.type === "BinaryExpr") {
+				const childPrec = PRECEDENCE[child.operator] ?? 0;
+				const parentPrec = PRECEDENCE[parent.operator] ?? 0;
+				if (childPrec < parentPrec) return true;
+				if (childPrec === parentPrec && position === "right" && !RIGHT_ASSOCIATIVE.has(parent.operator)) return true;
+			}
+			return false;
+		case "UnaryExpr": return position === "argument" && (child.type === "BinaryExpr" || child.type === "ConditionalExpr");
+		case "MemberExpr":
+		case "CallExpr":
+			if (position !== "object" && position !== "callee") return false;
+			if ([
+				"BinaryExpr",
+				"ConditionalExpr",
+				"UnaryExpr",
+				"ArrowFunctionExpr",
+				"ObjectExpr"
+			].includes(child.type)) return true;
+			if (child.type === "NumberLiteral" && parent.type === "MemberExpr" && !parent.computed) return !child.raw.includes(".") && !child.raw.includes("e") && !child.raw.includes("x");
+			return false;
+		case "ConditionalExpr": return position === "test" && child.type === "ConditionalExpr";
+		default: return false;
 	}
-	parseConditional() {
-		let node = this.parseBinary(0);
-		this.skipWhitespace();
-		if (this.peek() === "?") {
-			this.advance();
-			this.skipWhitespace();
-			const consequent = this.parseExpression();
-			this.skipWhitespace();
-			this.expect(":");
-			this.skipWhitespace();
-			const alternate = this.parseExpression();
-			node = {
-				type: "ConditionalExpr",
-				test: node,
-				consequent,
-				alternate
-			};
+}
+/**
+* 转换 AST 中的标识符
+* 回调函数可以返回：
+* - string: 替换标识符名称
+* - ASTNode: 内联该 AST 节点（用于子表达式内联）
+*/
+function transformIdentifiers(node, transform) {
+	switch (node.type) {
+		case "Identifier": {
+			const result = transform(node.name);
+			return typeof result === "string" ? {
+				...node,
+				name: result
+			} : result;
 		}
-		return node;
-	}
-	parseBinary(minPrec) {
-		let left = this.parseUnary();
-		while (true) {
-			this.skipWhitespace();
-			const op = this.peekOperator();
-			if (!op || PRECEDENCE[op] === void 0 || PRECEDENCE[op] < minPrec) break;
-			this.pos += op.length;
-			this.skipWhitespace();
-			const nextMinPrec = RIGHT_ASSOCIATIVE.has(op) ? PRECEDENCE[op] : PRECEDENCE[op] + 1;
-			const right = this.parseBinary(nextMinPrec);
-			left = {
-				type: "BinaryExpr",
-				operator: op,
-				left,
-				right
+		case "Placeholder": return node;
+		case "BinaryExpr": return {
+			...node,
+			left: transformIdentifiers(node.left, transform),
+			right: transformIdentifiers(node.right, transform)
+		};
+		case "UnaryExpr": return {
+			...node,
+			argument: transformIdentifiers(node.argument, transform)
+		};
+		case "ConditionalExpr": return {
+			...node,
+			test: transformIdentifiers(node.test, transform),
+			consequent: transformIdentifiers(node.consequent, transform),
+			alternate: transformIdentifiers(node.alternate, transform)
+		};
+		case "MemberExpr": return {
+			...node,
+			object: transformIdentifiers(node.object, transform),
+			property: node.computed ? transformIdentifiers(node.property, transform) : node.property
+		};
+		case "CallExpr": return {
+			...node,
+			callee: transformIdentifiers(node.callee, transform),
+			arguments: node.arguments.map((arg) => transformIdentifiers(arg, transform))
+		};
+		case "ArrayExpr": return {
+			...node,
+			elements: node.elements.map((el) => transformIdentifiers(el, transform))
+		};
+		case "ObjectExpr": return {
+			...node,
+			properties: node.properties.map((prop) => ({
+				...prop,
+				key: prop.computed ? transformIdentifiers(prop.key, transform) : prop.key,
+				value: transformIdentifiers(prop.value, transform)
+			}))
+		};
+		case "ArrowFunctionExpr": {
+			const paramNames = new Set(node.params.filter((p) => p.type === "Identifier").map((p) => p.name));
+			return {
+				...node,
+				body: transformIdentifiers(node.body, (name) => paramNames.has(name) ? name : transform(name))
 			};
 		}
-		return left;
+		default: return node;
 	}
-	parseUnary() {
-		this.skipWhitespace();
-		const ch = this.peek();
-		if (ch === "!" || ch === "~" || ch === "+" || ch === "-") {
-			this.advance();
-			this.skipWhitespace();
-			return {
-				type: "UnaryExpr",
-				operator: ch,
-				argument: this.parseUnary(),
-				prefix: true
-			};
+}
+/**
+* 转换 AST 中的占位符节点
+* 回调函数接收 symbol，返回 Identifier 节点的名称
+* 如果返回 null/undefined，则保留原始 Placeholder 节点
+*/
+function transformPlaceholders(node, transform) {
+	switch (node.type) {
+		case "Placeholder": {
+			const name = transform(node.id);
+			return name != null ? {
+				type: "Identifier",
+				name
+			} : node;
 		}
-		for (const keyword of ["typeof", "void"]) if (this.matchKeyword(keyword)) {
-			this.skipWhitespace();
+		case "Identifier": return node;
+		case "BinaryExpr": return {
+			...node,
+			left: transformPlaceholders(node.left, transform),
+			right: transformPlaceholders(node.right, transform)
+		};
+		case "UnaryExpr": return {
+			...node,
+			argument: transformPlaceholders(node.argument, transform)
+		};
+		case "ConditionalExpr": return {
+			...node,
+			test: transformPlaceholders(node.test, transform),
+			consequent: transformPlaceholders(node.consequent, transform),
+			alternate: transformPlaceholders(node.alternate, transform)
+		};
+		case "MemberExpr": return {
+			...node,
+			object: transformPlaceholders(node.object, transform),
+			property: node.computed ? transformPlaceholders(node.property, transform) : node.property
+		};
+		case "CallExpr": return {
+			...node,
+			callee: transformPlaceholders(node.callee, transform),
+			arguments: node.arguments.map((arg) => transformPlaceholders(arg, transform))
+		};
+		case "ArrayExpr": return {
+			...node,
+			elements: node.elements.map((el) => transformPlaceholders(el, transform))
+		};
+		case "ObjectExpr": return {
+			...node,
+			properties: node.properties.map((prop) => ({
+				...prop,
+				key: prop.computed ? transformPlaceholders(prop.key, transform) : prop.key,
+				value: transformPlaceholders(prop.value, transform)
+			}))
+		};
+		case "ArrowFunctionExpr": {
+			const paramSymbols = new Set(node.params.filter((p) => p.type === "Placeholder").map((p) => p.id));
 			return {
-				type: "UnaryExpr",
-				operator: keyword,
-				argument: this.parseUnary(),
-				prefix: true
+				...node,
+				body: transformPlaceholders(node.body, (id) => paramSymbols.has(id) ? null : transform(id))
 			};
 		}
-		return this.parsePostfix();
+		default: return node;
 	}
-	parsePostfix() {
-		let node = this.parsePrimary();
-		while (true) {
-			this.skipWhitespace();
-			const ch = this.peek();
-			if (ch === ".") {
-				this.advance();
-				this.skipWhitespace();
-				const property = this.parseIdentifier();
-				node = {
-					type: "MemberExpr",
-					object: node,
-					property,
-					computed: false,
-					optional: false
-				};
-			} else if (ch === "[") {
-				this.advance();
-				this.skipWhitespace();
-				const property = this.parseExpression();
-				this.skipWhitespace();
-				this.expect("]");
-				node = {
-					type: "MemberExpr",
-					object: node,
-					property,
-					computed: true,
-					optional: false
-				};
-			} else if (ch === "(") {
-				this.advance();
-				const args = this.parseArguments();
-				this.expect(")");
-				node = {
-					type: "CallExpr",
-					callee: node,
-					arguments: args,
-					optional: false
-				};
-			} else if (ch === "?" && this.peekAt(1) === ".") {
-				this.advance();
-				this.advance();
-				this.skipWhitespace();
-				if (this.peek() === "[") {
-					this.advance();
-					this.skipWhitespace();
-					const property = this.parseExpression();
-					this.skipWhitespace();
-					this.expect("]");
-					node = {
-						type: "MemberExpr",
-						object: node,
-						property,
-						computed: true,
-						optional: true
-					};
-				} else if (this.peek() === "(") {
-					this.advance();
-					const args = this.parseArguments();
-					this.expect(")");
-					node = {
-						type: "CallExpr",
-						callee: node,
-						arguments: args,
-						optional: true
-					};
-				} else {
-					const property = this.parseIdentifier();
-					node = {
-						type: "MemberExpr",
-						object: node,
-						property,
-						computed: false,
-						optional: true
-					};
-				}
-			} else break;
+}
+
+//#endregion
+//#region src/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);
+}
+/**
+* 检查对象是否是 Proxy variable
+*/
+function isProxyVariable(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.get(obj)?.type === "variable";
+}
+/**
+* 检查对象是否是 Proxy expression
+*/
+function isProxyExpression(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.get(obj)?.type === "expression";
+}
+/**
+* 检查对象是否是任意 Proxy (variable 或 expression)
+*/
+function isProxy(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.has(obj);
+}
+
+//#endregion
+//#region src/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;
+	}
+	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);
 		}
-		return node;
 	}
-	parsePrimary() {
-		this.skipWhitespace();
-		const ch = this.peek();
-		if (this.isDigit(ch) || ch === "." && this.isDigit(this.peekAt(1))) return this.parseNumber();
-		if (ch === "\"" || ch === "'" || ch === "`") return this.parseString();
-		if (ch === "[") return this.parseArray();
-		if (ch === "{") return this.parseObject();
-		if (ch === "(") {
-			const arrowFunc = this.tryParseArrowFunction();
-			if (arrowFunc) return arrowFunc;
-			this.advance();
-			this.skipWhitespace();
-			const expr = this.parseExpression();
-			this.skipWhitespace();
-			this.expect(")");
-			return expr;
+	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);
 		}
-		if (this.matchKeyword("true")) return {
-			type: "BooleanLiteral",
-			value: true
-		};
-		if (this.matchKeyword("false")) return {
-			type: "BooleanLiteral",
-			value: false
-		};
-		if (this.matchKeyword("null")) return { type: "NullLiteral" };
-		if (this.matchKeyword("undefined")) return {
-			type: "Identifier",
-			name: "undefined"
-		};
-		if (this.isIdentifierStart(ch)) {
-			const arrowFunc = this.tryParseSingleParamArrowFunction();
-			if (arrowFunc) return arrowFunc;
-			return this.parseIdentifier();
+		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)]);
 		}
-		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
-				};
-			}
+		if (arg instanceof Map) {
+			const entries = [];
+			arg.forEach((value, key) => {
+				entries.push(arrayExpr([serializeArgumentToAST(key), serializeArgumentToAST(value)]));
+			});
+			return callExpr(identifier("Map"), [arrayExpr(entries)]);
 		}
-		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 (arg instanceof Set) {
+			const values = [];
+			arg.forEach((value) => values.push(serializeArgumentToAST(value)));
+			return callExpr(identifier("Set"), [arrayExpr(values)]);
 		}
-		if (this.peek()?.toLowerCase() === "e") {
-			this.advance();
-			if (this.peek() === "+" || this.peek() === "-") this.advance();
-			while (this.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)]);
 		}
-		const raw = this.source.slice(start, this.pos);
+		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: "NumberLiteral",
-			value: Number(raw),
-			raw
+			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
+				};
+			})
 		};
 	}
-	static ESCAPE_CHARS = {
-		n: "\n",
-		r: "\r",
-		t: "	",
-		"\\": "\\",
-		"'": "'",
-		"\"": "\"",
-		"`": "`"
+	if (arg === null) return { type: "NullLiteral" };
+	if (arg === void 0) return identifier("undefined");
+	if (typeof arg === "boolean") return {
+		type: "BooleanLiteral",
+		value: arg
 	};
-	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 = [];
-		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
-		};
-	}
-	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
-		};
-	}
-	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;
-		}
-	}
-	/**
-	* 尝试解析单参数无括号的箭头函数: 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;
-		}
-	}
-	parseArguments() {
-		const args = [];
-		this.skipWhitespace();
-		while (this.peek() !== ")") {
-			args.push(this.parseExpression());
-			this.skipWhitespace();
-			if (this.peek() === ",") {
-				this.advance();
-				this.skipWhitespace();
-			} else break;
-		}
-		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;
-		}
-		return null;
+	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);
 	}
-	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;
-			}
+}
+/**
+* 根据路径构建成员表达式 AST
+*/
+function buildMemberExprAst(rootId, path) {
+	let ast = placeholder(rootId);
+	for (const prop of path) ast = memberExpr(ast, identifier(prop));
+	return ast;
+}
+/**
+* 创建 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);
 		}
-		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;
-	}
-	isIdentifierPart(ch) {
-		const code = ch.charCodeAt(0);
-		return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95 || code === 36;
-	}
-};
+	};
+}
+/**
+* 创建根 Variable Proxy
+* 拦截属性访问，返回新的 expression proxy
+* 不可直接调用（apply 应该只在链式调用后可用）
+*
+* @param id - 变量的唯一标识 Symbol
+* @returns Proxy 包装的 Variable
+*/
+function createProxyVariable(id) {
+	const deps = new Set([id]);
+	const proxy = new Proxy(function() {}, {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpressionWithAST(buildMemberExprAst(id, [String(prop)]), deps);
+		},
+		apply() {
+			throw new Error("Variable cannot be called directly");
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "variable",
+		path: [],
+		rootVariable: id,
+		dependencies: deps
+	});
+	return proxy;
+}
 /**
-* 解析 JavaScript 表达式为 AST
+* 创建带完整 AST 的 Proxy（方法调用后）
+* 可以继续链式访问和调用
+*
+* @param ast - 完整的表达式 AST
+* @param deps - 依赖集合
+* @returns Proxy 包装的 Expression
 */
-function parse(source) {
-	return new Parser(source).parse();
+function createProxyExpressionWithAST(ast, deps) {
+	const proxy = new Proxy(function() {}, createProxyHandler(ast, deps));
+	setProxyMetadata(proxy, {
+		type: "expression",
+		path: [],
+		ast,
+		dependencies: deps
+	});
+	return proxy;
 }
+
+//#endregion
+//#region src/variable.ts
 /**
-* 从 AST 生成规范化的代码
+* 跟踪每个 variable 的唯一 Symbol ID
 */
-function generate(node) {
-	switch (node.type) {
-		case "NumberLiteral": return node.raw;
-		case "StringLiteral": return JSON.stringify(node.value);
-		case "BooleanLiteral": return node.value ? "true" : "false";
-		case "NullLiteral": return "null";
-		case "Identifier": return node.name;
-		case "BinaryExpr": {
-			const left = wrapIfNeeded(node.left, node, "left");
-			const right = wrapIfNeeded(node.right, node, "right");
-			if (node.operator === "in" || node.operator === "instanceof") return `${left} ${node.operator} ${right}`;
-			return `${left}${node.operator}${right}`;
-		}
-		case "UnaryExpr":
-			if (node.prefix) {
-				const arg = wrapIfNeeded(node.argument, node, "argument");
-				if (node.operator === "typeof" || node.operator === "void") return `${node.operator} ${arg}`;
-				return `${node.operator}${arg}`;
-			}
-			return generate(node.argument) + node.operator;
-		case "ConditionalExpr": return `${generate(node.test)}?${generate(node.consequent)}:${generate(node.alternate)}`;
-		case "MemberExpr": {
-			const object = wrapIfNeeded(node.object, node, "object");
-			if (node.computed) {
-				const property = generate(node.property);
-				return node.optional ? `${object}?.[${property}]` : `${object}[${property}]`;
-			}
-			const property = generate(node.property);
-			return node.optional ? `${object}?.${property}` : `${object}.${property}`;
-		}
-		case "CallExpr": {
-			const callee = wrapIfNeeded(node.callee, node, "callee");
-			const args = node.arguments.map(generate).join(",");
-			if (node.callee.type === "Identifier" && [
-				"Date",
-				"RegExp",
-				"URL",
-				"URLSearchParams",
-				"Map",
-				"Set",
-				"Int8Array",
-				"Uint8Array",
-				"Uint8ClampedArray",
-				"Int16Array",
-				"Uint16Array",
-				"Int32Array",
-				"Uint32Array",
-				"Float32Array",
-				"Float64Array",
-				"BigInt64Array",
-				"BigUint64Array",
-				"ArrayBuffer",
-				"DataView"
-			].includes(node.callee.name)) return node.optional ? `new ${callee}?.(${args})` : `new ${callee}(${args})`;
-			return node.optional ? `${callee}?.(${args})` : `${callee}(${args})`;
-		}
-		case "ArrayExpr": return `[${node.elements.map(generate).join(",")}]`;
-		case "ObjectExpr": return `{${node.properties.map((prop) => {
-			if (prop.shorthand) return generate(prop.key);
-			return `${prop.computed ? `[${generate(prop.key)}]` : generate(prop.key)}:${generate(prop.value)}`;
-		}).join(",")}}`;
-		case "ArrowFunctionExpr": {
-			const params = node.params.map((p) => p.name).join(",");
-			let body = generate(node.body);
-			if (node.body.type === "ObjectExpr") body = `(${body})`;
-			if (node.params.length === 1) return `${params}=>${body}`;
-			return `(${params})=>${body}`;
-		}
-		default: {
-			const nodeType = node.type ?? "unknown";
-			throw new Error(`Unknown node type: ${nodeType}`);
-		}
-	}
+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 wrapIfNeeded(child, parent, position) {
-	const code = generate(child);
-	if (needsParens(child, parent, position)) return `(${code})`;
-	return code;
+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 needsParens(child, parent, position) {
-	if (child.type === "ConditionalExpr" && parent.type === "BinaryExpr") return true;
-	if (child.type === "BinaryExpr" && parent.type === "BinaryExpr") {
-		const childPrec = PRECEDENCE[child.operator] || 0;
-		const parentPrec = PRECEDENCE[parent.operator] || 0;
-		if (childPrec < parentPrec) return true;
-		if (childPrec === parentPrec && position === "right") {
-			if (!RIGHT_ASSOCIATIVE.has(parent.operator)) return true;
+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);
 		}
+		const id = getVariableId(value);
+		if (id) symbolToName.set(id, name);
 	}
-	if ((child.type === "BinaryExpr" || child.type === "ConditionalExpr") && parent.type === "UnaryExpr" && position === "argument") return true;
-	if (child.type === "UnaryExpr" && parent.type === "BinaryExpr") {
-		if (parent.operator === "**" && position === "left") return true;
-		return true;
+	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(", ")}`);
 	}
-	return false;
-}
-/**
-* 转换 AST 中的标识符
-* 回调函数可以返回：
-* - string: 替换标识符名称
-* - ASTNode: 内联该 AST 节点（用于子表达式内联）
-*/
-function transformIdentifiers(node, transform) {
-	switch (node.type) {
-		case "Identifier": {
-			const result = transform(node.name);
-			return typeof result === "string" ? {
-				...node,
-				name: result
-			} : result;
+	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++;
 		}
-		case "BinaryExpr": return {
-			...node,
-			left: transformIdentifiers(node.left, transform),
-			right: transformIdentifiers(node.right, transform)
-		};
-		case "UnaryExpr": return {
-			...node,
-			argument: transformIdentifiers(node.argument, transform)
-		};
-		case "ConditionalExpr": return {
-			...node,
-			test: transformIdentifiers(node.test, transform),
-			consequent: transformIdentifiers(node.consequent, transform),
-			alternate: transformIdentifiers(node.alternate, transform)
-		};
-		case "MemberExpr": return {
-			...node,
-			object: transformIdentifiers(node.object, transform),
-			property: node.computed ? transformIdentifiers(node.property, transform) : node.property
-		};
-		case "CallExpr": return {
-			...node,
-			callee: transformIdentifiers(node.callee, transform),
-			arguments: node.arguments.map((arg) => transformIdentifiers(arg, transform))
-		};
-		case "ArrayExpr": return {
-			...node,
-			elements: node.elements.map((el) => transformIdentifiers(el, transform))
-		};
-		case "ObjectExpr": return {
-			...node,
-			properties: node.properties.map((prop) => ({
-				...prop,
-				key: prop.computed ? transformIdentifiers(prop.key, transform) : prop.key,
-				value: transformIdentifiers(prop.value, transform)
-			}))
-		};
-		case "ArrowFunctionExpr": {
-			const paramNames = new Set(node.params.map((p) => p.name));
-			return {
-				...node,
-				body: transformIdentifiers(node.body, (name) => paramNames.has(name) ? name : transform(name))
+		function compileShortCircuit(node) {
+			const leftIdx = compileAst(node.left);
+			const branchConditions = {
+				"||": `$${leftIdx}`,
+				"&&": `!$${leftIdx}`,
+				"??": `$${leftIdx}!=null`
 			};
+			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;
 		}
-		default: return node;
-	}
+		compileAst(transformed);
+	} else expressions.push(generate(transformed));
+	return [variableOrder, ...expressions];
 }
 
 //#endregion
-//#region src/proxy-metadata.ts
-/**
-* 全局 WeakMap 存储
-*/
-const proxyMetadata = /* @__PURE__ */ new WeakMap();
+//#region src/evaluate.ts
 /**
-* 设置 Proxy 元数据
+* 缓存已构造的求值函数，以提升重复执行性能
 */
-function setProxyMetadata(proxy, metadata) {
-	proxyMetadata.set(proxy, metadata);
-}
+const evaluatorCache = /* @__PURE__ */ new Map();
 /**
-* 获取 Proxy 元数据
+* 检测编译数据是否包含控制流节点（V2 格式）
 */
-function getProxyMetadata(proxy) {
-	return proxyMetadata.get(proxy);
+function isV2Format(expressions) {
+	return expressions.some((expr) => Array.isArray(expr));
 }
 /**
-* 检查对象是否是 Proxy variable
+* 执行编译后的表达式
+*
+* @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 isProxyVariable(obj) {
-	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
-	return proxyMetadata.get(obj)?.type === "variable";
+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 = isV2Format(expressions) ? buildEvaluatorFunctionBodyV2(expressions, variableNames.length) : buildEvaluatorFunctionBody(expressions, variableNames.length);
+		evaluator = new Function("$values", 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)}`);
+	}
 }
 /**
-* 检查对象是否是 Proxy expression
+* 构造求值函数体
+*
+* @param expressions - 表达式列表
+* @param variableCount - 变量数量
+* @returns 函数体字符串
+*
+* @example
+* ```ts
+* buildEvaluatorFunctionBody(["$0+$1", "$2*2"], 2)
+* // 返回执行 $0+$1 并存储到 $values[2]，然后执行 $2*2 的函数体
+* ```
 */
-function isProxyExpression(obj) {
-	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
-	return proxyMetadata.get(obj)?.type === "expression";
+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");
 }
 /**
-* 检查对象是否是任意 Proxy (variable 或 expression)
+* 构造带控制流支持的求值函数体（V2 格式）
+*
+* @param expressions - 表达式列表（可包含控制流节点）
+* @param variableCount - 变量数量
+* @returns 函数体字符串
 */
-function isProxy(obj) {
-	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
-	return proxyMetadata.has(obj);
+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;
+			}
+		}
+		lines.push("    }");
+	});
+	lines.push("  }", "}", "return $values[$values.length - 1];");
+	return lines.join("\n");
 }
 
 //#endregion
-//#region src/proxy-variable.ts
-/**
-* 使用 Symbol.description 生成占位符
-* 用于在表达式源码中标识变量
-*/
-function getVariablePlaceholder$1(id) {
-	return `$$VAR_${id.description}$$`;
-}
-/**
-* 序列化参数为 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 {
-				type: "Identifier",
-				name: getVariablePlaceholder$1(meta.rootVariable)
+//#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;
+	}
+	parseExpression() {
+		return this.parseConditional();
+	}
+	parseConditional() {
+		let node = this.parseBinary(0);
+		this.skipWhitespace();
+		if (this.peek() === "?") {
+			this.advance();
+			this.skipWhitespace();
+			const consequent = this.parseExpression();
+			this.skipWhitespace();
+			this.expect(":");
+			this.skipWhitespace();
+			const alternate = this.parseExpression();
+			node = {
+				type: "ConditionalExpr",
+				test: node,
+				consequent,
+				alternate
+			};
+		}
+		return node;
+	}
+	parseBinary(minPrec) {
+		let left = this.parseUnary();
+		while (true) {
+			this.skipWhitespace();
+			const op = this.peekOperator();
+			if (!op || PRECEDENCE[op] === void 0 || PRECEDENCE[op] < minPrec) break;
+			this.pos += op.length;
+			this.skipWhitespace();
+			const nextMinPrec = RIGHT_ASSOCIATIVE.has(op) ? PRECEDENCE[op] : PRECEDENCE[op] + 1;
+			const right = this.parseBinary(nextMinPrec);
+			left = {
+				type: "BinaryExpr",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseUnary() {
+		this.skipWhitespace();
+		const ch = this.peek();
+		if (ch === "!" || ch === "~" || ch === "+" || ch === "-") {
+			this.advance();
+			this.skipWhitespace();
+			return {
+				type: "UnaryExpr",
+				operator: ch,
+				argument: this.parseUnary(),
+				prefix: true
+			};
+		}
+		for (const keyword of ["typeof", "void"]) if (this.matchKeyword(keyword)) {
+			this.skipWhitespace();
+			return {
+				type: "UnaryExpr",
+				operator: keyword,
+				argument: this.parseUnary(),
+				prefix: true
 			};
 		}
+		return this.parsePostfix();
+	}
+	parsePostfix() {
+		let node = this.parsePrimary();
+		while (true) {
+			this.skipWhitespace();
+			const ch = this.peek();
+			if (ch === ".") {
+				this.advance();
+				this.skipWhitespace();
+				const property = this.parseIdentifier();
+				node = {
+					type: "MemberExpr",
+					object: node,
+					property,
+					computed: false,
+					optional: false
+				};
+			} else if (ch === "[") {
+				this.advance();
+				this.skipWhitespace();
+				const property = this.parseExpression();
+				this.skipWhitespace();
+				this.expect("]");
+				node = {
+					type: "MemberExpr",
+					object: node,
+					property,
+					computed: true,
+					optional: false
+				};
+			} else if (ch === "(") {
+				this.advance();
+				const args = this.parseArguments();
+				this.expect(")");
+				node = {
+					type: "CallExpr",
+					callee: node,
+					arguments: args,
+					optional: false
+				};
+			} else if (ch === "?" && this.peekAt(1) === ".") {
+				this.advance();
+				this.advance();
+				this.skipWhitespace();
+				if (this.peek() === "[") {
+					this.advance();
+					this.skipWhitespace();
+					const property = this.parseExpression();
+					this.skipWhitespace();
+					this.expect("]");
+					node = {
+						type: "MemberExpr",
+						object: node,
+						property,
+						computed: true,
+						optional: true
+					};
+				} else if (this.peek() === "(") {
+					this.advance();
+					const args = this.parseArguments();
+					this.expect(")");
+					node = {
+						type: "CallExpr",
+						callee: node,
+						arguments: args,
+						optional: true
+					};
+				} else {
+					const property = this.parseIdentifier();
+					node = {
+						type: "MemberExpr",
+						object: node,
+						property,
+						computed: false,
+						optional: true
+					};
+				}
+			} else break;
+		}
+		return node;
 	}
-	if (Array.isArray(arg)) return {
-		type: "ArrayExpr",
-		elements: arg.map(serializeArgumentToAST)
-	};
-	if (typeof arg === "object" && arg !== null) {
-		if (arg instanceof Date) return {
-			type: "CallExpr",
-			callee: {
-				type: "Identifier",
-				name: "Date"
-			},
-			arguments: [{
-				type: "NumberLiteral",
-				value: arg.getTime(),
-				raw: String(arg.getTime())
-			}],
-			optional: false
-		};
-		if (arg instanceof RegExp) {
-			const args = [{
-				type: "StringLiteral",
-				value: arg.source,
-				quote: "\""
-			}];
-			if (arg.flags) args.push({
-				type: "StringLiteral",
-				value: arg.flags,
-				quote: "\""
-			});
-			return {
-				type: "CallExpr",
-				callee: {
-					type: "Identifier",
-					name: "RegExp"
-				},
-				arguments: args,
-				optional: false
-			};
+	parsePrimary() {
+		this.skipWhitespace();
+		const ch = this.peek();
+		if (this.isDigit(ch) || ch === "." && this.isDigit(this.peekAt(1))) return this.parseNumber();
+		if (ch === "\"" || ch === "'" || ch === "`") return this.parseString();
+		if (ch === "[") return this.parseArray();
+		if (ch === "{") return this.parseObject();
+		if (ch === "(") {
+			const arrowFunc = this.tryParseArrowFunction();
+			if (arrowFunc) return arrowFunc;
+			this.advance();
+			this.skipWhitespace();
+			const expr = this.parseExpression();
+			this.skipWhitespace();
+			this.expect(")");
+			return expr;
 		}
-		if (typeof URL !== "undefined" && arg instanceof URL) return {
-			type: "CallExpr",
-			callee: {
-				type: "Identifier",
-				name: "URL"
-			},
-			arguments: [{
-				type: "StringLiteral",
-				value: arg.href,
-				quote: "\""
-			}],
-			optional: false
+		if (this.matchKeyword("true")) return {
+			type: "BooleanLiteral",
+			value: true
 		};
-		if (typeof URLSearchParams !== "undefined" && arg instanceof URLSearchParams) {
-			const entries = [];
-			arg.forEach((value, key) => {
-				entries.push({
-					type: "ArrayExpr",
-					elements: [{
-						type: "StringLiteral",
-						value: key,
-						quote: "\""
-					}, {
-						type: "StringLiteral",
-						value,
-						quote: "\""
-					}]
-				});
-			});
-			return {
-				type: "CallExpr",
-				callee: {
-					type: "Identifier",
-					name: "URLSearchParams"
-				},
-				arguments: [{
-					type: "ArrayExpr",
-					elements: entries
-				}],
-				optional: false
-			};
-		}
-		if (arg instanceof Map) {
-			const entries = [];
-			arg.forEach((value, key) => {
-				entries.push({
-					type: "ArrayExpr",
-					elements: [serializeArgumentToAST(key), serializeArgumentToAST(value)]
-				});
-			});
-			return {
-				type: "CallExpr",
-				callee: {
-					type: "Identifier",
-					name: "Map"
-				},
-				arguments: [{
-					type: "ArrayExpr",
-					elements: entries
-				}],
-				optional: false
-			};
-		}
-		if (arg instanceof Set) {
-			const values = [];
-			arg.forEach((value) => {
-				values.push(serializeArgumentToAST(value));
-			});
-			return {
-				type: "CallExpr",
-				callee: {
-					type: "Identifier",
-					name: "Set"
-				},
-				arguments: [{
-					type: "ArrayExpr",
-					elements: values
-				}],
-				optional: false
-			};
+		if (this.matchKeyword("false")) return {
+			type: "BooleanLiteral",
+			value: false
+		};
+		if (this.matchKeyword("null")) return { type: "NullLiteral" };
+		if (this.matchKeyword("undefined")) return {
+			type: "Identifier",
+			name: "undefined"
+		};
+		if (this.isIdentifierStart(ch)) {
+			const arrowFunc = this.tryParseSingleParamArrowFunction();
+			if (arrowFunc) return arrowFunc;
+			return this.parseIdentifier();
 		}
-		for (const constructorName of [
-			"Int8Array",
-			"Uint8Array",
-			"Uint8ClampedArray",
-			"Int16Array",
-			"Uint16Array",
-			"Int32Array",
-			"Uint32Array",
-			"Float32Array",
-			"Float64Array",
-			"BigInt64Array",
-			"BigUint64Array"
-		]) if (typeof globalThis[constructorName] !== "undefined") {
-			if (arg instanceof globalThis[constructorName]) {
-				const values = [...arg].map((val) => serializeArgumentToAST(val));
+		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: "CallExpr",
-					callee: {
-						type: "Identifier",
-						name: constructorName
-					},
-					arguments: [{
-						type: "ArrayExpr",
-						elements: values
-					}],
-					optional: false
+					type: "NumberLiteral",
+					value: Number(raw),
+					raw
 				};
 			}
 		}
-		if (arg instanceof ArrayBuffer) {
-			const uint8Array = new Uint8Array(arg);
-			return {
-				type: "MemberExpr",
-				object: {
-					type: "CallExpr",
-					callee: {
-						type: "Identifier",
-						name: "Uint8Array"
-					},
-					arguments: [{
-						type: "ArrayExpr",
-						elements: Array.from(uint8Array).map((val) => serializeArgumentToAST(val))
-					}],
-					optional: false
-				},
-				property: {
-					type: "Identifier",
-					name: "buffer"
-				},
-				computed: false,
-				optional: false
-			};
+		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 (arg instanceof DataView) return {
-			type: "CallExpr",
-			callee: {
-				type: "Identifier",
-				name: "DataView"
-			},
-			arguments: [serializeArgumentToAST(arg.buffer)],
-			optional: false
+		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
 		};
 	}
-	if (typeof arg === "object" && arg !== null) return {
-		type: "ObjectExpr",
-		properties: Object.entries(arg).map(([k, v]) => {
-			return {
-				key: /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? {
-					type: "Identifier",
-					name: k
-				} : {
-					type: "StringLiteral",
-					value: k,
-					quote: "\""
-				},
-				value: serializeArgumentToAST(v),
-				computed: false,
-				shorthand: false
-			};
-		})
-	};
-	if (arg === null) return { type: "NullLiteral" };
-	if (arg === void 0) return {
-		type: "Identifier",
-		name: "undefined"
-	};
-	if (typeof arg === "boolean") return {
-		type: "BooleanLiteral",
-		value: arg
-	};
-	if (typeof arg === "number") return {
-		type: "NumberLiteral",
-		value: arg,
-		raw: String(arg)
-	};
-	if (typeof arg === "string") return {
-		type: "StringLiteral",
-		value: arg,
-		quote: "\""
+	static ESCAPE_CHARS = {
+		n: "\n",
+		r: "\r",
+		t: "	",
+		"\\": "\\",
+		"'": "'",
+		"\"": "\"",
+		"`": "`"
 	};
-	if (typeof arg === "bigint") return {
-		type: "CallExpr",
-		callee: {
-			type: "Identifier",
-			name: "BigInt"
-		},
-		arguments: [{
+	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: arg.toString(),
-			quote: "\""
-		}],
-		optional: false
-	};
-	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);
+			value,
+			quote
+		};
 	}
-}
-/**
-* 创建根 Variable Proxy
-* 拦截属性访问，返回新的 expression proxy
-* 不可直接调用（apply 应该只在链式调用后可用）
-*
-* @param id - 变量的唯一标识 Symbol
-* @returns Proxy 包装的 Variable
-*/
-function createProxyVariable(id) {
-	const deps = new Set([id]);
-	const proxy = new Proxy(function() {}, {
-		get(_target, prop) {
-			if (typeof prop === "symbol") return void 0;
-			return createProxyExpression(id, [String(prop)], deps);
-		},
-		apply() {
-			throw new Error("Variable cannot be called directly");
+	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;
 		}
-	});
-	setProxyMetadata(proxy, {
-		type: "variable",
-		path: [],
-		rootVariable: id,
-		dependencies: deps
-	});
-	return proxy;
-}
-/**
-* 创建属性访问后的 Proxy
-* 继续拦截属性访问（链式访问）
-* 拦截 apply 进行方法调用
-*
-* @param rootId - 根变量的 Symbol
-* @param path - 属性访问路径
-* @param deps - 依赖集合
-* @returns Proxy 包装的 Expression
-*/
-function createProxyExpression(rootId, path, deps) {
-	let ast = {
-		type: "Identifier",
-		name: getVariablePlaceholder$1(rootId)
-	};
-	for (const prop of path) ast = {
-		type: "MemberExpr",
-		object: ast,
-		property: {
-			type: "Identifier",
-			name: prop
-		},
-		computed: false,
-		optional: false
-	};
-	const proxy = new Proxy(function() {}, {
-		get(_target, prop) {
-			if (typeof prop === "symbol") return void 0;
-			return createProxyExpression(rootId, [...path, String(prop)], deps);
-		},
-		apply(_target, _thisArg, args) {
-			const callAst = {
-				type: "CallExpr",
-				callee: ast,
-				arguments: args.map(serializeArgumentToAST),
-				optional: false
-			};
-			const newDeps = new Set(deps);
-			collectDepsFromArgs(args, newDeps);
-			return createProxyExpressionWithAST(callAst, newDeps);
+		this.expect("]");
+		return {
+			type: "ArrayExpr",
+			elements
+		};
+	}
+	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;
 		}
-	});
-	setProxyMetadata(proxy, {
-		type: "expression",
-		path,
-		rootVariable: rootId,
-		ast,
-		dependencies: deps
-	});
-	return proxy;
-}
-/**
-* 创建带完整 AST 的 Proxy（方法调用后）
-* 可以继续链式访问和调用
-*
-* @param ast - 完整的表达式 AST
-* @param deps - 依赖集合
-* @returns Proxy 包装的 Expression
-*/
-function createProxyExpressionWithAST(ast, deps) {
-	const proxy = new Proxy(function() {}, {
-		get(_target, prop) {
-			if (typeof prop === "symbol") return void 0;
-			return createProxyExpressionWithAST({
-				type: "MemberExpr",
-				object: ast,
-				property: {
-					type: "Identifier",
-					name: String(prop)
-				},
-				computed: false,
-				optional: false
-			}, deps);
-		},
-		apply(_target, _thisArg, args) {
-			const callAst = {
-				type: "CallExpr",
-				callee: ast,
-				arguments: args.map(serializeArgumentToAST),
-				optional: false
+		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 newDeps = new Set(deps);
-			collectDepsFromArgs(args, newDeps);
-			return createProxyExpressionWithAST(callAst, newDeps);
 		}
-	});
-	setProxyMetadata(proxy, {
-		type: "expression",
-		path: [],
-		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);
-}
-/**
-* 生成变量占位符字符串
-* 格式：$$VAR_var_N$$
-*/
-function getVariablePlaceholder(id) {
-	return `$$VAR_${id.description}$$`;
-}
-
-//#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();
-	for (const name of Object.keys(variables)) if (!variableToIndex.has(name)) {
-		variableToIndex.set(name, variableOrder.length);
-		variableOrder.push(name);
+		if (key.type !== "Identifier") throw new Error("Shorthand property must be an identifier");
+		return {
+			key,
+			value: key,
+			computed: false,
+			shorthand: true
+		};
 	}
-	const descToName = /* @__PURE__ */ new Map();
-	for (const [name, value] of Object.entries(variables)) {
-		const id = getVariableId(value);
-		if (id && id.description) descToName.set(id.description, name);
+	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
+		};
 	}
-	const undefinedVars = [];
-	const transformed = transformIdentifiers(ast, (name) => {
-		const placeholderMatch = name.match(/^\$\$VAR_(.+)\$\$$/);
-		if (placeholderMatch) {
-			const desc = placeholderMatch[1];
-			const varName = descToName.get(desc);
-			if (!varName) throw new Error(`Unknown variable placeholder: ${name}`);
-			name = varName;
+	/**
+	* 尝试解析带括号的箭头函数: (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;
 		}
-		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 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);
-			const idx = nextIndex++;
-			expressions.push(exprStr);
-			return idx;
+	}
+	/**
+	* 尝试解析单参数无括号的箭头函数: 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;
 		}
-		function compileShortCircuit(node) {
-			const leftIdx = compileAst(node.left);
-			let branchCondition;
-			switch (node.operator) {
-				case "||":
-					branchCondition = `$${leftIdx}`;
-					break;
-				case "&&":
-					branchCondition = `!$${leftIdx}`;
-					break;
-				default: branchCondition = `$${leftIdx}!=null`;
+	}
+	parseArguments() {
+		const args = [];
+		this.skipWhitespace();
+		while (this.peek() !== ")") {
+			args.push(this.parseExpression());
+			this.skipWhitespace();
+			if (this.peek() === ",") {
+				this.advance();
+				this.skipWhitespace();
+			} else break;
+		}
+		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;
 			}
-			const branchIdx = expressions.length;
-			expressions.push([
-				"br",
-				branchCondition,
-				0
-			]);
-			nextIndex++;
-			compileAst(node.right);
-			const skipCount = expressions.length - branchIdx - 1;
-			expressions[branchIdx][2] = skipCount;
-			const phiIdx = nextIndex++;
-			expressions.push(["phi"]);
-			return phiIdx;
+			return op;
 		}
-		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;
+		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;
+			}
 		}
-		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}`);
+		return false;
 	}
-	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);
+	peek() {
+		return this.source[this.pos] || "";
 	}
-	try {
-		return evaluator(valueArray);
-	} catch (error) {
-		throw new Error(`Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`);
+	peekAt(offset) {
+		return this.source[this.pos + offset] || "";
 	}
-}
-/**
-* 构造求值函数体
-*
-* @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");
-	const lines = [];
-	for (let i = 0; i < variableCount; i++) lines.push(`const $${i} = $values[${i}];`);
-	for (let i = 0; i < expressions.length; i++) {
-		const exprSource = expressions[i];
-		const resultIndex = variableCount + i;
-		lines.push(`const $${resultIndex} = ${exprSource};`);
-		lines.push(`$values[${resultIndex}] = $${resultIndex};`);
+	advance() {
+		return this.source[this.pos++] || "";
 	}
-	lines.push(`return $values[$values.length - 1];`);
-	return lines.join("\n");
-}
+	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;
+	}
+	isIdentifierPart(ch) {
+		const code = ch.charCodeAt(0);
+		return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95 || code === 36;
+	}
+};
 /**
-* 构造带控制流支持的求值函数体（V2 格式）
-*
-* @param expressions - 表达式列表（可包含控制流节点）
-* @param variableCount - 变量数量
-* @returns 函数体字符串
+* 解析 JavaScript 表达式为 AST
 */
-function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
-	if (expressions.length === 0) throw new Error("No expressions to evaluate");
-	const lines = [];
-	for (let i = 0; i < variableCount; i++) lines.push(`const $${i} = $values[${i}];`);
-	lines.push(`let $pc = 0;`);
-	lines.push(`let $lastValue;`);
-	for (let i = 0; i < expressions.length; i++) lines.push(`let $${variableCount + i};`);
-	lines.push(`while ($pc < ${expressions.length}) {`);
-	lines.push(`  switch ($pc) {`);
-	for (let i = 0; i < expressions.length; i++) {
-		const expr = expressions[i];
-		const idx = variableCount + i;
-		lines.push(`    case ${i}: {`);
-		if (typeof expr === "string") {
-			lines.push(`      $${idx} = ${expr};`);
-			lines.push(`      $values[${idx}] = $${idx};`);
-			lines.push(`      $lastValue = $${idx};`);
-			lines.push(`      $pc++; break;`);
-		} else if (expr[0] === "br") {
-			const [, condExpr, offset] = expr;
-			lines.push(`      if (${condExpr}) { $pc += ${offset + 1}; } else { $pc++; }`);
-			lines.push(`      break;`);
-		} else if (expr[0] === "jmp") {
-			const [, offset] = expr;
-			lines.push(`      $pc += ${offset + 1}; break;`);
-		} else if (expr[0] === "phi") {
-			lines.push(`      $${idx} = $lastValue;`);
-			lines.push(`      $values[${idx}] = $lastValue;`);
-			lines.push(`      $pc++; break;`);
-		}
-		lines.push(`    }`);
-	}
-	lines.push(`  }`);
-	lines.push(`}`);
-	lines.push(`return $values[$values.length - 1];`);
-	return lines.join("\n");
+function parse(source) {
+	return new Parser(source).parse();
 }
 
 //#endregion
@@ -1499,7 +1450,10 @@ function expr(context) {
 		}
 		return createProxyExpressionWithAST(transformIdentifiers(parse(source), (name) => {
 			const id = nameToId.get(name);
-			if (id) return getVariablePlaceholder(id);
+			if (id) return {
+				type: "Placeholder",
+				id
+			};
 			const exprAST = nameToExprAST.get(name);
 			if (exprAST) return exprAST;
 			return name;
@@ -1550,6 +1504,20 @@ function createLambdaParam(index) {
 */
 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++) {
@@ -1558,43 +1526,50 @@ function lambda(builder) {
 		const meta = getProxyMetadata(param);
 		if (meta?.rootVariable) paramSymbols.push(meta.rootVariable);
 	}
-	const bodyExpr = builder(...params);
-	let bodyAst;
-	let bodyDeps;
+	return {
+		params,
+		paramSymbols
+	};
+}
+/**
+* 从表达式中提取 AST 和依赖
+*/
+function extractBodyAstAndDeps(bodyExpr) {
 	const meta = (typeof bodyExpr === "object" || typeof bodyExpr === "function") && bodyExpr !== null ? getProxyMetadata(bodyExpr) : void 0;
-	if (meta?.ast) {
-		bodyAst = meta.ast;
-		bodyDeps = meta.dependencies ?? /* @__PURE__ */ new Set();
-	} else {
-		bodyAst = serializeArgumentToAST(bodyExpr);
-		bodyDeps = /* @__PURE__ */ new Set();
+	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
+		};
 	}
-	const transformedBodyAst = transformIdentifiers(bodyAst, (name) => {
-		for (let i = 0; i < paramSymbols.length; i++) {
-			const sym = paramSymbols[i];
-			if (!sym) continue;
-			if (name === `$$VAR_${sym.description}$$`) return `_${i}`;
-		}
-		return name;
-	});
-	const arrowFunctionAst = {
+}
+/**
+* 创建箭头函数 AST
+* 使用 Placeholder 节点作为参数，在代码生成时再分配实际参数名
+*/
+function createArrowFunctionAst(bodyAst, paramCount, paramSymbols) {
+	return {
 		type: "ArrowFunctionExpr",
-		params: params.map((_, i) => ({
-			type: "Identifier",
-			name: `_${i}`
+		params: Array.from({ length: paramCount }, (_, i) => ({
+			type: "Placeholder",
+			id: paramSymbols[i]
 		})),
-		body: transformedBodyAst
+		body: bodyAst
 	};
+}
+/**
+* 过滤掉 lambda 参数依赖，只保留外部闭包变量
+*/
+function filterClosureDeps(bodyDeps, paramSymbols) {
 	const closureDeps = /* @__PURE__ */ new Set();
 	for (const dep of bodyDeps) if (!paramSymbols.includes(dep)) closureDeps.add(dep);
-	const lambdaProxy = createProxyExpressionWithAST(arrowFunctionAst, closureDeps);
-	const existingMeta = getProxyMetadata(lambdaProxy);
-	if (existingMeta) setProxyMetadata(lambdaProxy, {
-		...existingMeta,
-		type: "expression"
-	});
-	return lambdaProxy;
+	return closureDeps;
 }
 
 //#endregion