@codehz/json-expr 0.2.1 → 0.4.0

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 //#region src/parser.ts
 const PRECEDENCE = {
 	"||": 1,
@@ -539,192 +537,311 @@ function needsParens(child, parent, position) {
 	}
 	return false;
 }
+
+//#endregion
+//#region src/proxy-metadata.ts
+/**
+* 全局 WeakMap 存储
+*/
+const proxyMetadata = /* @__PURE__ */ new WeakMap();
+/**
+* 设置 Proxy 元数据
+*/
+function setProxyMetadata(proxy, metadata) {
+	proxyMetadata.set(proxy, metadata);
+}
+/**
+* 获取 Proxy 元数据
+*/
+function getProxyMetadata(proxy) {
+	return proxyMetadata.get(proxy);
+}
+/**
+* 检查对象是否是 Proxy variable
+*/
+function isProxyVariable(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.get(obj)?.type === "variable";
+}
+/**
+* 检查对象是否是 Proxy expression
+*/
+function isProxyExpression(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.get(obj)?.type === "expression";
+}
+/**
+* 检查对象是否是任意 Proxy (variable 或 expression)
+*/
+function isProxy(obj) {
+	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
+	return proxyMetadata.has(obj);
+}
+
+//#endregion
+//#region src/proxy-variable.ts
 /**
-* 收集 AST 中所有使用的标识符名称
+* 使用 Symbol.description 生成占位符
+* 用于在表达式源码中标识变量
 */
