@codehz/json-expr 0.5.0 → 0.5.2

package/dist/index.mjs

@@ -27,6 +27,27 @@ const PRECEDENCE = {
 	"**": 11
 };
 const RIGHT_ASSOCIATIVE = new Set(["**"]);
+const BUILTIN_CONSTRUCTORS = new Set([
+	"Date",
+	"RegExp",
+	"URL",
+	"URLSearchParams",
+	"Map",
+	"Set",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"ArrayBuffer",
+	"DataView"
+]);
 var Parser = class Parser {
 	pos = 0;
 	source;
@@ -546,41 +567,16 @@ function generate(node) {
 				return `${node.operator}${arg}`;
 			}
 			return generate(node.argument) + node.operator;
-		case "ConditionalExpr": return `${generate(node.test)}?${generate(node.consequent)}:${generate(node.alternate)}`;
+		case "ConditionalExpr": return `${wrapIfNeeded(node.test, node, "test")}?${wrapIfNeeded(node.consequent, node, "consequent")}:${wrapIfNeeded(node.alternate, 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}`;
+			return node.computed ? `${object}${node.optional ? "?." : ""}[${property}]` : `${object}${node.optional ? "?." : "."}${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})`;
+			return `${node.callee.type === "Identifier" && BUILTIN_CONSTRUCTORS.has(node.callee.name) ? "new " : ""}${callee}${node.optional ? "?." : ""}(${args})`;
 		}
 		case "ArrayExpr": return `[${node.elements.map(generate).join(",")}]`;
 		case "ObjectExpr": return `{${node.properties.map((prop) => {
@@ -589,10 +585,8 @@ function generate(node) {
 		}).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}`;
+			const body = node.body.type === "ObjectExpr" ? `(${generate(node.body)})` : generate(node.body);
+			return `${node.params.length === 1 ? params : `(${params})`}=>${body}`;
 		}
 		default: {
 			const nodeType = node.type ?? "unknown";
@@ -612,21 +606,32 @@ function wrapIfNeeded(child, parent, position) {
 * 判断子节点是否需要括号
 */
 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;
-		}
-	}
-	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;
+	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;
 	}
