@zentto/report-core 0.4.0 → 1.0.0

package/dist/engine/expression.js

@@ -1,112 +1,1437 @@
 // @zentto/report-core — Expression engine
-// Evaluates formulas and expressions in report fields
+// Complete formula language with recursive descent parser
+// Inspired by Crystal Reports formula syntax
 import { computeAggregate } from './data-binding.js';
-/** Built-in functions available in expressions */
-const FUNCTIONS = {
-    // Aggregates
-    SUM: (...args) => args.reduce((a, b) => a + b, 0),
-    AVG: (...args) => {
-        const nums = args;
-        return nums.reduce((a, b) => a + b, 0) / nums.length;
-    },
-    COUNT: (...args) => args.length,
-    MIN: (...args) => Math.min(...args),
-    MAX: (...args) => Math.max(...args),
-    // Math
-    ROUND: (val, decimals) => Math.round(val * 10 ** decimals) / 10 ** decimals,
-    ABS: (val) => Math.abs(val),
-    CEIL: (val) => Math.ceil(val),
-    FLOOR: (val) => Math.floor(val),
-    // String
-    UPPER: (val) => String(val).toUpperCase(),
-    LOWER: (val) => String(val).toLowerCase(),
-    TRIM: (val) => String(val).trim(),
-    LEFT: (val, n) => String(val).slice(0, n),
-    RIGHT: (val, n) => String(val).slice(-n),
-    LEN: (val) => String(val).length,
-    CONCAT: (...args) => args.map(String).join(''),
-    // Logic
-    IF: (cond, trueVal, falseVal) => cond ? trueVal : falseVal,
-    IIF: (cond, trueVal, falseVal) => cond ? trueVal : falseVal,
-    // Date
-    NOW: () => new Date().toISOString(),
-    TODAY: () => new Date().toISOString().split('T')[0],
-    YEAR: (val) => new Date(val).getFullYear(),
-    MONTH: (val) => new Date(val).getMonth() + 1,
-    DAY: (val) => new Date(val).getDate(),
-    // Format
-    FORMAT: (val, fmt) => {
-        if (typeof val === 'number' && typeof fmt === 'string') {
-            if (fmt.startsWith('$')) {
-                return '$' + val.toFixed(2);
-            }
-            const decimals = (fmt.split('.')[1] || '').length;
-            return val.toFixed(decimals);
-        }
-        return String(val);
-    },
-    // Null handling
-    ISNULL: (val, fallback) => val ?? fallback,
-    COALESCE: (...args) => args.find(a => a != null) ?? null,
-};
+// ─── Token Types ───────────────────────────────────────────────────
+var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["Number"] = 0] = "Number";
+    TokenType[TokenType["String"] = 1] = "String";
+    TokenType[TokenType["Boolean"] = 2] = "Boolean";
+    TokenType[TokenType["Null"] = 3] = "Null";
+    TokenType[TokenType["Identifier"] = 4] = "Identifier";
+    TokenType[TokenType["FieldRef"] = 5] = "FieldRef";
+    TokenType[TokenType["LParen"] = 6] = "LParen";
+    TokenType[TokenType["RParen"] = 7] = "RParen";
+    TokenType[TokenType["Comma"] = 8] = "Comma";
+    TokenType[TokenType["Plus"] = 9] = "Plus";
+    TokenType[TokenType["Minus"] = 10] = "Minus";
+    TokenType[TokenType["Star"] = 11] = "Star";
+    TokenType[TokenType["Slash"] = 12] = "Slash";
+    TokenType[TokenType["Percent"] = 13] = "Percent";
+    TokenType[TokenType["Caret"] = 14] = "Caret";
+    TokenType[TokenType["Ampersand"] = 15] = "Ampersand";
+    TokenType[TokenType["Eq"] = 16] = "Eq";
+    TokenType[TokenType["Neq"] = 17] = "Neq";
+    TokenType[TokenType["Lt"] = 18] = "Lt";
+    TokenType[TokenType["Gt"] = 19] = "Gt";
+    TokenType[TokenType["Lte"] = 20] = "Lte";
+    TokenType[TokenType["Gte"] = 21] = "Gte";
+    TokenType[TokenType["And"] = 22] = "And";
+    TokenType[TokenType["Or"] = 23] = "Or";
+    TokenType[TokenType["Not"] = 24] = "Not";
+    TokenType[TokenType["EOF"] = 25] = "EOF";
+})(TokenType || (TokenType = {}));
+// ─── Lexer ─────────────────────────────────────────────────────────
+class Lexer {
+    input;
+    pos = 0;
+    tokens = [];
+    constructor(input) {
+        this.input = input;
+        this.tokenize();
+    }
+    tokenize() {
+        const src = this.input;
+        let i = 0;
+        while (i < src.length) {
+            // Skip whitespace
+            if (/\s/.test(src[i])) {
+                i++;
+                continue;
+            }
+            // Field reference: {field} or {ds.field}
+            if (src[i] === '{') {
+                const start = i;
+                i++; // skip {
+                let ref = '';
+                while (i < src.length && src[i] !== '}') {
+                    ref += src[i];
+                    i++;
+                }
+                if (i < src.length)
+                    i++; // skip }
+                this.tokens.push({ type: TokenType.FieldRef, value: ref, pos: start });
+                continue;
+            }
+            // String literal (single or double quotes)
+            if (src[i] === '"' || src[i] === "'") {
+                const quote = src[i];
+                const start = i;
+                i++;
+                let str = '';
+                while (i < src.length && src[i] !== quote) {
+                    if (src[i] === '\\' && i + 1 < src.length) {
+                        i++;
+                        if (src[i] === 'n')
+                            str += '\n';
+                        else if (src[i] === 't')
+                            str += '\t';
+                        else if (src[i] === '\\')
+                            str += '\\';
+                        else if (src[i] === quote)
+                            str += quote;
+                        else
+                            str += src[i];
+                    }
+                    else {
+                        str += src[i];
+                    }
+                    i++;
+                }
+                if (i < src.length)
+                    i++; // skip closing quote
+                this.tokens.push({ type: TokenType.String, value: str, pos: start });
+                continue;
+            }
+            // Number literal (integer or decimal)
+            if (/\d/.test(src[i]) || (src[i] === '.' && i + 1 < src.length && /\d/.test(src[i + 1]))) {
+                const start = i;
+                let num = '';
+                while (i < src.length && /[\d.]/.test(src[i])) {
+                    num += src[i];
+                    i++;
+                }
+                this.tokens.push({ type: TokenType.Number, value: num, pos: start });
+                continue;
+            }
+            // Two-character operators
+            if (i + 1 < src.length) {
+                const two = src[i] + src[i + 1];
+                if (two === '==') {
+                    this.tokens.push({ type: TokenType.Eq, value: '==', pos: i });
+                    i += 2;
+                    continue;
+                }
+                if (two === '!=') {
+                    this.tokens.push({ type: TokenType.Neq, value: '!=', pos: i });
+                    i += 2;
+                    continue;
+                }
+                if (two === '<=') {
+                    this.tokens.push({ type: TokenType.Lte, value: '<=', pos: i });
+                    i += 2;
+                    continue;
+                }
+                if (two === '>=') {
+                    this.tokens.push({ type: TokenType.Gte, value: '>=', pos: i });
+                    i += 2;
+                    continue;
+                }
+                if (two === '<>') {
+                    this.tokens.push({ type: TokenType.Neq, value: '<>', pos: i });
+                    i += 2;
+                    continue;
+                }
+            }
+            // Single-character operators
+            const ch = src[i];
+            if (ch === '(') {
+                this.tokens.push({ type: TokenType.LParen, value: '(', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === ')') {
+                this.tokens.push({ type: TokenType.RParen, value: ')', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === ',') {
+                this.tokens.push({ type: TokenType.Comma, value: ',', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '+') {
+                this.tokens.push({ type: TokenType.Plus, value: '+', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '-') {
+                this.tokens.push({ type: TokenType.Minus, value: '-', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '*') {
+                this.tokens.push({ type: TokenType.Star, value: '*', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '/') {
+                this.tokens.push({ type: TokenType.Slash, value: '/', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '%') {
+                this.tokens.push({ type: TokenType.Percent, value: '%', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '^') {
+                this.tokens.push({ type: TokenType.Caret, value: '^', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '&') {
+                this.tokens.push({ type: TokenType.Ampersand, value: '&', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '<') {
+                this.tokens.push({ type: TokenType.Lt, value: '<', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '>') {
+                this.tokens.push({ type: TokenType.Gt, value: '>', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '=') {
+                this.tokens.push({ type: TokenType.Eq, value: '=', pos: i });
+                i++;
+                continue;
+            }
+            if (ch === '!') {
+                this.tokens.push({ type: TokenType.Not, value: '!', pos: i });
+                i++;
+                continue;
+            }
+            // Identifiers and keywords
+            if (/[a-zA-Z_]/.test(ch)) {
+                const start = i;
+                let id = '';
+                while (i < src.length && /[a-zA-Z0-9_]/.test(src[i])) {
+                    id += src[i];
+                    i++;
+                }
+                const upper = id.toUpperCase();
+                if (upper === 'TRUE') {
+                    this.tokens.push({ type: TokenType.Boolean, value: 'true', pos: start });
+                    continue;
+                }
+                if (upper === 'FALSE') {
+                    this.tokens.push({ type: TokenType.Boolean, value: 'false', pos: start });
+                    continue;
+                }
+                if (upper === 'NULL' || upper === 'NIL') {
+                    this.tokens.push({ type: TokenType.Null, value: 'null', pos: start });
+                    continue;
+                }
+                if (upper === 'AND') {
+                    this.tokens.push({ type: TokenType.And, value: 'AND', pos: start });
+                    continue;
+                }
+                if (upper === 'OR') {
+                    this.tokens.push({ type: TokenType.Or, value: 'OR', pos: start });
+                    continue;
+                }
+                if (upper === 'NOT') {
+                    this.tokens.push({ type: TokenType.Not, value: 'NOT', pos: start });
+                    continue;
+                }
+                this.tokens.push({ type: TokenType.Identifier, value: id, pos: start });
+                continue;
+            }
+            // Unknown character — skip
+            i++;
+        }
+        this.tokens.push({ type: TokenType.EOF, value: '', pos: i });
+    }
+    getTokens() { return this.tokens; }
+}
+// ─── Parser (Recursive Descent) ───────────────────────────────────
+class Parser {
+    pos = 0;
+    tokens;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const result = this.parseOr();
+        if (this.peek().type !== TokenType.EOF) {
+            throw new ExprError(`Token inesperado: "${this.peek().value}" en posicion ${this.peek().pos}`);
+        }
+        return result;
+    }
+    peek() {
+        return this.tokens[this.pos] || { type: TokenType.EOF, value: '', pos: -1 };
+    }
+    advance() {
+        const t = this.tokens[this.pos];
+        this.pos++;
+        return t;
+    }
+    expect(type) {
+        const t = this.peek();
+        if (t.type !== type) {
+            throw new ExprError(`Se esperaba ${TokenType[type]}, se encontro "${t.value}" en posicion ${t.pos}`);
+        }
+        return this.advance();
+    }
+    // OR
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.peek().type === TokenType.Or) {
+            this.advance();
+            const right = this.parseAnd();
+            left = { kind: 'binary', op: 'OR', left, right };
+        }
+        return left;
+    }
+    // AND
+    parseAnd() {
+        let left = this.parseNot();
+        while (this.peek().type === TokenType.And) {
+            this.advance();
+            const right = this.parseNot();
+            left = { kind: 'binary', op: 'AND', left, right };
+        }
+        return left;
+    }
+    // NOT
+    parseNot() {
+        if (this.peek().type === TokenType.Not) {
+            this.advance();
+            const operand = this.parseNot();
+            return { kind: 'unary', op: 'NOT', operand };
+        }
+        return this.parseComparison();
+    }
+    // Comparison: ==, !=, <, >, <=, >=
+    parseComparison() {
+        let left = this.parseConcatenation();
+        const compOps = [TokenType.Eq, TokenType.Neq, TokenType.Lt, TokenType.Gt, TokenType.Lte, TokenType.Gte];
+        while (compOps.includes(this.peek().type)) {
+            const op = this.advance().value;
+            const right = this.parseConcatenation();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // String concatenation &
+    parseConcatenation() {
+        let left = this.parseAddSub();
+        while (this.peek().type === TokenType.Ampersand) {
+            this.advance();
+            const right = this.parseAddSub();
+            left = { kind: 'binary', op: '&', left, right };
+        }
+        return left;
+    }
+    // Addition / Subtraction
+    parseAddSub() {
+        let left = this.parseMulDiv();
+        while (this.peek().type === TokenType.Plus || this.peek().type === TokenType.Minus) {
+            const op = this.advance().value;
+            const right = this.parseMulDiv();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // Multiplication / Division / Modulo
+    parseMulDiv() {
+        let left = this.parsePower();
+        while (this.peek().type === TokenType.Star || this.peek().type === TokenType.Slash || this.peek().type === TokenType.Percent) {
+            const op = this.advance().value;
+            const right = this.parsePower();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // Power ^
+    parsePower() {
+        let left = this.parseUnary();
+        while (this.peek().type === TokenType.Caret) {
+            this.advance();
+            const right = this.parseUnary(); // right-associative would use parsePower here
+            left = { kind: 'binary', op: '^', left, right };
+        }
+        return left;
+    }
+    // Unary + / -
+    parseUnary() {
+        if (this.peek().type === TokenType.Minus) {
+            this.advance();
+            const operand = this.parseUnary();
+            return { kind: 'unary', op: '-', operand };
+        }
+        if (this.peek().type === TokenType.Plus) {
+            this.advance();
+            return this.parseUnary();
+        }
+        return this.parsePrimary();
+    }
+    // Primary: literals, field refs, function calls, identifiers, parenthesized expressions
+    parsePrimary() {
+        const t = this.peek();
+        // Number
+        if (t.type === TokenType.Number) {
+            this.advance();
+            return { kind: 'number', value: parseFloat(t.value) };
+        }
+        // String
+        if (t.type === TokenType.String) {
+            this.advance();
+            return { kind: 'string', value: t.value };
+        }
+        // Boolean
+        if (t.type === TokenType.Boolean) {
+            this.advance();
+            return { kind: 'boolean', value: t.value === 'true' };
+        }
+        // Null
+        if (t.type === TokenType.Null) {
+            this.advance();
+            return { kind: 'null' };
+        }
+        // Field reference
+        if (t.type === TokenType.FieldRef) {
+            this.advance();
+            return { kind: 'fieldRef', ref: t.value };
+        }
+        // Identifier — could be function call or bare identifier
+        if (t.type === TokenType.Identifier) {
+            this.advance();
+            if (this.peek().type === TokenType.LParen) {
+                // Function call
+                this.advance(); // skip (
+                const args = [];
+                if (this.peek().type !== TokenType.RParen) {
+                    args.push(this.parseOr());
+                    while (this.peek().type === TokenType.Comma) {
+                        this.advance();
+                        args.push(this.parseOr());
+                    }
+                }
+                this.expect(TokenType.RParen);
+                return { kind: 'call', name: t.value.toUpperCase(), args };
+            }
+            return { kind: 'identifier', name: t.value };
+        }
+        // Parenthesized expression
+        if (t.type === TokenType.LParen) {
+            this.advance();
+            const expr = this.parseOr();
+            this.expect(TokenType.RParen);
+            return expr;
+        }
+        throw new ExprError(`Token inesperado: "${t.value}" (${TokenType[t.type]}) en posicion ${t.pos}`);
+    }
+}
+// ─── Expression Error ──────────────────────────────────────────────
+class ExprError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ExprError';
+    }
+}
+// ─── Report-level Variable Store (persists across report execution) ─
+const reportVariables = new Map();
+/** Reset all report variables (call before a new render) */
+export function resetReportVariables() {
+    reportVariables.clear();
+}
+// ─── Number to Words ───────────────────────────────────────────────
+const ONES_EN = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
+    'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
+const TENS_EN = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
+const SCALES_EN = ['', 'thousand', 'million', 'billion', 'trillion'];
+const ONES_ES = ['', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve',
+    'diez', 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciseis', 'diecisiete', 'dieciocho', 'diecinueve'];
+const TENS_ES = ['', '', 'veinte', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa'];
+const HUNDREDS_ES = ['', 'ciento', 'doscientos', 'trescientos', 'cuatrocientos', 'quinientos',
+    'seiscientos', 'setecientos', 'ochocientos', 'novecientos'];
+const SCALES_ES = ['', 'mil', 'millon', 'billon', 'trillon'];
+function numberToWordsEN(n) {
+    if (n === 0)
+        return 'zero';
+    if (n < 0)
+        return 'negative ' + numberToWordsEN(-n);
+    const intPart = Math.floor(n);
+    const decPart = Math.round((n - intPart) * 100);
+    let result = intToWordsEN(intPart);
+    if (decPart > 0) {
+        result += ' and ' + intToWordsEN(decPart) + '/100';
+    }
+    return result;
+}
+function intToWordsEN(n) {
+    if (n === 0)
+        return 'zero';
+    if (n < 0)
+        return 'negative ' + intToWordsEN(-n);
+    let result = '';
+    let scaleIdx = 0;
+    while (n > 0) {
+        const chunk = n % 1000;
+        if (chunk !== 0) {
+            const chunkStr = chunkToWordsEN(chunk);
+            const scale = SCALES_EN[scaleIdx];
+            result = chunkStr + (scale ? ' ' + scale : '') + (result ? ' ' + result : '');
+        }
+        n = Math.floor(n / 1000);
+        scaleIdx++;
+    }
+    return result.trim();
+}
+function chunkToWordsEN(n) {
+    if (n === 0)
+        return '';
+    if (n < 20)
+        return ONES_EN[n];
+    if (n < 100) {
+        return TENS_EN[Math.floor(n / 10)] + (n % 10 ? '-' + ONES_EN[n % 10] : '');
+    }
+    const hundreds = ONES_EN[Math.floor(n / 100)] + ' hundred';
+    const remainder = n % 100;
+    return remainder ? hundreds + ' ' + chunkToWordsEN(remainder) : hundreds;
+}
+function numberToWordsES(n) {
+    if (n === 0)
+        return 'cero';
+    if (n < 0)
+        return 'menos ' + numberToWordsES(-n);
+    const intPart = Math.floor(n);
+    const decPart = Math.round((n - intPart) * 100);
+    let result = intToWordsES(intPart);
+    if (decPart > 0) {
+        result += ' con ' + intToWordsES(decPart) + '/100';
+    }
+    return result;
+}
+function intToWordsES(n) {
+    if (n === 0)
+        return 'cero';
+    if (n < 0)
+        return 'menos ' + intToWordsES(-n);
+    if (n === 100)
+        return 'cien';
+    let result = '';
+    let scaleIdx = 0;
+    while (n > 0) {
+        const chunk = n % 1000;
+        if (chunk !== 0) {
+            let chunkStr;
+            if (scaleIdx === 1 && chunk === 1) {
+                // "mil" not "uno mil"
+                chunkStr = '';
+            }
+            else {
+                chunkStr = chunkToWordsES(chunk);
+            }
+            const scale = SCALES_ES[scaleIdx];
+            let scalePart = scale;
+            // "millon" -> "millones" for plural
+            if (scaleIdx >= 2 && chunk > 1) {
+                scalePart = scale + 'es';
+            }
+            const part = (chunkStr ? chunkStr + ' ' : '') + scalePart;
+            result = part.trim() + (result ? ' ' + result : '');
+        }
+        n = Math.floor(n / 1000);
+        scaleIdx++;
+    }
+    return result.trim();
+}
+function chunkToWordsES(n) {
+    if (n === 0)
+        return '';
+    if (n === 100)
+        return 'cien';
+    if (n < 20)
+        return ONES_ES[n];
+    if (n < 30) {
+        const remainder = n % 10;
+        return remainder === 0 ? 'veinte' : 'veinti' + ONES_ES[remainder];
+    }
+    if (n < 100) {
+        const tens = TENS_ES[Math.floor(n / 10)];
+        const remainder = n % 10;
+        return remainder ? tens + ' y ' + ONES_ES[remainder] : tens;
+    }
+    const hundreds = HUNDREDS_ES[Math.floor(n / 100)];
+    const remainder = n % 100;
+    return remainder ? hundreds + ' ' + chunkToWordsES(remainder) : hundreds;
+}
+// ─── Format Helpers ────────────────────────────────────────────────
+function formatNumberPattern(value, pattern) {
+    // Patterns: #,##0.00  $#,##0.00  0.00%  etc.
+    const isNeg = value < 0;
+    let absVal = Math.abs(value);
+    let prefix = '';
+    let suffix = '';
+    let workPattern = pattern;
+    // Extract leading currency/symbol
+    const prefixMatch = workPattern.match(/^([^#0,.]+)/);
+    if (prefixMatch) {
+        prefix = prefixMatch[1];
+        workPattern = workPattern.slice(prefix.length);
+    }
+    // Extract trailing symbol
+    const suffixMatch = workPattern.match(/([^#0,.]+)$/);
+    if (suffixMatch) {
+        suffix = suffixMatch[1];
+        workPattern = workPattern.slice(0, workPattern.length - suffix.length);
+    }
+    // Determine decimals from pattern
+    const dotPos = workPattern.indexOf('.');
+    let decimals = 0;
+    if (dotPos >= 0) {
+        decimals = workPattern.length - dotPos - 1;
+    }
+    // Handle percentage
+    if (suffix === '%') {
+        absVal = absVal * 100;
+    }
+    // Check for thousand separator
+    const useThousands = workPattern.includes(',');
+    let formatted;
+    if (useThousands) {
+        const parts = absVal.toFixed(decimals).split('.');
+        parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+        formatted = parts.join('.');
+    }
+    else {
+        formatted = absVal.toFixed(decimals);
+    }
+    return (isNeg ? '-' : '') + prefix + formatted + suffix;
+}
+function formatDatePattern(date, pattern) {
+    const pad = (n, len = 2) => String(n).padStart(len, '0');
+    const yyyy = String(date.getFullYear());
+    const yy = yyyy.slice(-2);
+    const M = date.getMonth() + 1;
+    const d = date.getDate();
+    const H = date.getHours();
+    const h = H % 12 || 12;
+    const m = date.getMinutes();
+    const s = date.getSeconds();
+    const ampm = H < 12 ? 'AM' : 'PM';
+    const dayNamesEN = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+    const dayNamesShortEN = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    const monthNamesEN = ['January', 'February', 'March', 'April', 'May', 'June',
+        'July', 'August', 'September', 'October', 'November', 'December'];
+    const monthNamesShortEN = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+        'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    // Replace from longest to shortest to avoid partial matches
+    let result = pattern;
+    result = result.replace(/yyyy/g, yyyy);
+    result = result.replace(/yy/g, yy);
+    result = result.replace(/MMMM/g, monthNamesEN[M - 1]);
+    result = result.replace(/MMM/g, monthNamesShortEN[M - 1]);
+    result = result.replace(/MM/g, pad(M));
+    result = result.replace(/(?<![\w])M(?![\w])/g, String(M));
+    result = result.replace(/dddd/g, dayNamesEN[date.getDay()]);
+    result = result.replace(/ddd/g, dayNamesShortEN[date.getDay()]);
+    result = result.replace(/dd/g, pad(d));
+    result = result.replace(/(?<![a-zA-Z])d(?![a-zA-Z])/g, String(d));
+    result = result.replace(/HH/g, pad(H));
+    result = result.replace(/(?<![a-zA-Z])H(?![a-zA-Z])/g, String(H));
+    result = result.replace(/hh/g, pad(h));
+    result = result.replace(/mm/g, pad(m));
+    result = result.replace(/ss/g, pad(s));
+    result = result.replace(/tt/g, ampm);
+    result = result.replace(/TT/g, ampm);
+    return result;
+}
+const MONTH_NAMES_EN = ['January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December'];
+const MONTH_NAMES_ES = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio',
+    'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'];
+const DAY_NAMES_EN = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const DAY_NAMES_ES = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado'];
+// ─── Safe date parsing ─────────────────────────────────────────────
+function toDate(val) {
+    if (val instanceof Date)
+        return val;
+    if (typeof val === 'string') {
+        const d = new Date(val);
+        return isNaN(d.getTime()) ? null : d;
+    }
+    if (typeof val === 'number')
+        return new Date(val);
+    return null;
+}
+function toNumber(val) {
+    if (typeof val === 'number')
+        return val;
+    if (typeof val === 'string') {
+        const n = parseFloat(val);
+        return isNaN(n) ? 0 : n;
+    }
+    if (typeof val === 'boolean')
+        return val ? 1 : 0;
+    return 0;
+}
+function toBool(val) {
+    if (typeof val === 'boolean')
+        return val;
+    if (typeof val === 'number')
+        return val !== 0;
+    if (typeof val === 'string') {
+        const lower = val.toLowerCase();
+        return lower === 'true' || lower === 'yes' || lower === 'si' || lower === '1';
+    }
+    return val != null;
+}
+function toString(val) {
+    if (val == null)
+        return '';
+    if (val instanceof Date)
+        return val.toISOString();
+    return String(val);
+}
+const FUNCTIONS = {};
+function registerFn(name, fn) {
+    FUNCTIONS[name.toUpperCase()] = fn;
+}
+// ─── String Functions (26) ─────────────────────────────────────────
+registerFn('LEFT', (args) => toString(args[0]).slice(0, toNumber(args[1])));
+registerFn('RIGHT', (args) => {
+    const s = toString(args[0]);
+    const n = toNumber(args[1]);
+    return s.slice(Math.max(0, s.length - n));
+});
+registerFn('MID', (args) => {
+    const s = toString(args[0]);
+    const start = toNumber(args[1]) - 1; // 1-based
+    const len = args.length > 2 ? toNumber(args[2]) : s.length - start;
+    return s.slice(Math.max(0, start), start + len);
+});
+registerFn('LEN', (args) => toString(args[0]).length);
+registerFn('TRIM', (args) => toString(args[0]).trim());
+registerFn('LTRIM', (args) => toString(args[0]).replace(/^\s+/, ''));
+registerFn('RTRIM', (args) => toString(args[0]).replace(/\s+$/, ''));
+registerFn('UPPER', (args) => toString(args[0]).toUpperCase());
+registerFn('LOWER', (args) => toString(args[0]).toLowerCase());
+registerFn('PROPERCASE', (args) => toString(args[0]).toLowerCase().replace(/(?:^|\s)\S/g, c => c.toUpperCase()));
+registerFn('REPLACE', (args) => {
+    const s = toString(args[0]);
+    const search = toString(args[1]);
+    const replacement = toString(args[2]);
+    // Replace all occurrences
+    return s.split(search).join(replacement);
+});
+registerFn('INSTR', (args) => {
+    const s = toString(args[0]);
+    const search = toString(args[1]);
+    const start = args.length > 2 ? toNumber(args[2]) - 1 : 0;
+    const idx = s.indexOf(search, Math.max(0, start));
+    return idx >= 0 ? idx + 1 : 0; // 1-based, 0 = not found
+});
+registerFn('SPLIT', (args) => {
+    const s = toString(args[0]);
+    const delim = toString(args[1]);
+    const parts = s.split(delim);
+    if (args.length > 2) {
+        const idx = toNumber(args[2]) - 1;
+        return idx >= 0 && idx < parts.length ? parts[idx] : '';
+    }
+    return parts.join(', ');
+});
+registerFn('JOIN', (args) => {
+    // JOIN(delimiter, val1, val2, ...) — joins all values with delimiter
+    const delim = toString(args[0]);
+    return args.slice(1).map(toString).join(delim);
+});
+registerFn('CHR', (args) => String.fromCharCode(toNumber(args[0])));
+registerFn('ASC', (args) => {
+    const s = toString(args[0]);
+    return s.length > 0 ? s.charCodeAt(0) : 0;
+});
+registerFn('SPACE', (args) => ' '.repeat(Math.max(0, toNumber(args[0]))));
+registerFn('REPLICATESTRING', (args) => toString(args[0]).repeat(Math.max(0, toNumber(args[1]))));
+registerFn('STRREVERSE', (args) => toString(args[0]).split('').reverse().join(''));
+registerFn('CONTAINS', (args) => toString(args[0]).toLowerCase().includes(toString(args[1]).toLowerCase()));
+registerFn('STARTSWITH', (args) => toString(args[0]).toLowerCase().startsWith(toString(args[1]).toLowerCase()));
+registerFn('ENDSWITH', (args) => toString(args[0]).toLowerCase().endsWith(toString(args[1]).toLowerCase()));
+registerFn('PADLEFT', (args) => toString(args[0]).padStart(toNumber(args[1]), args.length > 2 ? toString(args[2]) : ' '));
+registerFn('PADRIGHT', (args) => toString(args[0]).padEnd(toNumber(args[1]), args.length > 2 ? toString(args[2]) : ' '));
+registerFn('TOTEXT', (args) => {
+    if (args.length > 1) {
+        const val = args[0];
+        const fmt = toString(args[1]);
+        if (typeof val === 'number')
+            return formatNumberPattern(val, fmt);
+        const d = toDate(val);
+        if (d)
+            return formatDatePattern(d, fmt);
+    }
+    return toString(args[0]);
+});
+registerFn('TOWORDS', (args) => {
+    const n = toNumber(args[0]);
+    const lang = args.length > 1 ? toString(args[1]).toLowerCase() : 'es';
+    return lang === 'en' ? numberToWordsEN(n) : numberToWordsES(n);
+});
+registerFn('CONCAT', (args) => args.map(toString).join(''));
+// ─── Math Functions (16) ───────────────────────────────────────────
+registerFn('ABS', (args) => Math.abs(toNumber(args[0])));
+registerFn('ROUND', (args) => {
+    const val = toNumber(args[0]);
+    const dec = args.length > 1 ? toNumber(args[1]) : 0;
+    const factor = Math.pow(10, dec);
+    return Math.round(val * factor) / factor;
+});
+registerFn('TRUNCATE', (args) => {
+    const val = toNumber(args[0]);
+    const dec = args.length > 1 ? toNumber(args[1]) : 0;
+    const factor = Math.pow(10, dec);
+    return Math.trunc(val * factor) / factor;
+});
+registerFn('FLOOR', (args) => Math.floor(toNumber(args[0])));
+registerFn('CEILING', (args) => Math.ceil(toNumber(args[0])));
+registerFn('CEIL', (args) => Math.ceil(toNumber(args[0])));
+registerFn('REMAINDER', (args) => toNumber(args[0]) % toNumber(args[1]));
+registerFn('MOD', (args) => toNumber(args[0]) % toNumber(args[1]));
+registerFn('SGN', (args) => Math.sign(toNumber(args[0])));
+registerFn('SQRT', (args) => Math.sqrt(toNumber(args[0])));
+registerFn('EXP', (args) => Math.exp(toNumber(args[0])));
+registerFn('LOG', (args) => {
+    if (args.length > 1)
+        return Math.log(toNumber(args[0])) / Math.log(toNumber(args[1]));
+    return Math.log(toNumber(args[0]));
+});
+registerFn('LOG10', (args) => Math.log10(toNumber(args[0])));
+registerFn('PI', () => Math.PI);
+registerFn('POWER', (args) => Math.pow(toNumber(args[0]), toNumber(args[1])));
+registerFn('RANDOM', () => Math.random());
+registerFn('MIN2', (args) => Math.min(toNumber(args[0]), toNumber(args[1])));
+registerFn('MAX2', (args) => Math.max(toNumber(args[0]), toNumber(args[1])));
+// ─── Date Functions (16) ───────────────────────────────────────────
+registerFn('NOW', () => new Date());
+registerFn('TODAY', () => {
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    return d;
+});
+registerFn('YEAR', (args) => { const d = toDate(args[0]); return d ? d.getFullYear() : 0; });
+registerFn('MONTH', (args) => { const d = toDate(args[0]); return d ? d.getMonth() + 1 : 0; });
+registerFn('DAY', (args) => { const d = toDate(args[0]); return d ? d.getDate() : 0; });
+registerFn('HOUR', (args) => { const d = toDate(args[0]); return d ? d.getHours() : 0; });
+registerFn('MINUTE', (args) => { const d = toDate(args[0]); return d ? d.getMinutes() : 0; });
+registerFn('SECOND', (args) => { const d = toDate(args[0]); return d ? d.getSeconds() : 0; });
+registerFn('DATEADD', (args) => {
+    const interval = toString(args[0]).toLowerCase();
+    const amount = toNumber(args[1]);
+    const d = toDate(args[2]);
+    if (!d)
+        return null;
+    const result = new Date(d.getTime());
+    switch (interval) {
+        case 'y':
+        case 'year':
+        case 'years':
+            result.setFullYear(result.getFullYear() + amount);
+            break;
+        case 'm':
+        case 'month':
+        case 'months':
+            result.setMonth(result.getMonth() + amount);
+            break;
+        case 'd':
+        case 'day':
+        case 'days':
+            result.setDate(result.getDate() + amount);
+            break;
+        case 'h':
+        case 'hour':
+        case 'hours':
+            result.setHours(result.getHours() + amount);
+            break;
+        case 'mi':
+        case 'minute':
+        case 'minutes':
+            result.setMinutes(result.getMinutes() + amount);
+            break;
+        case 's':
+        case 'second':
+        case 'seconds':
+            result.setSeconds(result.getSeconds() + amount);
+            break;
+    }
+    return result;
+});
+registerFn('DATEDIFF', (args) => {
+    const interval = toString(args[0]).toLowerCase();
+    const d1 = toDate(args[1]);
+    const d2 = toDate(args[2]);
+    if (!d1 || !d2)
+        return 0;
+    const ms = d2.getTime() - d1.getTime();
+    switch (interval) {
+        case 'y':
+        case 'year':
+        case 'years': return d2.getFullYear() - d1.getFullYear();
+        case 'm':
+        case 'month':
+        case 'months':
+            return (d2.getFullYear() - d1.getFullYear()) * 12 + (d2.getMonth() - d1.getMonth());
+        case 'd':
+        case 'day':
+        case 'days': return Math.floor(ms / 86400000);
+        case 'h':
+        case 'hour':
+        case 'hours': return Math.floor(ms / 3600000);
+        case 'mi':
+        case 'minute':
+        case 'minutes': return Math.floor(ms / 60000);
+        case 's':
+        case 'second':
+        case 'seconds': return Math.floor(ms / 1000);
+        default: return Math.floor(ms / 86400000);
+    }
+});
+registerFn('DAYOFWEEK', (args) => {
+    const d = toDate(args[0]);
+    return d ? d.getDay() + 1 : 0; // 1=Sunday .. 7=Saturday
+});
+registerFn('MONTHNAME', (args) => {
+    const m = toNumber(args[0]);
+    const lang = args.length > 1 ? toString(args[1]).toLowerCase() : 'en';
+    if (m < 1 || m > 12)
+        return '';
+    return lang === 'es' ? MONTH_NAMES_ES[m - 1] : MONTH_NAMES_EN[m - 1];
+});
+registerFn('DAYNAME', (args) => {
+    const d = args.length === 1 ? toDate(args[0]) : null;
+    const dayNum = d ? d.getDay() : toNumber(args[0]) - 1;
+    const lang = args.length > 1 && !toDate(args[0]) ? toString(args[1]).toLowerCase() : 'en';
+    if (dayNum < 0 || dayNum > 6)
+        return '';
+    return lang === 'es' ? DAY_NAMES_ES[dayNum] : DAY_NAMES_EN[dayNum];
+});
+registerFn('ISDATE', (args) => toDate(args[0]) !== null);
+registerFn('FORMATDATE', (args) => {
+    const d = toDate(args[0]);
+    if (!d)
+        return '';
+    const pattern = args.length > 1 ? toString(args[1]) : 'yyyy-MM-dd';
+    return formatDatePattern(d, pattern);
+});
+registerFn('DATESERIAL', (args) => {
+    const y = toNumber(args[0]);
+    const m = toNumber(args[1]) - 1;
+    const d = toNumber(args[2]);
+    return new Date(y, m, d);
+});
+// ─── Type Conversion Functions (8) ─────────────────────────────────
+registerFn('TONUMBER', (args) => toNumber(args[0]));
+registerFn('TOSTRING', (args) => toString(args[0]));
+registerFn('TODATE', (args) => toDate(args[0]));
+registerFn('TOBOOLEAN', (args) => toBool(args[0]));
+registerFn('ISNUMBER', (args) => typeof args[0] === 'number' || (typeof args[0] === 'string' && !isNaN(parseFloat(args[0]))));
+registerFn('ISNULL', (args) => {
+    // ISNULL(val) -> boolean, ISNULL(val, fallback) -> coalesce
+    if (args.length === 1)
+        return args[0] == null;
+    return args[0] ?? args[1];
+});
+registerFn('COALESCE', (args) => args.find(a => a != null) ?? null);
+// ─── Aggregate Functions (12) ──────────────────────────────────────
+function getAggRows(ctx) {
+    return ctx.binding.groupRows || ctx.binding.allRows || [];
+}
+function extractNumericValues(rows, field) {
+    return rows.map(r => r[field]).filter((v) => typeof v === 'number');
+}
+registerFn('SUM', (args, ctx) => {
+    // SUM({field}) — aggregate over rows; SUM(a, b, c) — sum of args
+    if (args.length === 1 && typeof args[0] === 'string') {
+        const rows = getAggRows(ctx);
+        return extractNumericValues(rows, args[0]).reduce((a, b) => a + b, 0);
+    }
+    return args.map(toNumber).reduce((a, b) => a + b, 0);
+});
+registerFn('AVG', (args, ctx) => {
+    if (args.length === 1 && typeof args[0] === 'string') {
+        const vals = extractNumericValues(getAggRows(ctx), args[0]);
+        return vals.length ? vals.reduce((a, b) => a + b, 0) / vals.length : 0;
+    }
+    const nums = args.map(toNumber);
+    return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : 0;
+});
+registerFn('COUNT', (args, ctx) => {
+    if (args.length === 1 && typeof args[0] === 'string') {
+        const rows = getAggRows(ctx);
+        return rows.filter(r => r[args[0]] != null).length;
+    }
+    return args.filter(a => a != null).length;
+});
+registerFn('DISTINCTCOUNT', (args, ctx) => {
+    if (args.length === 1 && typeof args[0] === 'string') {
+        const rows = getAggRows(ctx);
+        const values = rows.map(r => r[args[0]]).filter(v => v != null);
+        return new Set(values.map(String)).size;
+    }
+    return new Set(args.filter(a => a != null).map(String)).size;
+});
+registerFn('MIN', (args, ctx) => {
+    if (args.length === 1 && typeof args[0] === 'string') {
+        const vals = extractNumericValues(getAggRows(ctx), args[0]);
+        return vals.length ? Math.min(...vals) : 0;
+    }
+    const nums = args.map(toNumber);
+    return nums.length ? Math.min(...nums) : 0;
+});
+registerFn('MAX', (args, ctx) => {
+    if (args.length === 1 && typeof args[0] === 'string') {
+        const vals = extractNumericValues(getAggRows(ctx), args[0]);
+        return vals.length ? Math.max(...vals) : 0;
+    }
+    const nums = args.map(toNumber);
+    return nums.length ? Math.max(...nums) : 0;
+});
+registerFn('MEDIAN', (args, ctx) => {
+    let vals;
+    if (args.length === 1 && typeof args[0] === 'string') {
+        vals = extractNumericValues(getAggRows(ctx), args[0]);
+    }
+    else {
+        vals = args.map(toNumber);
+    }
+    if (vals.length === 0)
+        return 0;
+    const sorted = [...vals].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+});
+registerFn('STDDEV', (args, ctx) => {
+    let vals;
+    if (args.length === 1 && typeof args[0] === 'string') {
+        vals = extractNumericValues(getAggRows(ctx), args[0]);
+    }
+    else {
+        vals = args.map(toNumber);
+    }
+    if (vals.length < 2)
+        return 0;
+    const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+    const variance = vals.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (vals.length - 1);
+    return Math.sqrt(variance);
+});
+registerFn('VARIANCE', (args, ctx) => {
+    let vals;
+    if (args.length === 1 && typeof args[0] === 'string') {
+        vals = extractNumericValues(getAggRows(ctx), args[0]);
+    }
+    else {
+        vals = args.map(toNumber);
+    }
+    if (vals.length < 2)
+        return 0;
+    const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+    return vals.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (vals.length - 1);
+});
+registerFn('PERCENTOFSUM', (args, ctx) => {
+    const fieldVal = toNumber(args[0]);
+    let total;
+    if (args.length > 1 && typeof args[1] === 'string') {
+        total = extractNumericValues(getAggRows(ctx), args[1]).reduce((a, b) => a + b, 0);
+    }
+    else {
+        // Use same field from context
+        const rows = getAggRows(ctx);
+        total = rows.map(r => toNumber(r[Object.keys(r)[0]])).reduce((a, b) => a + b, 0);
+    }
+    return total !== 0 ? (fieldVal / total) * 100 : 0;
+});
+registerFn('NTHLARGEST', (args, ctx) => {
+    const n = toNumber(args[1]);
+    let vals;
+    if (typeof args[0] === 'string') {
+        vals = extractNumericValues(getAggRows(ctx), args[0]);
+    }
+    else {
+        vals = args.slice(1).map(toNumber);
+    }
+    const sorted = [...vals].sort((a, b) => b - a);
+    return n >= 1 && n <= sorted.length ? sorted[n - 1] : 0;
+});
+registerFn('NTHSMALLEST', (args, ctx) => {
+    const n = toNumber(args[1]);
+    let vals;
+    if (typeof args[0] === 'string') {
+        vals = extractNumericValues(getAggRows(ctx), args[0]);
+    }
+    else {
+        vals = args.slice(1).map(toNumber);
+    }
+    const sorted = [...vals].sort((a, b) => a - b);
+    return n >= 1 && n <= sorted.length ? sorted[n - 1] : 0;
+});
+// Aggregate over group/all shortcuts: SUM_GROUP(dsId, field), SUM_ALL(field)
+registerFn('SUM_GROUP', (args, ctx) => {
+    const field = toString(args.length > 1 ? args[1] : args[0]);
+    const rows = ctx.binding.groupRows || ctx.binding.allRows || [];
+    return computeAggregate(rows, field, 'sum');
+});
+registerFn('AVG_GROUP', (args, ctx) => {
+    const field = toString(args.length > 1 ? args[1] : args[0]);
+    const rows = ctx.binding.groupRows || ctx.binding.allRows || [];
+    return computeAggregate(rows, field, 'avg');
+});
+registerFn('COUNT_GROUP', (args, ctx) => {
+    const rows = ctx.binding.groupRows || ctx.binding.allRows || [];
+    return rows.length;
+});
+registerFn('SUM_ALL', (args, ctx) => {
+    const field = toString(args[0]);
+    const rows = ctx.binding.allRows || [];
+    return computeAggregate(rows, field, 'sum');
+});
+registerFn('AVG_ALL', (args, ctx) => {
+    const field = toString(args[0]);
+    const rows = ctx.binding.allRows || [];
+    return computeAggregate(rows, field, 'avg');
+});
+registerFn('COUNT_ALL', (_args, ctx) => {
+    const rows = ctx.binding.allRows || [];
+    return rows.length;
+});
+// ─── Print State Functions (9) ─────────────────────────────────────
+registerFn('PREVIOUS', (args, ctx) => {
+    const field = toString(args[0]);
+    return ctx.printState.previousRow ? ctx.printState.previousRow[field] ?? null : null;
+});
+registerFn('NEXT', (args, ctx) => {
+    const field = toString(args[0]);
+    return ctx.printState.nextRow ? ctx.printState.nextRow[field] ?? null : null;
+});
+registerFn('RECORDNUMBER', (_args, ctx) => ctx.printState.recordNumber);
+registerFn('GROUPNUMBER', (_args, ctx) => ctx.printState.groupNumber);
+registerFn('PAGENUMBER', (_args, ctx) => ctx.printState.pageNumber);
+registerFn('TOTALPAGECOUNT', (_args, ctx) => ctx.printState.totalPageCount);
+registerFn('ONFIRSTRECORD', (_args, ctx) => ctx.printState.isFirstRecord);
+registerFn('ONLASTRECORD', (_args, ctx) => ctx.printState.isLastRecord);
+registerFn('INREPEATEDGROUPHEADER', (_args, ctx) => ctx.printState.inRepeatedGroupHeader);
+// ─── Control Structures (4) ───────────────────────────────────────
+registerFn('IF', (args) => toBool(args[0]) ? args[1] : (args.length > 2 ? args[2] : null));
+registerFn('IIF', (args) => toBool(args[0]) ? args[1] : (args.length > 2 ? args[2] : null));
+registerFn('SWITCH', (args) => {
+    // SWITCH(val, case1, result1, case2, result2, ..., default?)
+    const val = args[0];
+    for (let i = 1; i + 1 < args.length; i += 2) {
+        // Use loose equality for comparison
+        if (val == args[i] || String(val) === String(args[i])) {
+            return args[i + 1];
+        }
+    }
+    // Odd number of remaining args means last is default
+    return args.length % 2 === 0 ? args[args.length - 1] : null;
+});
+registerFn('CHOOSE', (args) => {
+    const index = toNumber(args[0]);
+    if (index >= 1 && index < args.length) {
+        return args[index];
+    }
+    return null;
+});
+// ─── Variable Support (2) ──────────────────────────────────────────
+registerFn('SETVAR', (args) => {
+    const name = toString(args[0]);
+    const value = args.length > 1 ? args[1] : null;
+    reportVariables.set(name, value);
+    return value;
+});
+registerFn('GETVAR', (args) => {
+    const name = toString(args[0]);
+    return reportVariables.get(name) ?? (args.length > 1 ? args[1] : null);
+});
+// ─── Format Functions (4) ──────────────────────────────────────────
+registerFn('FORMAT', (args) => {
+    const val = args[0];
+    const fmt = toString(args[1]);
+    if (typeof val === 'number')
+        return formatNumberPattern(val, fmt);
+    const d = toDate(val);
+    if (d)
+        return formatDatePattern(d, fmt);
+    return toString(val);
+});
+registerFn('FORMATCURRENCY', (args) => {
+    const val = toNumber(args[0]);
+    const symbol = args.length > 1 ? toString(args[1]) : '$';
+    const decimals = args.length > 2 ? toNumber(args[2]) : 2;
+    const isNeg = val < 0;
+    const absVal = Math.abs(val);
+    const parts = absVal.toFixed(decimals).split('.');
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    return (isNeg ? '-' : '') + symbol + parts.join('.');
+});
+registerFn('FORMATPERCENT', (args) => {
+    const val = toNumber(args[0]);
+    const decimals = args.length > 1 ? toNumber(args[1]) : 1;
+    return (val * 100).toFixed(decimals) + '%';
+});
+// FORMATDATE is already registered above in date functions
+// ─── AST Evaluator ─────────────────────────────────────────────────
+function evaluateNode(node, ctx) {
+    switch (node.kind) {
+        case 'number': return node.value;
+        case 'string': return node.value;
+        case 'boolean': return node.value;
+        case 'null': return null;
+        case 'fieldRef': {
+            const ref = node.ref;
+            const dotIdx = ref.indexOf('.');
+            if (dotIdx >= 0) {
+                // {dataSource.field}
+                const dsId = ref.slice(0, dotIdx);
+                const field = ref.slice(dotIdx + 1);
+                const ds = ctx.binding.dataSets[dsId];
+                if (ds && !Array.isArray(ds))
+                    return ds[field] ?? null;
+                if (ctx.binding.currentRow && field in ctx.binding.currentRow)
+                    return ctx.binding.currentRow[field];
+            }
+            // {field} — look in current row first, then parameters
+            if (ctx.binding.currentRow && ref in ctx.binding.currentRow) {
+                return ctx.binding.currentRow[ref];
+            }
+            if (ctx.binding.parameters && ref in ctx.binding.parameters) {
+                return ctx.binding.parameters[ref];
+            }
+            // Check all datasets for single-value (object) datasets
+            for (const [, ds] of Object.entries(ctx.binding.dataSets)) {
+                if (ds && !Array.isArray(ds) && ref in ds) {
+                    return ds[ref];
+                }
+            }
+            return null;
+        }
+        case 'identifier': {
+            // Bare identifier — treat as field name (same resolution as fieldRef)
+            const name = node.name;
+            if (ctx.binding.currentRow && name in ctx.binding.currentRow) {
+                return ctx.binding.currentRow[name];
+            }
+            if (ctx.binding.parameters && name in ctx.binding.parameters) {
+                return ctx.binding.parameters[name];
+            }
+            // Could be a string literal used as function argument
+            return name;
+        }
+        case 'unary': {
+            const operand = evaluateNode(node.operand, ctx);
+            switch (node.op) {
+                case '-': return -toNumber(operand);
+                case 'NOT': return !toBool(operand);
+                default: return operand;
+            }
+        }
+        case 'binary': {
+            const left = evaluateNode(node.left, ctx);
+            const right = evaluateNode(node.right, ctx);
+            switch (node.op) {
+                // Arithmetic
+                case '+': {
+                    // If both are numbers, add. Otherwise concatenate strings.
+                    if (typeof left === 'number' && typeof right === 'number')
+                        return left + right;
+                    if (typeof left === 'number' || typeof right === 'number') {
+                        const ln = Number(left);
+                        const rn = Number(right);
+                        if (!isNaN(ln) && !isNaN(rn))
+                            return ln + rn;
+                    }
+                    return toString(left) + toString(right);
+                }
+                case '-': return toNumber(left) - toNumber(right);
+                case '*': return toNumber(left) * toNumber(right);
+                case '/': {
+                    const divisor = toNumber(right);
+                    if (divisor === 0)
+                        return 0; // Avoid Infinity — return 0 like Crystal Reports
+                    return toNumber(left) / divisor;
+                }
+                case '%': return toNumber(left) % toNumber(right);
+                case '^': return Math.pow(toNumber(left), toNumber(right));
+                // String concatenation
+                case '&': return toString(left) + toString(right);
+                // Comparison
+                case '==':
+                case '=': {
+                    if (left == null && right == null)
+                        return true;
+                    if (left == null || right == null)
+                        return false;
+                    if (typeof left === 'number' && typeof right === 'number')
+                        return left === right;
+                    return String(left) === String(right);
+                }
+                case '!=':
+                case '<>': {
+                    if (left == null && right == null)
+                        return false;
+                    if (left == null || right == null)
+                        return true;
+                    if (typeof left === 'number' && typeof right === 'number')
+                        return left !== right;
+                    return String(left) !== String(right);
+                }
+                case '<': return toNumber(left) < toNumber(right);
+                case '>': return toNumber(left) > toNumber(right);
+                case '<=': return toNumber(left) <= toNumber(right);
+                case '>=': return toNumber(left) >= toNumber(right);
+                // Logical
+                case 'AND': return toBool(left) && toBool(right);
+                case 'OR': return toBool(left) || toBool(right);
+                default: return null;
+            }
+        }
+        case 'call': {
+            const fn = FUNCTIONS[node.name];
+            if (!fn) {
+                throw new ExprError(`Funcion desconocida: ${node.name}`);
+            }
+            const evaluatedArgs = node.args.map(arg => evaluateNode(arg, ctx));
+            return fn(evaluatedArgs, ctx);
+        }
+    }
+}
+// ─── Default Print State ───────────────────────────────────────────
+function defaultPrintState(ctx) {
+    return {
+        recordNumber: (ctx.currentIndex ?? 0) + 1,
+        groupNumber: 1,
+        pageNumber: ctx.pageNumber ?? 1,
+        totalPageCount: ctx.totalPages ?? 1,
+        isFirstRecord: ctx.currentIndex === 0,
+        isLastRecord: ctx.allRows ? ctx.currentIndex === ctx.allRows.length - 1 : false,
+        inRepeatedGroupHeader: false,
+        previousRow: ctx.allRows && ctx.currentIndex != null && ctx.currentIndex > 0
+            ? ctx.allRows[ctx.currentIndex - 1]
+            : undefined,
+        nextRow: ctx.allRows && ctx.currentIndex != null && ctx.currentIndex < (ctx.allRows.length - 1)
+            ? ctx.allRows[ctx.currentIndex + 1]
+            : undefined,
+    };
+}
+// ─── Public API ────────────────────────────────────────────────────
 /**
  * Evaluate an expression string with context.
  *
  * Supports:
  * - Field references: {fieldName} or {dataSource.field}
  * - Function calls: =SUM({qty}), =IF({status}=="paid","PAID","PENDING")
- * - Arithmetic: =qty*price
+ * - Arithmetic: =qty*price, ={qty}*{price}
+ * - String concatenation: ={firstName} & " " & {lastName}
+ * - Comparison: ={total} > 1000
+ * - Logical: ={active} AND {verified}
+ * - Nested calls: =IF({total} > 1000, FORMATCURRENCY({total}, "$", 2), "N/A")
  * - Aggregate over group: =SUM_GROUP(detail, total)
+ * - Variables: =SETVAR("runningTotal", GETVAR("runningTotal") + {amount})
  */
-export function evaluateExpression(expr, ctx) {
+export function evaluateExpression(expr, ctx, printState) {
     if (!expr)
         return '';
     // Non-expression strings are returned as-is
     if (!expr.startsWith('='))
         return expr;
     const formula = expr.slice(1).trim();
-    // Check for aggregate function over dataset: SUM_GROUP(dsId, field)
-    const aggGroupMatch = formula.match(/^(SUM|AVG|COUNT|MIN|MAX)_GROUP\((\w+),\s*(\w+)\)$/);
-    if (aggGroupMatch) {
-        const [, fn, _dsId, field] = aggGroupMatch;
-        const rows = ctx.groupRows || ctx.allRows || [];
-        return computeAggregate(rows, field, fn.toLowerCase());
-    }
-    // Check for aggregate function over all: SUM_ALL(field)
-    const aggAllMatch = formula.match(/^(SUM|AVG|COUNT|MIN|MAX)_ALL\((\w+)\)$/);
-    if (aggAllMatch) {
-        const [, fn, field] = aggAllMatch;
-        const rows = ctx.allRows || [];
-        return computeAggregate(rows, field, fn.toLowerCase());
-    }
-    // Replace {fieldName} with actual values
-    let resolved = formula.replace(/\{(\w+)(?:\.(\w+))?\}/g, (_m, ref1, ref2) => {
-        if (ref2) {
-            // {dataSource.field}
-            const ds = ctx.dataSets[ref1];
-            if (ds && !Array.isArray(ds))
-                return JSON.stringify(ds[ref2] ?? null);
-            if (ctx.currentRow && ref1 in ctx.currentRow)
-                return JSON.stringify(ctx.currentRow[ref1]);
-        }
-        // {field} — look in current row
-        if (ctx.currentRow && ref1 in ctx.currentRow) {
-            const val = ctx.currentRow[ref1];
-            return typeof val === 'string' ? JSON.stringify(val) : String(val ?? 'null');
-        }
-        return 'null';
-    });
-    // Replace function calls with JS equivalents
-    for (const [name, fn] of Object.entries(FUNCTIONS)) {
-        const regex = new RegExp(`\\b${name}\\(`, 'g');
-        resolved = resolved.replace(regex, `__fn.${name}(`);
+    if (!formula)
+        return '';
+    try {
+        const lexer = new Lexer(formula);
+        const parser = new Parser(lexer.getTokens());
+        const ast = parser.parse();
+        const evalCtx = {
+            binding: ctx,
+            variables: reportVariables,
+            printState: {
+                ...defaultPrintState(ctx),
+                ...printState,
+            },
+        };
+        return evaluateNode(ast, evalCtx);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return `#ERR: ${message}`;
     }
+}
+/**
+ * Evaluate an expression and return the result as a string.
+ * Convenience wrapper for display purposes.
+ */
+export function evaluateExpressionAsString(expr, ctx, printState) {
+    const result = evaluateExpression(expr, ctx, printState);
+    if (result == null)
+        return '';
+    if (result instanceof Date)
+        return result.toISOString();
+    return String(result);
+}
+/**
+ * Validate an expression without evaluating it.
+ * Returns null if valid, or an error message if invalid.
+ */
+export function validateExpression(expr) {
+    if (!expr || !expr.startsWith('='))
+        return null;
+    const formula = expr.slice(1).trim();
+    if (!formula)
+        return null;
     try {
-        const fn = new Function('__fn', `"use strict"; return (${resolved});`);
-        return fn(FUNCTIONS);
+        const lexer = new Lexer(formula);
+        const parser = new Parser(lexer.getTokens());
+        parser.parse();
+        return null;
     }
-    catch {
-        return `#ERR: ${expr}`;
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
     }
 }
+/**
+ * Get a list of all field references used in an expression.
+ * Useful for dependency analysis and validation in the designer.
+ */
+export function getExpressionFields(expr) {
+    if (!expr || !expr.startsWith('='))
+        return [];
+    const fields = [];
+    const regex = /\{([^}]+)\}/g;
+    let match;
+    while ((match = regex.exec(expr)) !== null) {
+        fields.push(match[1]);
+    }
+    return fields;
+}
+/**
+ * Get a list of all functions used in an expression.
+ * Useful for validation in the designer.
+ */
+export function getExpressionFunctions(expr) {
+    if (!expr || !expr.startsWith('='))
+        return [];
+    const formula = expr.slice(1).trim();
+    const fns = [];
+    const regex = /\b([A-Za-z_]\w*)\s*\(/g;
+    let match;
+    while ((match = regex.exec(formula)) !== null) {
+        const name = match[1].toUpperCase();
+        if (FUNCTIONS[name] && !fns.includes(name)) {
+            fns.push(name);
+        }
+    }
+    return fns;
+}
+/**
+ * Get the full list of available function names.
+ * Useful for autocomplete in the designer.
+ */
+export function getAvailableFunctions() {
+    return Object.keys(FUNCTIONS).sort();
+}
 //# sourceMappingURL=expression.js.map