ts-workflow-engine-lite 2.1.0

package/dist/src/engine/ExpressionEvaluator.js

@@ -0,0 +1,1046 @@
+import { Logger } from "../utils/Logger.js";
+import { registerFunctionLibrary } from "./functions/index.js";
+let traceEnabled = false;
+let expressionTraces = [];
+export async function withExpressionTrace(fn) {
+    const previousEnabled = traceEnabled;
+    const previousTraces = expressionTraces;
+    traceEnabled = true;
+    expressionTraces = [];
+    try {
+        return await fn();
+    }
+    finally {
+        traceEnabled = previousEnabled;
+        if (!previousEnabled) {
+        }
+        else {
+            expressionTraces = previousTraces;
+        }
+    }
+}
+export function getExpressionTraces() {
+    return [...expressionTraces];
+}
+var TokenType;
+(function (TokenType) {
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["STRING"] = "STRING";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["OPERATOR"] = "OPERATOR";
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACKET"] = "LBRACKET";
+    TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["ARROW"] = "ARROW";
+    TokenType["DOT"] = "DOT";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+const OPERATORS = {
+    "|": {
+        precedence: 0,
+        associativity: "left",
+        fn: (_a, _b) => {
+            throw new Error("Pipe operator should be handled by the parser");
+        },
+    },
+    "||": {
+        precedence: 1,
+        associativity: "left",
+        fn: (a, b) => Boolean(a) || Boolean(b),
+    },
+    "&&": {
+        precedence: 2,
+        associativity: "left",
+        fn: (a, b) => Boolean(a) && Boolean(b),
+    },
+    "==": {
+        precedence: 3,
+        associativity: "left",
+        fn: (a, b) => a === b,
+    },
+    "!=": {
+        precedence: 3,
+        associativity: "left",
+        fn: (a, b) => a !== b,
+    },
+    "===": {
+        precedence: 3,
+        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: 4,
+        associativity: "left",
+        fn: (a, b) => a > b,
+    },
+    "<=": {
+        precedence: 4,
+        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: 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: "right",
+        fn: (a, b) => a ** b,
+    },
+    "!": {
+        precedence: 8,
+        associativity: "right",
+        unary: true,
+        fn: (a) => !a,
+    },
+    "u-": {
+        precedence: 8,
+        associativity: "right",
+        unary: true,
+        fn: (a) => -a,
+    },
+};
+const FUNCTIONS = {};
+export function registerFunction(name, fn) {
+    FUNCTIONS[name] = fn;
+}
+function initializeBuiltInFunctions() {
+    registerFunction("abs", (x) => Math.abs(x));
+    registerFunction("ceil", (x) => Math.ceil(x));
+    registerFunction("floor", (x) => Math.floor(x));
+    registerFunction("round", (x, decimals = 0) => {
+        if (decimals === 0)
+            return Math.round(x);
+        const factor = 10 ** decimals;
+        return Math.round(x * factor) / factor;
+    });
+    registerFunction("min", (...args) => Math.min(...args));
+    registerFunction("max", (...args) => Math.max(...args));
+    registerFunction("sqrt", (x) => Math.sqrt(x));
+    registerFunction("pow", (x, y) => x ** y);
+    registerFunction("length", (s) => {
+        if (typeof s === "string")
+            return s.length;
+        if (Array.isArray(s))
+            return s.length;
+        return 0;
+    });
+    registerFunction("substring", (s, start, end) => {
+        return s.substring(start, end);
+    });
+    registerFunction("toLowerCase", (s) => s.toLowerCase());
+    registerFunction("toUpperCase", (s) => s.toUpperCase());
+    registerFunction("trim", (s) => s.trim());
+    registerFunction("concat", (...args) => args.join(""));
+    registerFunction("includes", (s, search) => {
+        if (typeof s === "string")
+            return s.includes(String(search));
+        if (Array.isArray(s))
+            return s.includes(search);
+        return false;
+    });
+    registerFunction("startsWith", (s, prefix) => s.startsWith(prefix));
+    registerFunction("endsWith", (s, suffix) => s.endsWith(suffix));
+    registerFunction("now", () => Date.now());
+    registerFunction("parse", (s) => Date.parse(s));
+    registerFunction("format", (timestamp, format) => {
+        const date = new Date(timestamp);
+        if (!format)
+            return date.toISOString();
+        return date.toISOString();
+    });
+    registerFunction("addDays", (timestamp, days) => {
+        return timestamp + days * 24 * 60 * 60 * 1000;
+    });
+    registerFunction("addHours", (timestamp, hours) => {
+        return timestamp + hours * 60 * 60 * 1000;
+    });
+    registerFunction("diff", (timestamp1, timestamp2, unit = "ms") => {
+        const diff = timestamp1 - timestamp2;
+        switch (unit) {
+            case "ms":
+                return diff;
+            case "s":
+                return diff / 1000;
+            case "m":
+                return diff / (1000 * 60);
+            case "h":
+                return diff / (1000 * 60 * 60);
+            case "d":
+                return diff / (1000 * 60 * 60 * 24);
+            default:
+                return diff;
+        }
+    });
+    registerFunction("join", (arr, separator = ",") => {
+        if (!Array.isArray(arr))
+            return String(arr);
+        return arr.join(separator);
+    });
+    registerFunction("map", (arr, fn) => {
+        if (!Array.isArray(arr))
+            return [];
+        if (typeof fn === "function")
+            return arr.map(fn);
+        return arr;
+    });
+    registerFunction("filter", (arr, fn) => {
+        if (!Array.isArray(arr))
+            return [];
+        if (typeof fn === "function")
+            return arr.filter(fn);
+        return arr;
+    });
+    registerFunction("reduce", (arr, fn, initial) => {
+        if (!Array.isArray(arr))
+            return initial;
+        if (typeof fn === "function") {
+            return initial !== undefined ? arr.reduce(fn, initial) : arr.reduce(fn);
+        }
+        return initial;
+    });
+    registerFunction("find", (arr, fn) => {
+        if (!Array.isArray(arr))
+            return undefined;
+        if (typeof fn === "function")
+            return arr.find(fn);
+        return undefined;
+    });
+    registerFunction("some", (arr, fn) => {
+        if (!Array.isArray(arr))
+            return false;
+        if (typeof fn === "function")
+            return arr.some(fn);
+        return false;
+    });
+    registerFunction("every", (arr, fn) => {
+        if (!Array.isArray(arr))
+            return false;
+        if (typeof fn === "function")
+            return arr.every(fn);
+        return false;
+    });
+    registerFunction("flat", (arr, depth = 1) => {
+        if (!Array.isArray(arr))
+            return [];
+        return arr.flat(depth);
+    });
+    registerFunction("flatMap", (arr, fn) => {
+        if (!Array.isArray(arr))
+            return [];
+        if (typeof fn === "function")
+            return arr.flatMap(fn);
+        return arr;
+    });
+}
+initializeBuiltInFunctions();
+registerFunctionLibrary(registerFunction, (name) => name in FUNCTIONS);
+class Tokenizer {
+    expression;
+    position = 0;
+    current;
+    constructor(expression) {
+        this.expression = expression;
+        this.current = expression[0] || "";
+    }
+    advance() {
+        this.position++;
+        this.current =
+            this.position < this.expression.length
+                ? this.expression[this.position]
+                : "";
+    }
+    peek(offset = 1) {
+        const pos = this.position + offset;
+        return pos < this.expression.length ? this.expression[pos] : "";
+    }
+    skipWhitespace() {
+        while (this.current && /\s/.test(this.current)) {
+            this.advance();
+        }
+    }
+    readNumber() {
+        const start = this.position;
+        let value = "";
+        while (this.current && /[\d.]/.test(this.current)) {
+            value += this.current;
+            this.advance();
+        }
+        return {
+            type: TokenType.NUMBER,
+            value: Number.parseFloat(value),
+            position: start,
+        };
+    }
+    readString(quote) {
+        const start = this.position;
+        let value = "";
+        this.advance();
+        while (this.current && this.current !== quote) {
+            if (this.current === "\\") {
+                this.advance();
+                const ch = this.current;
+                if (ch === "n") {
+                    value += "\n";
+                }
+                else if (ch === "t") {
+                    value += "\t";
+                }
+                else if (ch === "r") {
+                    value += "\r";
+                }
+                else if (ch === "\\") {
+                    value += "\\";
+                }
+                else if (ch === quote) {
+                    value += quote;
+                }
+                else {
+                    value += ch;
+                }
+            }
+            else {
+                value += this.current;
+            }
+            this.advance();
+        }
+        if (this.current === quote) {
+            this.advance();
+        }
+        return {
+            type: TokenType.STRING,
+            value,
+            position: start,
+        };
+    }
+    readIdentifier() {
+        const start = this.position;
+        let value = "";
+        while (this.current && /[a-zA-Z0-9_.]/.test(this.current)) {
+            value += this.current;
+            this.advance();
+        }
+        if (value === "true") {
+            return { type: TokenType.BOOLEAN, value: true, position: start };
+        }
+        if (value === "false") {
+            return { type: TokenType.BOOLEAN, value: false, position: start };
+        }
+        if (value === "null") {
+            return { type: TokenType.NULL, value: null, position: start };
+        }
+        return {
+            type: TokenType.IDENTIFIER,
+            value,
+            position: start,
+        };
+    }
+    readOperator() {
+        const start = this.position;
+        const threeChar = this.current + this.peek() + this.peek(2);
+        if (["===", "!=="].includes(threeChar)) {
+            this.advance();
+            this.advance();
+            this.advance();
+            return {
+                type: TokenType.OPERATOR,
+                value: threeChar,
+                position: start,
+            };
+        }
+        if (this.current === "=" && this.peek() === ">") {
+            this.advance();
+            this.advance();
+            return { type: TokenType.ARROW, value: "=>", position: start };
+        }
+        const twoChar = this.current + this.peek();
+        if (["==", "!=", "<=", ">=", "&&", "||", "**"].includes(twoChar)) {
+            this.advance();
+            this.advance();
+            return {
+                type: TokenType.OPERATOR,
+                value: twoChar,
+                position: start,
+            };
+        }
+        if (this.current === ".") {
+            this.advance();
+            return { type: TokenType.DOT, value: ".", position: start };
+        }
+        if (this.current === "[") {
+            this.advance();
+            return { type: TokenType.LBRACKET, value: "[", position: start };
+        }
+        if (this.current === "]") {
+            this.advance();
+            return { type: TokenType.RBRACKET, value: "]", position: start };
+        }
+        const oneChar = this.current;
+        this.advance();
+        return {
+            type: TokenType.OPERATOR,
+            value: oneChar,
+            position: start,
+        };
+    }
+    nextToken() {
+        this.skipWhitespace();
+        if (!this.current) {
+            return { type: TokenType.EOF, value: null, position: this.position };
+        }
+        if (/\d/.test(this.current)) {
+            return this.readNumber();
+        }
+        if (this.current === '"' || this.current === "'") {
+            return this.readString(this.current);
+        }
+        if (/[a-zA-Z_]/.test(this.current)) {
+            return this.readIdentifier();
+        }
+        if (this.current === "(") {
+            const token = {
+                type: TokenType.LPAREN,
+                value: "(",
+                position: this.position,
+            };
+            this.advance();
+            return token;
+        }
+        if (this.current === ")") {
+            const token = {
+                type: TokenType.RPAREN,
+                value: ")",
+                position: this.position,
+            };
+            this.advance();
+            return token;
+        }
+        if (this.current === ",") {
+            const token = {
+                type: TokenType.COMMA,
+                value: ",",
+                position: this.position,
+            };
+            this.advance();
+            return token;
+        }
+        if ("+-*/%<>=!&|".includes(this.current)) {
+            return this.readOperator();
+        }
+        throw new Error(`Unexpected character '${this.current}' at position ${this.position}`);
+    }
+    tokenize() {
+        const tokens = [];
+        let token = this.nextToken();
+        while (token.type !== TokenType.EOF) {
+            tokens.push(token);
+            token = this.nextToken();
+        }
+        tokens.push(token);
+        return tokens;
+    }
+}
+const TOKEN_CACHE_MAX_SIZE = 2000;
+const TOKEN_CACHE_MAX_EXPRESSION_LENGTH = 4000;
+const tokenCache = new Map();
+function tokenizeCached(expression) {
+    if (expression.length > TOKEN_CACHE_MAX_EXPRESSION_LENGTH) {
+        return new Tokenizer(expression).tokenize();
+    }
+    const cached = tokenCache.get(expression);
+    if (cached)
+        return cached;
+    const tokens = new Tokenizer(expression).tokenize();
+    if (tokenCache.size >= TOKEN_CACHE_MAX_SIZE) {
+        const oldest = tokenCache.keys().next().value;
+        if (oldest !== undefined)
+            tokenCache.delete(oldest);
+    }
+    tokenCache.set(expression, tokens);
+    return tokens;
+}
+export function clearExpressionCache() {
+    tokenCache.clear();
+}
+export function getExpressionCacheStats() {
+    return { size: tokenCache.size, maxSize: TOKEN_CACHE_MAX_SIZE };
+}
+class ExpressionParser {
+    tokens;
+    position = 0;
+    context;
+    constructor(tokens, context) {
+        this.tokens = tokens;
+        this.context = context;
+    }
+    currentToken() {
+        return (this.tokens[this.position] || {
+            type: TokenType.EOF,
+            value: null,
+            position: -1,
+        });
+    }
+    advance() {
+        this.position++;
+    }
+    tryParseLambda() {
+        const saved = this.position;
+        const paramNames = [];
+        if (this.currentToken().type === TokenType.LPAREN) {
+            this.advance();
+            while (this.currentToken().type === TokenType.IDENTIFIER) {
+                paramNames.push(this.currentToken().value);
+                this.advance();
+                if (this.currentToken().type === TokenType.COMMA) {
+                    this.advance();
+                }
+            }
+            if (this.currentToken().type !== TokenType.RPAREN) {
+                this.position = saved;
+                return null;
+            }
+            this.advance();
+        }
+        else if (this.currentToken().type === TokenType.IDENTIFIER) {
+            paramNames.push(this.currentToken().value);
+            this.advance();
+        }
+        else {
+            return null;
+        }
+        if (this.currentToken().type !== TokenType.ARROW) {
+            this.position = saved;
+            return null;
+        }
+        this.advance();
+        const bodyStart = this.position;
+        this.parseExpression(true, true, true);
+        const bodyEnd = this.position;
+        const lambda = (...args) => {
+            const paramContext = { ...this.context };
+            for (let i = 0; i < paramNames.length; i++) {
+                paramContext[paramNames[i]] = args[i];
+            }
+            const bodyTokens = this.tokens.slice(bodyStart, bodyEnd);
+            const parser = new ExpressionParser(bodyTokens, paramContext);
+            return parser.parse();
+        };
+        return lambda;
+    }
+    parseExpression(stopAtComma = false, stopAtRParen = false, stopAtRBracket = false) {
+        const outputQueue = [];
+        const operatorStack = [];
+        let expectOperand = true;
+        while (this.currentToken().type !== TokenType.EOF &&
+            !(stopAtComma && this.currentToken().type === TokenType.COMMA) &&
+            !(stopAtRParen && this.currentToken().type === TokenType.RPAREN) &&
+            !(stopAtRBracket && this.currentToken().type === TokenType.RBRACKET)) {
+            const token = this.currentToken();
+            if (token.type === TokenType.NUMBER ||
+                token.type === TokenType.STRING ||
+                token.type === TokenType.BOOLEAN ||
+                token.type === TokenType.NULL) {
+                outputQueue.push(token.value);
+                this.advance();
+                expectOperand = false;
+            }
+            else if (token.type === TokenType.IDENTIFIER) {
+                if (expectOperand) {
+                    const lambda = this.tryParseLambda();
+                    if (lambda) {
+                        outputQueue.push(lambda);
+                        expectOperand = false;
+                        continue;
+                    }
+                }
+                this.advance();
+                if (this.currentToken().type === TokenType.LPAREN) {
+                    const funcName = token.value;
+                    this.advance();
+                    const args = [];
+                    if (this.currentToken().type !== TokenType.RPAREN) {
+                        const lambda = this.tryParseLambda();
+                        if (lambda) {
+                            args.push(lambda);
+                        }
+                        else {
+                            args.push(this.parseExpression(true, true, false));
+                        }
+                        while (this.currentToken().type === TokenType.COMMA) {
+                            this.advance();
+                            const lambdaArg = this.tryParseLambda();
+                            if (lambdaArg) {
+                                args.push(lambdaArg);
+                            }
+                            else {
+                                args.push(this.parseExpression(true, true, false));
+                            }
+                        }
+                    }
+                    if (this.currentToken().type !== TokenType.RPAREN) {
+                        throw new Error(`Expected ')' after function arguments`);
+                    }
+                    this.advance();
+                    const func = FUNCTIONS[funcName];
+                    if (!func) {
+                        throw new Error(`Unknown function: ${funcName}`);
+                    }
+                    const result = func(...args);
+                    outputQueue.push(result);
+                    while (this.currentToken().type === TokenType.DOT) {
+                        this.advance();
+                        if (this.currentToken().type !== TokenType.IDENTIFIER) {
+                            throw new Error(`Expected method name after '.'`);
+                        }
+                        const methodName = this.currentToken().value;
+                        this.advance();
+                        if (this.currentToken().type !== TokenType.LPAREN) {
+                            throw new Error(`Expected '(' after method name '${methodName}'`);
+                        }
+                        this.advance();
+                        const methodArgs = [outputQueue.pop()];
+                        if (this.currentToken().type !== TokenType.RPAREN) {
+                            const lambdaArg = this.tryParseLambda();
+                            if (lambdaArg) {
+                                methodArgs.push(lambdaArg);
+                            }
+                            else {
+                                methodArgs.push(this.parseExpression(true, true, false));
+                            }
+                            while (this.currentToken().type === TokenType.COMMA) {
+                                this.advance();
+                                const la = this.tryParseLambda();
+                                if (la) {
+                                    methodArgs.push(la);
+                                }
+                                else {
+                                    methodArgs.push(this.parseExpression(true, true, false));
+                                }
+                            }
+                        }
+                        if (this.currentToken().type !== TokenType.RPAREN) {
+                            throw new Error(`Expected ')' after method arguments`);
+                        }
+                        this.advance();
+                        const method = FUNCTIONS[methodName];
+                        if (!method) {
+                            throw new Error(`Unknown function: ${methodName}`);
+                        }
+                        outputQueue.push(method(...methodArgs));
+                    }
+                }
+                else {
+                    let value = getNestedValue(this.context, token.value);
+                    while (this.currentToken().type === TokenType.DOT) {
+                        this.advance();
+                        if (this.currentToken().type !== TokenType.IDENTIFIER) {
+                            throw new Error(`Expected method name after '.'`);
+                        }
+                        const methodName = this.currentToken().value;
+                        this.advance();
+                        if (this.currentToken().type !== TokenType.LPAREN) {
+                            value = getNestedValue(value ?? {}, methodName);
+                            continue;
+                        }
+                        this.advance();
+                        const methodArgs = [value];
+                        if (this.currentToken().type !== TokenType.RPAREN) {
+                            const lambdaArg = this.tryParseLambda();
+                            if (lambdaArg) {
+                                methodArgs.push(lambdaArg);
+                            }
+                            else {
+                                methodArgs.push(this.parseExpression(true, true, false));
+                            }
+                            while (this.currentToken().type === TokenType.COMMA) {
+                                this.advance();
+                                const la = this.tryParseLambda();
+                                if (la) {
+                                    methodArgs.push(la);
+                                }
+                                else {
+                                    methodArgs.push(this.parseExpression(true, true, false));
+                                }
+                            }
+                        }
+                        if (this.currentToken().type !== TokenType.RPAREN) {
+                            throw new Error(`Expected ')' after method arguments`);
+                        }
+                        this.advance();
+                        const method = FUNCTIONS[methodName];
+                        if (!method) {
+                            throw new Error(`Unknown function: ${methodName}`);
+                        }
+                        value = method(...methodArgs);
+                    }
+                    outputQueue.push(value);
+                }
+                expectOperand = false;
+            }
+            else if (token.type === TokenType.OPERATOR) {
+                let op = token.value;
+                if (op === "-" && expectOperand) {
+                    op = "u-";
+                }
+                const opDef = OPERATORS[op];
+                if (!opDef) {
+                    throw new Error(`Unknown operator: ${op}`);
+                }
+                if (op === "|") {
+                    while (operatorStack.length > 0) {
+                        const topToken = operatorStack[operatorStack.length - 1];
+                        if (topToken.type !== TokenType.OPERATOR)
+                            break;
+                        const topOp = OPERATORS[topToken.value];
+                        if (!topOp)
+                            break;
+                        if (topOp.precedence <= opDef.precedence)
+                            break;
+                        outputQueue.push(operatorStack.pop());
+                    }
+                    const leftValue = this.evaluateRPN([...outputQueue]);
+                    outputQueue.length = 0;
+                    operatorStack.length = 0;
+                    this.advance();
+                    const rightValue = this.parseExpression(true, true, false);
+                    if (typeof rightValue === "function") {
+                        outputQueue.push(rightValue(leftValue));
+                    }
+                    else {
+                        throw new Error("Pipe operator expects a function on the right side");
+                    }
+                    expectOperand = false;
+                    continue;
+                }
+                if (opDef.unary) {
+                    operatorStack.push({ ...token, value: op });
+                    this.advance();
+                    expectOperand = true;
+                    continue;
+                }
+                while (operatorStack.length > 0) {
+                    const topToken = operatorStack[operatorStack.length - 1];
+                    if (topToken.type !== TokenType.OPERATOR)
+                        break;
+                    const topOp = OPERATORS[topToken.value];
+                    if (!topOp)
+                        break;
+                    const shouldPop = (opDef.associativity === "left" &&
+                        opDef.precedence <= topOp.precedence) ||
+                        (opDef.associativity === "right" &&
+                            opDef.precedence < topOp.precedence);
+                    if (!shouldPop)
+                        break;
+                    outputQueue.push(operatorStack.pop());
+                }
+                operatorStack.push({ ...token, value: op });
+                this.advance();
+                expectOperand = true;
+            }
+            else if (token.type === TokenType.LPAREN) {
+                operatorStack.push(token);
+                this.advance();
+                expectOperand = true;
+            }
+            else if (token.type === TokenType.RPAREN) {
+                while (operatorStack.length > 0 &&
+                    operatorStack[operatorStack.length - 1].type !== TokenType.LPAREN) {
+                    outputQueue.push(operatorStack.pop());
+                }
+                if (operatorStack.length === 0 ||
+                    operatorStack[operatorStack.length - 1].type !== TokenType.LPAREN) {
+                    throw new Error("Mismatched parentheses");
+                }
+                operatorStack.pop();
+                this.advance();
+                expectOperand = false;
+            }
+            else if (token.type === TokenType.LBRACKET) {
+                this.advance();
+                const elements = [];
+                if (this.currentToken().type !== TokenType.RBRACKET) {
+                    elements.push(this.parseExpression(true, false, true));
+                    while (this.currentToken().type === TokenType.COMMA) {
+                        this.advance();
+                        elements.push(this.parseExpression(true, false, true));
+                    }
+                }
+                if (this.currentToken().type !== TokenType.RBRACKET) {
+                    throw new Error(`Expected ']' after array elements`);
+                }
+                this.advance();
+                outputQueue.push(elements);
+                expectOperand = false;
+            }
+            else if (token.type === TokenType.RBRACKET) {
+                break;
+            }
+            else if (token.type === TokenType.ARROW) {
+                throw new Error(`Unexpected '=>' — arrow operator must follow a parameter`);
+            }
+            else {
+                throw new Error(`Unexpected token: ${token.type}`);
+            }
+        }
+        while (operatorStack.length > 0) {
+            const token = operatorStack.pop();
+            if (token.type === TokenType.LPAREN || token.type === TokenType.RPAREN) {
+                throw new Error("Mismatched parentheses");
+            }
+            outputQueue.push(token);
+        }
+        return this.evaluateRPN(outputQueue);
+    }
+    evaluateRPN(queue) {
+        const stack = [];
+        for (const item of queue) {
+            if (item &&
+                typeof item === "object" &&
+                item.type === TokenType.OPERATOR) {
+                const opDef = OPERATORS[item.value];
+                if (opDef.unary) {
+                    if (stack.length < 1) {
+                        throw new Error(`Not enough operands for unary operator ${item.value}`);
+                    }
+                    const operand = stack.pop();
+                    stack.push(opDef.fn(operand));
+                }
+                else {
+                    if (stack.length < 2) {
+                        throw new Error(`Not enough operands for operator ${item.value}`);
+                    }
+                    const right = stack.pop();
+                    const left = stack.pop();
+                    stack.push(opDef.fn(left, right));
+                }
+            }
+            else {
+                stack.push(item);
+            }
+        }
+        if (stack.length !== 1) {
+            throw new Error("Invalid expression");
+        }
+        return stack[0];
+    }
+    parse() {
+        return this.parseExpression();
+    }
+}
+export function evaluate(expression, context = {}) {
+    const startTime = Date.now();
+    try {
+        const tokens = tokenizeCached(expression);
+        const parser = new ExpressionParser(tokens, context);
+        const result = parser.parse();
+        if (traceEnabled) {
+            expressionTraces.push({
+                expression,
+                result,
+                context: { ...context },
+                duration: Date.now() - startTime,
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        Logger.error("system", "expression", `Error evaluating expression: ${expression}`, error instanceof Error ? error.stack : String(error));
+        throw error;
+    }
+}
+export function getNestedValue(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+        if (arrayMatch) {
+            current = current[arrayMatch[1]];
+            if (Array.isArray(current)) {
+                current = current[Number.parseInt(arrayMatch[2], 10)];
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            current = current[part];
+        }
+    }
+    return current;
+}
+export function evaluateCondition(expression, context) {
+    try {
+        return Boolean(evaluate(expression, context));
+    }
+    catch (error) {
+        Logger.error("system", "expression", `Error evaluating expression: ${expression}`, error instanceof Error ? error.stack : String(error));
+        return false;
+    }
+}
+export function validateExpression(expression) {
+    try {
+        const dangerousPatterns = [
+            /\beval\b/,
+            /\bFunction\b/,
+            /\bimport\b/,
+            /\brequire\b/,
+            /\bprocess\b/,
+            /\bglobal\b/,
+            /\bwindow\b/,
+            /\bdocument\b/,
+        ];
+        for (const pattern of dangerousPatterns) {
+            if (pattern.test(expression)) {
+                return {
+                    valid: false,
+                    error: "Expression contains forbidden patterns",
+                };
+            }
+        }
+        const tokens = tokenizeCached(expression);
+        const parser = new ExpressionParser(tokens, {});
+        parser.parse();
+        return { valid: true };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        if (msg.startsWith("Unknown function: ") && expression.includes("=>")) {
+            return { valid: true };
+        }
+        return {
+            valid: false,
+            error: msg,
+        };
+    }
+}
+export function resolveConditionalNext(conditionalNext, defaultNext, context) {
+    for (const branch of conditionalNext) {
+        if (evaluateCondition(branch.condition, context)) {
+            Logger.debug("system", "expression", `Condition matched: ${branch.condition} -> ${branch.target}`);
+            return branch.target;
+        }
+    }
+    if (defaultNext) {
+        Logger.debug("system", "expression", `Using default branch: ${defaultNext}`);
+        return defaultNext;
+    }
+    return null;
+}
+export function resolveNodeOutput(nodeId, path, state) {
+    if (!state?.nodes?.[nodeId]) {
+        Logger.warn("system", "expression", `Node output not found: ${nodeId}`);
+        return undefined;
+    }
+    const nodeState = state.nodes[nodeId];
+    if (nodeState.output === undefined) {
+        Logger.warn("system", "expression", `Node ${nodeId} has no output`);
+        return undefined;
+    }
+    if (!path) {
+        return nodeState.output;
+    }
+    if (typeof nodeState.output === "object" && nodeState.output !== null) {
+        return getNestedValue(nodeState.output, path);
+    }
+    Logger.warn("system", "expression", `Cannot access path ${path} on non-object output of node ${nodeId}`);
+    return undefined;
+}
+const NODE_OUTPUT_PATTERN = /\$\{(\w+)\.output(?:\.([\w.]+))?\}/g;
+const CONTEXT_PATTERN = /\$\{([\w.]+)\}/g;
+export function interpolateExpressions(template, context, state) {
+    let result = template.replace(NODE_OUTPUT_PATTERN, (match, nodeId, path) => {
+        const value = resolveNodeOutput(nodeId, path, state);
+        return value !== undefined ? String(value) : match;
+    });
+    result = result.replace(CONTEXT_PATTERN, (match, path) => {
+        if (path.includes(".output")) {
+            return match;
+        }
+        const value = getNestedValue(context, path);
+        return value !== undefined ? String(value) : match;
+    });
+    return result;
+}
+export const MAX_INTERPOLATION_DEPTH = 100;
+export class InterpolationDepthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InterpolationDepthError";
+    }
+}
+export function interpolateObject(obj, context, state) {
+    return interpolateObjectInternal(obj, context, state, 0, new WeakSet());
+}
+function interpolateObjectInternal(obj, context, state, depth, seen) {
+    if (typeof obj === "string") {
+        return interpolateExpressions(obj, context, state);
+    }
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (depth >= MAX_INTERPOLATION_DEPTH) {
+        throw new InterpolationDepthError(`Interpolation exceeded maximum depth of ${MAX_INTERPOLATION_DEPTH}; ` +
+            "the value is nested too deeply or contains a cycle");
+    }
+    if (seen.has(obj)) {
+        throw new InterpolationDepthError("Interpolation encountered a circular reference");
+    }
+    seen.add(obj);
+    try {
+        if (Array.isArray(obj)) {
+            return obj.map((item) => interpolateObjectInternal(item, context, state, depth + 1, seen));
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = interpolateObjectInternal(value, context, state, depth + 1, seen);
+        }
+        return result;
+    }
+    finally {
+        seen.delete(obj);
+    }
+}
+//# sourceMappingURL=ExpressionEvaluator.js.map