-	return false;
 }
 /**
 * 转换 AST 中的标识符
@@ -733,6 +738,19 @@ function isProxy(obj) {
 
 //#endregion
 //#region src/proxy-variable.ts
+const typedArrayConstructors = [
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+];
 /**
 * 使用 Symbol.description 生成占位符
 * 用于在表达式源码中标识变量
@@ -741,6 +759,77 @@ function getVariablePlaceholder$1(id) {
 	return `$$VAR_${id.description}$$`;
 }
 /**
+* 创建标识符 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 节点
@@ -753,245 +842,70 @@ function serializeArgumentToAST(arg) {
 		const meta = getProxyMetadata(arg);
 		if (meta) {
 			if (meta.ast) return meta.ast;
-			if (meta.rootVariable) return {
-				type: "Identifier",
-				name: getVariablePlaceholder$1(meta.rootVariable)
-			};
+			if (meta.rootVariable) return identifier(getVariablePlaceholder$1(meta.rootVariable));
 		}
 	}
-	if (Array.isArray(arg)) return {
-		type: "ArrayExpr",
-		elements: arg.map(serializeArgumentToAST)
-	};
+	if (Array.isArray(arg)) return arrayExpr(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 Date) return callExpr(identifier("Date"), [numberLiteral(arg.getTime())]);
 		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
-			};
+			const args = [stringLiteral(arg.source)];
+			if (arg.flags) args.push(stringLiteral(arg.flags));
+			return callExpr(identifier("RegExp"), args);
 		}
-		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 (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({
-					type: "ArrayExpr",
-					elements: [{
-						type: "StringLiteral",
-						value: key,
-						quote: "\""
-					}, {
-						type: "StringLiteral",
-						value,
-						quote: "\""
-					}]
-				});
+				entries.push(arrayExpr([stringLiteral(key), stringLiteral(value)]));
 			});
-			return {
-				type: "CallExpr",
-				callee: {
-					type: "Identifier",
-					name: "URLSearchParams"
-				},
-				arguments: [{
-					type: "ArrayExpr",
-					elements: entries
-				}],
-				optional: false
-			};
+			return callExpr(identifier("URLSearchParams"), [arrayExpr(entries)]);
 		}
 		if (arg instanceof Map) {
 			const entries = [];
 			arg.forEach((value, key) => {
-				entries.push({
-					type: "ArrayExpr",
-					elements: [serializeArgumentToAST(key), serializeArgumentToAST(value)]
-				});
+				entries.push(arrayExpr([serializeArgumentToAST(key), serializeArgumentToAST(value)]));
 			});
-			return {
-				type: "CallExpr",
-				callee: {
-					type: "Identifier",
-					name: "Map"
-				},
-				arguments: [{
-					type: "ArrayExpr",
-					elements: entries
-				}],
-				optional: false
-			};
+			return callExpr(identifier("Map"), [arrayExpr(entries)]);
 		}
 		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
-			};
+			arg.forEach((value) => values.push(serializeArgumentToAST(value)));
+			return callExpr(identifier("Set"), [arrayExpr(values)]);
 		}
-		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));
-				return {
-					type: "CallExpr",
-					callee: {
-						type: "Identifier",
-						name: constructorName
-					},
-					arguments: [{
-						type: "ArrayExpr",
-						elements: values
-					}],
-					optional: false
-				};
-			}
+		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);
-			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
-			};
+			const values = Array.from(uint8Array).map(numberLiteral);
+			return memberExpr(callExpr(identifier("Uint8Array"), [arrayExpr(values)]), identifier("buffer"));
 		}
-		if (arg instanceof DataView) return {
-			type: "CallExpr",
-			callee: {
-				type: "Identifier",
-				name: "DataView"
-			},
-			arguments: [serializeArgumentToAST(arg.buffer)],
-			optional: false
+		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
+				};
+			})
 		};
 	}
-	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 (arg === void 0) return identifier("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: "\""
-	};
-	if (typeof arg === "bigint") return {
-		type: "CallExpr",
-		callee: {
-			type: "Identifier",
-			name: "BigInt"
-		},
-		arguments: [{
-			type: "StringLiteral",
-			value: arg.toString(),
-			quote: "\""
-		}],
-		optional: false
-	};
+	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}`);
 }
 /**
@@ -1007,6 +921,31 @@ function collectDepsFromArgs(args, deps) {
 	}
 }
 /**
+* 根据路径构建成员表达式 AST
+*/
+function buildMemberExprAst(rootId, path) {
+	let ast = identifier(getVariablePlaceholder$1(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);
+		}
+	};
+}
+/**
 * 创建根 Variable Proxy
 * 拦截属性访问，返回新的 expression proxy
 * 不可直接调用（apply 应该只在链式调用后可用）
@@ -1019,7 +958,7 @@ function createProxyVariable(id) {
 	const proxy = new Proxy(function() {}, {
 		get(_target, prop) {
 			if (typeof prop === "symbol") return void 0;
-			return createProxyExpression(id, [String(prop)], deps);
+			return createProxyExpressionWithAST(buildMemberExprAst(id, [String(prop)]), deps);
 		},
 		apply() {
 			throw new Error("Variable cannot be called directly");
@@ -1034,57 +973,6 @@ function createProxyVariable(id) {
 	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);
-		}
-	});
-	setProxyMetadata(proxy, {
-		type: "expression",
-		path,
-		rootVariable: rootId,
-		ast,
-		dependencies: deps
-	});
-	return proxy;
-}
-/**
 * 创建带完整 AST 的 Proxy（方法调用后）
 * 可以继续链式访问和调用
 *
@@ -1093,32 +981,7 @@ function createProxyExpression(rootId, path, 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
-			};
-			const newDeps = new Set(deps);
-			collectDepsFromArgs(args, newDeps);
-			return createProxyExpressionWithAST(callAst, newDeps);
-		}
-	});
+	const proxy = new Proxy(function() {}, createProxyHandler(ast, deps));
 	setProxyMetadata(proxy, {
 		type: "expression",
 		path: [],
@@ -1234,30 +1097,29 @@ function compile(expression, variables, 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);
-	}
 	const descToName = /* @__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 && id.description) descToName.set(id.description, name);
+		if (id?.description) descToName.set(id.description, 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;
-		}
-		const index = variableToIndex.get(name);
+		const resolvedName = placeholderMatch ? descToName.get(placeholderMatch[1]) : name;
+		if (placeholderMatch && !resolvedName) throw new Error(`Unknown variable placeholder: ${name}`);
+		const index = variableToIndex.get(resolvedName);
 		if (index !== void 0) return `$${index}`;
-		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
-		return name;
+		if (!ALLOWED_GLOBALS.has(resolvedName)) undefinedVars.push(resolvedName);
+		return resolvedName;
 	});
-	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
+	if (undefinedVars.length > 0) {
+		const uniqueVars = [...new Set(undefinedVars)];
+		throw new Error(`Undefined variable(s): ${uniqueVars.join(", ")}`);
+	}
 	const expressions = [];
 	if (shortCircuit) {
 		let nextIndex = variableOrder.length;
@@ -1265,26 +1127,20 @@ function compile(expression, variables, options = {}) {
 			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;
+			return nextIndex++;
 		}
 		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`;
-			}
+			const branchConditions = {
+				"||": `$${leftIdx}`,
+				"&&": `!$${leftIdx}`,
+				"??": `$${leftIdx}!=null`
+			};
 			const branchIdx = expressions.length;
 			expressions.push([
 				"br",
-				branchCondition,
+				branchConditions[node.operator],
 				0
 			]);
 			nextIndex++;
@@ -1388,16 +1244,14 @@ function evaluate(data, values) {
 */
 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};`);
-	}
-	lines.push(`return $values[$values.length - 1];`);
-	return lines.join("\n");
+	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");
 }
 /**
 * 构造带控制流支持的求值函数体（V2 格式）
@@ -1408,39 +1262,38 @@ function buildEvaluatorFunctionBody(expressions, variableCount) {
 */
 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 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} = ${expr};`);