-function collectIdentifiers(node) {
-	const identifiers = /* @__PURE__ */ new Set();
-	function visit(n) {
-		switch (n.type) {
-			case "Identifier":
-				identifiers.add(n.name);
-				break;
-			case "BinaryExpr":
-				visit(n.left);
-				visit(n.right);
-				break;
-			case "UnaryExpr":
-				visit(n.argument);
-				break;
-			case "ConditionalExpr":
-				visit(n.test);
-				visit(n.consequent);
-				visit(n.alternate);
-				break;
-			case "MemberExpr":
-				visit(n.object);
-				if (n.computed) visit(n.property);
-				break;
-			case "CallExpr":
-				visit(n.callee);
-				n.arguments.forEach(visit);
-				break;
-			case "ArrayExpr":
-				n.elements.forEach(visit);
-				break;
-			case "ObjectExpr":
-				n.properties.forEach((prop) => {
-					if (prop.computed) visit(prop.key);
-					visit(prop.value);
-				});
-				break;
+function getVariablePlaceholder$1(id) {
+	return `$$VAR_${id.description}$$`;
+}
+/**
+* 序列化参数为表达式字符串
+* - Proxy Variable/Expression：使用源码或占位符
+* - 数组：递归处理元素
+* - 对象：递归处理属性
+* - 原始值：JSON.stringify
+*/
+function serializeArgument(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);
 		}
 	}
-	visit(node);
-	return identifiers;
+	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);
+}
+/**
+* 从参数中收集依赖的 Symbol
+* 递归遍历数组和对象，收集所有 Proxy 的依赖
+*/
+function collectDepsFromArgs(args, deps) {
+	for (const arg of args) if ((typeof arg === "object" || typeof arg === "function") && arg !== null) {
+		const meta = getProxyMetadata(arg);
+		if (meta?.dependencies) for (const dep of meta.dependencies) deps.add(dep);
+		else if (Array.isArray(arg)) collectDepsFromArgs(arg, deps);
+		else if (typeof arg === "object") collectDepsFromArgs(Object.values(arg), deps);
+	}
+}
+/**
+* 创建根 Variable Proxy
+* 拦截属性访问，返回新的 expression proxy
+* 不可直接调用（apply 应该只在链式调用后可用）
+*
+* @param id - 变量的唯一标识 Symbol
+* @returns Proxy 包装的 Variable
+*/
+function createProxyVariable(id) {
+	const deps = new Set([id]);
+	const proxy = new Proxy(function() {}, {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpression(id, [String(prop)], deps);
+		},
+		apply() {
+			throw new Error("Variable cannot be called directly");
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "variable",
+		path: [],
+		rootVariable: id,
+		dependencies: deps
+	});
+	return proxy;
+}
+/**
+* 创建属性访问后的 Proxy
+* 继续拦截属性访问（链式访问）
+* 拦截 apply 进行方法调用
+*
+* @param rootId - 根变量的 Symbol
+* @param path - 属性访问路径
+* @param deps - 依赖集合
+* @returns Proxy 包装的 Expression
+*/
+function createProxyExpression(rootId, path, deps) {
+	const source = `${getVariablePlaceholder$1(rootId)}.${path.join(".")}`;
+	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 newDeps = new Set(deps);
+			collectDepsFromArgs(args, newDeps);
+			return createProxyExpressionWithSource(callSource, newDeps);
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "expression",
+		path,
+		rootVariable: rootId,
+		source,
+		dependencies: deps
+	});
+	return proxy;
+}
+/**
+* 创建带完整源码的 Proxy（方法调用后）
+* 可以继续链式访问和调用
+*
+* @param source - 完整的表达式源码
+* @param deps - 依赖集合
+* @returns Proxy 包装的 Expression
+*/
+function createProxyExpressionWithSource(source, deps) {
+	const proxy = new Proxy(function() {}, {
+		get(_target, prop) {
+			if (typeof prop === "symbol") return void 0;
+			return createProxyExpressionWithSource(`(${source}).${String(prop)}`, deps);
+		},
+		apply(_target, _thisArg, args) {
+			const callSource = `(${source})(${args.map(serializeArgument).join(", ")})`;
+			const newDeps = new Set(deps);
+			collectDepsFromArgs(args, newDeps);
+			return createProxyExpressionWithSource(callSource, newDeps);
+		}
+	});
+	setProxyMetadata(proxy, {
+		type: "expression",
+		path: [source],
+		source,
+		dependencies: deps
+	});
+	return proxy;
+}
+
+//#endregion
+//#region src/variable.ts
+/**
+* 跟踪每个 variable 的唯一 Symbol ID
+*/
+const variableIds = /* @__PURE__ */ new WeakMap();
+/**
+* 计数器用于生成唯一变量 ID
+*/
+let variableCounter = 0;
+/**
+* 创建一个类型化变量
+* 返回 Proxy 对象，支持链式属性访问和方法调用
+*
+* @example
+* ```ts
+* const x = variable<number>();
+* const config = variable<{ timeout: number }>();
+* const timeout = config.timeout; // Proxy expression
+* ```
+*/
+function variable() {
+	const id = Symbol(`var_${variableCounter++}`);
+	const proxy = createProxyVariable(id);
+	variableIds.set(proxy, id);
+	return proxy;
+}
+/**
+* 获取 variable 的唯一 Symbol ID
+*/
+function getVariableId(variable) {
+	if (typeof variable !== "object" && typeof variable !== "function" || variable === null) return void 0;
+	return variableIds.get(variable);
+}
+/**
+* 生成变量占位符字符串
+* 格式：$$VAR_var_N$$
+*/
+function getVariablePlaceholder(id) {
+	return `$$VAR_${id.description}$$`;
 }
 
 //#endregion
 //#region src/compile.ts
