@codehz/json-expr 0.6.2 → 0.6.4

package/dist/index.mjs

@@ -63,8 +63,8 @@ function createGenerateContext() {
 /**
 * 从 AST 生成规范化的代码
 */
-function generate(node) {
-	return generateWithContext(node, createGenerateContext());
+function generate(node, options = {}) {
+	return generateWithContext(node, createGenerateContext(), options);
 }
 /** 需要空格分隔的关键字运算符 */
 const KEYWORD_BINARY_OPERATORS = new Set(["in", "instanceof"]);
@@ -72,46 +72,47 @@ const KEYWORD_UNARY_OPERATORS = new Set(["typeof", "void"]);
 /**
 * 带上下文的代码生成
 */
-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";
+function generateWithContext(node, ctx, options = {}) {
+	const rewritten = options.rewriteNode?.(node, ctx) ?? node;
+	switch (rewritten.type) {
+		case "NumberLiteral": return rewritten.raw;
+		case "StringLiteral": return JSON.stringify(rewritten.value);
+		case "BooleanLiteral": return rewritten.value ? "true" : "false";
 		case "NullLiteral": return "null";
-		case "Identifier": return node.name;
-		case "Placeholder": return ctx.paramMapping.get(node.id) ?? `$$${node.id.description}$$`;
+		case "Identifier": return rewritten.name;
+		case "Placeholder": return ctx.paramMapping.get(rewritten.id) ?? `$$${rewritten.id.description}$$`;
 		case "BinaryExpr": {
-			const left = wrapIfNeededWithContext(node.left, node, "left", ctx);
-			const right = wrapIfNeededWithContext(node.right, node, "right", ctx);
-			const sep = KEYWORD_BINARY_OPERATORS.has(node.operator) ? " " : "";
-			return `${left}${sep}${node.operator}${sep}${right}`;
+			const left = wrapIfNeededWithContext(rewritten.left, rewritten, "left", ctx, options);
+			const right = wrapIfNeededWithContext(rewritten.right, rewritten, "right", ctx, options);
+			const sep = KEYWORD_BINARY_OPERATORS.has(rewritten.operator) ? " " : "";
+			return `${left}${sep}${rewritten.operator}${sep}${right}`;
 		}
 		case "UnaryExpr": {
-			if (!node.prefix) return generateWithContext(node.argument, ctx) + node.operator;
-			const arg = wrapIfNeededWithContext(node.argument, node, "argument", ctx);
-			const sep = KEYWORD_UNARY_OPERATORS.has(node.operator) ? " " : "";
-			return `${node.operator}${sep}${arg}`;
+			if (!rewritten.prefix) return generateWithContext(rewritten.argument, ctx, options) + rewritten.operator;
+			const arg = wrapIfNeededWithContext(rewritten.argument, rewritten, "argument", ctx, options);
+			const sep = KEYWORD_UNARY_OPERATORS.has(rewritten.operator) ? " " : "";
+			return `${rewritten.operator}${sep}${arg}`;
 		}
-		case "ConditionalExpr": return `${wrapIfNeededWithContext(node.test, node, "test", ctx)}?${wrapIfNeededWithContext(node.consequent, node, "consequent", ctx)}:${wrapIfNeededWithContext(node.alternate, node, "alternate", ctx)}`;
+		case "ConditionalExpr": return `${wrapIfNeededWithContext(rewritten.test, rewritten, "test", ctx, options)}?${wrapIfNeededWithContext(rewritten.consequent, rewritten, "consequent", ctx, options)}:${wrapIfNeededWithContext(rewritten.alternate, rewritten, "alternate", ctx, options)}`;
 		case "MemberExpr": {
-			const object = wrapIfNeededWithContext(node.object, node, "object", ctx);
-			const property = generateWithContext(node.property, ctx);
-			const accessor = node.optional ? "?." : node.computed ? "" : ".";
-			return node.computed ? `${object}${accessor}[${property}]` : `${object}${accessor}${property}`;
+			const object = wrapIfNeededWithContext(rewritten.object, rewritten, "object", ctx, options);
+			const property = generateWithContext(rewritten.property, ctx, options);
+			const accessor = rewritten.optional ? "?." : rewritten.computed ? "" : ".";
+			return rewritten.computed ? `${object}${accessor}[${property}]` : `${object}${accessor}${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)}`;
+			const callee = wrapIfNeededWithContext(rewritten.callee, rewritten, "callee", ctx, options);
+			const args = rewritten.arguments.map((arg) => generateWithContext(arg, ctx, options)).join(",");
+			return `${rewritten.callee.type === "Identifier" && BUILTIN_CONSTRUCTORS.has(rewritten.callee.name) ? "new " : ""}${callee}${rewritten.optional ? "?." : ""}(${args})`;
+		}
+		case "ArrayExpr": return `[${rewritten.elements.map((el) => generateWithContext(el, ctx, options)).join(",")}]`;
+		case "ObjectExpr": return `{${rewritten.properties.map((prop) => {
+			if (prop.shorthand) return generateWithContext(prop.key, ctx, options);
+			return `${prop.computed ? `[${generateWithContext(prop.key, ctx, options)}]` : generateWithContext(prop.key, ctx, options)}:${generateWithContext(prop.value, ctx, options)}`;
 		}).join(",")}}`;
-		case "ArrowFunctionExpr": return generateArrowFunction(node, ctx);
+		case "ArrowFunctionExpr": return generateArrowFunction(rewritten, ctx, options);
 		default: {
-			const unknownNode = node;
+			const unknownNode = rewritten;
 			throw new Error(`Unknown node type: ${unknownNode.type ?? "unknown"}`);
 		}
 	}
@@ -120,7 +121,7 @@ function generateWithContext(node, ctx) {
 * 生成箭头函数代码
 * 为 Placeholder 参数分配唯一名称，避免嵌套 lambda 冲突
 */
-function generateArrowFunction(node, ctx) {
+function generateArrowFunction(node, ctx, options) {
 	const allocatedParams = [];
 	const paramNames = [];
 	for (const param of node.params) if (param.type === "Identifier") paramNames.push(param.name);
@@ -135,7 +136,7 @@ function generateArrowFunction(node, ctx) {
 		ctx.paramMapping.set(param.id, name);
 	}
 	const paramsStr = paramNames.length === 1 ? paramNames[0] : `(${paramNames.join(",")})`;
-	const bodyStr = node.body.type === "ObjectExpr" ? `(${generateWithContext(node.body, ctx)})` : generateWithContext(node.body, ctx);
+	const bodyStr = node.body.type === "ObjectExpr" ? `(${generateWithContext(node.body, ctx, options)})` : generateWithContext(node.body, ctx, options);
 	for (const { id, name } of allocatedParams) {
 		ctx.paramMapping.delete(id);
 		ctx.usedParamNames.delete(name);
@@ -153,9 +154,10 @@ function allocateUniqueName(usedNames) {
 /**
 * 判断是否需要括号包裹，并生成代码（带上下文版本）
 */
-function wrapIfNeededWithContext(child, parent, position, ctx) {
-	const code = generateWithContext(child, ctx);
-	if (needsParens(child, parent, position)) return `(${code})`;
+function wrapIfNeededWithContext(child, parent, position, ctx, options = {}) {
+	const rewrittenChild = options.rewriteNode?.(child, ctx) ?? child;
+	const code = generateWithContext(rewrittenChild, ctx, options);
+	if (needsParens(rewrittenChild, parent, position)) return `(${code})`;
 	return code;
 }
 /**
@@ -199,169 +201,257 @@ function transformIdentifiers(node, transform) {
 	switch (node.type) {
 		case "Identifier": {
 			const result = transform(node.name);
-			return typeof result === "string" ? {
+			if (typeof result !== "string") return result;
+			return result === node.name ? node : {
 				...node,
 				name: result
-			} : result;
+			};
 		}
 		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 "BinaryExpr": {
+			const left = transformIdentifiers(node.left, transform);
+			const right = transformIdentifiers(node.right, transform);
+			return left === node.left && right === node.right ? node : {
+				...node,
+				left,
+				right
+			};
+		}
+		case "UnaryExpr": {
+			const argument = transformIdentifiers(node.argument, transform);
+			return argument === node.argument ? node : {
+				...node,
+				argument
+			};
+		}
+		case "ConditionalExpr": {
+			const test = transformIdentifiers(node.test, transform);
+			const consequent = transformIdentifiers(node.consequent, transform);
+			const alternate = transformIdentifiers(node.alternate, transform);
+			return test === node.test && consequent === node.consequent && alternate === node.alternate ? node : {
+				...node,
+				test,
+				consequent,
+				alternate
+			};
+		}
+		case "MemberExpr": {
+			const object = transformIdentifiers(node.object, transform);
+			const property = node.computed ? transformIdentifiers(node.property, transform) : node.property;
+			return object === node.object && property === node.property ? node : {
+				...node,
+				object,
+				property
+			};
+		}
+		case "CallExpr": {
+			const callee = transformIdentifiers(node.callee, transform);
+			const arguments_ = mapAstNodes$1(node.arguments, (arg) => transformIdentifiers(arg, transform));
+			return callee === node.callee && arguments_ === node.arguments ? node : {
+				...node,
+				callee,
+				arguments: arguments_
+			};
+		}
+		case "ArrayExpr": {
+			const elements = mapAstNodes$1(node.elements, (el) => transformIdentifiers(el, transform));
+			return elements === node.elements ? node : {
+				...node,
+				elements
+			};
+		}
+		case "ObjectExpr": {
+			const properties = mapObjectProperties$1(node.properties, (prop) => {
+				const key = prop.computed ? transformIdentifiers(prop.key, transform) : prop.key;
+				const value = transformIdentifiers(prop.value, transform);
+				return key === prop.key && value === prop.value ? prop : {
+					...prop,
+					key,
+					value
+				};
+			});
+			return properties === node.properties ? node : {
+				...node,
+				properties
+			};
+		}
 		case "ArrowFunctionExpr": {
 			const paramNames = new Set(node.params.filter((p) => p.type === "Identifier").map((p) => p.name));
-			return {
+			const body = transformIdentifiers(node.body, (name) => paramNames.has(name) ? name : transform(name));
+			return body === node.body ? node : {
 				...node,
-				body: transformIdentifiers(node.body, (name) => paramNames.has(name) ? name : transform(name))
+				body
 			};
 		}
 		default: return node;
 	}
 }
 /**
-* 转换 AST 中的占位符节点
-* 回调函数接收 symbol，返回 Identifier 节点的名称
-* 如果返回 null/undefined，则保留原始 Placeholder 节点
+* expr() 专用：将 context 中的变量替换为 Placeholder。
 */
-function transformPlaceholders(node, transform) {
+function transformExprVariables(node, nameToId) {
+	return transformIdentifiers(node, (name) => {
+		const id = nameToId.get(name);
+		return id ? {
+			type: "Placeholder",
+			id
+		} : name;
+	});
+}
+/**
+* expr() 专用：单次遍历完成变量替换、子表达式引用计数和延迟编译收集。
+*/
+function transformExprIdentifiers(node, nameToId, nameToExprAST) {
+	const refCounts = /* @__PURE__ */ new Map();
+	const candidateRefs = /* @__PURE__ */ new Map();
+	const ast = transformExprIdentifiersWithScope(node, nameToId, nameToExprAST, refCounts, candidateRefs);
+	let deferredAsts;
+	for (const [name, refs] of candidateRefs) {
+		if ((refCounts.get(name) ?? 0) <= 1) {
+			replaceNode(refs[0], nameToExprAST.get(name));
+			continue;
+		}
+		if (!deferredAsts) deferredAsts = /* @__PURE__ */ new Map();
+		deferredAsts.set(name, nameToExprAST.get(name));
+	}
+	return {
+		ast,
+		deferredAsts
+	};
+}
+function mapAstNodes$1(nodes, transform) {
+	let result;
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const transformed = transform(node);
+		if (result) {
+			result.push(transformed);
+			continue;
+		}
+		if (transformed !== node) {
+			result = nodes.slice(0, i);
+			result.push(transformed);
+		}
+	}
+	return result ?? nodes;
+}
+function mapObjectProperties$1(properties, transform) {
+	let result;
+	for (let i = 0; i < properties.length; i++) {
+		const property = properties[i];
+		const transformed = transform(property);
+		if (result) {
+			result.push(transformed);
+			continue;
+		}
+		if (transformed !== property) {
+			result = properties.slice(0, i);
+			result.push(transformed);
+		}
+	}
+	return result ?? properties;
+}
+function transformExprIdentifiersWithScope(node, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames) {
 	switch (node.type) {
-		case "Placeholder": {
-			const name = transform(node.id);
-			return name != null ? {
-				type: "Identifier",
-				name
-			} : node;
+		case "Identifier": {
+			if (shadowedNames?.has(node.name)) return node;
+			const id = nameToId.get(node.name);
+			if (id) return {
+				type: "Placeholder",
+				id
+			};
+			if (!nameToExprAST.get(node.name)) return node;
+			refCounts.set(node.name, (refCounts.get(node.name) ?? 0) + 1);
+			const candidateNode = { ...node };
+			const refs = candidateRefs.get(node.name);
+			if (refs) refs.push(candidateNode);
+			else candidateRefs.set(node.name, [candidateNode]);
+			return candidateNode;
+		}
+		case "Placeholder": return node;
+		case "BinaryExpr": {
+			const left = transformExprIdentifiersWithScope(node.left, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			const right = transformExprIdentifiersWithScope(node.right, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			return left === node.left && right === node.right ? node : {
+				...node,
+				left,
+				right
+			};
+		}
+		case "UnaryExpr": {
+			const argument = transformExprIdentifiersWithScope(node.argument, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			return argument === node.argument ? node : {
+				...node,
+				argument
+			};
+		}
+		case "ConditionalExpr": {
+			const test = transformExprIdentifiersWithScope(node.test, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			const consequent = transformExprIdentifiersWithScope(node.consequent, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			const alternate = transformExprIdentifiersWithScope(node.alternate, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			return test === node.test && consequent === node.consequent && alternate === node.alternate ? node : {
+				...node,
+				test,
+				consequent,
+				alternate
+			};
+		}
+		case "MemberExpr": {
+			const object = transformExprIdentifiersWithScope(node.object, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			const property = node.computed ? transformExprIdentifiersWithScope(node.property, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames) : node.property;
+			return object === node.object && property === node.property ? node : {
+				...node,
+				object,
+				property
+			};
+		}
+		case "CallExpr": {
+			const callee = transformExprIdentifiersWithScope(node.callee, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+			const arguments_ = mapAstNodes$1(node.arguments, (arg) => transformExprIdentifiersWithScope(arg, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames));
+			return callee === node.callee && arguments_ === node.arguments ? node : {
+				...node,
+				callee,
+				arguments: arguments_
+			};
+		}
+		case "ArrayExpr": {
+			const elements = mapAstNodes$1(node.elements, (el) => transformExprIdentifiersWithScope(el, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames));
+			return elements === node.elements ? node : {
+				...node,
+				elements
+			};
+		}
+		case "ObjectExpr": {
+			const properties = mapObjectProperties$1(node.properties, (prop) => {
+				const key = prop.computed ? transformExprIdentifiersWithScope(prop.key, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames) : prop.key;
+				const value = transformExprIdentifiersWithScope(prop.value, nameToId, nameToExprAST, refCounts, candidateRefs, shadowedNames);
+				return key === prop.key && value === prop.value ? prop : {
+					...prop,
+					key,
+					value
+				};
+			});
+			return properties === node.properties ? node : {
+				...node,
+				properties
+			};
 		}
-		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 {
+			const paramNames = node.params.filter((p) => p.type === "Identifier");
+			const nextShadowedNames = paramNames.length === 0 ? shadowedNames : new Set([...shadowedNames ?? [], ...paramNames.map((param) => param.name)]);
+			const body = transformExprIdentifiersWithScope(node.body, nameToId, nameToExprAST, refCounts, candidateRefs, nextShadowedNames);
+			return body === node.body ? node : {
 				...node,
-				body: transformPlaceholders(node.body, (id) => paramSymbols.has(id) ? null : transform(id))
+				body
 			};
 		}
 		default: return node;
 	}
 }
-/**
-* 统计 AST 中各标识符名称的出现次数
-* 用于判断子表达式是否应该内联（引用次数 = 1 则内联，> 1 则推迟为独立编译）
-*/
-function countIdentifierReferences(node, counts) {
-	switch (node.type) {
-		case "Identifier":
-			counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
-			break;
-		case "Placeholder": break;
-		case "BinaryExpr":
-			countIdentifierReferences(node.left, counts);
-			countIdentifierReferences(node.right, counts);
-			break;
-		case "UnaryExpr":
-			countIdentifierReferences(node.argument, counts);
-			break;
-		case "ConditionalExpr":
-			countIdentifierReferences(node.test, counts);
-			countIdentifierReferences(node.consequent, counts);
-			countIdentifierReferences(node.alternate, counts);
-			break;
-		case "MemberExpr":
-			countIdentifierReferences(node.object, counts);
-			if (node.computed) countIdentifierReferences(node.property, counts);
-			break;
-		case "CallExpr":
-			countIdentifierReferences(node.callee, counts);
-			for (const arg of node.arguments) countIdentifierReferences(arg, counts);
-			break;
-		case "ArrayExpr":
-			for (const el of node.elements) countIdentifierReferences(el, counts);
-			break;
-		case "ObjectExpr":
-			for (const prop of node.properties) {
-				if (prop.computed) countIdentifierReferences(prop.key, counts);
-				countIdentifierReferences(prop.value, counts);
-			}
-			break;
-		case "ArrowFunctionExpr":
-			{
-				const paramNames = new Set(node.params.filter((p) => p.type === "Identifier").map((p) => p.name));
-				const bodyCounts = /* @__PURE__ */ new Map();
-				countIdentifierReferences(node.body, bodyCounts);
-				for (const [name, count] of bodyCounts) if (!paramNames.has(name)) counts.set(name, (counts.get(name) ?? 0) + count);
-			}
-			break;
-	}
+function replaceNode(target, replacement) {
+	const record = target;
+	for (const key of Object.keys(record)) delete record[key];
+	Object.assign(record, replacement);
 }
 
 //#endregion
@@ -1336,6 +1426,7 @@ function expr(context) {
 	return (source) => {
 		const deps = /* @__PURE__ */ new Set();
 		const nameToId = /* @__PURE__ */ new Map();
+		const nameToExprAST = /* @__PURE__ */ new Map();
 		for (const [name, value] of Object.entries(context)) {
 			let id = getVariableId(value);
 			if (!id && (typeof value === "object" || typeof value === "function") && value !== null) {
@@ -1348,32 +1439,15 @@ function expr(context) {
 			} else {
 				const meta = (typeof value === "object" || typeof value === "function") && value !== null ? getProxyMetadata(value) : void 0;
 				if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
+				if (meta?.ast) nameToExprAST.set(name, meta.ast);
 			}
 		}
-		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?.ast) nameToExprAST.set(name, meta.ast);
-		}
 		const ast = parse(source);
-		const refCounts = /* @__PURE__ */ new Map();
-		countIdentifierReferences(ast, refCounts);
-		const deferredAsts = /* @__PURE__ */ new Map();
-		return createProxyExpressionWithAST(transformIdentifiers(ast, (name) => {
-			const id = nameToId.get(name);
-			if (id) return {
-				type: "Placeholder",
-				id
-			};
-			const exprAST = nameToExprAST.get(name);
-			if (exprAST) {
-				if ((refCounts.get(name) ?? 0) <= 1) return exprAST;
-				deferredAsts.set(name, exprAST);
-				return name;
-			}
-			return name;
-		}), deps, deferredAsts.size > 0 ? deferredAsts : void 0);
+		const { ast: transformedAst, deferredAsts } = nameToExprAST.size === 0 ? {
+			ast: transformExprVariables(ast, nameToId),
+			deferredAsts: void 0
+		} : transformExprIdentifiers(ast, nameToId, nameToExprAST);
+		return createProxyExpressionWithAST(transformedAst, deps, deferredAsts);
 	};
 }
 
@@ -1635,12 +1709,10 @@ const BRANCH_CONDITIONS = {
 * ```
 */
 function compile(expression, variables, _options = {}) {
-	let deferredAsts;
-	if ((typeof expression === "object" || typeof expression === "function") && expression !== null) deferredAsts = getProxyMetadata(expression)?.deferredAsts;
-	const ast = serializeArgumentToAST(expression);
+	const { ast, deferredAsts } = normalizeCompileInput(expression);
 	const variableOrder = [];
 	const variableToIndex = /* @__PURE__ */ new Map();
-	const symbolToName = /* @__PURE__ */ new Map();
+	const placeholderNames = /* @__PURE__ */ new Map();
 	for (const [name, value] of Object.entries(variables)) {
 		if (!variableToIndex.has(name)) {
 			const index = variableOrder.length;
@@ -1648,38 +1720,122 @@ function compile(expression, variables, _options = {}) {
 			variableOrder.push(name);
 		}
 		const id = getVariableId(value);
-		if (id) symbolToName.set(id, name);
+		if (id) placeholderNames.set(id, `$[${variableToIndex.get(name)}]`);
 	}
 	const topLevelExprs = [];
+	const baseScope = { placeholderNames };
 	const ctx = {
 		nextParamIndex: 0,
 		expressionStack: [topLevelExprs],
 		nextIndex: variableOrder.length,
-		variableCount: variableOrder.length
+		variableCount: variableOrder.length,
+		baseScope
 	};
 	const deferredIndexMap = /* @__PURE__ */ new Map();
-	if (deferredAsts && deferredAsts.size > 0) compileDeferredExprs(deferredAsts, ctx, symbolToName, variableToIndex, deferredIndexMap);
-	const placeholderTransformed = transformPlaceholders(ast, (id) => {
-		const name = symbolToName.get(id);
-		if (!name) return null;
-		const index = variableToIndex.get(name);
-		return index !== void 0 ? `$[${index}]` : null;
-	});
+	if (deferredAsts && deferredAsts.size > 0) compileDeferredExprs(deferredAsts, ctx, baseScope, deferredIndexMap);
 	const undefinedVars = [];
-	const transformed = transformIdentifiers(placeholderTransformed, (name) => {
-		if (/^\$\[\d+\]$/.test(name)) return name;
-		if (/^_\d+$/.test(name)) return name;
-		const index = variableToIndex.get(name);
-		if (index !== void 0) return `$[${index}]`;
-		const deferredIdx = deferredIndexMap.get(name);
-		if (deferredIdx !== void 0) return `$[${deferredIdx}]`;
-		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
-		return name;
+	const transformed = rewriteAstForCompile(ast, {
+		...baseScope,
+		deferredIndexMap,
+		undefinedVars
 	});
 	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
-	compileAst(transformed, ctx);
+	compileAst(transformed, ctx, baseScope);
 	return [variableOrder, ...topLevelExprs];
 }
+function normalizeCompileInput(expression) {
+	const state = {
+		deferredAsts: /* @__PURE__ */ new Map(),
+		nextDeferredGroup: 0
+	};
+	return {
+		ast: normalizeCompileValueToAST(expression, state),
+		deferredAsts: state.deferredAsts.size > 0 ? state.deferredAsts : void 0
+	};
+}
+function normalizeCompileValueToAST(value, state) {
+	if ((typeof value === "object" || typeof value === "function") && value !== null) {
+		const meta = getProxyMetadata(value);
+		if (meta) {
+			if (meta.ast) {
+				if (meta.deferredAsts && meta.deferredAsts.size > 0) {
+					const renamed = renameDeferredExpressions(meta.ast, meta.deferredAsts, state.nextDeferredGroup++);
+					for (const [name, ast] of renamed.deferredAsts) state.deferredAsts.set(name, ast);
+					return renamed.ast;
+				}
+				return meta.ast;
+			}
+			if (meta.rootVariable) return {
+				type: "Placeholder",
+				id: meta.rootVariable
+			};
+		}
+	}
+	if (Array.isArray(value)) return {
+		type: "ArrayExpr",
+		elements: value.map((item) => normalizeCompileValueToAST(item, state))
+	};
+	if (value instanceof Map) return {
+		type: "CallExpr",
+		callee: {
+			type: "Identifier",
+			name: "Map"
+		},
+		arguments: [{
+			type: "ArrayExpr",
+			elements: Array.from(value, ([key, entryValue]) => ({
+				type: "ArrayExpr",
+				elements: [normalizeCompileValueToAST(key, state), normalizeCompileValueToAST(entryValue, state)]
+			}))
+		}],
+		optional: false
+	};
+	if (value instanceof Set) return {
+		type: "CallExpr",
+		callee: {
+			type: "Identifier",
+			name: "Set"
+		},
+		arguments: [{
+			type: "ArrayExpr",
+			elements: Array.from(value, (item) => normalizeCompileValueToAST(item, state))
+		}],
+		optional: false
+	};
+	if (isRecursivelySerializableObject(value)) return {
+		type: "ObjectExpr",
+		properties: Object.entries(value).map(([key, entryValue]) => ({
+			key: /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? {
+				type: "Identifier",
+				name: key
+			} : {
+				type: "StringLiteral",
+				value: key,
+				quote: "\""
+			},
+			value: normalizeCompileValueToAST(entryValue, state),
+			computed: false,
+			shorthand: false
+		}))
+	};
+	return serializeArgumentToAST(value);
+}
+function isRecursivelySerializableObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (value instanceof Date || value instanceof RegExp || typeof URL !== "undefined" && value instanceof URL || typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams || value instanceof ArrayBuffer || value instanceof DataView || ArrayBuffer.isView(value)) return false;
+	return true;
+}
+function renameDeferredExpressions(ast, deferredAsts, groupIndex) {
+	const renamedNames = /* @__PURE__ */ new Map();
+	for (const name of deferredAsts.keys()) renamedNames.set(name, `__deferred_${groupIndex}_${name}`);
+	const renameNode = (node) => transformIdentifiers(node, (name) => renamedNames.get(name) ?? name);
+	const renamedDeferredAsts = /* @__PURE__ */ new Map();
+	for (const [name, deferredAst] of deferredAsts) renamedDeferredAsts.set(renamedNames.get(name), renameNode(deferredAst));
+	return {
+		ast: renameNode(ast),
+		deferredAsts: renamedDeferredAsts
+	};
+}
 /**
 * 获取当前表达式列表
 */
@@ -1690,7 +1846,7 @@ function currentExprs(ctx) {
 * 编译推迟的子表达式（因引用计数 >1 未内联）
 * 使用递归处理，自动按依赖拓扑顺序编译
 */
-function compileDeferredExprs(deferredAsts, ctx, symbolToName, variableToIndex, deferredIndexMap) {
+function compileDeferredExprs(deferredAsts, ctx, baseScope, deferredIndexMap) {
 	const processing = /* @__PURE__ */ new Set();
 	function compileOne(name) {
 		if (processing.has(name)) throw new Error(`Circular reference in deferred expressions: ${name}`);
@@ -1699,91 +1855,175 @@ function compileDeferredExprs(deferredAsts, ctx, symbolToName, variableToIndex,
 		const ast = deferredAsts.get(name);
 		if (!ast) throw new Error(`Unknown deferred expression: ${name}`);
 		processing.add(name);
-		const t1 = transformPlaceholders(ast, (id) => {
-			const vName = symbolToName.get(id);
-			if (!vName) return null;
-			const idx = variableToIndex.get(vName);
-			return idx !== void 0 ? `$[${idx}]` : null;
-		});
 		const undefinedVars = [];
-		const t2 = transformIdentifiers(t1, (n) => {
-			if (/^\$\[\d+\]$/.test(n)) return n;
-			if (/^_\d+$/.test(n)) return n;
-			const varIdx = variableToIndex.get(n);
-			if (varIdx !== void 0) return `$[${varIdx}]`;
-			if (deferredAsts.has(n)) return `$[${compileOne(n)}]`;
-			if (!ALLOWED_GLOBALS.has(n)) undefinedVars.push(n);
-			return n;
+		const transformed = rewriteAstForCompile(ast, {
+			...baseScope,
+			deferredAsts,
+			deferredIndexMap,
+			onDeferredReference: compileOne,
+			undefinedVars
 		});
 		if (undefinedVars.length > 0) throw new Error(`Undefined variable(s) in deferred expression "${name}": ${[...new Set(undefinedVars)].join(", ")}`);
-		const idx = compileAst(t2, ctx);
+		const idx = compileAst(transformed, ctx, baseScope);
 		deferredIndexMap.set(name, idx);
 		processing.delete(name);
 		return idx;
 	}
 	for (const name of deferredAsts.keys()) compileOne(name);
 }
+function rewriteAstForCompile(node, scope) {
+	switch (node.type) {
+		case "Placeholder": {
+			const name = scope.placeholderNames.get(node.id);
+			return name ? {
+				type: "Identifier",
+				name
+			} : node;
+		}
+		case "Identifier": {
+			if (scope.shadowedNames?.has(node.name)) return node;
+			const resolved = resolveIdentifierName(node.name, scope);
+			return resolved === node.name ? node : {
+				...node,
+				name: resolved
+			};
+		}
+		case "BinaryExpr": {
+			const left = rewriteAstForCompile(node.left, scope);
+			const right = rewriteAstForCompile(node.right, scope);
+			return left === node.left && right === node.right ? node : {
+				...node,
+				left,
+				right
+			};
+		}
+		case "UnaryExpr": {
+			const argument = rewriteAstForCompile(node.argument, scope);
+			return argument === node.argument ? node : {
+				...node,
+				argument
+			};
+		}
+		case "ConditionalExpr": {
+			const test = rewriteAstForCompile(node.test, scope);
+			const consequent = rewriteAstForCompile(node.consequent, scope);
+			const alternate = rewriteAstForCompile(node.alternate, scope);
+			return test === node.test && consequent === node.consequent && alternate === node.alternate ? node : {
+				...node,
+				test,
+				consequent,
+				alternate
+			};
+		}
+		case "MemberExpr": {
+			const object = rewriteAstForCompile(node.object, scope);
+			const property = node.computed ? rewriteAstForCompile(node.property, scope) : node.property;
+			return object === node.object && property === node.property ? node : {
+				...node,
+				object,
+				property
+			};
+		}
+		case "CallExpr": {
+			const callee = rewriteAstForCompile(node.callee, scope);
+			const arguments_ = mapAstNodes(node.arguments, (arg) => rewriteAstForCompile(arg, scope));
+			return callee === node.callee && arguments_ === node.arguments ? node : {
+				...node,
+				callee,
+				arguments: arguments_
+			};
+		}
+		case "ArrayExpr": {
+			const elements = mapAstNodes(node.elements, (el) => rewriteAstForCompile(el, scope));
+			return elements === node.elements ? node : {
+				...node,
+				elements
+			};
+		}
+		case "ObjectExpr": {
+			const properties = mapObjectProperties(node.properties, (prop) => {
+				const key = prop.computed ? rewriteAstForCompile(prop.key, scope) : prop.key;
+				const value = rewriteAstForCompile(prop.value, scope);
+				return key === prop.key && value === prop.value ? prop : {
+					...prop,
+					key,
+					value
+				};
+			});
+			return properties === node.properties ? node : {
+				...node,
+				properties
+			};
+		}
+		case "ArrowFunctionExpr": return node;
+		default: return node;
+	}
+}
+function resolveIdentifierName(name, scope) {
+	if (/^\$\[\d+\]$/.test(name) || /^_\d+$/.test(name)) return name;
+	const deferredIdx = scope.deferredIndexMap?.get(name);
+	if (deferredIdx !== void 0) return `$[${deferredIdx}]`;
+	if (scope.deferredAsts?.has(name) && scope.onDeferredReference) return `$[${scope.onDeferredReference(name)}]`;
+	if (!ALLOWED_GLOBALS.has(name)) scope.undefinedVars?.push(name);
+	return name;
+}
+function extendShadowedNames(shadowedNames, names) {
+	if (names.length === 0) return shadowedNames;
+	return new Set([...shadowedNames ?? [], ...names]);
+}
+function mapAstNodes(nodes, transform) {
+	let result;
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const transformed = transform(node);
+		if (result) {
+			result.push(transformed);
+			continue;
+		}
+		if (transformed !== node) {
+			result = nodes.slice(0, i);
+			result.push(transformed);
+		}
+	}
+	return result ?? nodes;
+}
+function mapObjectProperties(properties, transform) {
+	let result;
+	for (let i = 0; i < properties.length; i++) {
+		const property = properties[i];
+		const transformed = transform(property);
+		if (result) {
+			result.push(transformed);
+			continue;
+		}
+		if (transformed !== property) {
+			result = properties.slice(0, i);
+			result.push(transformed);
+		}
+	}
+	return result ?? properties;
+}
 /**
 * 提取 AST 中所有 ArrowFunctionExpr 节点，编译为 FnNode，
 * 并将原始位置替换为 $[N] 标识符引用。
 */
-function extractAndCompileArrowFunctions(node, ctx) {
-	switch (node.type) {
-		case "ArrowFunctionExpr": return {
+function compileAst(node, ctx, scope) {
+	if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node, ctx, scope);
+	if (node.type === "ConditionalExpr") return compileConditional(node, ctx, scope);
+	if (node.type === "ArrowFunctionExpr") return compileArrowFunction(node, ctx, scope);
+	const exprStr = generate(node, { rewriteNode: (current) => {
+		if (current.type !== "ArrowFunctionExpr") return current;
+		return {
 			type: "Identifier",
-			name: `$[${compileArrowFunction(node, ctx)}]`
-		};
-		case "BinaryExpr": return {
-			...node,
-			left: extractAndCompileArrowFunctions(node.left, ctx),
-			right: extractAndCompileArrowFunctions(node.right, ctx)
+			name: `$[${compileArrowFunction(current, ctx, scope)}]`
 		};
-		case "UnaryExpr": return {
-			...node,
-			argument: extractAndCompileArrowFunctions(node.argument, ctx)
-		};
-		case "ConditionalExpr": return {
-			...node,
-			test: extractAndCompileArrowFunctions(node.test, ctx),
-			consequent: extractAndCompileArrowFunctions(node.consequent, ctx),
-			alternate: extractAndCompileArrowFunctions(node.alternate, ctx)
-		};
-		case "MemberExpr": return {
-			...node,
-			object: extractAndCompileArrowFunctions(node.object, ctx),
-			property: node.computed ? extractAndCompileArrowFunctions(node.property, ctx) : node.property
-		};
-		case "CallExpr": return {
-			...node,
-			callee: extractAndCompileArrowFunctions(node.callee, ctx),
-			arguments: node.arguments.map((arg) => extractAndCompileArrowFunctions(arg, ctx))
-		};
-		case "ArrayExpr": return {
-			...node,
-			elements: node.elements.map((el) => extractAndCompileArrowFunctions(el, ctx))
-		};
-		case "ObjectExpr": return {
-			...node,
-			properties: node.properties.map((prop) => ({
-				...prop,
-				key: prop.computed ? extractAndCompileArrowFunctions(prop.key, ctx) : prop.key,
-				value: extractAndCompileArrowFunctions(prop.value, ctx)
-			}))
-		};
-		default: return node;
-	}
-}
-function compileAst(node, ctx) {
-	if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node, ctx);
-	if (node.type === "ConditionalExpr") return compileConditional(node, ctx);
-	if (node.type === "ArrowFunctionExpr") return compileArrowFunction(node, ctx);
-	const exprStr = generate(extractAndCompileArrowFunctions(node, ctx));
+	} });
 	currentExprs(ctx).push(exprStr);
 	return ctx.nextIndex++;
 }
-function compileShortCircuit(node, ctx) {
+function compileShortCircuit(node, ctx, scope) {
 	const exprs = currentExprs(ctx);
-	const leftIdx = compileAst(node.left, ctx);
+	const leftIdx = compileAst(node.left, ctx, scope);
 	const condition = BRANCH_CONDITIONS[node.operator]?.(leftIdx);
 	if (!condition) throw new Error(`Unexpected operator: ${node.operator}`);
 	const branchIdx = exprs.length;
@@ -1793,16 +2033,16 @@ function compileShortCircuit(node, ctx) {
 		0
 	]);
 	ctx.nextIndex++;
-	compileAst(node.right, ctx);
+	compileAst(node.right, ctx, scope);
 	const skipCount = exprs.length - branchIdx - 1;
 	exprs[branchIdx][2] = skipCount;
 	const phiIdx = ctx.nextIndex++;
 	exprs.push(["phi"]);
 	return phiIdx;
 }
-function compileConditional(node, ctx) {
+function compileConditional(node, ctx, scope) {
 	const exprs = currentExprs(ctx);
-	const testIdx = compileAst(node.test, ctx);
+	const testIdx = compileAst(node.test, ctx, scope);
 	const branchIdx = exprs.length;
 	exprs.push([
 		"br",
@@ -1810,11 +2050,11 @@ function compileConditional(node, ctx) {
 		0
 	]);
 	ctx.nextIndex++;
-	compileAst(node.alternate, ctx);
+	compileAst(node.alternate, ctx, scope);
 	const jmpIdx = exprs.length;
 	exprs.push(["jmp", 0]);
 	ctx.nextIndex++;
-	compileAst(node.consequent, ctx);
+	compileAst(node.consequent, ctx, scope);
 	const thenEndIdx = exprs.length;
 	exprs[branchIdx][2] = jmpIdx - branchIdx;
 	exprs[jmpIdx][1] = thenEndIdx - jmpIdx - 1;
@@ -1822,14 +2062,21 @@ function compileConditional(node, ctx) {
 	exprs.push(["phi"]);
 	return phiIdx;
 }
-function compileArrowFunction(node, ctx) {
+function compileArrowFunction(node, ctx, scope) {
 	const fnIndex = ctx.nextIndex++;
-	const paramMapping = /* @__PURE__ */ new Map();
-	for (const param of node.params) if (param.type === "Placeholder") paramMapping.set(param.id, `_${ctx.nextParamIndex++}`);
-	const transformedBody = transformPlaceholders(node.body, (id) => paramMapping.get(id) ?? null);
+	const placeholderNames = new Map(scope.placeholderNames);
+	const shadowedNames = [];
+	for (const param of node.params) if (param.type === "Placeholder") placeholderNames.set(param.id, `_${ctx.nextParamIndex++}`);
+	else shadowedNames.push(param.name);
+	const lambdaScope = {
+		...scope,
+		placeholderNames,
+		shadowedNames: extendShadowedNames(scope.shadowedNames, shadowedNames)
+	};
+	const transformedBody = rewriteAstForCompile(node.body, lambdaScope);
 	const lambdaStmts = [];
 	ctx.expressionStack.push(lambdaStmts);
-	compileAst(transformedBody, ctx);
+	compileAst(transformedBody, ctx, lambdaScope);
 	ctx.expressionStack.pop();
 	const fnNode = [
 		"fn",
@@ -1843,9 +2090,40 @@ function compileArrowFunction(node, ctx) {
 //#endregion
 //#region src/core/evaluate.ts
 /**
-* 缓存已构造的求值函数，以提升重复执行性能
+* 一级缓存：WeakMap - 使用 CompiledData 对象引用作为 key
+* 优势：O(1) 查找，无序列化开销，自动 GC
+* 适用：相同引用被重复使用的场景
+*/
+const weakEvaluatorCache = /* @__PURE__ */ new WeakMap();
+/**
+* 二级缓存：LRU Map - 使用编译数据指纹作为 key
+* 优势：支持内容相同但引用不同的对象，有大小限制避免内存泄漏
+* 适用：CompiledData 被频繁重建但内容重复的场景
 */
-const evaluatorCache = /* @__PURE__ */ new Map();
+const MAX_LRU_CACHE_SIZE = 128;
+const lruEvaluatorCache = /* @__PURE__ */ new Map();
+/**
+* 从 LRU 缓存获取求值函数，并将命中项移至末尾（最近使用）
+*/
+function getFromLruCache(key) {
+	const evaluator = lruEvaluatorCache.get(key);
+	if (evaluator) {
+		lruEvaluatorCache.delete(key);
+		lruEvaluatorCache.set(key, evaluator);
+	}
+	return evaluator;
+}
+/**
+* 向 LRU 缓存写入求值函数，超出限制时淘汰最久未使用的项
+*/
+function setToLruCache(key, evaluator) {
+	if (lruEvaluatorCache.has(key)) lruEvaluatorCache.delete(key);
+	else if (lruEvaluatorCache.size >= MAX_LRU_CACHE_SIZE) {
+		const firstKey = lruEvaluatorCache.keys().next().value;
+		if (firstKey !== void 0) lruEvaluatorCache.delete(firstKey);
+	}
+	lruEvaluatorCache.set(key, evaluator);
+}
 /**
 * 判断是否是 FnNode
 */
@@ -2006,21 +2284,29 @@ function translateControlFlow(expressions, variableCount) {
 * ```
 */
 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}`);
+	let evaluator = weakEvaluatorCache.get(data);
+	let variableNames;
+	if (evaluator) variableNames = data[0];
+	else {
+		if (data.length < 1) throw new Error("Invalid compiled data: must have at least variable names");
+		variableNames = data[0];
+		if (!Array.isArray(variableNames)) throw new Error("Invalid compiled data: first element must be variable names array");
+		for (let i = 0; i < variableNames.length; i++) if (typeof variableNames[i] !== "string") throw new Error("Invalid compiled data: variable names must be strings");
+		const cacheKey = JSON.stringify(data);
+		evaluator = getFromLruCache(cacheKey);
+		if (!evaluator) {
+			const functionBody = buildEvaluatorFunctionBody(data.slice(1), variableNames.length);
+			evaluator = new Function("$", functionBody);
+			setToLruCache(cacheKey, evaluator);
+		}
+		weakEvaluatorCache.set(data, evaluator);
 	}
+	const len = variableNames.length;
 	const valueArray = [];
-	for (const varName of variableNames) valueArray.push(values[varName]);
-	const cacheKey = JSON.stringify(data);
-	let evaluator = evaluatorCache.get(cacheKey);
-	if (!evaluator) {
-		const functionBody = buildEvaluatorFunctionBody(expressions, variableNames.length);
-		evaluator = new Function("$", functionBody);
-		evaluatorCache.set(cacheKey, evaluator);
+	for (let i = 0; i < len; i++) {
+		const name = variableNames[i];
+		if (!(name in values)) throw new Error(`Missing required variable: ${name}`);
+		valueArray.push(values[name]);
 	}
 	try {
 		return evaluator(valueArray);