@codehz/json-expr 0.4.0 → 0.5.1

package/dist/index.mjs

@@ -194,6 +194,8 @@ var Parser = class Parser {
 		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();
@@ -214,7 +216,11 @@ var Parser = class Parser {
 			type: "Identifier",
 			name: "undefined"
 		};
-		if (this.isIdentifierStart(ch)) return this.parseIdentifier();
+		if (this.isIdentifierStart(ch)) {
+			const arrowFunc = this.tryParseSingleParamArrowFunction();
+			if (arrowFunc) return arrowFunc;
+			return this.parseIdentifier();
+		}
 		throw new Error(`Unexpected character at position ${this.pos}: ${ch}`);
 	}
 	parseNumber() {
@@ -359,6 +365,63 @@ var Parser = class Parser {
 			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();
@@ -496,6 +559,27 @@ function generate(node) {
 		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(",")}]`;
@@ -503,6 +587,13 @@ function generate(node) {
 			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}`);
@@ -537,6 +628,68 @@ function needsParens(child, parent, position) {
 	}
 	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;
+		}
+		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))
+			};
+		}
+		default: return node;
+	}
+}
 
 //#endregion
 //#region src/proxy-metadata.ts
@@ -588,25 +741,258 @@ function getVariablePlaceholder$1(id) {
 	return `$$VAR_${id.description}$$`;
 }
 /**
-* 序列化参数为表达式字符串
-* - Proxy Variable/Expression：使用源码或占位符
-* - 数组：递归处理元素
-* - 对象：递归处理属性
-* - 原始值：JSON.stringify
+* 序列化参数为 AST 节点
+* - Proxy Variable/Expression：使用 ast 或占位符标识符
+* - 数组：返回 ArrayExpr 节点
+* - 对象：返回 ObjectExpr 节点
+* - 原始值：返回对应的字面量节点
+* - Date, RegExp, BigInt, URL, URLSearchParams, Map, Set, TypedArray, DataView: 构造函数调用
 */
-function serializeArgument(arg) {
+function serializeArgumentToAST(arg) {
 	if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
 		const meta = getProxyMetadata(arg);
 		if (meta) {
-			if (meta.source) return meta.source;
-			if (meta.rootVariable) return getVariablePlaceholder$1(meta.rootVariable);
+			if (meta.ast) return meta.ast;
+			if (meta.rootVariable) return {
+				type: "Identifier",
+				name: getVariablePlaceholder$1(meta.rootVariable)
+			};
 		}
 	}
-	if (Array.isArray(arg)) return `[${arg.map(serializeArgument).join(", ")}]`;
-	if (typeof arg === "object" && arg !== null) return `{${Object.entries(arg).map(([k, v]) => {
-		return `${/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k)}: ${serializeArgument(v)}`;
-	}).join(", ")}}`;
-	return JSON.stringify(arg);
+	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
+			};
+		}
+		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 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
+			};
+		}
+		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
+				};
+			}
+		}
+		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
+			};
+		}
+		if (arg instanceof DataView) return {
+			type: "CallExpr",
+			callee: {
+				type: "Identifier",
+				name: "DataView"
+			},
+			arguments: [serializeArgumentToAST(arg.buffer)],
+			optional: 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 (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
+	};
+	throw new Error(`Unsupported argument type: ${typeof arg}`);
 }
 /**
 * 从参数中收集依赖的 Symbol
@@ -658,53 +1044,85 @@ function createProxyVariable(id) {
 * @returns Proxy 包装的 Expression
 */
 function createProxyExpression(rootId, path, deps) {
-	const source = `${getVariablePlaceholder$1(rootId)}.${path.join(".")}`;
+	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 callSource = `${source}(${args.map(serializeArgument).join(", ")})`;
+			const callAst = {
+				type: "CallExpr",
+				callee: ast,
+				arguments: args.map(serializeArgumentToAST),
+				optional: false
+			};
 			const newDeps = new Set(deps);
 			collectDepsFromArgs(args, newDeps);
-			return createProxyExpressionWithSource(callSource, newDeps);
+			return createProxyExpressionWithAST(callAst, newDeps);
 		}
 	});
 	setProxyMetadata(proxy, {
 		type: "expression",
 		path,
 		rootVariable: rootId,
-		source,
+		ast,
 		dependencies: deps
 	});
 	return proxy;
 }
 /**
-* 创建带完整源码的 Proxy（方法调用后）
+* 创建带完整 AST 的 Proxy（方法调用后）
 * 可以继续链式访问和调用
 *
-* @param source - 完整的表达式源码
+* @param ast - 完整的表达式 AST
 * @param deps - 依赖集合
 * @returns Proxy 包装的 Expression
 */