+const ALLOWED_GLOBALS = new Set([
+	"Math",
+	"JSON",
+	"Date",
+	"RegExp",
+	"Number",
+	"String",
+	"Boolean",
+	"Array",
+	"Object",
+	"undefined",
+	"NaN",
+	"Infinity",
+	"isNaN",
+	"isFinite",
+	"parseInt",
+	"parseFloat"
+]);
 /**
-* 将表达式树编译为可序列化的 JSON 结构
+* 将占位符替换为实际变量名
+*
+* @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 - 根表达式
+* @param expression - Proxy Expression
 * @param variables - 所有使用的变量定义
 * @param options - 编译选项
 * @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
 *
-* @throws 如果检测到循环依赖或未定义的变量引用
+* @throws 如果传入无效的表达式或未定义的变量引用
 *
 * @example
 * ```ts
-* const x = variable(z.number())
-* const y = variable(z.number())
-* const sum = expr({ x, y })<number>("x + y")
-* const result = expr({ sum })<number>("sum * 2")
+* const x = variable<number>()
+* const y = variable<number>()
+* const sum = expr({ x, y })("x + y")
+* const result = expr({ sum, x })("sum * x")
 * const compiled = compile(result, { x, y })
-* // => [["x", "y"], "($0+$1)*2"]  // 内联优化后
+* // => [["x", "y"], "($0+$1)*$0"]
 * ```
 */
 function compile(expression, variables, options = {}) {
-	const { inline = true, shortCircuit = true } = options;
-	const context = {
-		variableOrder: [],
-		nodeToIndex: /* @__PURE__ */ new Map(),
-		expressions: []
-	};
-	const exprIdMap = /* @__PURE__ */ new WeakMap();
-	function getExprId(expr) {
-		let id = exprIdMap.get(expr);
-		if (id === void 0) {
-			id = Symbol("expr");
-			exprIdMap.set(expr, id);
-		}
-		return id;
+	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 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 nodeMap = /* @__PURE__ */ new Map();
-	const variableNodes = /* @__PURE__ */ new Map();
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	for (const [name, variable] of Object.entries(variables)) {
-		const id = Symbol(`var:${name}`);
-		const node = {
-			id,
-			tag: "variable",
-			schema: variable.schema
-		};
-		nodeMap.set(id, node);
-		variableNodes.set(name, node);
-	}
-	const exprNodes = /* @__PURE__ */ new Map();
-	function collectNodes(expr) {
-		const exprId = getExprId(expr);
-		if (visited.has(exprId)) return nodeMap.get(exprId);
-		if (visiting.has(exprId)) throw new Error("Circular dependency detected in expressions");
-		visiting.add(exprId);
-		const contextNodes = {};
-		for (const [key, contextItem] of Object.entries(expr.context)) {
-			const item = contextItem;
-			if (item._tag === "variable") {
-				const varNode = variableNodes.get(key);
-				if (!varNode) throw new Error(`Undefined variable reference: ${key}`);
-				contextNodes[key] = varNode;
-			} else if (item._tag === "expression") contextNodes[key] = collectNodes(item);
-		}
-		const node = {
-			id: exprId,
-			tag: "expression",
-			context: contextNodes,
-			source: expr.source
-		};
-		nodeMap.set(exprId, node);
-		exprNodes.set(exprId, node);
-		visited.add(exprId);
-		visiting.delete(exprId);
-		return node;
-	}
-	const rootNode = collectNodes(expression);
-	const sortedExprNodes = [];
-	const exprVisited = /* @__PURE__ */ new Set();
-	function topologicalSort(node) {
-		if (exprVisited.has(node.id)) return;
-		exprVisited.add(node.id);
-		if (node.tag === "expression" && node.context) for (const contextNode of Object.values(node.context)) topologicalSort(contextNode);
-		if (node.tag === "expression") sortedExprNodes.push(node);
-	}
-	topologicalSort(rootNode);
-	for (const [name, varNode] of variableNodes.entries()) if (!context.nodeToIndex.has(varNode.id)) {
-		context.nodeToIndex.set(varNode.id, context.variableOrder.length);
-		context.variableOrder.push(name);
-	}
-	const refCount = /* @__PURE__ */ new Map();
-	for (const exprNode of sortedExprNodes) refCount.set(exprNode.id, 0);
-	for (const exprNode of sortedExprNodes) if (exprNode.context) {
-		for (const contextNode of Object.values(exprNode.context)) if (contextNode.tag === "expression") refCount.set(contextNode.id, (refCount.get(contextNode.id) ?? 0) + 1);
-	}
-	function canInline(node) {
-		if (!inline) return false;
-		if (node.id === rootNode.id) return false;
-		return (refCount.get(node.id) ?? 0) === 1;
-	}
-	let exprIndex = 0;
-	for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) {
-		const index = context.variableOrder.length + exprIndex;
-		context.nodeToIndex.set(exprNode.id, index);
-		exprIndex++;
-	}
-	const nodeAstMap = /* @__PURE__ */ new Map();
-	for (const [, varNode] of variableNodes.entries()) {
-		const index = context.nodeToIndex.get(varNode.id);
-		nodeAstMap.set(varNode.id, {
+	const ast = parse(source);
+	const undefinedVars = [];
+	const transformed = transformIdentifiers(ast, (name) => {
+		const index = variableToIndex.get(name);
+		if (index !== void 0) return {
 			type: "Identifier",
 			name: `$${index}`
-		});
-	}
-	for (const exprNode of sortedExprNodes) {
-		if (!exprNode.context || !exprNode.source) throw new Error("Invalid expression node");
-		const usedVariables = extractVariableNames(exprNode.source);
-		for (const varName of usedVariables) if (!(varName in exprNode.context)) throw new Error(`Undefined variable reference: ${varName} (available: ${Object.keys(exprNode.context).join(", ")})`);
-		const transformed = inlineTransform(parse(exprNode.source), (name) => {
-			const contextNode = exprNode.context[name];
-			if (!contextNode) return null;
-			if (contextNode.tag === "variable") return nodeAstMap.get(contextNode.id) ?? null;
-			else if (canInline(contextNode)) return nodeAstMap.get(contextNode.id) ?? null;
-			else return {
-				type: "Identifier",
-				name: `$${context.nodeToIndex.get(contextNode.id)}`
-			};
-		});
-		nodeAstMap.set(exprNode.id, transformed);
-	}
+		};
+		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
+		return null;
+	});
+	if (undefinedVars.length > 0) throw new Error(`Undefined variable(s): ${[...new Set(undefinedVars)].join(", ")}`);
+	const expressions = [];
 	if (shortCircuit) {
-		const expressions = [];
-		let nextIndex = context.variableOrder.length;
-		function compileAst(ast) {
-			if (ast.type === "BinaryExpr" && (ast.operator === "||" || ast.operator === "&&" || ast.operator === "??")) return compileShortCircuit(ast);
-			if (ast.type === "ConditionalExpr") return compileConditional(ast);
-			const exprStr = generate(ast);
+		let nextIndex = variableOrder.length;
+		function compileAst(node) {
+			if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node);
+			if (node.type === "ConditionalExpr") return compileConditional(node);
+			const exprStr = generate(node);
 			const idx = nextIndex++;
 			expressions.push(exprStr);
 			return idx;
@@ -776,141 +893,60 @@ function compile(expression, variables, options = {}) {
 			expressions.push(["phi"]);
 			return phiIdx;
 		}
-		for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) compileAst(nodeAstMap.get(exprNode.id));
-		context.expressions = expressions;
-	} else for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) {
-		const ast = nodeAstMap.get(exprNode.id);
-		context.expressions.push(generate(ast));
-	}
-	return [context.variableOrder, ...context.expressions];
+		compileAst(transformed);
+	} else expressions.push(generate(transformed));
+	return [variableOrder, ...expressions];
 }
 /**
-* 将 AST 中的标识符替换为对应的 AST 节点（用于内联优化）
+* 将 AST 中的标识符替换为对应的 AST 节点
 *
 * @param node - 要转换的 AST 节点
 * @param getReplacementAst - 根据标识符名称返回替换的 AST 节点，返回 null 表示不替换
 * @returns 转换后的 AST 节点
 */
