@data7expressions/3xpr 5.0.0

package/expression/infrastructure/library.js

@@ -0,0 +1,1813 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreLibrary = void 0;
+const crypto_1 = require("crypto");
+const domain_1 = require("../../shared/domain");
+const domain_2 = require("../../operand/domain");
+class CoreLibrary {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(builder, cloner, helper) {
+        this.builder = builder;
+        this.cloner = cloner;
+        this.helper = helper;
+    }
+    load(model) {
+        this.constants(model);
+        this.enums(model);
+        this.formats(model);
+        this.operators(model);
+        this.generalFunctions(model);
+        this.comparisonFunctions(model);
+        this.nullFunctions(model);
+        this.numberFunctions(model);
+        this.stringFunctions(model);
+        this.arrayFunctions(model);
+        this.groupFunctions(model);
+        this.dateTimeFunctions(model);
+        this.conversionFunctions(model);
+        this.setsFunctions(model);
+        this.extAggregationFunctions(model);
+        this.windowFunctions(model);
+        this.jsonFunctions(model);
+        this.statisticalFunctions(model);
+        this.systemFunctions(model);
+    }
+    constants(model) {
+        model.addConstant('true', true);
+        model.addConstant('false', false);
+        model.addConstant('null', null);
+    }
+    enums(model) {
+        model.addEnum('DayOfWeek', [['Sunday', 0], ['Monday', 1], ['Tuesday', 2], ['Wednesday', 3], ['Thursday', 4], ['Friday', 5], ['Saturday', 6]]);
+    }
+    formats(model) {
+        model.addFormat('email', '^\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,3})+$');
+        model.addFormat('integer', '^\\d+$');
+        model.addFormat('decimal', '^\\d+\\.\\d+$');
+        model.addFormat('string', '^[a-zA-Z0-9_.]+$');
+        // https://stackoverflow.com/questions/3143070/javascript-regex-iso-dateTime
+        model.addFormat('date', '^\\d{4}-\\d{2}-\\d{2}$');
+        model.addFormat('dateTime', '\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\d\\.\\d+([+-][0-2]\\d:[0-5]\\d|Z)');
+        model.addFormat('time', '\\[0-2]\\d:[0-5]\\d:[0-5]\\d');
+    }
+    operators(model) {
+        model.addOperator('+(a:T,b:T):T', (a, b) => a + b, { priority: 5, description: 'Addition' });
+        model.addOperator('-(a:number,b:number):number', (a, b) => a - b, { priority: 5, description: 'Subtraction' });
+        model.addOperator('-(a:number):number', (a) => a * (-1), { priority: 9, description: 'Negation' });
+        model.addOperator('*(a:number,b:number):number', (a, b) => a * b, { priority: 6, description: 'Multiplication' });
+        model.addOperator('/(a:number,b:number):number', (a, b) => a / b, { priority: 6, description: 'Division' });
+        model.addOperator('**(a:number,b:number):number', (a, b) => a ** b, { priority: 7, description: 'Exponentiation' });
+        model.addOperator('//(a:number,b:number):number', (a, b) => Math.pow(a, (1 / b)), { priority: 7, description: 'Root' });
+        model.addOperator('%(a:number,b:number):number', (a, b) => a % b, { priority: 8, description: 'Modulus' });
+        model.addOperator('&(a:number,b:number):number', (a, b) => a & b, { priority: 5, description: 'Bitwise AND' });
+        model.addOperator('|(a:number,b:number):number', (a, b) => a | b, { priority: 5, description: 'Bitwise OR' });
+        model.addOperator('^(a:number,b:number):number', (a, b) => a ^ b, { priority: 5, description: 'Bitwise XOR' });
+        model.addOperator('~(a:number):number', (a) => ~a, { priority: 9, description: 'Bitwise NOT' });
+        model.addOperator('<<(a:number,b:number):number', (a, b) => a << b, { priority: 5, description: 'Bitwise Left Shift' });
+        model.addOperator('>>(a:number,b:number):number', (a, b) => a >> b, { priority: 5, description: 'Bitwise Right Shift' });
+        model.addOperator('==(a:T,b:T):boolean', (a, b) => a === b, { priority: 4, description: 'Equality' });
+        model.addOperatorAlias('===', '==');
+        model.addOperator('!=(a:T,b:T):boolean', (a, b) => a !== b, { priority: 4, description: 'Inequality' });
+        model.addOperatorAlias('!==', '!=');
+        model.addOperatorAlias('<>', '!=');
+        model.addOperator('>(a:T,b:T):boolean', (a, b) => a > b, { priority: 4, description: 'Greater than' });
+        model.addOperator('<(a:T,b:T):boolean', (a, b) => a < b, { priority: 4, description: 'Less than' });
+        model.addOperator('>=(a:T,b:T):boolean', (a, b) => a >= b, { priority: 4, description: 'Greater than or equal' });
+        model.addOperator('<=(a:T,b:T):boolean', (a, b) => a <= b, { priority: 4, description: 'Less than or equal' });
+        model.addOperator('&&(a:boolean,b:boolean):boolean', new And(), { priority: 3, description: 'Logical AND' });
+        model.addOperator('||(a:boolean,b:boolean):boolean', new Or(), { priority: 3, description: 'Logical OR' });
+        model.addOperator('!(a:boolean):boolean', (a) => !a, { priority: 5, description: 'Logical NOT' });
+        // index is any, because it can also be string when used to access a property of an object
+        // example: orders[0]["number"]
+        model.addOperator('[](list:T[],index:any):T', (list, index) => list[index], { priority: 2, description: 'Index' });
+        model.addOperator('$(name:string):string', (name) => process.env[name], { priority: 9, description: 'Environment Variable' });
+        model.addOperator('=(a:T,b:T):T', new Assignment(), { priority: 1, description: 'Assignment' });
+        model.addOperator('+=(a:number,b:number):number', new AssignmentOp((a, b) => a + b), { priority: 1, description: 'Assignment Addition' });
+        model.addOperator('-=(a:number,b:number):number', new AssignmentOp((a, b) => a - b), { priority: 1, description: 'Assignment Subtraction' });
+        model.addOperator('*=(a:number,b:number):number', new AssignmentOp((a, b) => a * b), { priority: 1, description: 'Assignment Multiplication' });
+        model.addOperator('/=(a:number,b:number):number', new AssignmentOp((a, b) => a / b), { priority: 1, description: 'Assignment Division' });
+        model.addOperator('**=(a:number,b:number):number', new AssignmentOp((a, b) => a ** b), { priority: 1, description: 'Assignment Exponentiation' });
+        model.addOperator('//=(a:number,b:number):number', new AssignmentOp((a, b) => Math.floor(a / b)), { priority: 1, description: 'Assignment Floor Division' });
+        model.addOperator('%=(a:number,b:number):number', new AssignmentOp((a, b) => a % b), { priority: 1, description: 'Assignment Modulus' });
+        model.addOperator('&=(a:number,b:number):number', new AssignmentOp((a, b) => a & b), { priority: 1, description: 'Assignment Bitwise AND' });
+        model.addOperator('|=(a:number,b:number):number', new AssignmentOp((a, b) => a | b), { priority: 1, description: 'Assignment Bitwise OR' });
+        model.addOperator('^=(a:number,b:number):number', new AssignmentOp((a, b) => a ^ b), { priority: 1, description: 'Assignment Bitwise XOR' });
+        model.addOperator('<<=(a:number,b:number):number', new AssignmentOp((a, b) => a << b), { priority: 1, description: 'Assignment Bitwise Left Shift' });
+        model.addOperator('>>=(a:number,b:number):number', new AssignmentOp((a, b) => a >> b), { priority: 1, description: 'Assignment Bitwise Right Shift' });
+    }
+    generalFunctions(model) {
+        model.addFunction('sleep(ms?: number):void', async (ms = 0) => {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }, { async: true, description: 'Sleeps for the specified number of milliseconds' });
+        model.addFunction('console(value:any):void', (value) => {
+            console.log(typeof value === 'object' ? JSON.stringify(value) : value);
+        }, { description: 'Prints to console' });
+    }
+    nullFunctions(model) {
+        model.addFunction('nvl(value:T, default:T):T', (value, _default) => this.helper.utils.nvl(value, _default), { description: 'Null value' });
+        model.addFunction('nvl2(value:any, a:T,b:T):T', (value, a, b) => this.helper.utils.nvl2(value, a, b), { description: 'Null value' });
+        model.addFunctionAlias('ifNull', 'nvl');
+    }
+    comparisonFunctions(model) {
+        model.addFunction('between(value:T,from:T,to:T):boolean', (value, from, to) => this.helper.val.between(value, from, to), { description: 'Between' });
+        model.addFunction('includes(source:string|T[],value:string|T):boolean', (source, value) => source && value ? source.includes(value) : false, { description: 'Includes' });
+        model.addFunctionAlias('contains', 'includes');
+        model.addFunction('in(source:T,...values:T):boolean', (source, ...values) => {
+            if (source === undefined || values === undefined) {
+                return false;
+            }
+            if (values.length === 1 && Array.isArray(values[0])) {
+                return values[0].includes(source);
+            }
+            else {
+                return values.includes(source);
+            }
+        }, { description: 'In' });
+        model.addFunction('like(value:string,pattern:string):boolean', (value, pattern) => value && pattern ? value.includes(pattern) : false, { description: 'String contains pattern' });
+        model.addFunction('isNull(value:any):boolean', (value) => this.helper.val.isNull(value), { description: 'Check if value is null' });
+        model.addFunction('isNotNull(value:any):boolean', (value) => this.helper.val.isNotNull(value), { description: 'Check if value is not null' });
+        model.addFunction('isEmpty(value:string):boolean', (value) => this.helper.val.isEmpty(value), { description: 'Check if value is empty' });
+        model.addFunction('isNotEmpty(value:string):boolean', (value) => this.helper.val.isNotEmpty(value), { description: 'Check if value is not empty' });
+        model.addFunction('isBoolean(value:any):boolean', (value) => this.helper.val.isBoolean(value), { description: 'Check if value is boolean' });
+        model.addFunction('isNumber(value:any):boolean', (value) => this.helper.val.isNumber(value), { description: 'Check if value is number' });
+        model.addFunction('isInteger(value:any):boolean', (value) => this.helper.val.isInteger(value), { description: 'Check if value is integer' });
+        model.addFunction('isDecimal(value:any):boolean', (value) => this.helper.val.isDecimal(value), { description: 'Check if value is decimal' });
+        model.addFunction('isString(value:any):boolean', (value) => this.helper.val.isString(value), { description: 'Check if value is string' });
+        model.addFunction('isDate(value:any):boolean', (value) => this.helper.val.isDate(value), { description: 'Check if value is date' });
+        model.addFunction('isDateTime(value:any):boolean', (value) => this.helper.val.isDateTime(value), { description: 'Check if value is date time' });
+        model.addFunction('isTime(value:any):boolean', (value) => this.helper.val.isTime(value), { description: 'Check if value is time' });
+        model.addFunction('isObject(value:any):boolean', (value) => this.helper.val.isObject(value), { description: 'Check if value is object' });
+        model.addFunction('isArray(value:any):boolean', (value) => this.helper.val.isArray(value), { description: 'Check if value is array' });
+        model.addFunction('isBooleanFormat(value:string):boolean', (value) => this.helper.val.isBooleanFormat(value), { description: 'Check if value is boolean format' });
+        model.addFunction('isNumberFormat(value:string):boolean', (value) => this.helper.val.isNumberFormat(value), { description: 'Check if value is number format' });
+        model.addFunction('isIntegerFormat(value:string):boolean', (value) => this.helper.val.isIntegerFormat(value), { description: 'Check if value is integer format' });
+        model.addFunction('isDecimalFormat(value:string):boolean', (value) => this.helper.val.isDecimalFormat(value), { description: 'Check if value is decimal format' });
+        model.addFunction('isDateFormat(value:string):boolean', (value) => this.helper.val.isDateFormat(value), { description: 'Check if value is date format' });
+        model.addFunction('isDateTimeFormat(value:string):boolean', (value) => this.helper.val.isDateTimeFormat(value), { description: 'Check if value is date time format' });
+        model.addFunction('isTimeFormat(value:string):boolean', (value) => this.helper.val.isTimeFormat(value), { description: 'Check if value is time format' });
+        model.addFunction('coalesce(...values:T):T', (...values) => { var _a; return (_a = values.find(v => v !== null && v !== undefined)) !== null && _a !== void 0 ? _a : null; }, { description: 'First non-null value' });
+        model.addFunction('nullIf(a:T,b:T):T', (a, b) => a === b ? null : a, { description: 'Null if two values are equal' });
+        model.addFunction('greatest(...values:T):T', (...values) => values.filter(v => v !== null && v !== undefined).reduce((m, v) => v > m ? v : m), { description: 'Greatest of values' });
+        model.addFunction('least(...values:T):T', (...values) => values.filter(v => v !== null && v !== undefined).reduce((m, v) => v < m ? v : m), { description: 'Least of values' });
+        model.addFunction('iif(condition:boolean,trueValue:T,falseValue:T):T', (condition, trueValue, falseValue) => condition ? trueValue : falseValue, { description: 'Inline if' });
+        model.addFunction('choose(index:integer,...values:T):T', (index, ...values) => index >= 1 && index <= values.length ? values[index - 1] : null, { description: 'Choose value by 1-based index' });
+    }
+    numberFunctions(model) {
+        model.addFunction('abs(x:number):number', Math.abs, { description: 'Absolute value' });
+        model.addFunction('acos(x:number):number', Math.acos, { description: 'Arc cosine' });
+        model.addFunction('asin(x:number):number', Math.asin, { description: 'Arc sine' });
+        model.addFunction('atan(x:number):number', Math.atan, { description: 'Arc tangent' });
+        model.addFunction('atan2(y:number,x:number):number', Math.atan2, { description: 'Arc tangent of two variables' });
+        model.addFunction('ceil(x:number):number', Math.ceil, { description: 'Ceiling' });
+        model.addFunction('cos(x:number):number', Math.cos, { description: 'Cosine' });
+        model.addFunction('cosh(x:number):number', Math.cosh, { description: 'Hyperbolic cosine' });
+        model.addFunction('exp(x:number):number', Math.exp, { description: 'Exponential' });
+        model.addFunction('floor(x:number):number', Math.floor, { description: 'Floor' });
+        model.addFunction('ln(x:number):number', Math.log, { description: 'Natural logarithm' });
+        model.addFunction('log10(x:number):number', Math.log10, { description: 'Base 10 logarithm' });
+        model.addFunction('log(x:number):number', Math.log, { description: 'Natural logarithm' });
+        model.addFunction('remainder(n1:number,n2:number):number', (n1, n2) => n1 % n2, { description: 'Remainder' });
+        model.addFunction('round(num:number,decimals=0):number', (num, decimals = 0) => decimals > 0 ? Number(num.toFixed(decimals)) : Math.round(num), { description: 'Round' });
+        model.addFunction('sign(x:number):number', Math.sign, { description: 'Sign' });
+        model.addFunction('sin(x:number):number', Math.sin, { description: 'Sine' });
+        model.addFunction('sinh(x:number):number', Math.sinh, { description: 'Hyperbolic sine' });
+        model.addFunction('tan(x:number):number', Math.tan, { description: 'Tangent' });
+        model.addFunction('tanh(x:number):number', Math.tanh, { description: 'Hyperbolic tangent' });
+        model.addFunction('trunc(x:number):number', Math.trunc, { description: 'Truncate' });
+        model.addFunctionAlias('mod', 'remainder');
+        model.addFunction('power(x:number,y:number):number', Math.pow, { description: 'Power' });
+        model.addFunction('sqrt(x:number):number', Math.sqrt, { description: 'Square root' });
+        model.addFunction('rand():number', Math.random, { deterministic: false, description: 'Random number between 0 and 1' });
+        model.addFunction('cot(x:number):number', (x) => 1 / Math.tan(x), { description: 'Cotangent' });
+        model.addFunction('degrees(x:number):number', (x) => x * (180 / Math.PI), { description: 'Radians to degrees' });
+        model.addFunction('radians(x:number):number', (x) => x * (Math.PI / 180), { description: 'Degrees to radians' });
+        model.addFunction('pi():number', () => Math.PI, { description: 'Pi constant' });
+    }
+    conversionFunctions(model) {
+        model.addFunction('toString(value:any):string', (value) => this.helper.str.toString(value), { description: 'Convert to string' });
+        model.addFunction('toNumber(value:any):number', (value) => this.helper.utils.toNumber(value), { description: 'Convert to number' });
+        model.addFunction('dateToString(date:date):string', (date) => {
+            if (typeof date === 'string') {
+                return new Date(date).toISOString();
+            }
+            return date.toISOString();
+        }, { description: 'Convert date to string' });
+        model.addFunction('stringify(value:any):string', (value) => JSON.stringify(value), { description: 'Convert to JSON string' });
+        model.addFunction('parse(value:string):any', (value) => JSON.parse(value), { description: 'Parse JSON string' });
+        model.addFunction('keys(obj: any):string[]', (obj) => typeof obj === 'object' ? Object.keys(obj) : [], { description: 'Object keys' });
+        model.addFunction('values(obj: any):any[]', (obj) => typeof obj === 'object' ? Object.values(obj) : [], { description: 'Object values' });
+        model.addFunction('entries(obj: any):[string,any][]', (obj) => typeof obj === 'object' ? Object.entries(obj) : [], { description: 'Object entries' });
+        model.addFunction('fromEntries(entries: [string,any][]): any', (entries) => this.helper.obj.fromEntries(entries), { description: 'Object from entries' });
+    }
+    stringFunctions(model) {
+        model.addFunction('chr(ascii: number):string', (ascii) => String.fromCharCode(ascii), { description: 'Character' });
+        model.addFunction('capitalize(value:string):string', (value) => this.helper.str.capitalize(value), { description: 'Capitalize' });
+        model.addFunction('endsWith(value:string, sub:string, start:number):boolean', (value, sub, start) => value.endsWith(sub, start), { description: 'Ends with' });
+        model.addFunction('strCount(source: string, value: string):number', (source, value) => source.split(value).length - 1, { description: 'Count' });
+        model.addFunction('lower(value: string):string', (value) => value.toLowerCase(), { description: 'Lower case' });
+        model.addFunction('lpad(value: string, len: number, pad: string):string', (value, len, pad) => value.padStart(len, pad), { description: 'Left pad' });
+        model.addFunction('ltrim(value: string):string', (value) => value.trimStart(), { description: 'Left trim' });
+        model.addFunction('indexOf(value:string, sub:string, start:number):number', (value, sub, start) => value.indexOf(sub, start), { description: 'Index of' });
+        model.addFunction('join(values:string[],separator:string=","):string', (values, separator = ',') => values.join(separator), { description: 'Join' });
+        model.addFunction('replace(value: string, source: string, target: string):string', (value, source, target) => this.helper.str.replace(value, source, target), { description: 'Replace' });
+        model.addFunction('rpad(value: string, len: number, pad: string):string', (value, len, pad) => value.padEnd(len, pad), { description: 'Right pad' });
+        model.addFunction('rtrim(value: string):string', (value) => value.trimEnd(), { description: 'Right trim' });
+        model.addFunction('substring(value: string, from: number, end: number):string', (value, from, end) => value.substring(from, end), { description: 'Substring' });
+        model.addFunctionAlias('substr', 'substring');
+        model.addFunction('trim(value: string):string', (value) => value.trim(), { description: 'Trim' });
+        model.addFunction('upper(value: string):string', (value) => value.toUpperCase(), { description: 'Upper case' });
+        model.addFunction('concat(...values:any):string', (...values) => this.helper.str.concat(values), { description: 'Concatenate' });
+        model.addFunctionAlias('concatenate', 'concat');
+        model.addFunction('test(value: string, regexp: string):boolean', (value, regexp) => new RegExp(regexp).test(value), { description: 'Test' });
+        model.addFunction('title(value:string):string', (value) => this.helper.str.initCap(value), { description: 'Title case' });
+        model.addFunction('match(value: string, regexp: string):any', (value, regexp) => value ? value.match(regexp) : null, { description: 'Match' });
+        model.addFunction('mask(value: string):string', (value) => {
+            if (!value)
+                return value;
+            if (value.length > 8) {
+                return value.substring(0, 3) + '*****' + value.substring(value.length - 3, value.length);
+            }
+            else if (value.length > 5) {
+                return value.substring(0, 1) + '*****' + value.substring(value.length - 1, value.length);
+            }
+            else {
+                return '*';
+            }
+        }, { description: 'Mask sensitive data' });
+        model.addFunction('split(value:string,separator:string=","):string[]', (value, separator = ',') => value.split(separator), { description: 'Split string' });
+        model.addFunction('startWith(value:string, sub:string, start:number):boolean', (value, sub, start) => value.startsWith(sub, start), { description: 'Starts with' });
+        model.addFunctionAlias('startsWith', 'startWith');
+        model.addFunction('left(value:string,n:integer):string', (value, n) => n > 0 ? value.substring(0, n) : '', { description: 'Left N characters' });
+        model.addFunction('right(value:string,n:integer):string', (value, n) => n > 0 ? value.substring(value.length - n) : '', { description: 'Right N characters' });
+        model.addFunction('concatWs(separator:string,...values:any):string', (separator, ...values) => values.filter(v => v !== null && v !== undefined).join(separator), { description: 'Concatenate with separator' });
+        model.addFunction('inStr(value:string,sub:string,start?:number):number', (value, sub, start = 0) => value.indexOf(sub, start), { description: 'Position of substring' });
+        model.addFunctionAlias('locate', 'inStr');
+        model.addFunctionAlias('charIndex', 'inStr');
+        model.addFunctionAlias('position', 'inStr');
+        model.addFunctionAlias('initCap', 'title');
+        model.addFunctionAlias('char', 'chr');
+        model.addFunction('repeat(value:string,n:integer):string', (value, n) => value.repeat(Math.max(0, n)), { description: 'Repeat string N times' });
+        model.addFunction('space(n:integer):string', (n) => ' '.repeat(Math.max(0, n)), { description: 'N space characters' });
+        model.addFunction('splitPart(value:string,delimiter:string,n:integer):string', (value, delimiter, n) => {
+            const parts = value.split(delimiter);
+            return n >= 1 && n <= parts.length ? parts[n - 1] : '';
+        }, { description: 'Nth part of split string (1-based)' });
+        model.addFunction('translate(value:string,from:string,to:string):string', (value, from, to) => {
+            let result = value;
+            for (let i = 0; i < from.length; i++) {
+                result = result.split(from[i]).join(i < to.length ? to[i] : '');
+            }
+            return result;
+        }, { description: 'Replace individual characters' });
+        model.addFunction('ascii(value:string):integer', (value) => value ? value.charCodeAt(0) : 0, { description: 'ASCII code of first character' });
+        model.addFunction('soundex(value:string):string', (value) => {
+            const map = { B: '1', F: '1', P: '1', V: '1', C: '2', G: '2', J: '2', K: '2', Q: '2', S: '2', X: '2', Z: '2', D: '3', T: '3', L: '4', M: '5', N: '5', R: '6' };
+            const s = value.toUpperCase().replace(/[^A-Z]/g, '');
+            if (!s)
+                return '0000';
+            let code = s[0];
+            let prev = map[s[0]] || '0';
+            for (let i = 1; i < s.length && code.length < 4; i++) {
+                const curr = map[s[i]] || '0';
+                if (curr !== '0' && curr !== prev)
+                    code += curr;
+                prev = curr;
+            }
+            return code.padEnd(4, '0');
+        }, { description: 'Soundex phonetic code' });
+        model.addFunction('md5(value:string):string', (value) => (0, crypto_1.createHash)('md5').update(value).digest('hex'), { description: 'MD5 hash' });
+        model.addFunction('sha1(value:string):string', (value) => (0, crypto_1.createHash)('sha1').update(value).digest('hex'), { description: 'SHA1 hash' });
+        model.addFunction('sha2(value:string,bits?:number):string', (value, bits = 256) => (0, crypto_1.createHash)(`sha${bits}`).update(value).digest('hex'), { description: 'SHA2 hash' });
+        model.addFunction('regexpReplace(value:string,pattern:string,replacement:string):string', (value, pattern, replacement) => value.replace(new RegExp(pattern, 'g'), replacement), { description: 'Replace all regex matches' });
+        model.addFunctionAlias('regexpLike', 'test');
+        model.addFunction('regexpSubstr(value:string,pattern:string,n?:integer):string', (value, pattern, n = 1) => {
+            const matches = [...value.matchAll(new RegExp(pattern, 'g'))];
+            return n >= 1 && n <= matches.length ? matches[n - 1][0] : '';
+        }, { description: 'Extract Nth regex match' });
+        model.addFunction('regexpInstr(value:string,pattern:string,n?:integer):integer', (value, pattern, n = 1) => {
+            var _a;
+            const matches = [...value.matchAll(new RegExp(pattern, 'g'))];
+            return n >= 1 && n <= matches.length ? ((_a = matches[n - 1].index) !== null && _a !== void 0 ? _a : -1) + 1 : 0;
+        }, { description: 'Position of Nth regex match (1-based, 0 if not found)' });
+        model.addFunction('regexpCount(value:string,pattern:string):integer', (value, pattern) => (value.match(new RegExp(pattern, 'g')) || []).length, { description: 'Count regex matches' });
+        model.addFunction('reverseStr(value:string):string', (value) => value.split('').reverse().join(''), { description: 'Reverse string characters' });
+        model.addFunctionAlias('groupConcat', 'join');
+        model.addFunctionAlias('stringAgg', 'join');
+        model.addFunctionAlias('listAgg', 'join');
+    }
+    dateTimeFunctions(model) {
+        model.addFunction('curTime():time', () => {
+            const d = new Date();
+            return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}`;
+        }, { description: 'Current time' });
+        model.addFunction('today():date', () => {
+            const d = new Date();
+            return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+        }, { description: 'Current date' });
+        model.addFunction('now():dateTime', () => new Date().toISOString(), { description: 'Current date time' });
+        model.addFunction('time(value: string):time', (value) => {
+            const d = new Date(value);
+            return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}`;
+        }, { description: 'Get time' });
+        model.addFunction('date(value: string):date', (value) => {
+            const d = new Date(value);
+            return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+        }, { description: 'Get date' });
+        model.addFunction('dateTime(value: string):dateTime', (value) => new Date(value).toISOString(), { description: 'Get date time' });
+        model.addFunction('year(value: dateTime):integer', (value) => {
+            return new Date(value).getFullYear();
+        }, { description: 'Get year' });
+        model.addFunction('month(value: dateTime):integer', (value) => {
+            return new Date(value).getMonth() + 1;
+        }, { description: 'Get month' });
+        model.addFunction('day(value: dateTime):integer', (value) => {
+            return new Date(value).getDate();
+        }, { description: 'Get day' });
+        model.addFunction('weekday(value: dateTime):integer', (value) => {
+            return new Date(value).getDay();
+        }, { description: 'Get day of week' });
+        model.addFunction('hour(value: dateTime):integer', (value) => {
+            return new Date(value).getHours();
+        }, { description: 'Get hours' });
+        model.addFunction('minute(value: dateTime):integer', (value) => {
+            return new Date(value).getMinutes();
+        }, { description: 'Get minutes' });
+        model.addFunction('second(value: dateTime):integer', (value) => {
+            return new Date(value).getSeconds();
+        }, { description: 'Get seconds' });
+        model.addFunction('millisecond(value: dateTime):integer', (value) => {
+            return new Date(value).getMilliseconds();
+        }, { description: 'Get milliseconds' });
+        model.addFunction('addYear(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setFullYear(_date.getFullYear() + value);
+            return _date.toISOString();
+        }, { description: 'Add years' });
+        model.addFunction('addMonth(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setMonth(_date.getMonth() + value);
+            return _date.toISOString();
+        }, { description: 'Add months' });
+        model.addFunction('addDay(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setDate(_date.getDate() + value);
+            return _date.toISOString();
+        }, { description: 'Add days' });
+        model.addFunction('addHour(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setHours(_date.getHours() + value);
+            return _date.toISOString();
+        }, { description: 'Add hours' });
+        model.addFunction('addMinute(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setMinutes(_date.getMinutes() + value);
+            return _date.toISOString();
+        }, { description: 'Add minutes' });
+        model.addFunction('addSecond(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setSeconds(_date.getSeconds() + value);
+            return _date.toISOString();
+        }, { description: 'Add seconds' });
+        model.addFunction('addMillisecond(date: dateTime, value: number):dateTime', (date, value) => {
+            const _date = new Date(date);
+            _date.setMilliseconds(_date.getMilliseconds() + value);
+            return _date.toISOString();
+        }, { description: 'Add milliseconds' });
+        model.addFunction('addTime(date: dateTime, time: time):dateTime', (date, time) => {
+            const _time = new Date('2000-01-01T' + time);
+            const _date = new Date(date);
+            _date.setHours(_date.getHours() + _time.getHours());
+            _date.setMinutes(_date.getMinutes() + _time.getMinutes());
+            _date.setSeconds(_date.getSeconds() + _time.getSeconds());
+            _date.setMilliseconds(_date.getMilliseconds() + _time.getMilliseconds());
+            return _date.toISOString();
+        }, { description: 'Add time' });
+        model.addFunction('subtractTime(date: dateTime, time: time):dateTime', (date, time) => {
+            const _time = new Date('2000-01-01T' + time);
+            const _date = new Date(date);
+            _date.setHours(_date.getHours() - _time.getHours());
+            _date.setMinutes(_date.getMinutes() - _time.getMinutes());
+            _date.setSeconds(_date.getSeconds() - _time.getSeconds());
+            _date.setMilliseconds(_date.getMilliseconds() - _time.getMilliseconds());
+            return _date.toISOString();
+        }, { description: 'Subtract time' });
+        model.addFunction('yearDiff(date1: dateTime, date2: dateTime):integer', (date1, date2) => {
+            return Math.abs(new Date(date2).getFullYear() - new Date(date1).getFullYear());
+        }, { description: 'Year difference' });
+        model.addFunction('dayDiff(date1: dateTime, date2: dateTime):integer', (date1, date2) => {
+            return Math.abs(Math.floor((new Date(date1).getTime() - new Date(date2).getTime()) / (24 * 3600 * 1000)));
+        }, { description: 'Day difference' });
+        model.addFunction('hourDiff(date1: dateTime, date2: dateTime):integer', (date1, date2) => {
+            return Math.abs(Math.floor((new Date(date1).getTime() - new Date(date2).getTime()) / (3600 * 1000)));
+        }, { description: 'Hour difference' });
+        model.addFunction('secondDiff(date1: dateTime, date2: dateTime):integer', (date1, date2) => {
+            return Math.abs(Math.floor((new Date(date1).getTime() - new Date(date2).getTime()) / 1000));
+        }, { description: 'Second difference' });
+        model.addFunction('millisecondDiff(date1: dateTime, date2: dateTime):integer', (date1, date2) => {
+            return Math.floor(new Date(date1).getTime() - new Date(date2).getTime());
+        }, { description: 'Millisecond difference' });
+        model.addFunction('dayToDate(value: number):dateTime', (value) => {
+            return new Date(value * 24 * 3600 * 1000).toISOString();
+        }, { description: 'Convert days to date time' });
+        model.addFunction('hourToDate(value: number):dateTime', (value) => {
+            return new Date(value * 3600 * 1000).toISOString();
+        }, { description: 'Convert hours to date time' });
+        model.addFunction('secondToDate(value: number):dateTime', (value) => {
+            return new Date(value * 1000).toISOString();
+        }, { description: 'Convert seconds to date time' });
+        model.addFunction('millisecondToDate(value: number):dateTime', (value) => {
+            return new Date(value).toISOString();
+        }, { description: 'Convert milliseconds to date time' });
+        model.addFunctionAlias('currentTimestamp', 'now');
+        model.addFunctionAlias('curDate', 'today');
+        model.addFunctionAlias('currentDate', 'today');
+        model.addFunctionAlias('currentTime', 'curTime');
+        model.addFunctionAlias('addMonths', 'addMonth');
+        model.addFunctionAlias('toDate', 'date');
+        model.addFunctionAlias('dateDiff', 'dayDiff');
+        model.addFunction('timeDiff(time1:time,time2:time):time', (time1, time2) => {
+            const t1 = new Date('2000-01-01T' + time1);
+            const t2 = new Date('2000-01-01T' + time2);
+            const totalSec = Math.abs(Math.floor((t1.getTime() - t2.getTime()) / 1000));
+            return `${String(Math.floor(totalSec / 3600)).padStart(2, '0')}:${String(Math.floor((totalSec % 3600) / 60)).padStart(2, '0')}:${String(totalSec % 60).padStart(2, '0')}`;
+        }, { description: 'Difference between two times' });
+        model.addFunction('monthsBetween(date1:dateTime,date2:dateTime):number', (date1, date2) => {
+            const d1 = new Date(date1);
+            const d2 = new Date(date2);
+            return Math.abs((d2.getFullYear() - d1.getFullYear()) * 12 + d2.getMonth() - d1.getMonth());
+        }, { description: 'Months between two dates' });
+        model.addFunction('extract(part:string,date:dateTime):integer', (part, date) => {
+            const d = new Date(date);
+            switch (part.toLowerCase()) {
+                case 'year': return d.getFullYear();
+                case 'month': return d.getMonth() + 1;
+                case 'day': return d.getDate();
+                case 'hour': return d.getHours();
+                case 'minute': return d.getMinutes();
+                case 'second': return d.getSeconds();
+                case 'millisecond': return d.getMilliseconds();
+                case 'weekday': return d.getDay();
+                case 'week': return Math.ceil(((d.getTime() - new Date(d.getFullYear(), 0, 1).getTime()) / 86400000 + new Date(d.getFullYear(), 0, 1).getDay() + 1) / 7);
+                case 'quarter': return Math.floor(d.getMonth() / 3) + 1;
+                default: return 0;
+            }
+        }, { description: 'Extract date part by name' });
+        model.addFunction('dateFormat(date:dateTime,format:string):string', (date, format) => {
+            const d = new Date(date);
+            return format
+                .replace('%Y', String(d.getFullYear()))
+                .replace('%y', String(d.getFullYear()).slice(2))
+                .replace('%m', String(d.getMonth() + 1).padStart(2, '0'))
+                .replace('%c', String(d.getMonth() + 1))
+                .replace('%d', String(d.getDate()).padStart(2, '0'))
+                .replace('%e', String(d.getDate()))
+                .replace('%H', String(d.getHours()).padStart(2, '0'))
+                .replace('%k', String(d.getHours()))
+                .replace('%i', String(d.getMinutes()).padStart(2, '0'))
+                .replace('%s', String(d.getSeconds()).padStart(2, '0'));
+        }, { description: 'Format date with pattern (%Y %m %d %H %i %s)' });
+        model.addFunctionAlias('toChar', 'dateFormat');
+        model.addFunction('lastDay(date:dateTime):date', (date) => {
+            const d = new Date(date);
+            d.setMonth(d.getMonth() + 1, 0);
+            return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+        }, { description: 'Last day of month' });
+        model.addFunction('nextDay(date:dateTime,weekday:integer):date', (date, weekday) => {
+            const d = new Date(date);
+            const daysUntil = ((weekday - d.getDay() + 7) % 7) || 7;
+            d.setDate(d.getDate() + daysUntil);
+            return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+        }, { description: 'Next occurrence of weekday (0=Sun,6=Sat)' });
+        model.addFunction('dayName(date:dateTime):string', (date) => ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][new Date(date).getDay()], { description: 'Name of weekday' });
+        model.addFunction('monthName(date:dateTime):string', (date) => ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][new Date(date).getMonth()], { description: 'Name of month' });
+        model.addFunction('week(date:dateTime):integer', (date) => {
+            const d = new Date(date);
+            const start = new Date(d.getFullYear(), 0, 1);
+            return Math.ceil(((d.getTime() - start.getTime()) / 86400000 + start.getDay() + 1) / 7);
+        }, { description: 'Week number of year' });
+        model.addFunction('quarter(date:dateTime):integer', (date) => Math.floor(new Date(date).getMonth() / 3) + 1, { description: 'Quarter of year (1-4)' });
+        model.addFunction('dateTrunc(date:dateTime,precision:string):dateTime', (date, precision) => {
+            const d = new Date(date);
+            switch (precision.toLowerCase()) {
+                case 'year': return new Date(Date.UTC(d.getUTCFullYear(), 0, 1)).toISOString();
+                case 'month': return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1)).toISOString();
+                case 'day': return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())).toISOString();
+                case 'hour': return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours())).toISOString();
+                case 'minute': return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes())).toISOString();
+                default: return d.toISOString();
+            }
+        }, { description: 'Truncate date to precision (year/month/day/hour/minute), UTC-based' });
+        model.addFunction('makeDate(year:integer,dayOfYear:integer):date', (year, dayOfYear) => {
+            const d = new Date(year, 0, dayOfYear);
+            return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+        }, { description: 'Create date from year and day-of-year' });
+        model.addFunction('unixTimestamp(date?:dateTime):integer', (date) => Math.floor((date ? new Date(date) : new Date()).getTime() / 1000), { description: 'Unix timestamp in seconds' });
+        model.addFunction('fromUnixTime(ts:integer):dateTime', (ts) => new Date(ts * 1000).toISOString(), { description: 'Date from Unix timestamp' });
+        model.addFunction('age(date1:dateTime,date2?:dateTime):string', (date1, date2) => {
+            const d1 = new Date(date1);
+            const d2 = date2 ? new Date(date2) : new Date();
+            let years = d2.getFullYear() - d1.getFullYear();
+            let months = d2.getMonth() - d1.getMonth();
+            let days = d2.getDate() - d1.getDate();
+            if (days < 0) {
+                months--;
+                days += 30;
+            }
+            if (months < 0) {
+                years--;
+                months += 12;
+            }
+            return `${years} years ${months} months ${days} days`;
+        }, { description: 'Age between two dates as text' });
+    }
+    arrayFunctions(model) {
+        model.addFunction('map(list: any[], predicate: T):T[]', new MapEval(this.builder, this.cloner, this.helper), { description: 'Map' });
+        model.addFunctionAlias('select', 'map');
+        model.addFunction('foreach(list: any[], predicate: any):void', new Foreach(), { description: 'Foreach' });
+        model.addFunctionAlias('each', 'foreach');
+        model.addFunction('filter(list: T[], predicate: boolean):T[]', new Filter(), { description: 'Filter' });
+        model.addFunctionAlias('where', 'filter');
+        model.addFunction('reverse(list: T[], predicate: any):T[]', new Reverse(), { description: 'Reverse' });
+        model.addFunction('sort(list: T[], predicate: any):T[]', new Sort(), { description: 'Sort' });
+        model.addFunctionAlias('order', 'sort');
+        model.addFunction('remove(list: T[], predicate: boolean):T[]', new Remove(), { description: 'Remove' });
+        model.addFunctionAlias('delete', 'remove');
+        model.addFunction('push(list: T[], value: T):T[]', (list, item) => {
+            list.push(item);
+            return list;
+        }, { description: 'Push' });
+        model.addFunctionAlias('insert', 'push');
+        model.addFunction('bulkInsert(list: T[], value: T[]):T[]', (list, items) => {
+            for (const item of items) {
+                list.push(item);
+            }
+            return list;
+        }, { description: 'Bulk Insert' });
+        model.addFunction('pop(list: T[]): T', (list) => list.pop(), { description: 'Pop' });
+        model.addFunction('length(source: any[]|string):number', (source) => source.length, { description: 'Length' });
+        model.addFunctionAlias('len', 'length');
+        model.addFunction('slice(list: T[], from:integer, to:integer):T[]', (list, from, to) => list.slice(from, to), { description: 'Slice' });
+        model.addFunction('page(list: T[], page:integer, records:integer):T[]', (list, page, records) => {
+            let from = (page - 1) * records;
+            if (from < 0) {
+                from = 0;
+            }
+            let to = from + records;
+            if (to > list.length) {
+                to = list.length;
+            }
+            return list.slice(from, to);
+        }, { description: 'Paging' });
+    }
+    groupFunctions(model) {
+        model.addFunction('distinct(list: any[], predicate: any): any[]', new Distinct(this.helper), { description: 'Distinct' });
+        model.addFunction('first(list: T[], predicate: boolean): T', new First(this.helper), { description: 'First' });
+        model.addFunction('last(list: T[], predicate: boolean): T', new Last(this.helper), { description: 'Last' });
+        model.addFunction('count(list: T[], predicate: boolean): integer', new Count(this.helper), { description: 'Count' });
+        model.addFunction('max(list: T[], predicate: boolean): T', new Max(this.helper), { description: 'Max' });
+        model.addFunction('min(list: T[], predicate: boolean): T', new Min(this.helper), { description: 'Min' });
+        model.addFunction('avg(list: T[], value: number): number', new Avg(this.helper), { description: 'Average' });
+        model.addFunction('sum(list: T[], value: number): number', new Sum(this.helper), { description: 'Sum' });
+    }
+    extAggregationFunctions(model) {
+        model.addFunction('countDistinct(list:T[],predicate?:any):integer', new CountDistinct(), { description: 'Count distinct values' });
+        model.addFunction('sumDistinct(list:T[],predicate?:number):number', new SumDistinct(), { description: 'Sum of distinct values' });
+        model.addFunction('avgDistinct(list:T[],predicate?:number):number', new AvgDistinct(), { description: 'Average of distinct values' });
+        model.addFunction('median(list:T[],predicate?:number):number', new Median(), { description: 'Median value' });
+        model.addFunction('percentileCont(list:number[],p:number):number', (list, p) => {
+            if (!list.length)
+                return 0;
+            const sorted = [...list].sort((a, b) => a - b);
+            const pos = p * (sorted.length - 1);
+            const lo = Math.floor(pos);
+            const hi = Math.ceil(pos);
+            return lo === hi ? sorted[lo] : sorted[lo] + (sorted[hi] - sorted[lo]) * (pos - lo);
+        }, { description: 'Continuous percentile interpolation' });
+        model.addFunction('percentileDisc(list:number[],p:number):number', (list, p) => {
+            if (!list.length)
+                return 0;
+            const sorted = [...list].sort((a, b) => a - b);
+            return sorted[Math.min(Math.floor(p * sorted.length), sorted.length - 1)];
+        }, { description: 'Discrete percentile' });
+        model.addFunction('stdDev(list:T[],predicate?:number):number', new StdDevEval(false), { description: 'Sample standard deviation' });
+        model.addFunctionAlias('stdDevSamp', 'stdDev');
+        model.addFunction('stdDevPop(list:T[],predicate?:number):number', new StdDevEval(true), { description: 'Population standard deviation' });
+        model.addFunction('variance(list:T[],predicate?:number):number', new VarianceEval(false), { description: 'Sample variance' });
+        model.addFunctionAlias('varSamp', 'variance');
+        model.addFunction('varPop(list:T[],predicate?:number):number', new VarianceEval(true), { description: 'Population variance' });
+        model.addFunction('boolAnd(list:T[],predicate?:boolean):boolean', new BoolAndEval(), { description: 'True if all values are truthy' });
+        model.addFunctionAlias('every', 'boolAnd');
+        model.addFunction('boolOr(list:T[],predicate?:boolean):boolean', new BoolOrEval(), { description: 'True if any value is truthy' });
+        model.addFunction('bitAnd(list:T[],predicate?:number):number', new BitAndAgg(), { description: 'Bitwise AND of all values' });
+        model.addFunction('bitOr(list:T[],predicate?:number):number', new BitOrAgg(), { description: 'Bitwise OR of all values' });
+    }
+    windowFunctions(model) {
+        model.addFunction('rowNumber(list:T[]):number[]', (list) => list.map((_, i) => i + 1), { description: 'Row numbers 1..n' });
+        model.addFunction('rank(list:T[],predicate?:any):number[]', new RankEval(false), { description: 'Rank with gaps for ties' });
+        model.addFunction('denseRank(list:T[],predicate?:any):number[]', new RankEval(true), { description: 'Dense rank without gaps' });
+        model.addFunction('lag(list:T[],n?:integer):T[]', (list, n = 1) => list.map((_, i) => i >= n ? list[i - n] : null), { description: 'Values shifted N positions back' });
+        model.addFunction('lead(list:T[],n?:integer):T[]', (list, n = 1) => list.map((_, i) => i + n < list.length ? list[i + n] : null), { description: 'Values shifted N positions forward' });
+        model.addFunction('firstValue(list:T[]):T', (list) => list.length > 0 ? list[0] : null, { description: 'First value in list' });
+        model.addFunction('lastValue(list:T[]):T', (list) => list.length > 0 ? list[list.length - 1] : null, { description: 'Last value in list' });
+        model.addFunction('nthValue(list:T[],n:integer):T', (list, n) => n >= 1 && n <= list.length ? list[n - 1] : null, { description: 'Nth value in list (1-based)' });
+        model.addFunction('ntile(list:T[],n:integer):number[]', (list, n) => list.map((_, i) => Math.floor(i * n / list.length) + 1), { description: 'NTile bucket numbers' });
+        model.addFunction('cumeDist(list:T[]):number[]', (list) => { const len = list.length; return list.map((_, i) => (i + 1) / len); }, { description: 'Cumulative distribution 0..1' });
+        model.addFunction('percentRank(list:T[]):number[]', (list) => {
+            const len = list.length;
+            if (len <= 1)
+                return list.map(() => 0);
+            return list.map((_, i) => i / (len - 1));
+        }, { description: 'Percent rank 0..1' });
+        model.addFunction('sumOver(list:number[]):number[]', (list) => { let r = 0; return list.map(v => { r += v; return r; }); }, { description: 'Running sum' });
+        model.addFunction('avgOver(list:number[]):number[]', (list) => { let r = 0; return list.map((v, i) => { r += v; return r / (i + 1); }); }, { description: 'Running average' });
+        model.addFunction('countOver(list:T[]):number[]', (list) => list.map((_, i) => i + 1), { description: 'Running count' });
+        model.addFunction('minOver(list:number[]):number[]', (list) => { let m = Infinity; return list.map(v => { if (v < m)
+            m = v; return m; }); }, { description: 'Running minimum' });
+        model.addFunction('maxOver(list:number[]):number[]', (list) => { let m = -Infinity; return list.map(v => { if (v > m)
+            m = v; return m; }); }, { description: 'Running maximum' });
+    }
+    jsonFunctions(model) {
+        model.addFunction('jsonExtract(obj:any,path:string):any', (obj, path) => {
+            if (obj === null || obj === undefined)
+                return null;
+            const parts = path.replace(/^\$\.?/, '').split('.').filter(p => p);
+            let cur = obj;
+            for (const p of parts) {
+                if (cur === null || cur === undefined)
+                    return null;
+                cur = cur[p];
+            }
+            return cur;
+        }, { description: 'Extract value from object by dot path ($. prefix optional)' });
+        model.addFunctionAlias('jsonValue', 'jsonExtract');
+        model.addFunctionAlias('jsonQuery', 'jsonExtract');
+        model.addFunction('jsonUnquote(value:string):any', (value) => { try {
+            return JSON.parse(value);
+        }
+        catch (_a) {
+            return value;
+        } }, { description: 'Parse JSON string, return as-is if invalid' });
+        model.addFunction('jsonArray(...values:any):any[]', (...values) => values, { description: 'Create JSON array' });
+        model.addFunction('jsonObject(...entries:any):any', (...entries) => {
+            const obj = {};
+            for (let i = 0; i + 1 < entries.length; i += 2)
+                obj[entries[i]] = entries[i + 1];
+            return obj;
+        }, { description: 'Create JSON object from key-value pairs' });
+        model.addFunction('jsonContains(obj:any,value:any):boolean', (obj, value) => {
+            if (!obj)
+                return false;
+            return JSON.stringify(obj).includes(JSON.stringify(value));
+        }, { description: 'Check if JSON contains value' });
+        model.addFunction('jsonMerge(a:any,b:any):any', (a, b) => (Object.assign(Object.assign({}, a), b)), { description: 'Merge two JSON objects' });
+        model.addFunction('jsonRemove(obj:any,key:string):any', (obj, key) => { const r = Object.assign({}, obj); delete r[key]; return r; }, { description: 'Remove property from JSON object' });
+        model.addFunction('jsonValid(value:string):boolean', (value) => { try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        } }, { description: 'Check if string is valid JSON' });
+        model.addFunctionAlias('jsonKeys', 'keys');
+        model.addFunction('jsonAgg(list:T[]):T[]', (list) => list, { description: 'Return list as JSON array' });
+        model.addFunctionAlias('jsonArrayAgg', 'jsonAgg');
+        model.addFunction('jsonObjectAgg(list:any[],keyProp:string,valueProp:string):any', (list, keyProp, valueProp) => {
+            const r = {};
+            for (const item of list)
+                r[item[keyProp]] = item[valueProp];
+            return r;
+        }, { description: 'Aggregate list to JSON object using key/value property names' });
+        model.addFunction('jsonModify(obj:any,path:string,value:any):any', (obj, path, value) => {
+            const result = JSON.parse(JSON.stringify(obj));
+            const parts = path.replace(/^\$\.?/, '').split('.').filter(p => p);
+            let cur = result;
+            for (let i = 0; i < parts.length - 1; i++) {
+                cur = cur[parts[i]];
+            }
+            if (parts.length > 0)
+                cur[parts[parts.length - 1]] = value;
+            return result;
+        }, { description: 'Set a value at a JSON path' });
+    }
+    statisticalFunctions(model) {
+        model.addFunction('corr(x:number[],y:number[]):number', (x, y) => {
+            const n = Math.min(x.length, y.length);
+            if (n === 0)
+                return 0;
+            const mx = x.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const my = y.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            let num = 0;
+            let dx = 0;
+            let dy = 0;
+            for (let i = 0; i < n; i++) {
+                num += (x[i] - mx) * (y[i] - my);
+                dx += (x[i] - mx) ** 2;
+                dy += (y[i] - my) ** 2;
+            }
+            return dx === 0 || dy === 0 ? 0 : num / Math.sqrt(dx * dy);
+        }, { description: 'Pearson correlation coefficient' });
+        model.addFunction('covarPop(x:number[],y:number[]):number', (x, y) => {
+            const n = Math.min(x.length, y.length);
+            if (n === 0)
+                return 0;
+            const mx = x.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const my = y.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            return x.slice(0, n).reduce((s, v, i) => s + (v - mx) * (y[i] - my), 0) / n;
+        }, { description: 'Population covariance' });
+        model.addFunction('covarSamp(x:number[],y:number[]):number', (x, y) => {
+            const n = Math.min(x.length, y.length);
+            if (n <= 1)
+                return 0;
+            const mx = x.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const my = y.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            return x.slice(0, n).reduce((s, v, i) => s + (v - mx) * (y[i] - my), 0) / (n - 1);
+        }, { description: 'Sample covariance' });
+        model.addFunction('regrSlope(y:number[],x:number[]):number', (y, x) => {
+            const n = Math.min(x.length, y.length);
+            if (n === 0)
+                return 0;
+            const mx = x.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const my = y.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const num = x.slice(0, n).reduce((s, v, i) => s + (v - mx) * (y[i] - my), 0);
+            const den = x.slice(0, n).reduce((s, v) => s + (v - mx) ** 2, 0);
+            return den === 0 ? 0 : num / den;
+        }, { description: 'Slope of linear regression line' });
+        model.addFunction('regrIntercept(y:number[],x:number[]):number', (y, x) => {
+            const n = Math.min(x.length, y.length);
+            if (n === 0)
+                return 0;
+            const mx = x.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const my = y.slice(0, n).reduce((s, v) => s + v, 0) / n;
+            const num = x.slice(0, n).reduce((s, v, i) => s + (v - mx) * (y[i] - my), 0);
+            const den = x.slice(0, n).reduce((s, v) => s + (v - mx) ** 2, 0);
+            return my - (den === 0 ? 0 : num / den) * mx;
+        }, { description: 'Intercept of linear regression line' });
+    }
+    systemFunctions(model) {
+        model.addFunction('uuid():string', () => {
+            if (typeof globalThis.crypto !== 'undefined' && typeof globalThis.crypto.randomUUID === 'function') {
+                return globalThis.crypto.randomUUID();
+            }
+            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+                const r = Math.random() * 16 | 0;
+                return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+            });
+        }, { deterministic: false, description: 'Generate UUID v4' });
+    }
+    setsFunctions(model) {
+        model.addFunction('union(a: T[], b: T[]): T[]', new Union(this.helper), { description: 'Union' });
+        model.addFunction('intersection(a: T[], b: T[]): T[]', new Intersection(this.helper), { description: 'Intersection' });
+        model.addFunction('difference(a: T[], b: T[]): T[]', new Difference(this.helper), { description: 'Difference' });
+        model.addFunction('symmetricDifference(a: T[], b: T[]): T[]', new SymmetricDifference(this.helper), { description: 'Symmetric Difference' });
+    }
+}
+exports.CoreLibrary = CoreLibrary;
+class And extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new And(operand);
+    }
+    eval(context) {
+        if (!this.op.children[0].eval(context))
+            return false;
+        return this.op.children[1].eval(context);
+    }
+    async evalAsync(context) {
+        if (!(await this.op.children[0].solve(context)))
+            return false;
+        return await this.op.children[1].solve(context);
+    }
+}
+class Or extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Or(operand);
+    }
+    eval(context) {
+        if (this.op.children[0].eval(context))
+            return true;
+        return this.op.children[1].eval(context);
+    }
+    async evalAsync(context) {
+        if (await this.op.children[0].solve(context))
+            return true;
+        return await this.op.children[1].solve(context);
+    }
+}
+class Assignment extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Assignment(operand);
+    }
+    eval(context) {
+        const value = this.op.children[1].eval(context);
+        context.data.set(this.op.children[0].name, value);
+        return value;
+    }
+    async evalAsync(context) {
+        const value = await this.op.children[1].solve(context);
+        context.data.set(this.op.children[0].name, value);
+        return value;
+    }
+}
+class AssignmentOp extends domain_2.PrototypeEvaluator {
+    constructor(operate, operand) {
+        super(operand);
+        this.operate = operate;
+    }
+    clone(operand) {
+        return new AssignmentOp(this.operate, operand);
+    }
+    eval(context) {
+        const value = this.operate(this.op.children[0].eval(context), this.op.children[1].eval(context));
+        context.data.set(this.op.children[0].name, value);
+        return value;
+    }
+    async evalAsync(context) {
+        const a = await this.op.children[0].solve(context);
+        const b = await this.op.children[1].solve(context);
+        const value = this.operate(a, b);
+        context.data.set(this.op.children[0].name, value);
+        return value;
+    }
+}
+class MapEval extends domain_2.PrototypeEvaluator {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(builder, cloner, helper, operand) {
+        super(operand);
+        this.builder = builder;
+        this.cloner = cloner;
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new MapEval(this.builder, this.cloner, this.helper, operand);
+    }
+    eval(context) {
+        const rows = [];
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children[2].type === domain_1.OperandType.Obj) {
+            const groupers = [];
+            const aggregates = [];
+            for (const child of this.op.children[2].children) {
+                const keyValue = child;
+                if (keyValue) {
+                    if (this.helper.operand.haveAggregates(keyValue.children[0])) {
+                        aggregates.push(keyValue);
+                    }
+                    else {
+                        groupers.push(keyValue);
+                    }
+                }
+            }
+            if (aggregates.length > 0) {
+                const keys = this.helper.operand.getKeys(this.op.children[1], groupers, list, context);
+                const variable = this.op.children[1];
+                for (const key of keys) {
+                    for (const keyValue of aggregates) {
+                        const operandCloned = this.cloner.clone(keyValue.children[0], 'expression');
+                        const operandResolved = this.helper.operand.solveAggregates(key.items, variable, operandCloned, context);
+                        const value = operandResolved.eval(context);
+                        key.summarizers.push({ name: keyValue.name, value });
+                    }
+                }
+                for (const key of keys) {
+                    const row = {};
+                    for (const value of key.values) {
+                        row[value.name] = value.value;
+                    }
+                    for (const summarizer of key.summarizers) {
+                        row[summarizer.name] = summarizer.value;
+                    }
+                    rows.push(row);
+                }
+                return rows;
+            }
+        }
+        else if (this.op.children[2].type === domain_1.OperandType.Var && !Array.isArray(list)) {
+            // Example orders.0.number
+            return list;
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const row = this.op.children[2].eval(childContext);
+            rows.push(row);
+        }
+        return rows;
+    }
+    async evalAsync(context) {
+        const rows = [];
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children[2].type === domain_1.OperandType.Obj) {
+            const groupers = [];
+            const aggregates = [];
+            for (const child of this.op.children[2].children) {
+                const keyValue = child;
+                if (keyValue) {
+                    if (this.helper.operand.haveAggregates(keyValue.children[0])) {
+                        aggregates.push(keyValue);
+                    }
+                    else {
+                        groupers.push(keyValue);
+                    }
+                }
+            }
+            if (aggregates.length > 0) {
+                const keys = this.helper.operand.getKeys(this.op.children[1], groupers, list, context);
+                const variable = this.op.children[1];
+                for (const key of keys) {
+                    for (const keyValue of aggregates) {
+                        const operandCloned = this.cloner.clone(keyValue.children[0], 'expression');
+                        const operandResolved = this.helper.operand.solveAggregates(key.items, variable, operandCloned, context);
+                        const value = await operandResolved.solve(context);
+                        key.summarizers.push({ name: keyValue.name, value });
+                    }
+                }
+                for (const key of keys) {
+                    const row = {};
+                    for (const value of key.values) {
+                        row[value.name] = value.value;
+                    }
+                    for (const summarizer of key.summarizers) {
+                        row[summarizer.name] = summarizer.value;
+                    }
+                    rows.push(row);
+                }
+                return rows;
+            }
+        }
+        else if (this.op.children[2].type === domain_1.OperandType.Var && !Array.isArray(list)) {
+            // Example orders.0.number
+            return list;
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const row = await this.op.children[2].solve(childContext);
+            rows.push(row);
+        }
+        return rows;
+    }
+}
+class Distinct extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Distinct(this.helper, operand);
+    }
+    eval(context) {
+        const rows = [];
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            for (const item of list) {
+                if (rows.find((p) => p === item) === undefined) {
+                    rows.push(item);
+                }
+            }
+            return rows;
+        }
+        else if (this.op.children[2].type === domain_1.OperandType.Obj) {
+            const keys = this.helper.operand.getKeys(this.op.children[1], this.op.children[2].children, list, context.newContext());
+            for (const key of keys) {
+                const row = {};
+                for (const value of key.values) {
+                    row[value.name] = value.value;
+                }
+                rows.push(row);
+            }
+            return rows;
+        }
+        else if (this.op.children[2].type === domain_1.OperandType.List) {
+            throw new Error('Distinct not support Array result');
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const value = this.op.children[2].eval(childContext);
+            if (rows.find((p) => p === value) === undefined) {
+                rows.push(value);
+            }
+        }
+        return rows;
+    }
+    async evalAsync(context) {
+        const rows = [];
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            for (const item of list) {
+                if (rows.find((p) => p === item) === undefined) {
+                    rows.push(item);
+                }
+            }
+            return rows;
+        }
+        else if (this.op.children[2].type === domain_1.OperandType.Obj) {
+            const keys = this.helper.operand.getKeys(this.op.children[1], this.op.children[2].children, list, context.newContext());
+            for (const key of keys) {
+                const row = {};
+                for (const value of key.values) {
+                    row[value.name] = value.value;
+                }
+                rows.push(row);
+            }
+            return rows;
+        }
+        else if (this.op.children[2].type === domain_1.OperandType.List) {
+            throw new Error('Distinct not support Array result');
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const value = await this.op.children[2].solve(childContext);
+            if (rows.find((p) => p === value) === undefined) {
+                rows.push(value);
+            }
+        }
+        return rows;
+    }
+}
+class Foreach extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Foreach(operand);
+    }
+    eval(context) {
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            this.op.children[2].eval(childContext);
+        }
+        return list;
+    }
+    async evalAsync(context) {
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            await this.op.children[2].solve(childContext);
+        }
+        return list;
+    }
+}
+class Filter extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Filter(operand);
+    }
+    eval(context) {
+        const rows = [];
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            if (this.op.children[2].eval(childContext)) {
+                rows.push(item);
+            }
+        }
+        return rows;
+    }
+    async evalAsync(context) {
+        const rows = [];
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            if (await this.op.children[2].solve(childContext)) {
+                rows.push(item);
+            }
+        }
+        return rows;
+    }
+}
+class Reverse extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Reverse(operand);
+    }
+    eval(context) {
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list.reverse();
+        }
+        const values = [];
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const value = this.op.children[2].eval(childContext);
+            values.push({ value, p: item });
+        }
+        values.sort((a, b) => a.value > b.value ? 1 : a.value < b.value ? -1 : 0);
+        values.reverse();
+        return values.map(p => p.p);
+    }
+    async evalAsync(context) {
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list.reverse();
+        }
+        const values = [];
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const value = await this.op.children[2].solve(childContext);
+            values.push({ value, p: item });
+        }
+        values.sort((a, b) => a.value > b.value ? 1 : a.value < b.value ? -1 : 0);
+        values.reverse();
+        return values.map(p => p.p);
+    }
+}
+class Sort extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Sort(operand);
+    }
+    eval(context) {
+        const values = [];
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list.sort();
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const value = this.op.children[2].eval(childContext);
+            values.push({ value, p: item });
+        }
+        values.sort((a, b) => a.value > b.value ? 1 : a.value < b.value ? -1 : 0);
+        return values.map(p => p.p);
+    }
+    async evalAsync(context) {
+        const values = [];
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list.sort();
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            const value = await this.op.children[2].solve(childContext);
+            values.push({ value, p: item });
+        }
+        values.sort((a, b) => a.value > b.value ? 1 : a.value < b.value ? -1 : 0);
+        return values.map(p => p.p);
+    }
+}
+class Remove extends domain_2.PrototypeEvaluator {
+    clone(operand) {
+        return new Remove(operand);
+    }
+    eval(context) {
+        const rows = [];
+        const list = this.op.children[0].eval(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            if (!this.op.children[2].eval(childContext)) {
+                rows.push(item);
+            }
+        }
+        return rows;
+    }
+    async evalAsync(context) {
+        const rows = [];
+        const list = await this.op.children[0].solve(context);
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        const childContext = context.newContext();
+        for (const item of list) {
+            childContext.data.set(this.op.children[1].name, item);
+            if (!(await this.op.children[2].solve(childContext))) {
+                rows.push(item);
+            }
+        }
+        return rows;
+    }
+}
+class First extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new First(this.helper, operand);
+    }
+    eval(context) {
+        return this.first(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.first(await this.op.children[0].solve(context), context);
+    }
+    first(list, context) {
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list && list.length > 0 ? list[0] : null;
+        }
+        return this.helper.operand.first(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Last extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Last(this.helper, operand);
+    }
+    eval(context) {
+        return this.last(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.last(await this.op.children[0].solve(context), context);
+    }
+    last(list, context) {
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list && list.length > 0 ? list[list.length - 1] : null;
+        }
+        return this.helper.operand.last(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Count extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Count(this.helper, operand);
+    }
+    eval(context) {
+        return this.count(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.count(await this.op.children[0].solve(context), context);
+    }
+    count(list, context) {
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            return list.length;
+        }
+        return this.helper.operand.count(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Max extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Max(this.helper, operand);
+    }
+    eval(context) {
+        return this.max(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.max(await this.op.children[0].solve(context), context);
+    }
+    max(list, context) {
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            let max;
+            for (const item of list) {
+                if (max === undefined || (item !== null && item > max)) {
+                    max = item;
+                }
+            }
+            return max;
+        }
+        return this.helper.operand.max(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Min extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Min(this.helper, operand);
+    }
+    eval(context) {
+        return this.min(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.min(await this.op.children[0].solve(context), context);
+    }
+    min(list, context) {
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            let min;
+            for (const item of list) {
+                if (min === undefined || (item !== null && item < min)) {
+                    min = item;
+                }
+            }
+            return min;
+        }
+        return this.helper.operand.min(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Avg extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Avg(this.helper, operand);
+    }
+    eval(context) {
+        return this.avg(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.avg(await this.op.children[0].solve(context), context);
+    }
+    avg(list, context) {
+        if (this.op.children.length === 1) {
+            let sum = 0;
+            for (const item of list) {
+                if (item !== null) {
+                    sum = sum + item;
+                }
+            }
+            return list.length > 0 ? sum / list.length : 0;
+        }
+        return this.helper.operand.avg(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Sum extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Sum(this.helper, operand);
+    }
+    eval(context) {
+        return this.sum(this.op.children[0].eval(context), context);
+    }
+    async evalAsync(context) {
+        return this.sum(await this.op.children[0].solve(context), context);
+    }
+    sum(list, context) {
+        if (!list) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (this.op.children.length === 1) {
+            let sum = 0;
+            for (const item of list) {
+                if (item !== null) {
+                    sum = sum + item;
+                }
+            }
+            return sum;
+        }
+        return this.helper.operand.sum(list, this.op.children[1], this.op.children[2], context.newContext());
+    }
+}
+class Union extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Union(this.helper, operand);
+    }
+    eval(context) {
+        const a = this.op.children[0].eval(context);
+        const b = this.op.children[1].eval(context);
+        return this.union(a, b);
+    }
+    async evalAsync(context) {
+        const a = await this.op.children[0].solve(context);
+        const b = await this.op.children[1].solve(context);
+        return this.union(a, b);
+    }
+    union(a, b) {
+        if (a.length === 0) {
+            return b;
+        }
+        if (b.length === 0) {
+            return a;
+        }
+        let result = [];
+        if (Array.isArray(a[0]) || Array.isArray(b[0])) {
+            throw new Error('Cannot union arrays of arrays');
+        }
+        else if (typeof a[0] === 'object') {
+            for (const element of a) {
+                const key = this.helper.operand.objectKey(element);
+                result.push({ key, value: element });
+            }
+            for (const element of b) {
+                const key = this.helper.operand.objectKey(element);
+                if (!result.find((p) => p.key === key)) {
+                    result.push({ key, value: element });
+                }
+            }
+            return result.map((p) => p.value);
+        }
+        result = result.concat(a);
+        for (const element of b) {
+            if (!result.includes(element)) {
+                result.push(element);
+            }
+        }
+        return result;
+    }
+}
+class Intersection extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Intersection(this.helper, operand);
+    }
+    eval(context) {
+        const a = this.op.children[0].eval(context);
+        const b = this.op.children[1].eval(context);
+        return this.intersection(a, b);
+    }
+    async evalAsync(context) {
+        const a = await this.op.children[0].solve(context);
+        const b = await this.op.children[1].solve(context);
+        return this.intersection(a, b);
+    }
+    intersection(a, b) {
+        if (!a) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (!b) {
+            throw new Error(`Array ${this.op.children[1].name} undefined`);
+        }
+        if (a.length === 0 || b.length === 0) {
+            return [];
+        }
+        const result = [];
+        if (Array.isArray(a[0]) || Array.isArray(b[0])) {
+            throw new Error('Cannot intersect arrays of arrays');
+        }
+        else if (typeof a[0] === 'object') {
+            const keys = a.map((p) => this.helper.operand.objectKey(p));
+            for (const element of b) {
+                const key = this.helper.operand.objectKey(element);
+                if (keys.includes(key)) {
+                    result.push(element);
+                }
+            }
+            return result;
+        }
+        else {
+            for (const element of b) {
+                if (a.includes(element)) {
+                    result.push(element);
+                }
+            }
+            return result;
+        }
+    }
+}
+class Difference extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new Difference(this.helper, operand);
+    }
+    eval(context) {
+        const a = this.op.children[0].eval(context);
+        const b = this.op.children[1].eval(context);
+        return this.difference(a, b);
+    }
+    async evalAsync(context) {
+        const a = await this.op.children[0].solve(context);
+        const b = await this.op.children[1].solve(context);
+        return this.difference(a, b);
+    }
+    difference(a, b) {
+        if (!a) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (!b) {
+            throw new Error(`Array ${this.op.children[1].name} undefined`);
+        }
+        if (a.length === 0) {
+            return [];
+        }
+        if (b.length === 0) {
+            return a;
+        }
+        const result = [];
+        if (Array.isArray(a[0]) || Array.isArray(b[0])) {
+            throw new Error('Cannot difference arrays of arrays');
+        }
+        else if (typeof a[0] === 'object') {
+            const keys = b.map((p) => this.helper.operand.objectKey(p));
+            for (const element of a) {
+                const key = this.helper.operand.objectKey(element);
+                if (!keys.includes(key)) {
+                    result.push(element);
+                }
+            }
+            return result;
+        }
+        else {
+            for (const element of a) {
+                if (!b.includes(element)) {
+                    result.push(element);
+                }
+            }
+            return result;
+        }
+    }
+}
+class SymmetricDifference extends domain_2.PrototypeEvaluator {
+    constructor(helper, operand) {
+        super(operand);
+        this.helper = helper;
+    }
+    clone(operand) {
+        return new SymmetricDifference(this.helper, operand);
+    }
+    eval(context) {
+        const a = this.op.children[0].eval(context);
+        const b = this.op.children[1].eval(context);
+        return this.symmetricDifference(a, b);
+    }
+    async evalAsync(context) {
+        const a = await this.op.children[0].solve(context);
+        const b = await this.op.children[1].solve(context);
+        return this.symmetricDifference(a, b);
+    }
+    symmetricDifference(a, b) {
+        if (!a) {
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        }
+        if (!b) {
+            throw new Error(`Array ${this.op.children[1].name} undefined`);
+        }
+        if (a.length === 0) {
+            return b;
+        }
+        if (b.length === 0) {
+            return a;
+        }
+        const result = [];
+        if (Array.isArray(a[0]) || Array.isArray(b[0])) {
+            throw new Error('Cannot compute symmetric difference of arrays of arrays');
+        }
+        else if (typeof a[0] === 'object') {
+            const aKeys = a.map((p) => this.helper.operand.objectKey(p));
+            const bKeys = b.map((p) => this.helper.operand.objectKey(p));
+            for (const element of a) {
+                const key = this.helper.operand.objectKey(element);
+                if (!bKeys.includes(key)) {
+                    result.push(element);
+                }
+            }
+            for (const element of b) {
+                const key = this.helper.operand.objectKey(element);
+                if (!aKeys.includes(key)) {
+                    result.push(element);
+                }
+            }
+            return result;
+        }
+        else {
+            for (const element of a) {
+                if (!b.includes(element)) {
+                    result.push(element);
+                }
+            }
+            for (const element of b) {
+                if (!a.includes(element)) {
+                    result.push(element);
+                }
+            }
+            return result;
+        }
+    }
+}
+class AggregateEval extends domain_2.PrototypeEvaluator {
+    getList(context) {
+        const list = this.op.children[0].eval(context);
+        if (!list)
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        return list;
+    }
+    async getListAsync(context) {
+        const list = await this.op.children[0].solve(context);
+        if (!list)
+            throw new Error(`Array ${this.op.children[0].name} undefined`);
+        return list;
+    }
+    evalValues(list, context) {
+        if (this.op.children.length === 1)
+            return list.filter(v => v !== null && v !== undefined);
+        const values = [];
+        const ctx = context.newContext();
+        for (const item of list) {
+            ctx.data.set(this.op.children[1].name, item);
+            const v = this.op.children[2].eval(ctx);
+            if (v !== null && v !== undefined)
+                values.push(v);
+        }
+        return values;
+    }
+    async evalValuesAsync(list, context) {
+        if (this.op.children.length === 1)
+            return list.filter(v => v !== null && v !== undefined);
+        const values = [];
+        const ctx = context.newContext();
+        for (const item of list) {
+            ctx.data.set(this.op.children[1].name, item);
+            const v = await this.op.children[2].solve(ctx);
+            if (v !== null && v !== undefined)
+                values.push(v);
+        }
+        return values;
+    }
+}
+class CountDistinct extends AggregateEval {
+    clone(operand) { return new CountDistinct(operand); }
+    eval(context) { return new Set(this.evalValues(this.getList(context), context)).size; }
+    async evalAsync(context) {
+        return new Set(await this.evalValuesAsync(await this.getListAsync(context), context)).size;
+    }
+}
+class SumDistinct extends AggregateEval {
+    clone(operand) { return new SumDistinct(operand); }
+    eval(context) { return [...new Set(this.evalValues(this.getList(context), context))].reduce((s, v) => s + v, 0); }
+    async evalAsync(context) {
+        return [...new Set(await this.evalValuesAsync(await this.getListAsync(context), context))].reduce((s, v) => s + v, 0);
+    }
+}
+class AvgDistinct extends AggregateEval {
+    clone(operand) { return new AvgDistinct(operand); }
+    eval(context) { return this.compute(this.evalValues(this.getList(context), context)); }
+    async evalAsync(context) { return this.compute(await this.evalValuesAsync(await this.getListAsync(context), context)); }
+    compute(values) {
+        const distinct = [...new Set(values)];
+        return distinct.length === 0 ? 0 : distinct.reduce((s, v) => s + v, 0) / distinct.length;
+    }
+}
+class Median extends AggregateEval {
+    clone(operand) { return new Median(operand); }
+    eval(context) { return this.compute(this.evalValues(this.getList(context), context)); }
+    async evalAsync(context) { return this.compute(await this.evalValuesAsync(await this.getListAsync(context), context)); }
+    compute(values) {
+        if (!values.length)
+            return null;
+        const sorted = [...values].sort((a, b) => a - b);
+        const mid = Math.floor(sorted.length / 2);
+        return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    }
+}
+class StdDevEval extends AggregateEval {
+    constructor(population, operand) {
+        super(operand);
+        this.population = population;
+    }
+    clone(operand) { return new StdDevEval(this.population, operand); }
+    eval(context) { return this.compute(this.evalValues(this.getList(context), context)); }
+    async evalAsync(context) { return this.compute(await this.evalValuesAsync(await this.getListAsync(context), context)); }
+    compute(values) {
+        const n = values.length;
+        if (n === 0)
+            return 0;
+        const mean = values.reduce((s, v) => s + v, 0) / n;
+        const divisor = this.population ? n : n - 1;
+        if (divisor === 0)
+            return 0;
+        return Math.sqrt(values.reduce((s, v) => s + (v - mean) ** 2, 0) / divisor);
+    }
+}
+class VarianceEval extends AggregateEval {
+    constructor(population, operand) {
+        super(operand);
+        this.population = population;
+    }
+    clone(operand) { return new VarianceEval(this.population, operand); }
+    eval(context) { return this.compute(this.evalValues(this.getList(context), context)); }
+    async evalAsync(context) { return this.compute(await this.evalValuesAsync(await this.getListAsync(context), context)); }
+    compute(values) {
+        const n = values.length;
+        if (n === 0)
+            return 0;
+        const mean = values.reduce((s, v) => s + v, 0) / n;
+        const divisor = this.population ? n : n - 1;
+        if (divisor === 0)
+            return 0;
+        return values.reduce((s, v) => s + (v - mean) ** 2, 0) / divisor;
+    }
+}
+class BoolAndEval extends AggregateEval {
+    clone(operand) { return new BoolAndEval(operand); }
+    eval(context) { return this.evalValues(this.getList(context), context).every(v => !!v); }
+    async evalAsync(context) { return (await this.evalValuesAsync(await this.getListAsync(context), context)).every(v => !!v); }
+}
+class BoolOrEval extends AggregateEval {
+    clone(operand) { return new BoolOrEval(operand); }
+    eval(context) { return this.evalValues(this.getList(context), context).some(v => !!v); }
+    async evalAsync(context) { return (await this.evalValuesAsync(await this.getListAsync(context), context)).some(v => !!v); }
+}
+class BitAndAgg extends AggregateEval {
+    clone(operand) { return new BitAndAgg(operand); }
+    eval(context) { return this.evalValues(this.getList(context), context).reduce((acc, v) => acc & v, -1); }
+    async evalAsync(context) { return (await this.evalValuesAsync(await this.getListAsync(context), context)).reduce((acc, v) => acc & v, -1); }
+}
+class BitOrAgg extends AggregateEval {
+    clone(operand) { return new BitOrAgg(operand); }
+    eval(context) { return this.evalValues(this.getList(context), context).reduce((acc, v) => acc | v, 0); }
+    async evalAsync(context) { return (await this.evalValuesAsync(await this.getListAsync(context), context)).reduce((acc, v) => acc | v, 0); }
+}
+class RankEval extends domain_2.PrototypeEvaluator {
+    constructor(dense, operand) {
+        super(operand);
+        this.dense = dense;
+    }
+    clone(operand) { return new RankEval(this.dense, operand); }
+    eval(context) { return this.computeRank(this.extractValues(this.op.children[0].eval(context), context)); }
+    async evalAsync(context) { return this.computeRank(await this.extractValuesAsync(await this.op.children[0].solve(context), context)); }
+    extractValues(list, context) {
+        if (this.op.children.length === 1)
+            return list;
+        const values = [];
+        const ctx = context.newContext();
+        for (const item of list) {
+            ctx.data.set(this.op.children[1].name, item);
+            values.push(this.op.children[2].eval(ctx));
+        }
+        return values;
+    }
+    async extractValuesAsync(list, context) {
+        if (this.op.children.length === 1)
+            return list;
+        const values = [];
+        const ctx = context.newContext();
+        for (const item of list) {
+            ctx.data.set(this.op.children[1].name, item);
+            values.push(await this.op.children[2].solve(ctx));
+        }
+        return values;
+    }
+    computeRank(values) {
+        const sorted = [...new Set(values)].sort((a, b) => a > b ? 1 : -1);
+        if (this.dense)
+            return values.map(v => sorted.indexOf(v) + 1);
+        const rankMap = new Map();
+        let rank = 1;
+        for (const v of sorted) {
+            rankMap.set(v, rank);
+            rank += values.filter(x => x === v).length;
+        }
+        return values.map(v => rankMap.get(v));
+    }
+}
+//# sourceMappingURL=library.js.map