-function createProxyExpressionWithSource(source, deps) {
+function createProxyExpressionWithAST(ast, deps) {
 	const proxy = new Proxy(function() {}, {
 		get(_target, prop) {
 			if (typeof prop === "symbol") return void 0;
-			return createProxyExpressionWithSource(`(${source}).${String(prop)}`, deps);
+			return createProxyExpressionWithAST({
+				type: "MemberExpr",
+				object: ast,
+				property: {
+					type: "Identifier",
+					name: String(prop)
+				},
+				computed: false,
+				optional: false
+			}, deps);
 		},
 		apply(_target, _thisArg, args) {
-			const callSource = `(${source})(${args.map(serializeArgument).join(", ")})`;
+			const callAst = {
+				type: "CallExpr",
+				callee: ast,
+				arguments: args.map(serializeArgumentToAST),
+				optional: false
+			};
 			const newDeps = new Set(deps);
 			collectDepsFromArgs(args, newDeps);
-			return createProxyExpressionWithSource(callSource, newDeps);
+			return createProxyExpressionWithAST(callAst, newDeps);
 		}
 	});
 	setProxyMetadata(proxy, {
 		type: "expression",
-		path: [source],
-		source,
+		path: [],
+		ast,
 		dependencies: deps
 	});
 	return proxy;
@@ -770,32 +1188,31 @@ const ALLOWED_GLOBALS = new Set([
 	"isNaN",
 	"isFinite",
 	"parseInt",
-	"parseFloat"
+	"parseFloat",
+	"BigInt",
+	"URL",
+	"URLSearchParams",
+	"Map",
+	"Set",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"ArrayBuffer",
+	"DataView"
 ]);
 /**
-* 将占位符替换为实际变量名
-*
-* @param source - 包含占位符的表达式源码
-* @param context - 变量名到值的映射
-* @returns 替换后的源码
-*/
-function preprocessExpression(source, context) {
-	const descToName = /* @__PURE__ */ new Map();
-	for (const [name, value] of Object.entries(context)) {
-		const id = getVariableId(value);
-		if (id && id.description) descToName.set(id.description, name);
-	}
-	return source.replace(/\$\$VAR_([^$]+)\$\$/g, (match, desc) => {
-		const name = descToName.get(desc);
-		if (!name) throw new Error(`Unknown variable placeholder: ${match}`);
-		return name;
-	});
-}
-/**
 * 将 Proxy Expression 编译为可序列化的 JSON 结构
 *
 * @template TResult - 表达式结果类型
-* @param expression - Proxy Expression
+* @param expression - Proxy Expression，或包含 Proxy 的对象/数组/原始值
 * @param variables - 所有使用的变量定义
 * @param options - 编译选项
 * @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
@@ -814,25 +1231,31 @@ function preprocessExpression(source, context) {
 */
 function compile(expression, variables, options = {}) {
 	const { shortCircuit = true } = options;
-	const meta = getProxyMetadata(expression);
-	if (!meta?.source) throw new Error("Invalid expression: expected a Proxy Expression");
-	const source = preprocessExpression(meta.source, variables);
+	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 ast = parse(source);
+	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);
+	}
 	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);
-		if (index !== void 0) return {
-			type: "Identifier",
-			name: `$${index}`
-		};
+		if (index !== void 0) return `$${index}`;
 		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
-		return null;
+		return name;
 	});
 	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
 	const expressions = [];
@@ -897,56 +1320,6 @@ function compile(expression, variables, options = {}) {
 	} else expressions.push(generate(transformed));
 	return [variableOrder, ...expressions];
 }