-function inlineTransform(node, getReplacementAst) {
+function transformIdentifiers(node, getReplacementAst) {
 	switch (node.type) {
 		case "Identifier": return getReplacementAst(node.name) ?? node;
 		case "BinaryExpr": return {
 			...node,
-			left: inlineTransform(node.left, getReplacementAst),
-			right: inlineTransform(node.right, getReplacementAst)
+			left: transformIdentifiers(node.left, getReplacementAst),
+			right: transformIdentifiers(node.right, getReplacementAst)
 		};
 		case "UnaryExpr": return {
 			...node,
-			argument: inlineTransform(node.argument, getReplacementAst)
+			argument: transformIdentifiers(node.argument, getReplacementAst)
 		};
 		case "ConditionalExpr": return {
 			...node,
-			test: inlineTransform(node.test, getReplacementAst),
-			consequent: inlineTransform(node.consequent, getReplacementAst),
-			alternate: inlineTransform(node.alternate, getReplacementAst)
+			test: transformIdentifiers(node.test, getReplacementAst),
+			consequent: transformIdentifiers(node.consequent, getReplacementAst),
+			alternate: transformIdentifiers(node.alternate, getReplacementAst)
 		};
 		case "MemberExpr": return {
 			...node,
-			object: inlineTransform(node.object, getReplacementAst),
-			property: node.computed ? inlineTransform(node.property, getReplacementAst) : node.property
+			object: transformIdentifiers(node.object, getReplacementAst),
+			property: node.computed ? transformIdentifiers(node.property, getReplacementAst) : node.property
 		};
 		case "CallExpr": return {
 			...node,
-			callee: inlineTransform(node.callee, getReplacementAst),
-			arguments: node.arguments.map((arg) => inlineTransform(arg, getReplacementAst))
+			callee: transformIdentifiers(node.callee, getReplacementAst),
+			arguments: node.arguments.map((arg) => transformIdentifiers(arg, getReplacementAst))
 		};
 		case "ArrayExpr": return {
 			...node,
-			elements: node.elements.map((el) => inlineTransform(el, getReplacementAst))
+			elements: node.elements.map((el) => transformIdentifiers(el, getReplacementAst))
 		};
 		case "ObjectExpr": return {
 			...node,
 			properties: node.properties.map((prop) => ({
 				...prop,
-				key: prop.computed ? inlineTransform(prop.key, getReplacementAst) : prop.key,
-				value: inlineTransform(prop.value, getReplacementAst)
+				key: prop.computed ? transformIdentifiers(prop.key, getReplacementAst) : prop.key,
+				value: transformIdentifiers(prop.value, getReplacementAst)
 			}))
 		};
 		default: return node;
 	}
 }
-/**
-* 允许在表达式中直接使用的全局对象
-* 这些对象不需要在上下文中定义
-*/
-const ALLOWED_GLOBALS = new Set([
-	"Math",
-	"JSON",
-	"Number",
-	"String",
-	"Boolean",
-	"Array",
-	"Object",
-	"Date",
-	"RegExp",
-	"undefined",
-	"NaN",
-	"Infinity",
-	"isNaN",
-	"isFinite",
-	"parseInt",
-	"parseFloat"
-]);
-/**
-* 从表达式源码中提取所有使用的变量名
-* 通过 AST 解析实现精确提取
-* 排除允许的全局对象
-*
-* @param source - 表达式源码字符串
-* @returns 使用的变量名列表（去重，不含全局对象）
-*
-* @example
-* ```ts
-* extractVariableNames("x + y * Math.PI")
-* // => ["x", "y"]  // Math 被排除
-* ```
-*/
-function extractVariableNames(source) {
-	const identifiers = collectIdentifiers(parse(source));
-	return Array.from(identifiers).filter((name) => !ALLOWED_GLOBALS.has(name));
-}
-
-//#endregion
-//#region src/constant.ts
-/**
-* 创建一个编译期常量表达式
-*
-* 这是 `expr({})(JSON.stringify(value))` 的快速路径，
-* 用于在表达式中嵌入静态值，避免在运行时传入或在多处重复编写。
-*
-* @template T - 常量值类型（必须是 JSON 可序列化的）
-* @param value - 要嵌入的常量值
-* @returns 返回一个 Expression 对象，其结果类型为 T
-*
-* @example
-* ```ts
-* // 创建一个数字常量
-* const PI = constant(3.14159)
-*
-* // 创建一个字符串常量
-* const greeting = constant("Hello, World!")
-*
-* // 创建一个对象常量
-* const config = constant({ maxRetries: 3, timeout: 5000 })
-*
-* // 在表达式中使用常量
-* const radius = variable(z.number())
-* const area = expr({ PI, radius })("PI * radius * radius")
-* ```
-*/
-function constant(value) {
-	return {
-		_tag: "expression",
-		context: {},
-		source: JSON.stringify(value),
-		_type: void 0
-	};
-}
 
 //#endregion
 //#region src/evaluate.ts
@@ -1038,11 +1074,12 @@ function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
 //#endregion
 //#region src/expr.ts
 /**
-* 创建一个表达式，支持编译时类型检查和返回类型自动推导
+* 创建表达式
+* 返回 Proxy Expression，可以继续链式调用
 *
-* @template TContext - 表达式上下文类型（Variable 或 Expression 的映射）
-* @param context - 包含 Variable 或 Expression 的上下文对象
-* @returns 返回一个函数，该函数接收表达式源码字符串并返回 Expression 对象
+* @template TContext - 表达式上下文类型
+* @param context - 包含 Variable 或 Proxy Expression 的上下文对象
+* @returns 返回一个函数，该函数接收表达式源码字符串并返回 Proxy Expression
 *
 * 类型系统会：
 * 1. 验证表达式中使用的所有标识符都在 context 中定义
@@ -1050,8 +1087,8 @@ function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
 *
 * @example
 * ```ts
-* const x = variable(z.number())
-* const y = variable(z.number())
+* const x = variable<number>();
+* const y = variable<number>();
 *
 * // 自动推导返回类型为 number
 * const sum = expr({ x, y })("x + y")
@@ -1065,42 +1102,76 @@ function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
 */
 function expr(context) {
 	return (source) => {
-		return {
-			_tag: "expression",
-			context,
-			source,
-			_type: void 0
-		};
+		const deps = /* @__PURE__ */ new Set();
+		const nameToId = /* @__PURE__ */ new Map();
+		for (const [name, value] of Object.entries(context)) {
+			const id = getVariableId(value);
+			if (id) {
+				deps.add(id);
+				nameToId.set(name, id);
+			} 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);
+			}
+		}
+		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 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);
+			}
+		}
+		return createProxyExpressionWithSource(transformedSource, deps);
 	};
 }
 
 //#endregion