+			lines.push(`      $${idx} = $lastValue = ${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("      $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(`  }`);
-	lines.push(`}`);
-	lines.push(`return $values[$values.length - 1];`);
+		lines.push("    }");
+	});
+	lines.push("  }", "}", "return $values[$values.length - 1];");
 	return lines.join("\n");
 }
 
@@ -1550,6 +1403,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(transformParamPlaceholders(bodyAst, paramSymbols), paramCount), 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,19 +1425,34 @@ 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) => {
+}
+/**
+* 将参数占位符标识符转换为实际参数名
+*/
+function transformParamPlaceholders(bodyAst, paramSymbols) {
+	return transformIdentifiers(bodyAst, (name) => {
 		for (let i = 0; i < paramSymbols.length; i++) {
 			const sym = paramSymbols[i];
 			if (!sym) continue;
@@ -1578,23 +1460,27 @@ function lambda(builder) {
 		}
 		return name;
 	});
-	const arrowFunctionAst = {
+}
+/**
+* 创建箭头函数 AST
+*/
+function createArrowFunctionAst(bodyAst, paramCount) {
+	return {
 		type: "ArrowFunctionExpr",
-		params: params.map((_, i) => ({
+		params: Array.from({ length: paramCount }, (_, i) => ({
 			type: "Identifier",
 			name: `_${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
@@ -1647,5 +1533,35 @@ function t(strings, ...values) {
 }
 
 //#endregion
-export { compile, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, lambda, t, variable };
+//#region src/wrap.ts
+/**
+* 将静态值包装为 Proxy Expression
+* 返回的 Proxy 可以像 Variable 一样调用方法和访问属性
+*
+* @template T - 值的类型
+* @param value - 要包装的静态值（支持原始值、对象、数组、Date、RegExp 等）
+* @returns Proxy Expression，可以继续链式调用
+*
+* @example
+* ```ts
+* // 包装 RegExp
+* const pattern = wrap(/^[a-z]+$/i);
+* const input = variable<string>();
+* const result = pattern.match(input);
+*
+* // 包装 Date
+* const now = wrap(new Date());
+* const year = now.getFullYear();
+*
+* // 包装数组
+* const numbers = wrap([1, 2, 3, 4, 5]);
+* const doubled = numbers.map((x) => x * 2);
+* ```
+*/
+function wrap(value) {
+	return createProxyExpressionWithAST(serializeArgumentToAST(value), /* @__PURE__ */ new Set());
+}
+
+//#endregion
+export { compile, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, lambda, t, variable, wrap };
 //# sourceMappingURL=index.mjs.map