-/**
-* 将 AST 中的标识符替换为对应的 AST 节点
-*
-* @param node - 要转换的 AST 节点
-* @param getReplacementAst - 根据标识符名称返回替换的 AST 节点，返回 null 表示不替换
-* @returns 转换后的 AST 节点
-*/
-function transformIdentifiers(node, getReplacementAst) {
-	switch (node.type) {
-		case "Identifier": return getReplacementAst(node.name) ?? node;
-		case "BinaryExpr": return {
-			...node,
-			left: transformIdentifiers(node.left, getReplacementAst),
-			right: transformIdentifiers(node.right, getReplacementAst)
-		};
-		case "UnaryExpr": return {
-			...node,
-			argument: transformIdentifiers(node.argument, getReplacementAst)
-		};
-		case "ConditionalExpr": return {
-			...node,
-			test: transformIdentifiers(node.test, getReplacementAst),
-			consequent: transformIdentifiers(node.consequent, getReplacementAst),
-			alternate: transformIdentifiers(node.alternate, getReplacementAst)
-		};
-		case "MemberExpr": return {
-			...node,
-			object: transformIdentifiers(node.object, getReplacementAst),
-			property: node.computed ? transformIdentifiers(node.property, getReplacementAst) : node.property
-		};
-		case "CallExpr": return {
-			...node,
-			callee: transformIdentifiers(node.callee, getReplacementAst),
-			arguments: node.arguments.map((arg) => transformIdentifiers(arg, getReplacementAst))
-		};
-		case "ArrayExpr": return {
-			...node,
-			elements: node.elements.map((el) => transformIdentifiers(el, getReplacementAst))
-		};
-		case "ObjectExpr": return {
-			...node,
-			properties: node.properties.map((prop) => ({
-				...prop,
-				key: prop.computed ? transformIdentifiers(prop.key, getReplacementAst) : prop.key,
-				value: transformIdentifiers(prop.value, getReplacementAst)
-			}))
-		};
-		default: return node;
-	}
-}
 
 //#endregion
 //#region src/evaluate.ts