-//#region src/variable.ts
+//#region src/template.ts
 /**
-* 创建一个类型化变量
-*
-* @template T - Zod schema 类型
-* @param schema - Zod schema 对象，定义变量的类型和验证规则
-* @returns 返回 Variable 对象，包含 _tag 标记和 schema
+* 转义字符串字面量中的特殊字符
+*/
+function escapeStringLiteral(str) {
+	return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+/**
+* Tagged template 函数，用于创建包含变量的字符串表达式
 *
 * @example
 * ```ts
-* const x = variable(z.number())
-* const name = variable(z.string())
-* const config = variable(z.object({
-*   count: z.number(),
-*   enabled: z.boolean()
-* }))
+* const name = variable<string>();
+* const count = variable<number>();
+*
+* const greeting = t`Hello, ${name}!`;
+* const message = t`You have ${count} items.`;
+*
+* const compiled = compile(greeting, { name });
+* const result = evaluate(compiled, { name: "Alice" }); // => "Hello, Alice!"
 * ```
 */
-function variable(schema) {
-	return {
-		_tag: "variable",
-		schema,
-		_type: void 0
-	};
+function t(strings, ...values) {
+	const deps = /* @__PURE__ */ new Set();
+	collectDepsFromArgs(values, deps);
+	const parts = [];
+	for (let i = 0; i < strings.length; i++) {
+		const str = strings[i];
+		if (str.length > 0) parts.push(`"${escapeStringLiteral(str)}"`);
+		if (i < values.length) {
+			const serialized = serializeArgument(values[i]);
+			parts.push(serialized);
+		}
+	}
+	if (parts.length === 0) return createProxyExpressionWithSource("\"\"", deps);
+	if (parts.length === 1) return createProxyExpressionWithSource(parts[0], deps);
+	return createProxyExpressionWithSource("(" + parts.join(" + ") + ")", deps);
 }
 
 //#endregion
-export { compile, constant, evaluate, expr, variable };
+export { compile, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, t, variable };
 //# sourceMappingURL=index.mjs.map