sh-tools 2.3.10 → 2.3.12

package/packages/expr/index.js

@@ -1,542 +1,550 @@
-import utilsModule from '../utils'
+import utils from '../utils'
+
+// ======================== Token 配置 ========================
+export const TOKEN_TYPES = [
+	{ type: 'JSON', reg: /#JSON#[\s\S]*?#JSON#/, handler: token => token },
+	{ type: 'STRING', reg: /(["'])(.*?)\1/, handler: token => token.slice(1, -1) },
+	{ type: 'NUMBER', reg: /\d+\.?\d*|\.\d+/, handler: token => Number(token) },
+	{
+		type: 'KEYWORD',
+		reg: /\b(?:if|else|null|undefined|true|false)\b/,
+		handler: token => {
+			switch (token) {
+				case 'null':
+					return null
+				case 'undefined':
+					return undefined
+				case 'true':
+					return true
+				case 'false':
+					return false
+				default:
+					return token
+			}
+		}
+	},
+	{ type: 'IDENTIFIER', reg: /[a-zA-Z_$][a-zA-Z0-9_$]*/, handler: token => token },
+	{ type: 'OPERATOR', reg: /===|!==|==|!=|<=|>=|<<|>>|>>>|\|\||&&|\*\*|[,.+\-*/%^&|<>!?()\[\]:]/, handler: token => token }
+]
+
+export const OPERATOR_CONFIG = {
+	// 三元运算符
+	'?': { precedence: 1, associativity: 'right', isTernary: true, fn: (c, a, b) => (c ? a : b) },
+	// 逻辑运算符
+	'||': { precedence: 2, associativity: 'left', fn: (a, b) => a || b },
+	'&&': { precedence: 3, associativity: 'left', fn: (a, b) => a && b },
+	// 位运算符
+	'|': { precedence: 4, associativity: 'left', fn: (a, b) => a | b },
+	'^': { precedence: 5, associativity: 'left', fn: (a, b) => a ^ b },
+	'&': { precedence: 6, associativity: 'left', fn: (a, b) => a & b },
+	// 比较运算符
+	'==': { precedence: 7, associativity: 'left', fn: (a, b) => a == b },
+	'!=': { precedence: 7, associativity: 'left', fn: (a, b) => a != b },
+	'===': { precedence: 7, associativity: 'left', fn: utils.isEqual },
+	'!==': { precedence: 7, associativity: 'left', fn: (a, b) => a !== b },
+	'<': { precedence: 8, associativity: 'left', fn: (a, b) => utils.compareValue(a, b) },
+	'>': { precedence: 8, associativity: 'left', fn: (a, b) => utils.compareValue(b, a) },
+	'<=': { precedence: 8, associativity: 'left', fn: (a, b) => !utils.compareValue(b, a) },
+	'>=': { precedence: 8, associativity: 'left', fn: (a, b) => !utils.compareValue(a, b) },
+	// 算术运算符
+	'+': { precedence: 10, associativity: 'left', fn: utils.add },
+	'-': { precedence: 10, associativity: 'left', fn: utils.subtract },
+	'*': { precedence: 11, associativity: 'left', fn: utils.multiply },
+	'/': { precedence: 11, associativity: 'left', fn: utils.divide },
+	'%': { precedence: 11, associativity: 'left', fn: (a, b) => a % b },
+	'**': { precedence: 12, associativity: 'right', fn: (a, b) => Math.pow(a, b) },
+	// 一元运算符
+	'!': { precedence: 13, associativity: 'right', isUnary: true, fn: a => !a },
+	'~': { precedence: 13, associativity: 'right', isUnary: true, fn: a => ~a }
+}
 
-/**
- * 表达式求值器 - 支持JSON标记解析、常用数学/数组/对象运算
- * @class ExprEvaluator
- * @description 通过#JSON#双标记精准解析嵌套JSON，聚焦核心运算场景
- */
-class ExprEvaluator {
-	// 静态常量 - 仅保留核心方法
-	static MATH_METHODS = ['abs', 'sin', 'cos', 'tan', 'log', 'exp', 'pow']
-	static UTIL_METHODS = {
-		base: [
-			'isNaN',
-			'isFinite',
-			'isArray',
-			'isFloat',
-			'isInteger',
-			'isBoolean',
-			'isString',
-			'isNumber',
-			'isPlainObject',
-			'isDate',
-			'isEmpty',
-			'isNull',
-			'isMatch',
-			'isEqual',
-			'getSize',
-			'first',
-			'last'
-		],
+// ======================== 工具函数 ========================
+function getUtilsFunctions() {
+	const utilMethods = {
+		base: ['isNaN', 'isArray', 'isFloat', 'isInteger', 'isBoolean', 'isString', 'isNumber', 'isPlainObject', 'isDate', 'isEmpty', 'isNull', 'isMatch', 'isEqual', 'getSize', 'first', 'last'],
 		object: ['has', 'get', 'assign', 'merge', 'pick', 'omit'],
-		array: [
-			'slice',
-			'indexOf',
-			'includes',
-			'includeArrays',
-			'sum',
-			'mean',
-			'zip',
-			'unzip',
-			'uniq',
-			'union',
-			'flatten',
-			'pluck',
-			'invoke',
-			'orderBy',
-			'groupBy',
-			'countBy',
-			'toArrayTree',
-			'toTreeArray'
-		],
-		date: ['toDateString', 'getYearDiff', 'getMonthDiff', 'getDayDiff', 'getHourDiff', 'getMinuteDiff', 'getSecondDiff', 'getYearDay', 'getYearWeek', 'getMonthWeek', 'getDayOfMonth'],
+		array: ['slice', 'indexOf', 'includes', 'includeArrays', 'sum', 'mean', 'unzip', 'uniq', 'union', 'flatten', 'pluck', 'invoke', 'orderBy', 'groupBy', 'countBy', 'toArrayTree', 'toTreeArray'],
+		date: ['now', 'timestamp', 'toDateString', 'getYearDiff', 'getMonthDiff', 'getDayDiff', 'getHourDiff', 'getMinuteDiff', 'getSecondDiff', 'getDayOfMonth'],
 		number: ['random', 'min', 'max', 'ceil', 'floor', 'round', 'truncate', 'toFixed', 'toNumber', 'toNumberString', 'toInteger', 'add', 'subtract', 'multiply', 'divide'],
-		string: ['toValueString', 'trim', 'trimLeft', 'trimRight', 'camelCase', 'kebabCase', 'startsWith', 'endsWith']
+		string: ['toValueString', 'trim', 'trimLeft', 'trimRight', 'camelCase', 'kebabCase']
 	}
+	return Object.values(utilMethods)
+		.flat()
+		.reduce((acc, method) => {
+			if (typeof utils[method] === 'function') acc[method] = utils[method]
+			else if (process.env.NODE_ENV === 'development') console.warn(`[ExprEvaluator] utils方法不存在: ${method}`)
+			return acc
+		}, {})
+}
 
-	// TOKEN_REG匹配
-	static TOKEN_REG = /\s*(?:#JSON#([\s\S]*?)#JSON#|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|if|else|[a-zA-Z_$][a-zA-Z0-9_$]*|\d+\.?\d*|\.\d+|===|!==|==|!=|<=|>=|\|\||&&|[,.+\-*/%^&|<>!?()\[\]:])\s*/g
+function getBuiltinFunctions() {
+	return {
+		...Object.fromEntries(['abs', 'sin', 'cos', 'tan', 'log', 'exp', 'pow'].map(name => [name, Math[name]])),
+		...getUtilsFunctions(),
+		startsWith: (str, value) => String(str || '').startsWith(value),
+		endsWith: (str, value) => String(str || '').endsWith(value),
+		length: value => value.length
+	}
+}
+
+function tokensToExpr(tokens, start, end) {
+	return tokens
+		.slice(start, end)
+		.map(t => t.raw)
+		.join('')
+		.replace(/\s+/g, ' ')
+		.trim()
+}
 
-	// 精简版OP_MAP：移除unary、shift，仅保留核心运算
-	static OP_MAP = {
-		equality: { '==': true, '!=': true, '===': true, '!==': true },
-		relational: { '<': true, '>': true, '<=': true, '>=': true },
-		arithmetic: { '+': true, '-': true, '*': true, '/': true, '%': true }
+// ======================== 分词器 ========================
+class Tokenizer {
+	tokenize(expr) {
+		const normalizedExpr = expr.replace(/[\n\r]/g, ' ').trim()
+		if (!normalizedExpr) throw new Error('表达式不能为空')
+		const tokens = []
+		let remaining = normalizedExpr
+		while (remaining) {
+			remaining = remaining.trim()
+			if (!remaining) break
+			let matchedType = null
+			let matchedValue = ''
+			for (const type of TOKEN_TYPES) {
+				const match = type.reg.exec(remaining)
+				if (match && match.index === 0) {
+					matchedType = type
+					matchedValue = match[0]
+					break
+				}
+			}
+			if (!matchedType) throw new Error(`无法识别的字符: ${remaining[0]}`)
+			tokens.push({
+				type: matchedType.type,
+				value: matchedType.handler(matchedValue),
+				raw: matchedValue
+			})
+			remaining = remaining.slice(matchedValue.length)
+		}
+		return tokens
 	}
+}
 
+// ======================== 解析器（简化日志版本） ========================
+class Parser {
 	constructor() {
-		this.functions = {} // 工具函数映射
-		this.operators = {} // 运算符执行函数
-		this._isInited = false // 懒加载标记
-		this._cachedUtilMethods = null // 缓存扁平化的工具方法列表
-
-		// 绑定this
-		this.parsePrimary = this.parsePrimary.bind(this)
-		this.parseFunctionArgs = this.parseFunctionArgs.bind(this)
+		this.functions = getBuiltinFunctions()
+		this.operators = { ...OPERATOR_CONFIG }
+		this.tokens = []
+		this.pos = 0
+		this.enableLog = true
+
+		// 日志相关 - 简化处理
+		this.executionLog = [] // 存储原始日志对象
+		this.idCounter = 1
+		this.parentStack = [] // 存储父节点的ID
 	}
 
-	/**
-	 * 类型归一化 - 为比较运算统一值类型（日期→数字→字符串）
-	 * @private
-	 * @param {any} value 待归一化的值
-	 * @returns {number|string} 归一化后的值（日期转时间戳，数字串转数字，其余转字符串）
-	 */
-	_normalizeCompareValue(value) {
-		// 1. 处理日期类型（日期对象/可解析的日期字符串）
-		if (value instanceof Date) {
-			return value.getTime() // 转时间戳（数字）
+	registerFunction(name, fn, override = false) {
+		if (typeof name === 'object') {
+			Object.entries(name).forEach(([key, func]) => this.registerFunction(key, func, override))
+			return
 		}
-		if (typeof value === 'string') {
-			// 尝试解析为日期（支持YYYY-MM-DD、YYYY/MM/DD、带时分秒的格式）
-			const date = new Date(value)
-			if (!isNaN(date.getTime())) {
-				return date.getTime()
-			}
-			// 尝试解析为数字（如"123"、"45.6"）
-			const num = Number(value)
-			if (!isNaN(num)) {
-				return num
-			}
-			// 普通字符串（去空格后比较）
-			return value.trim()
+		if (typeof fn !== 'function') throw new Error('注册的必须是函数')
+		if (!override && this.functions[name]) {
+			console.warn(`[ExprEvaluator] 函数 ${name} 已存在，使用 override=true 覆盖`)
+			return
+		}
+		this.functions[name] = fn
+	}
+
+	extendOperator(symbol, config, override = false) {
+		if (!config.precedence || !config.associativity || !config.fn) {
+			throw new Error('运算符配置必须包含 precedence、associativity、fn')
 		}
-		// 2. 处理数字类型（含数字对象）
-		if (typeof value === 'number' || (value && typeof value === 'object' && value.constructor === Number)) {
-			return Number(value)
+		if (!override && this.operators[symbol]) {
+			console.warn(`[ExprEvaluator] 运算符 ${symbol} 已存在，使用 override=true 覆盖`)
+			return
 		}
-		// 3. 其他类型（布尔值、null、undefined等）转字符串
-		return String(value)
+		this.operators[symbol] = config
 	}
 
-	/**
-	 * 懒加载初始化 - 仅首次调用evaluate时执行
-	 * @private
-	 */
-	_lazyInit() {
-		if (this._isInited) return
-		const utils = utilsModule.__esModule ? utilsModule.default : utilsModule
-
-		// 1. 初始化数学函数（仅保留核心）
-		ExprEvaluator.MATH_METHODS.forEach(method => {
-			this.functions[method] = Math[method]
-		})
-
-		// 2. 初始化工具函数
-		this._cachedUtilMethods = Object.values(ExprEvaluator.UTIL_METHODS).flat()
-		this._cachedUtilMethods.forEach(method => {
-			if (typeof utils[method] === 'function') {
-				this.functions[method] = utils[method]
-			} else if (process.env.NODE_ENV === 'development') {
-				console.warn(`[ExprEvaluator] 工具方法不存在: ${method}`)
-			}
-		})
-
-		// 3. 初始化核心运算符
-		this.operators = {
-			'?:': { precedence: 1, associativity: 'right', ternary: true, fn: (c, a, b) => (c ? a : b) },
-			'||': { precedence: 1, associativity: 'left', fn: (a, b) => a || b },
-			'&&': { precedence: 2, associativity: 'left', fn: (a, b) => a && b },
-			'|': { precedence: 3, associativity: 'left', fn: (a, b) => a | b },
-			'^': { precedence: 4, associativity: 'left', fn: (a, b) => a ^ b },
-			'&': { precedence: 5, associativity: 'left', fn: (a, b) => a & b },
-			'==': { precedence: 6, associativity: 'left', fn: (a, b) => a == b },
-			'!=': { precedence: 6, associativity: 'left', fn: (a, b) => a != b },
-			'!==': { precedence: 6, associativity: 'left', fn: (a, b) => a !== b },
-			'<': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) < this._normalizeCompareValue(b) },
-			'>': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) > this._normalizeCompareValue(b) },
-			'<=': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) <= this._normalizeCompareValue(b) },
-			'>=': { precedence: 7, associativity: 'left', fn: (a, b) => this._normalizeCompareValue(a) >= this._normalizeCompareValue(b) },
-			'===': { precedence: 6, associativity: 'left', fn: utils.isEqual },
-			'+': { precedence: 9, associativity: 'left', fn: utils.add },
-			'-': { precedence: 9, associativity: 'left', fn: utils.subtract },
-			'*': { precedence: 10, associativity: 'left', fn: utils.multiply },
-			'/': { precedence: 10, associativity: 'left', fn: utils.divide },
-			'%': { precedence: 10, associativity: 'left', fn: (a, b) => a % b },
-			'!': { precedence: 12, associativity: 'right', prefix: true, fn: a => !a },
-			'~': { precedence: 12, associativity: 'right', prefix: true, fn: a => ~a }
+	// 创建日志条目
+	addLogEntry(expr, result) {
+		if (!this.enableLog) return null
+
+		const id = this.idCounter++
+		const parentId = this.parentStack.length > 0 ? this.parentStack[this.parentStack.length - 1] : null
+
+		const logEntry = {
+			id,
+			parentId,
+			expr,
+			result,
+			children: []
 		}
 
-		this._isInited = true
+		this.executionLog.push(logEntry)
+		return id
 	}
 
-	/**
-	 * 解析函数参数
-	 * @private
-	 * @param {string} closeChar 闭合字符
-	 * @returns {Array} 参数列表
-	 */
-	parseFunctionArgs(closeChar) {
-		const args = []
-		this.pos++
-
-		if (this.tokens[this.pos] !== closeChar) {
-			args.push(this.parseTernary())
-			while (this.tokens[this.pos] === ',') {
-				this.pos++
-				if (this.tokens[this.pos] === closeChar) break
-				args.push(this.parseTernary())
-			}
-		}
+	// 进入上下文
+	enterContext(id) {
+		this.parentStack.push(id)
+	}
+
+	// 退出上下文
+	exitContext() {
+		this.parentStack.pop()
+	}
+
+	parse(tokens, enableLog = true) {
+		this.tokens = tokens
+		this.pos = 0
+		this.enableLog = enableLog
+
+		// 重置状态
+		this.executionLog = []
+		this.idCounter = 1
+		this.parentStack = []
+
+		const result = this.parseExpression()
 
-		if (this.tokens[this.pos] !== closeChar) {
-			throw new Error(`函数参数未闭合：缺少 ${closeChar}（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
+		if (this.pos < tokens.length) {
+			const remaining = tokens
+				.slice(this.pos)
+				.map(t => t.raw)
+				.join('')
+			throw new Error(`表达式多余内容: ${remaining}`)
 		}
-		this.pos++
-		return args
+
+		return { result, executionLog: this.executionLog }
 	}
 
-	/**
-	 * 解析数组字面量
-	 * @private
-	 * @returns {Array} 解析后的数组
-	 */
-	parseArrayLiteral() {
+	parseExpression(precedence = 1) {
 		const startPos = this.pos
-		this.pos++
-		const arr = []
+		let left = this.parsePrimary()
+
+		while (this.peek() && this.isOperator(this.peek()) && this.getOperatorPrecedence(this.peek()) >= precedence) {
+			const opToken = this.consume()
+			const opConfig = this.operators[opToken.value]
+
+			if (opConfig?.isTernary) {
+				// 三元运算符特殊处理
+				const condition = left
+				const conditionExpr = tokensToExpr(this.tokens, startPos, this.pos - 1)
+
+				// 记录条件
+				const conditionId = this.addLogEntry(conditionExpr, condition)
+
+				// 记录三元表达式开始
+				const ternaryStartPos = startPos
+
+				// 处理真分支
+				this.enterContext(conditionId)
+				const trueBranch = this.parseExpression(1)
+				this.exitContext()
+
+				this.consumeToken('OPERATOR', ':')
 
-		if (this.tokens[this.pos] !== ']') {
-			arr.push(this.parseTernary())
-			while (this.tokens[this.pos] === ',') {
-				this.pos++
-				if (this.tokens[this.pos] === ']') break
-				arr.push(this.parseTernary())
+				// 处理假分支
+				this.enterContext(conditionId)
+				const falseBranch = this.parseExpression(1)
+				this.exitContext()
+
+				const result = opConfig.fn(condition, trueBranch, falseBranch)
+
+				// 记录完整的三元表达式
+				const fullExpr = tokensToExpr(this.tokens, ternaryStartPos, this.pos)
+				this.addLogEntry(fullExpr, result)
+
+				left = result
+				continue
 			}
-		}
 
-		if (this.tokens[this.pos] !== ']') {
-			throw new Error(`数组未闭合：在位置 ${startPos} 开始的数组缺少 ]（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
-		return arr
-	}
+			const nextPrecedence = opConfig.associativity === 'left' ? opConfig.precedence + 1 : opConfig.precedence
+			const right = this.parseExpression(nextPrecedence)
 
-	/**
-	 * 校验JSON格式
-	 * @private
-	 * @param {string} jsonStr JSON字符串
-	 * @returns {boolean} 是否有效
-	 */
-	_isValidJson(jsonStr) {
-		if (!jsonStr) return false
-		try {
-			JSON.parse(jsonStr)
-			return true
-		} catch {
-			return false
+			// 记录运算符表达式
+			if (this.enableLog) {
+				const leftStr = typeof left === 'object' ? JSON.stringify(left) : String(left)
+				const rightStr = typeof right === 'object' ? JSON.stringify(right) : String(right)
+				const expr = `${leftStr} ${opToken.value} ${rightStr}`
+				this.addLogEntry(expr, opConfig.fn(left, right))
+			}
+
+			left = opConfig.fn(left, right)
 		}
+
+		return left
 	}
 
-	/**
-	 * 解析基础Token
-	 * @private
-	 * @returns {any} 解析后的值
-	 */
 	parsePrimary() {
-		if (this.pos >= this.tokens.length) throw new Error('表达式意外结束')
-		const currentToken = this.tokens[this.pos]
-
-		// 解析双标记JSON
-		if (typeof currentToken === 'string' && currentToken.includes('#JSON#')) {
-			this.pos++
-			const jsonMatch = currentToken.match(/#JSON#([\s\S]*?)#JSON#/)
-			if (!jsonMatch || !this._isValidJson(jsonMatch[1])) {
-				throw new Error(`JSON解析失败：${jsonMatch?.[1] || currentToken}（原Token：${currentToken}）`)
-			}
-			return JSON.parse(jsonMatch[1])
+		const token = this.peek()
+		if (!token) throw new Error('表达式意外结束')
+
+		// if-else 表达式
+		if (token.type === 'KEYWORD' && token.value === 'if') {
+			return this.parseIfElse()
 		}
 
-		// 解析字符串字面量
-		if (typeof currentToken === 'string' && (currentToken.startsWith('"') || currentToken.startsWith("'"))) {
-			this.pos++
-			return currentToken.slice(1, -1)
+		// 括号表达式
+		if (token.type === 'OPERATOR' && token.value === '(') {
+			return this.parseParenthesizedExpression()
 		}
 
-		// 解析数组字面量
-		if (currentToken === '[') return this.parseArrayLiteral()
+		// JSON
+		if (token.type === 'JSON') {
+			return this.parseJsonLiteral()
+		}
 
-		// 解析括号表达式
-		if (currentToken === '(') {
-			this.pos++
-			const res = this.parseTernary()
-			if (this.tokens[this.pos] !== ')') {
-				throw new Error(`括号未闭合：缺少 )（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
+		// 字面量
+		if (['STRING', 'NUMBER', 'KEYWORD'].includes(token.type)) {
+			const value = this.consume().value
+			if (this.enableLog && token.type !== 'KEYWORD') {
+				this.addLogEntry(token.raw, value)
 			}
-			this.pos++
-			return res
+			return value
 		}
 
-		// 解析函数调用
-		if (typeof currentToken === 'string' && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(currentToken)) {
-			const funcName = currentToken
-			this.pos++
+		// 一元运算符
+		if (this.isUnaryOperator(token)) {
+			const opToken = this.consume()
+			const opConfig = this.operators[opToken.value]
+			const operand = this.parsePrimary()
+			const result = opConfig.fn(operand)
 
-			const callType = this.tokens[this.pos]
-			if (callType === '(' || callType === '[') {
-				const args = this.parseFunctionArgs(callType === '(' ? ')' : ']')
-				if (!this.functions[funcName]) throw new Error(`未定义函数: ${funcName}`)
-				return this.functions[funcName](...args)
+			if (this.enableLog) {
+				const expr = `${opToken.value}${operand}`
+				this.addLogEntry(expr, result)
 			}
 
-			throw new Error(`不支持变量: ${funcName}（仅支持函数调用和字面量）`)
+			return result
 		}
 
-		// 解析数字
-		if (typeof currentToken === 'number' || /^\d+\.?\d*|\.\d+$/.test(currentToken)) {
-			this.pos++
-			return Number(currentToken)
+		// 数组
+		if (token.type === 'OPERATOR' && token.value === '[') {
+			return this.parseArrayLiteral()
 		}
 
-		throw new Error(`无效Token: ${currentToken}（位置：${this.pos}）`)
-	}
-
-	// ========== 精简后的解析链（仅保留核心运算） ==========
-	/**
-	 * 解析乘/除/取模运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseMultiplicative() {
-		let res = this.parsePrimary()
-		while (ExprEvaluator.OP_MAP.arithmetic[this.tokens[this.pos]] && ['*', '/', '%'].includes(this.tokens[this.pos])) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parsePrimary())
+		// 函数调用
+		if (token.type === 'IDENTIFIER') {
+			return this.parseFunctionCall()
 		}
-		return res
-	}
 
-	/**
-	 * 解析加/减运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseAdditive() {
-		let res = this.parseMultiplicative()
-		while (ExprEvaluator.OP_MAP.arithmetic[this.tokens[this.pos]] && ['+', '-'].includes(this.tokens[this.pos])) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parseMultiplicative())
-		}
-		return res
+		throw new Error(`无效Token: ${token.raw}`)
 	}
 
-	/**
-	 * 解析关系运算（<、>、<=、>=）
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseRelational() {
-		let res = this.parseAdditive()
-		while (ExprEvaluator.OP_MAP.relational[this.tokens[this.pos]]) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parseAdditive())
-		}
-		return res
-	}
+	parseParenthesizedExpression() {
+		const startPos = this.pos
+		this.consumeToken('OPERATOR', '(')
 
-	/**
-	 * 解析相等运算（==、!=、===、!==）
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseEquality() {
-		let res = this.parseRelational()
-		while (ExprEvaluator.OP_MAP.equality[this.tokens[this.pos]]) {
-			const op = this.tokens[this.pos]
-			this.pos++
-			res = this.operators[op].fn(res, this.parseRelational())
-		}
-		return res
-	}
+		// 记录括号开始
+		const parentId = this.addLogEntry('(', null)
+		this.enterContext(parentId)
 
-	/**
-	 * 解析按位与运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseBitwiseAnd() {
-		let res = this.parseEquality()
-		while (this.tokens[this.pos] === '&') {
-			this.pos++
-			res = this.operators['&'].fn(res, this.parseEquality())
+		let result
+		if (this.matchToken('KEYWORD', 'if')) {
+			result = this.parseIfElse()
+		} else {
+			result = this.parseExpression(1)
 		}
-		return res
-	}
 
-	/**
-	 * 解析按位异或运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseBitwiseXor() {
-		let res = this.parseBitwiseAnd()
-		while (this.tokens[this.pos] === '^') {
-			this.pos++
-			res = this.operators['^'].fn(res, this.parseBitwiseAnd())
-		}
-		return res
-	}
+		this.consumeToken('OPERATOR', ')')
 
-	/**
-	 * 解析按位或运算
-	 * @private
-	 * @returns {number} 运算结果
-	 */
-	parseBitwiseOr() {
-		let res = this.parseBitwiseXor()
-		while (this.tokens[this.pos] === '|') {
-			this.pos++
-			res = this.operators['|'].fn(res, this.parseBitwiseXor())
+		// 更新括号表达式
+		const expr = tokensToExpr(this.tokens, startPos, this.pos)
+		const log = this.executionLog.find(l => l.id === parentId)
+		if (log) {
+			log.expr = expr
+			log.result = result
 		}
-		return res
+
+		this.exitContext()
+		return result
 	}
 
-	/**
-	 * 解析逻辑与运算
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseLogicalAnd() {
-		let res = this.parseBitwiseOr()
-		while (this.tokens[this.pos] === '&&') {
-			this.pos++
-			res = this.operators['&&'].fn(res, this.parseBitwiseOr())
+	parseJsonLiteral() {
+		const token = this.consume()
+		try {
+			const jsonStr = token.raw.slice(6, -6)
+			const result = JSON.parse(jsonStr)
+
+			if (this.enableLog) {
+				this.addLogEntry(token.raw, result)
+			}
+
+			return result
+		} catch (e) {
+			throw new Error(`JSON解析失败: ${token.raw}，原因：${e.message}`)
 		}
-		return res
 	}
 
-	/**
-	 * 解析逻辑或运算
-	 * @private
-	 * @returns {boolean} 运算结果
-	 */
-	parseLogicalOr() {
-		let res = this.parseLogicalAnd()
-		while (this.tokens[this.pos] === '||') {
-			this.pos++
-			res = this.operators['||'].fn(res, this.parseLogicalAnd())
+	parseArrayLiteral() {
+		const startPos = this.pos
+		this.consumeToken('OPERATOR', '[')
+
+		// 记录数组开始
+		const arrayId = this.addLogEntry('[', null)
+		this.enterContext(arrayId)
+
+		const arr = []
+
+		if (!this.matchToken('OPERATOR', ']')) {
+			arr.push(this.parseExpression())
+			while (this.matchToken('OPERATOR', ',')) {
+				this.consumeToken('OPERATOR', ',')
+				arr.push(this.parseExpression())
+			}
 		}
-		return res
-	}
 
-	/**
-	 * 解析三元运算核心逻辑
-	 * @private
-	 * @returns {any} 运算结果
-	 */
-	parseTernaryCore() {
-		let res = this.parseLogicalOr()
-		if (this.tokens[this.pos] === '?') {
-			this.pos++
-			const a = this.parseTernaryCore()
-			if (this.tokens[this.pos] !== ':') throw new Error('三元运算符缺少冒号')
-			this.pos++
-			const b = this.parseTernaryCore()
-			res = this.operators['?:'].fn(res, a, b)
+		this.consumeToken('OPERATOR', ']')
+
+		// 更新数组表达式
+		const expr = tokensToExpr(this.tokens, startPos, this.pos)
+		const log = this.executionLog.find(l => l.id === arrayId)
+		if (log) {
+			log.expr = expr
+			log.result = arr
 		}
-		return res
+
+		this.exitContext()
+		return arr
 	}
 
-	/**
-	 * 解析if/else和三元运算
-	 * @private
-	 * @returns {any} 运算结果
-	 */
 	parseIfElse() {
-		if (this.tokens[this.pos] !== 'if') return this.parseTernaryCore()
-		this.pos++
+		const startPos = this.pos
 
-		if (this.tokens[this.pos] !== '(') {
-			throw new Error(`if语法错误：缺少左括号（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
+		this.consumeToken('KEYWORD', 'if')
+		this.consumeToken('OPERATOR', '(')
 
-		const condition = this.parseTernaryCore()
-		if (this.tokens[this.pos] !== ')') {
-			throw new Error(`if语法错误：缺少右括号（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
+		const condition = this.parseExpression()
+		this.consumeToken('OPERATOR', ')')
 
-		const thenValue = this.parseTernaryCore()
-		if (this.tokens[this.pos] !== 'else') {
-			throw new Error(`if语法错误：缺少else关键字（当前Token：${this.tokens[this.pos] || '空'}, 位置：${this.pos}）`)
-		}
-		this.pos++
+		const ifExpr = this.parseExpression()
 
-		const elseValue = this.parseTernaryCore()
-		return condition ? thenValue : elseValue
-	}
+		let elseExpr = undefined
 
-	/**
-	 * 入口解析方法
-	 * @private
-	 * @returns {any} 运算结果
-	 */
-	parseTernary() {
-		return this.parseIfElse()
-	}
+		if (this.matchToken('KEYWORD', 'else')) {
+			this.consumeToken('KEYWORD', 'else')
 
-	/**
-	 * 分词处理
-	 * @private
-	 * @param {string} expr 表达式
-	 * @returns {Array} 分词结果
-	 */
-	_tokenize(expr) {
-		const tokens = []
-		const reg = new RegExp(ExprEvaluator.TOKEN_REG.source, 'g')
-		let match
-
-		while ((match = reg.exec(expr)) !== null) {
-			const token = match[0].trim()
-			if (!token) continue
-
-			if (token.includes('#JSON#')) {
-				tokens.push(token)
-			} else if (token.startsWith('"') || token.startsWith("'")) {
-				tokens.push(token)
-			} else if (/^\d+\.?\d*|\.\d+$/.test(token)) {
-				tokens.push(Number(token))
+			if (this.matchToken('KEYWORD', 'if')) {
+				elseExpr = this.parseIfElse()
 			} else {
-				tokens.push(token)
+				elseExpr = this.parseExpression()
 			}
 		}
 
-		if (tokens.length === 0) throw new Error('表达式为空')
-		return tokens
+		const result = condition ? ifExpr : elseExpr
+
+		if (this.enableLog) {
+			const fullExpr = tokensToExpr(this.tokens, startPos, this.pos)
+			this.addLogEntry(fullExpr, result)
+		}
+
+		return result
 	}
 
-	/**
-	 * 对外求值方法
-	 * @public
-	 * @param {string} expr 表达式
-	 * @returns {any} 结果
-	 */
-	evaluate(expr) {
-		this._lazyInit()
+	parseFunctionCall() {
+		const startPos = this.pos
+		const funcName = this.consume().value
+		const openChar = this.matchToken('OPERATOR', '(') ? '(' : this.matchToken('OPERATOR', '[') ? '[' : null
+		if (!openChar) throw new Error(`不支持变量: ${funcName}（仅支持函数调用）`)
+		const closeChar = openChar === '(' ? ')' : ']'
 
-		if (typeof expr !== 'string') throw new Error('表达式必须是字符串')
-		const normalizedExpr = expr.replace(/[\n\r]/g, ' ').trim()
-		if (!normalizedExpr) throw new Error('表达式不能为空')
+		// 记录函数调用开始
+		const funcId = this.addLogEntry(`${funcName}${openChar}`, null)
+		this.enterContext(funcId)
 
-		try {
-			this.tokens = this._tokenize(normalizedExpr)
-			this.pos = 0
-			const result = this.parseTernary()
+		this.consumeToken('OPERATOR', openChar)
 
-			if (this.pos < this.tokens.length) {
-				throw new Error(`表达式多余内容: ${this.tokens.slice(this.pos).join('')}（位置：${this.pos}）`)
+		// 收集参数
+		const args = []
+		if (!this.matchToken('OPERATOR', closeChar)) {
+			args.push(this.parseExpression())
+			while (this.matchToken('OPERATOR', ',')) {
+				this.consumeToken('OPERATOR', ',')
+				args.push(this.parseExpression())
 			}
+		}
+
+		this.consumeToken('OPERATOR', closeChar)
+
+		// 执行函数调用
+		if (!this.functions[funcName]) {
+			throw new Error(`未定义函数: ${funcName}`)
+		}
+
+		const result = this.functions[funcName](...args)
 
+		// 更新函数调用表达式
+		const expr = tokensToExpr(this.tokens, startPos, this.pos)
+		const log = this.executionLog.find(l => l.id === funcId)
+		if (log) {
+			log.expr = expr
+			log.result = result
+		}
+
+		this.exitContext()
+		return result
+	}
+
+	// ======================== 工具方法 ========================
+	peek() {
+		return this.tokens[this.pos]
+	}
+	consume() {
+		return this.tokens[this.pos++]
+	}
+	matchToken(type, value) {
+		const token = this.peek()
+		return token && token.type === type && token.value === value
+	}
+	consumeToken(type, value) {
+		if (!this.matchToken(type, value)) throw new Error(`缺少Token: ${value}`)
+		return this.consume()
+	}
+	isOperator(token) {
+		return token.type === 'OPERATOR' && !!this.operators[token.value]
+	}
+	isUnaryOperator(token) {
+		return this.isOperator(token) && this.operators[token.value]?.isUnary
+	}
+	getOperatorPrecedence(token) {
+		return this.operators[token.value]?.precedence || 0
+	}
+}
+
+// ======================== 求值器 ========================
+class ExprEvaluator {
+	constructor() {
+		this.tokenizer = new Tokenizer()
+		this.parser = new Parser()
+	}
+	registerFunction(name, fn, override = false) {
+		this.parser.registerFunction(name, fn, override)
+	}
+	extendOperator(symbol, config, override = false) {
+		this.parser.extendOperator(symbol, config, override)
+	}
+	evaluateLog(expr, enableLog = true) {
+		try {
+			const tokens = this.tokenizer.tokenize(expr)
+			const { result, executionLog } = this.parser.parse(tokens, enableLog)
+			return { result, log: utils.orderBy(executionLog, 'parentId'), treeLog: utils.toArrayTree(executionLog) }
+		} catch (error) {
+			throw new Error(`[ExprEvaluator] ${error.message}（原表达式：${expr}）`)
+		}
+	}
+	evaluate(expr) {
+		try {
+			const tokens = this.tokenizer.tokenize(expr)
+			const { result } = this.parser.parse(tokens, false)
 			return result
 		} catch (error) {
-			throw new Error(`表达式计算失败: ${error.message}（原表达式：${expr}）`)
+			throw new Error(`[ExprEvaluator] ${error.message}（原表达式：${expr}）`)
 		}
 	}
 }
 
-// 单例导出
-const evaluator = new ExprEvaluator()
-export default evaluator
+// ======================== 单例导出 ========================
+const exprEvaluator = new ExprEvaluator()
+export default exprEvaluator