@@ -1105,7 +1478,11 @@ function expr(context) {
 		const deps = /* @__PURE__ */ new Set();
 		const nameToId = /* @__PURE__ */ new Map();
 		for (const [name, value] of Object.entries(context)) {
-			const id = getVariableId(value);
+			let id = getVariableId(value);
+			if (!id && (typeof value === "object" || typeof value === "function") && value !== null) {
+				const meta = getProxyMetadata(value);
+				if (meta?.type === "variable" && meta.rootVariable) id = meta.rootVariable;
+			}
 			if (id) {
 				deps.add(id);
 				nameToId.set(name, id);
@@ -1114,33 +1491,115 @@ function expr(context) {
 				if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
 			}
 		}
-		let transformedSource = source;
-		for (const [name, id] of nameToId) {
-			const escapedPlaceholder = getVariablePlaceholder(id).replace(/\$/g, "$$$$");
-			const regex = new RegExp(`\\b${name}\\b`, "g");
-			transformedSource = transformedSource.replace(regex, escapedPlaceholder);
-		}
-		for (const [name, value] of Object.entries(context)) if ((typeof value === "object" || typeof value === "function") && value !== null && !getVariableId(value)) {
+		const nameToExprAST = /* @__PURE__ */ new Map();
+		for (const [name, value] of Object.entries(context)) if ((typeof value === "object" || typeof value === "function") && value !== null) {
+			if (nameToId.has(name)) continue;
 			const meta = getProxyMetadata(value);
-			if (meta?.source) {
-				const regex = new RegExp(`\\b${name}\\b`, "g");
-				const escapedSource = `(${meta.source})`.replace(/\$/g, "$$$$");
-				transformedSource = transformedSource.replace(regex, escapedSource);
-			}
+			if (meta?.ast) nameToExprAST.set(name, meta.ast);
 		}
-		return createProxyExpressionWithSource(transformedSource, deps);
+		return createProxyExpressionWithAST(transformIdentifiers(parse(source), (name) => {
+			const id = nameToId.get(name);
+			if (id) return getVariablePlaceholder(id);
+			const exprAST = nameToExprAST.get(name);
+			if (exprAST) return exprAST;
+			return name;
+		}), deps);
 	};
 }
 
 //#endregion
-//#region src/template.ts
+//#region src/lambda.ts
+/**
+* Lambda 参数计数器，用于生成唯一 ID
+*/
+let lambdaParamCounter = 0;
 /**
-* 转义字符串字面量中的特殊字符
+* Lambda 参数到索引的映射
+* 用于编译时确定参数位置
 */
-function escapeStringLiteral(str) {
-	return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+const lambdaParamIndices = /* @__PURE__ */ new WeakMap();
+/**
+* 创建 lambda 参数代理
+* 生成带特殊标记的 Proxy，用于在表达式中追踪参数
+*
+* @param index - 参数索引（0, 1, 2...）
+* @returns Lambda 参数代理
+*/
+function createLambdaParam(index) {
+	const proxy = createProxyVariable(Symbol(`lambda_param_${lambdaParamCounter++}_${index}`));
+	lambdaParamIndices.set(proxy, index);
+	return proxy;
 }
 /**
+* 创建类型安全的 lambda 表达式
+*
+* @template Args - 参数类型元组
+* @template R - 返回值类型
+* @param builder - Lambda 构建函数，接收参数代理，返回函数体表达式
+* @returns Lambda 表达式代理
+*
+* @example
+* ```ts
+* const add = lambda<[number, number], number>(
+*   (a, b) => expr({ a, b })("a + b")
+* );
+*
+* const numbers = variable<number[]>();
+* const sum = numbers.reduce(add, 0);
+* ```
+*/
+function lambda(builder) {
+	const paramCount = builder.length;
+	const params = [];
+	const paramSymbols = [];
+	for (let i = 0; i < paramCount; i++) {
+		const param = createLambdaParam(i);
+		params.push(param);
+		const meta = getProxyMetadata(param);
+		if (meta?.rootVariable) paramSymbols.push(meta.rootVariable);
+	}
+	const bodyExpr = builder(...params);
+	let bodyAst;
+	let bodyDeps;
+	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();
+		collectDepsFromArgs([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 = {
+		type: "ArrowFunctionExpr",
+		params: params.map((_, i) => ({
+			type: "Identifier",
+			name: `_${i}`
+		})),
+		body: transformedBodyAst
+	};
+	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;
+}
+
+//#endregion
+//#region src/template.ts
+/**
 * Tagged template 函数，用于创建包含变量的字符串表达式
 *
 * @example
@@ -1161,17 +1620,62 @@ function t(strings, ...values) {
 	const parts = [];
 	for (let i = 0; i < strings.length; i++) {
 		const str = strings[i];
-		if (str.length > 0) parts.push(`"${escapeStringLiteral(str)}"`);
+		if (str.length > 0) parts.push({
+			type: "StringLiteral",
+			value: str,
+			quote: "\""
+		});
 		if (i < values.length) {
-			const serialized = serializeArgument(values[i]);
-			parts.push(serialized);
+			const ast = serializeArgumentToAST(values[i]);
+			parts.push(ast);
 		}
 	}
-	if (parts.length === 0) return createProxyExpressionWithSource("\"\"", deps);
-	if (parts.length === 1) return createProxyExpressionWithSource(parts[0], deps);
-	return createProxyExpressionWithSource("(" + parts.join(" + ") + ")", deps);
+	if (parts.length === 0) return createProxyExpressionWithAST({
+		type: "StringLiteral",
+		value: "",
+		quote: "\""
+	}, deps);
+	if (parts.length === 1) return createProxyExpressionWithAST(parts[0], deps);
+	let resultAst = parts[0];
+	for (let i = 1; i < parts.length; i++) resultAst = {
+		type: "BinaryExpr",
+		operator: "+",
+		left: resultAst,
+		right: parts[i]
+	};
+	return createProxyExpressionWithAST(resultAst, deps);
+}
+
+//#endregion
+//#region src/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, t, variable };
+export { compile, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, lambda, t, variable, wrap };
 //# sourceMappingURL=index.mjs.map