@codehz/json-expr 0.0.0

package/dist/index.mjs

@@ -0,0 +1,981 @@
+import { z } from "zod";
+
+//#region src/parser.ts
+const PRECEDENCE = {
+	"||": 1,
+	"??": 1,
+	"&&": 2,
+	"|": 3,
+	"^": 4,
+	"&": 5,
+	"==": 6,
+	"!=": 6,
+	"===": 6,
+	"!==": 6,
+	"<": 7,
+	">": 7,
+	"<=": 7,
+	">=": 7,
+	in: 7,
+	instanceof: 7,
+	"<<": 8,
+	">>": 8,
+	">>>": 8,
+	"+": 9,
+	"-": 9,
+	"*": 10,
+	"/": 10,
+	"%": 10,
+	"**": 11
+};
+const RIGHT_ASSOCIATIVE = new Set(["**"]);
+var Parser = class {
+	pos = 0;
+	source;
+	constructor(source) {
+		this.source = source;
+	}
+	parse() {
+		this.skipWhitespace();
+		const node = this.parseExpression();
+		this.skipWhitespace();
+		if (this.pos < this.source.length) throw new Error(`Unexpected token at position ${this.pos}: ${this.source.slice(this.pos, this.pos + 10)}`);
+		return node;
+	}
+	parseExpression() {
+		return this.parseConditional();
+	}
+	parseConditional() {
+		let node = this.parseBinary(0);
+		this.skipWhitespace();
+		if (this.peek() === "?") {
+			this.advance();
+			this.skipWhitespace();
+			const consequent = this.parseExpression();
+			this.skipWhitespace();
+			this.expect(":");
+			this.skipWhitespace();
+			const alternate = this.parseExpression();
+			node = {
+				type: "ConditionalExpr",
+				test: node,
+				consequent,
+				alternate
+			};
+		}
+		return node;
+	}
+	parseBinary(minPrec) {
+		let left = this.parseUnary();
+		while (true) {
+			this.skipWhitespace();
+			const op = this.peekOperator();
+			if (!op || PRECEDENCE[op] === void 0 || PRECEDENCE[op] < minPrec) break;
+			this.pos += op.length;
+			this.skipWhitespace();
+			const nextMinPrec = RIGHT_ASSOCIATIVE.has(op) ? PRECEDENCE[op] : PRECEDENCE[op] + 1;
+			const right = this.parseBinary(nextMinPrec);
+			left = {
+				type: "BinaryExpr",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseUnary() {
+		this.skipWhitespace();
+		const ch = this.peek();
+		if (ch === "!" || ch === "~" || ch === "+" || ch === "-") {
+			if (ch === "+" || ch === "-") {
+				this.advance();
+				this.skipWhitespace();
+				return {
+					type: "UnaryExpr",
+					operator: ch,
+					argument: this.parseUnary(),
+					prefix: true
+				};
+			}
+			this.advance();
+			this.skipWhitespace();
+			return {
+				type: "UnaryExpr",
+				operator: ch,
+				argument: this.parseUnary(),
+				prefix: true
+			};
+		}
+		if (this.matchKeyword("typeof")) {
+			this.skipWhitespace();
+			return {
+				type: "UnaryExpr",
+				operator: "typeof",
+				argument: this.parseUnary(),
+				prefix: true
+			};
+		}
+		if (this.matchKeyword("void")) {
+			this.skipWhitespace();
+			return {
+				type: "UnaryExpr",
+				operator: "void",
+				argument: this.parseUnary(),
+				prefix: true
+			};
+		}
+		return this.parsePostfix();
+	}
+	parsePostfix() {
+		let node = this.parsePrimary();
+		while (true) {
+			this.skipWhitespace();
+			const ch = this.peek();
+			if (ch === ".") {
+				this.advance();
+				this.skipWhitespace();
+				const property = this.parseIdentifier();
+				node = {
+					type: "MemberExpr",
+					object: node,
+					property,
+					computed: false,
+					optional: false
+				};
+			} else if (ch === "[") {
+				this.advance();
+				this.skipWhitespace();
+				const property = this.parseExpression();
+				this.skipWhitespace();
+				this.expect("]");
+				node = {
+					type: "MemberExpr",
+					object: node,
+					property,
+					computed: true,
+					optional: false
+				};
+			} else if (ch === "(") {
+				this.advance();
+				const args = this.parseArguments();
+				this.expect(")");
+				node = {
+					type: "CallExpr",
+					callee: node,
+					arguments: args,
+					optional: false
+				};
+			} else if (ch === "?" && this.peekAt(1) === ".") {
+				this.advance();
+				this.advance();
+				this.skipWhitespace();
+				if (this.peek() === "[") {
+					this.advance();
+					this.skipWhitespace();
+					const property = this.parseExpression();
+					this.skipWhitespace();
+					this.expect("]");
+					node = {
+						type: "MemberExpr",
+						object: node,
+						property,
+						computed: true,
+						optional: true
+					};
+				} else if (this.peek() === "(") {
+					this.advance();
+					const args = this.parseArguments();
+					this.expect(")");
+					node = {
+						type: "CallExpr",
+						callee: node,
+						arguments: args,
+						optional: true
+					};
+				} else {
+					const property = this.parseIdentifier();
+					node = {
+						type: "MemberExpr",
+						object: node,
+						property,
+						computed: false,
+						optional: true
+					};
+				}
+			} else break;
+		}
+		return node;
+	}
+	parsePrimary() {
+		this.skipWhitespace();
+		const ch = this.peek();
+		if (this.isDigit(ch) || ch === "." && this.isDigit(this.peekAt(1))) return this.parseNumber();
+		if (ch === "\"" || ch === "'" || ch === "`") return this.parseString();
+		if (ch === "[") return this.parseArray();
+		if (ch === "{") return this.parseObject();
+		if (ch === "(") {
+			this.advance();
+			this.skipWhitespace();
+			const expr = this.parseExpression();
+			this.skipWhitespace();
+			this.expect(")");
+			return expr;
+		}
+		if (this.matchKeyword("true")) return {
+			type: "BooleanLiteral",
+			value: true
+		};
+		if (this.matchKeyword("false")) return {
+			type: "BooleanLiteral",
+			value: false
+		};
+		if (this.matchKeyword("null")) return { type: "NullLiteral" };
+		if (this.matchKeyword("undefined")) return {
+			type: "Identifier",
+			name: "undefined"
+		};
+		if (this.isIdentifierStart(ch)) return this.parseIdentifier();
+		throw new Error(`Unexpected character at position ${this.pos}: ${ch}`);
+	}
+	parseNumber() {
+		const start = this.pos;
+		if (this.peek() === "0") {
+			const next = this.peekAt(1)?.toLowerCase();
+			if (next === "x" || next === "o" || next === "b") {
+				this.advance();
+				this.advance();
+				while (this.isHexDigit(this.peek())) this.advance();
+				const raw = this.source.slice(start, this.pos);
+				return {
+					type: "NumberLiteral",
+					value: Number(raw),
+					raw
+				};
+			}
+		}
+		while (this.isDigit(this.peek())) this.advance();
+		if (this.peek() === "." && this.isDigit(this.peekAt(1))) {
+			this.advance();
+			while (this.isDigit(this.peek())) this.advance();
+		}
+		if (this.peek()?.toLowerCase() === "e") {
+			this.advance();
+			if (this.peek() === "+" || this.peek() === "-") this.advance();
+			while (this.isDigit(this.peek())) this.advance();
+		}
+		const raw = this.source.slice(start, this.pos);
+		return {
+			type: "NumberLiteral",
+			value: Number(raw),
+			raw
+		};
+	}
+	parseString() {
+		const quote = this.peek();
+		this.advance();
+		let value = "";
+		while (this.pos < this.source.length && this.peek() !== quote) if (this.peek() === "\\") {
+			this.advance();
+			const escaped = this.peek();
+			switch (escaped) {
+				case "n":
+					value += "\n";
+					break;
+				case "r":
+					value += "\r";
+					break;
+				case "t":
+					value += "	";
+					break;
+				case "\\":
+					value += "\\";
+					break;
+				case "'":
+					value += "'";
+					break;
+				case "\"":
+					value += "\"";
+					break;
+				case "`":
+					value += "`";
+					break;
+				default: value += escaped;
+			}
+			this.advance();
+		} else {
+			value += this.peek();
+			this.advance();
+		}
+		this.expect(quote);
+		return {
+			type: "StringLiteral",
+			value,
+			quote
+		};
+	}
+	parseArray() {
+		this.expect("[");
+		const elements = [];
+		this.skipWhitespace();
+		while (this.peek() !== "]") {
+			elements.push(this.parseExpression());
+			this.skipWhitespace();
+			if (this.peek() === ",") {
+				this.advance();
+				this.skipWhitespace();
+			} else break;
+		}
+		this.expect("]");
+		return {
+			type: "ArrayExpr",
+			elements
+		};
+	}
+	parseObject() {
+		this.expect("{");
+		const properties = [];
+		this.skipWhitespace();
+		while (this.peek() !== "}") {
+			const prop = this.parseObjectProperty();
+			properties.push(prop);
+			this.skipWhitespace();
+			if (this.peek() === ",") {
+				this.advance();
+				this.skipWhitespace();
+			} else break;
+		}
+		this.expect("}");
+		return {
+			type: "ObjectExpr",
+			properties
+		};
+	}
+	parseObjectProperty() {
+		this.skipWhitespace();
+		let key;
+		let computed = false;
+		if (this.peek() === "[") {
+			this.advance();
+			this.skipWhitespace();
+			key = this.parseExpression();
+			this.skipWhitespace();
+			this.expect("]");
+			computed = true;
+		} else if (this.peek() === "\"" || this.peek() === "'") key = this.parseString();
+		else key = this.parseIdentifier();
+		this.skipWhitespace();
+		if (this.peek() === ":") {
+			this.advance();
+			this.skipWhitespace();
+			const value = this.parseExpression();
+			return {
+				key,
+				value,
+				computed,
+				shorthand: false
+			};
+		}
+		if (key.type !== "Identifier") throw new Error("Shorthand property must be an identifier");
+		return {
+			key,
+			value: key,
+			computed: false,
+			shorthand: true
+		};
+	}
+	parseIdentifier() {
+		const start = this.pos;
+		while (this.isIdentifierPart(this.peek())) this.advance();
+		const name = this.source.slice(start, this.pos);
+		if (!name) throw new Error(`Expected identifier at position ${this.pos}`);
+		return {
+			type: "Identifier",
+			name
+		};
+	}
+	parseArguments() {
+		const args = [];
+		this.skipWhitespace();
+		while (this.peek() !== ")") {
+			args.push(this.parseExpression());
+			this.skipWhitespace();
+			if (this.peek() === ",") {
+				this.advance();
+				this.skipWhitespace();
+			} else break;
+		}
+		return args;
+	}
+	peekOperator() {
+		for (const op of [
+			">>>",
+			"===",
+			"!==",
+			"instanceof",
+			"&&",
+			"||",
+			"??",
+			"==",
+			"!=",
+			"<=",
+			">=",
+			"<<",
+			">>",
+			"**",
+			"in",
+			"+",
+			"-",
+			"*",
+			"/",
+			"%",
+			"<",
+			">",
+			"&",
+			"|",
+			"^"
+		]) if (this.source.startsWith(op, this.pos)) {
+			if (op === "in" || op === "instanceof") {
+				const nextChar = this.source[this.pos + op.length];
+				if (nextChar && this.isIdentifierPart(nextChar)) continue;
+			}
+			return op;
+		}
+		return null;
+	}
+	matchKeyword(keyword) {
+		if (this.source.startsWith(keyword, this.pos)) {
+			const nextChar = this.source[this.pos + keyword.length];
+			if (!nextChar || !this.isIdentifierPart(nextChar)) {
+				this.pos += keyword.length;
+				return true;
+			}
+		}
+		return false;
+	}
+	peek() {
+		return this.source[this.pos] || "";
+	}
+	peekAt(offset) {
+		return this.source[this.pos + offset] || "";
+	}
+	advance() {
+		return this.source[this.pos++] || "";
+	}
+	expect(ch) {
+		if (this.peek() !== ch) throw new Error(`Expected '${ch}' at position ${this.pos}, got '${this.peek()}'`);
+		this.advance();
+	}
+	skipWhitespace() {
+		while (/\s/.test(this.peek())) this.advance();
+	}
+	isDigit(ch) {
+		return /[0-9]/.test(ch);
+	}
+	isHexDigit(ch) {
+		return /[0-9a-fA-F]/.test(ch);
+	}
+	isIdentifierStart(ch) {
+		return /[a-zA-Z_$]/.test(ch);
+	}
+	isIdentifierPart(ch) {
+		return /[a-zA-Z0-9_$]/.test(ch);
+	}
+};
+/**
+* 解析 JavaScript 表达式为 AST
+*/
+function parse(source) {
+	return new Parser(source).parse();
+}
+/**
+* 从 AST 生成规范化的代码
+*/
+function generate(node) {
+	switch (node.type) {
+		case "NumberLiteral": return node.raw;
+		case "StringLiteral": return JSON.stringify(node.value);
+		case "BooleanLiteral": return node.value ? "true" : "false";
+		case "NullLiteral": return "null";
+		case "Identifier": return node.name;
+		case "BinaryExpr": {
+			const left = wrapIfNeeded(node.left, node, "left");
+			const right = wrapIfNeeded(node.right, node, "right");
+			return `${left}${node.operator}${right}`;
+		}
+		case "UnaryExpr":
+			if (node.prefix) {
+				const arg = wrapIfNeeded(node.argument, node, "argument");
+				if (node.operator === "typeof" || node.operator === "void") return `${node.operator} ${arg}`;
+				return `${node.operator}${arg}`;
+			}
+			return generate(node.argument) + node.operator;
+		case "ConditionalExpr": return `${generate(node.test)}?${generate(node.consequent)}:${generate(node.alternate)}`;
+		case "MemberExpr": {
+			const object = wrapIfNeeded(node.object, node, "object");
+			if (node.computed) {
+				const property = generate(node.property);
+				return node.optional ? `${object}?.[${property}]` : `${object}[${property}]`;
+			}
+			const property = generate(node.property);
+			return node.optional ? `${object}?.${property}` : `${object}.${property}`;
+		}
+		case "CallExpr": {
+			const callee = wrapIfNeeded(node.callee, node, "callee");
+			const args = node.arguments.map(generate).join(",");
+			return node.optional ? `${callee}?.(${args})` : `${callee}(${args})`;
+		}
+		case "ArrayExpr": return `[${node.elements.map(generate).join(",")}]`;
+		case "ObjectExpr": return `{${node.properties.map((prop) => {
+			if (prop.shorthand) return generate(prop.key);
+			return `${prop.computed ? `[${generate(prop.key)}]` : generate(prop.key)}:${generate(prop.value)}`;
+		}).join(",")}}`;
+		default: {
+			const nodeType = node.type ?? "unknown";
+			throw new Error(`Unknown node type: ${nodeType}`);
+		}
+	}
+}
+/**
+* 判断是否需要括号包裹，并生成代码
+*/
+function wrapIfNeeded(child, parent, position) {
+	const code = generate(child);
+	if (needsParens(child, parent, position)) return `(${code})`;
+	return code;
+}
+/**
+* 判断子节点是否需要括号
+*/
+function needsParens(child, parent, position) {
+	if (child.type === "ConditionalExpr" && parent.type === "BinaryExpr") return true;
+	if (child.type === "BinaryExpr" && parent.type === "BinaryExpr") {
+		const childPrec = PRECEDENCE[child.operator] || 0;
+		const parentPrec = PRECEDENCE[parent.operator] || 0;
+		if (childPrec < parentPrec) return true;
+		if (childPrec === parentPrec && position === "right") {
+			if (!RIGHT_ASSOCIATIVE.has(parent.operator)) return true;
+		}
+	}
+	if (child.type === "UnaryExpr" && parent.type === "BinaryExpr") {
+		if (parent.operator === "**" && position === "left") return true;
+	}
+	return false;
+}
+/**
+* 收集 AST 中所有使用的标识符名称
+*/
+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;
+		}
+	}
+	visit(node);
+	return identifiers;
+}
+
+//#endregion
+//#region src/compile.ts
+/**
+* 将表达式树编译为可序列化的 JSON 结构
+*
+* @template TResult - 表达式结果类型
+* @param expression - 根表达式
+* @param variables - 所有使用的变量定义
+* @param options - 编译选项
+* @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
+*
+* @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 compiled = compile(result, { x, y })
+* // => [["x", "y"], "($0+$1)*2"]  // 内联优化后
+* ```
+*/
+function compile(expression, variables, options = {}) {
+	const { inline = true } = options;
+	const context = {
+		variableOrder: [],
+		nodeToIndex: /* @__PURE__ */ new Map(),
+		expressions: []
+	};
+	const exprIdMap = /* @__PURE__ */ new WeakMap();
+	const getExprId = (expr) => {
+		if (!exprIdMap.has(expr)) exprIdMap.set(expr, Symbol("expr"));
+		const id = exprIdMap.get(expr);
+		if (id === void 0) throw new Error("Expression ID not found");
+		return id;
+	};
+	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();
+	const 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();
+	const 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);
+	}
+	const 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, {
+			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);
+	}
+	for (const exprNode of sortedExprNodes) if (!canInline(exprNode)) {
+		const ast = nodeAstMap.get(exprNode.id);
+		context.expressions.push(generate(ast));
+	}
+	return [context.variableOrder, ...context.expressions];
+}
+/**
+* 将 AST 中的标识符替换为对应的 AST 节点（用于内联优化）
+*
+* @param node - 要转换的 AST 节点
+* @param getReplacementAst - 根据标识符名称返回替换的 AST 节点，返回 null 表示不替换
+* @returns 转换后的 AST 节点
+*/
+function inlineTransform(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)
+		};
+		case "UnaryExpr": return {
+			...node,
+			argument: inlineTransform(node.argument, getReplacementAst)
+		};
+		case "ConditionalExpr": return {
+			...node,
+			test: inlineTransform(node.test, getReplacementAst),
+			consequent: inlineTransform(node.consequent, getReplacementAst),
+			alternate: inlineTransform(node.alternate, getReplacementAst)
+		};
+		case "MemberExpr": return {
+			...node,
+			object: inlineTransform(node.object, getReplacementAst),
+			property: node.computed ? inlineTransform(node.property, getReplacementAst) : node.property
+		};
+		case "CallExpr": return {
+			...node,
+			callee: inlineTransform(node.callee, getReplacementAst),
+			arguments: node.arguments.map((arg) => inlineTransform(arg, getReplacementAst))
+		};
+		case "ArrayExpr": return {
+			...node,
+			elements: node.elements.map((el) => inlineTransform(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)
+			}))
+		};
+		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/evaluate.ts
+/**
+* 缓存已构造的求值函数，以提升重复执行性能
+*/
+const evaluatorCache = /* @__PURE__ */ new Map();
+/**
+* 执行编译后的表达式
+*
+* @template TResult - 表达式结果类型
+* @param data - 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
+* @param values - 变量值映射，按变量名提供值
+* @returns 最后一个表达式的求值结果
+*
+* @throws 如果运行时类型验证失败或表达式执行出错
+*
+* @example
+* ```ts
+* const compiled = [["x", "y"], "$0+$1", "$1*2"]
+* const result = evaluate<number>(compiled, { x: 2, y: 3 })
+* // => 6  (3 * 2)
+* ```
+*/
+function evaluate(data, values) {
+	if (data.length < 1) throw new Error("Invalid compiled data: must have at least variable names");
+	const [variableNames, ...expressions] = data;
+	if (!Array.isArray(variableNames)) throw new Error("Invalid compiled data: first element must be variable names array");
+	for (const varName of variableNames) {
+		if (typeof varName !== "string") throw new Error("Invalid compiled data: variable names must be strings");
+		if (!(varName in values)) throw new Error(`Missing required variable: ${varName}`);
+	}
+	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("$values", functionBody);
+		evaluatorCache.set(cacheKey, evaluator);
+	}
+	try {
+		return evaluator(valueArray);
+	} catch (error) {
+		throw new Error(`Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* 构造求值函数体
+*
+* @param expressions - 表达式列表
+* @param variableCount - 变量数量
+* @returns 函数体字符串
+*
+* @example
+* ```ts
+* buildEvaluatorFunctionBody(["$0+$1", "$2*2"], 2)
+* // 返回执行 $0+$1 并存储到 $values[2]，然后执行 $2*2 的函数体
+* ```
+*/
+function buildEvaluatorFunctionBody(expressions, variableCount) {
+	if (expressions.length === 0) throw new Error("No expressions to evaluate");
+	const lines = [];
+	lines.push("const $0 = $values[0];");
+	for (let i = 1; i < variableCount; i++) lines.push(`const $${i} = $values[${i}];`);
+	for (let i = 0; i < expressions.length; i++) {
+		const exprSource = expressions[i];
+		const resultIndex = variableCount + i;
+		lines.push(`const $${resultIndex} = ${exprSource};`);
+		lines.push(`$values[${resultIndex}] = $${resultIndex};`);
+	}
+	lines.push(`return $values[$values.length - 1];`);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/expr.ts
+/**
+* 创建一个表达式，支持编译时类型检查和返回类型自动推导
+*
+* @template TContext - 表达式上下文类型（Variable 或 Expression 的映射）
+* @param context - 包含 Variable 或 Expression 的上下文对象
+* @returns 返回一个函数，该函数接收表达式源码字符串并返回 Expression 对象
+*
+* 类型系统会：
+* 1. 验证表达式中使用的所有标识符都在 context 中定义
+* 2. 根据表达式和操作数类型自动推导返回类型
+*
+* @example
+* ```ts
+* const x = variable(z.number())
+* const y = variable(z.number())
+*
+* // 自动推导返回类型为 number
+* const sum = expr({ x, y })("x + y")
+*
+* // 自动推导返回类型为 boolean
+* const isPositive = expr({ sum })("sum > 0")
+*
+* // 编译错误：z 未在 context 中定义
+* // const invalid = expr({ x, y })("x + z")
+* ```
+*/
+function expr(context) {
+	return (source) => {
+		return {
+			_tag: "expression",
+			context,
+			source,
+			_type: void 0
+		};
+	};
+}
+
+//#endregion
+//#region src/variable.ts
+/**
+* 创建一个类型化变量
+*
+* @template T - Zod schema 类型
+* @param schema - Zod schema 对象，定义变量的类型和验证规则
+* @returns 返回 Variable 对象，包含 _tag 标记和 schema
+*
+* @example
+* ```ts
+* const x = variable(z.number())
+* const name = variable(z.string())
+* const config = variable(z.object({
+*   count: z.number(),
+*   enabled: z.boolean()
+* }))
+* ```
+*/
+function variable(schema) {
+	return {
+		_tag: "variable",
+		schema,
+		_type: void 0
+	};
+}
+
+//#endregion
+export { compile, evaluate, expr, variable };
+//# sourceMappingURL=index.mjs.map