@elwood-lang/core 0.1.0

package/dist/evaluator.js

@@ -0,0 +1,879 @@
+import { Scope } from './scope.js';
+// ── Helpers ──
+function isArray(v) { return Array.isArray(v); }
+function isObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function toArray(v) {
+    if (isArray(v))
+        return v;
+    return [v];
+}
+function isTruthy(v) {
+    if (v === null || v === undefined)
+        return false;
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    if (typeof v === 'string')
+        return v !== '';
+    if (isArray(v))
+        return v.length > 0;
+    return true;
+}
+function valuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return a === b;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a === 'number' && typeof b === 'number')
+        return Math.abs(a - b) < 1e-10;
+    if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => valuesEqual(v, b[i]));
+    }
+    if (isObject(a) && isObject(b)) {
+        const ka = Object.keys(a), kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        return ka.every(k => valuesEqual(a[k], b[k]));
+    }
+    return false;
+}
+function serialize(v) {
+    if (v === null || v === undefined)
+        return 'null';
+    if (typeof v === 'string')
+        return JSON.stringify(v);
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return JSON.stringify(v);
+}
+function valueToString(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number')
+        return String(v);
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    return JSON.stringify(v);
+}
+function getProperty(obj, name) {
+    if (isObject(obj))
+        return obj[name] ?? null;
+    // Auto-map over arrays
+    if (isArray(obj))
+        return obj.map(item => getProperty(item, name)).filter(v => v !== null);
+    return null;
+}
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const d = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        d[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= m; i++)
+        for (let j = 1; j <= n; j++)
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    return d[m][n];
+}
+function suggestProperty(attempted, obj) {
+    if (!isObject(obj))
+        return undefined;
+    const names = Object.keys(obj);
+    if (names.length === 0)
+        return undefined;
+    const closest = names
+        .map(n => ({ n, d: levenshtein(attempted.toLowerCase(), n.toLowerCase()) }))
+        .filter(x => x.d <= 3)
+        .sort((a, b) => a.d - b.d)[0];
+    if (closest)
+        return `Did you mean '${closest.n}'? Available: ${names.slice(0, 10).join(', ')}`;
+    return `Available properties: ${names.slice(0, 10).join(', ')}`;
+}
+// ── Memoized Function ──
+class MemoizedFunction {
+    lambda;
+    closure;
+    evalFn;
+    cache = new Map();
+    constructor(lambda, closure, evalFn) {
+        this.lambda = lambda;
+        this.closure = closure;
+        this.evalFn = evalFn;
+    }
+    invoke(args, _current) {
+        const key = args.map(serialize).join('|');
+        if (this.cache.has(key))
+            return this.cache.get(key);
+        const childScope = this.closure.child();
+        for (let i = 0; i < this.lambda.parameters.length && i < args.length; i++)
+            childScope.set(this.lambda.parameters[i], args[i]);
+        const root = this.closure.get('$root') ?? _current;
+        const result = this.evalFn(this.lambda.body, root, childScope);
+        this.cache.set(key, result);
+        return result;
+    }
+}
+// ── Main Evaluator ──
+export function evaluateExpression(expr, input) {
+    const scope = new Scope();
+    scope.set('$root', input);
+    return evaluate(expr, input, scope);
+}
+export function evaluateScript(script, input) {
+    const scope = new Scope();
+    scope.set('$root', input);
+    for (const binding of script.bindings) {
+        scope.set(binding.name, evaluate(binding.value, input, scope));
+    }
+    if (script.returnExpression)
+        return evaluate(script.returnExpression, input, scope);
+    return null;
+}
+function evaluate(expr, current, scope) {
+    switch (expr.type) {
+        case 'Literal': return expr.value;
+        case 'Path': return evalPath(expr, current, scope);
+        case 'Identifier': return evalIdentifier(expr, scope);
+        case 'Binary': return evalBinary(expr, current, scope);
+        case 'Unary': return evalUnary(expr, current, scope);
+        case 'If': return isTruthy(evaluate(expr.condition, current, scope))
+            ? evaluate(expr.thenBranch, current, scope)
+            : evaluate(expr.elseBranch, current, scope);
+        case 'Object': return evalObject(expr, current, scope);
+        case 'Array': return expr.items.map(i => evaluate(i, current, scope));
+        case 'Pipeline': return evalPipeline(expr, current, scope);
+        case 'MemberAccess': return evalMemberAccess(expr, current, scope);
+        case 'MethodCall': return evalMethodCall(expr, current, scope);
+        case 'FunctionCall': return evalFunctionCall(expr, current, scope);
+        case 'Index': return evalIndex(expr, current, scope);
+        case 'InterpolatedString': return evalInterpolation(expr, current, scope);
+        case 'Match': return evalMatch(expr, current, scope);
+        case 'Memo': return new MemoizedFunction(expr.lambda, scope, evaluate);
+        case 'Lambda': throw new Error('Lambda cannot be evaluated directly');
+    }
+}
+// ── Path evaluation ──
+function evalPath(expr, current, scope) {
+    let value = expr.isRooted ? (scope.get('$root') ?? current) : current;
+    for (const seg of expr.segments) {
+        switch (seg.type) {
+            case 'Property':
+                if (isArray(value)) {
+                    value = value.map(item => isObject(item) ? item[seg.name] : null).filter(v => v !== null);
+                }
+                else if (isObject(value)) {
+                    const prop = value[seg.name];
+                    if (prop === undefined) {
+                        const suggestion = suggestProperty(seg.name, value);
+                        throw new Error(`Property '${seg.name}' not found on Object.${suggestion ? ' ' + suggestion : ''}`);
+                    }
+                    value = prop;
+                }
+                else {
+                    return null;
+                }
+                break;
+            case 'Index':
+                if (seg.index === null)
+                    value = toArray(value); // [*]
+                else
+                    value = toArray(value)[seg.index] ?? null;
+                break;
+            case 'Slice': {
+                const arr = toArray(value);
+                let s = seg.start ?? 0, e = seg.end ?? arr.length;
+                if (s < 0)
+                    s = Math.max(0, arr.length + s);
+                if (e < 0)
+                    e = Math.max(0, arr.length + e);
+                value = arr.slice(s, e);
+                break;
+            }
+            case 'RecursiveDescent': {
+                const results = [];
+                collectRecursive(value, seg.name, results);
+                value = results;
+                break;
+            }
+        }
+    }
+    return value;
+}
+function collectRecursive(value, name, results) {
+    if (isObject(value)) {
+        if (name in value)
+            results.push(value[name]);
+        for (const k of Object.keys(value))
+            collectRecursive(value[k], name, results);
+    }
+    else if (isArray(value)) {
+        for (const item of value)
+            collectRecursive(item, name, results);
+    }
+}
+function evalIdentifier(expr, scope) {
+    const val = scope.get(expr.name);
+    if (val === undefined)
+        throw new Error(`Undefined variable '${expr.name}'.`);
+    return val;
+}
+// ── Binary / Unary ──
+function evalBinary(expr, current, scope) {
+    const left = evaluate(expr.left, current, scope);
+    const right = evaluate(expr.right, current, scope);
+    switch (expr.operator) {
+        case 'Add':
+            if (typeof left === 'string' || typeof right === 'string')
+                return valueToString(left) + valueToString(right);
+            return left + right;
+        case 'Subtract': return left - right;
+        case 'Multiply': return left * right;
+        case 'Divide': return right !== 0 ? left / right : 0;
+        case 'Equal': return valuesEqual(left, right);
+        case 'NotEqual': return !valuesEqual(left, right);
+        case 'LessThan':
+            if (typeof left === 'string' && typeof right === 'string')
+                return left < right;
+            return left < right;
+        case 'LessThanOrEqual':
+            if (typeof left === 'string' && typeof right === 'string')
+                return left <= right;
+            return left <= right;
+        case 'GreaterThan':
+            if (typeof left === 'string' && typeof right === 'string')
+                return left > right;
+            return left > right;
+        case 'GreaterThanOrEqual':
+            if (typeof left === 'string' && typeof right === 'string')
+                return left >= right;
+            return left >= right;
+        case 'And': return isTruthy(left) && isTruthy(right);
+        case 'Or': return isTruthy(left) || isTruthy(right);
+    }
+}
+function evalUnary(expr, current, scope) {
+    const operand = evaluate(expr.operand, current, scope);
+    return expr.operator === 'Not' ? !isTruthy(operand) : -operand;
+}
+// ── Object ──
+function evalObject(expr, current, scope) {
+    const result = {};
+    for (const p of expr.properties) {
+        if (p.isSpread) {
+            const spread = evaluate(p.value, current, scope);
+            if (isObject(spread))
+                Object.assign(result, spread);
+        }
+        else if (p.computedKey) {
+            const key = valueToString(evaluate(p.computedKey, current, scope));
+            result[key] = evaluate(p.value, current, scope);
+        }
+        else {
+            result[p.key] = evaluate(p.value, current, scope);
+        }
+    }
+    return result;
+}
+// ── Pipeline ──
+function evalPipeline(expr, current, scope) {
+    let value = evaluate(expr.source, current, scope);
+    for (const op of expr.operations) {
+        value = evalPipeOp(op, value, scope);
+    }
+    return value;
+}
+function evalWithLambdaOrImplicit(expr, item, scope) {
+    if (expr.type === 'Lambda') {
+        const child = scope.child();
+        if (expr.parameters.length >= 1)
+            child.set(expr.parameters[0], item);
+        child.set('$root', item);
+        return evaluate(expr.body, item, child);
+    }
+    const child = scope.child();
+    child.set('$root', item);
+    return evaluate(expr, item, child);
+}
+function evalPipeOp(op, input, scope) {
+    const items = toArray(input);
+    switch (op.type) {
+        case 'Where': return items.filter(item => isTruthy(evalWithLambdaOrImplicit(op.predicate, item, scope)));
+        case 'Select': return items.map(item => evalWithLambdaOrImplicit(op.projection, item, scope));
+        case 'SelectMany': return items.flatMap(item => {
+            const r = evalWithLambdaOrImplicit(op.projection, item, scope);
+            return isArray(r) ? r : [r];
+        });
+        case 'Distinct': {
+            const seen = new Set();
+            return items.filter(item => { const k = serialize(item); if (seen.has(k))
+                return false; seen.add(k); return true; });
+        }
+        case 'Aggregate': return evalAggregate(op, items, scope);
+        case 'Slice':
+            return op.kind === 'take' ? items.slice(0, evaluate(op.count, input, scope))
+                : items.slice(evaluate(op.count, input, scope));
+        case 'OrderBy': return evalOrderBy(op, items, scope);
+        case 'GroupBy': return evalGroupBy(op, items, scope);
+        case 'Batch': {
+            const size = evaluate(op.size, input, scope);
+            const batches = [];
+            for (let i = 0; i < items.length; i += size)
+                batches.push(items.slice(i, i + size));
+            return batches;
+        }
+        case 'Concat': {
+            const sep = op.separator ? valueToString(evaluate(op.separator, input, scope)) : '|';
+            return items.map(valueToString).join(sep);
+        }
+        case 'Reduce': return evalReduce(op, items, scope);
+        case 'Join': return evalJoin(op, items, scope);
+        case 'Quantifier':
+            return op.kind === 'all'
+                ? items.every(item => isTruthy(evalWithLambdaOrImplicit(op.predicate, item, scope)))
+                : items.some(item => isTruthy(evalWithLambdaOrImplicit(op.predicate, item, scope)));
+        case 'MatchOp': return evalMatchArms(op.arms, input, scope);
+    }
+}
+function evalAggregate(op, items, scope) {
+    if (op.name === 'first') {
+        if (op.predicate) {
+            return items.find(item => isTruthy(evalWithLambdaOrImplicit(op.predicate, item, scope))) ?? null;
+        }
+        return items[0] ?? null;
+    }
+    if (op.name === 'last' && op.predicate) {
+        return [...items].reverse().find(item => isTruthy(evalWithLambdaOrImplicit(op.predicate, item, scope))) ?? null;
+    }
+    switch (op.name) {
+        case 'count': return items.length;
+        case 'last': return items[items.length - 1] ?? null;
+        case 'sum': return items.reduce((a, b) => a + b, 0);
+        case 'min': return Math.min(...items.map(Number));
+        case 'max': return Math.max(...items.map(Number));
+        case 'index': return items.map((_, i) => i);
+        default: throw new Error(`Unknown aggregate: ${op.name}`);
+    }
+}
+function evalOrderBy(op, items, scope) {
+    return [...items].sort((a, b) => {
+        for (const { key, ascending } of op.keys) {
+            const ka = evalWithLambdaOrImplicit(key, a, scope);
+            const kb = evalWithLambdaOrImplicit(key, b, scope);
+            let cmp = 0;
+            if (typeof ka === 'string' && typeof kb === 'string')
+                cmp = ka.localeCompare(kb);
+            else if (typeof ka === 'number' && typeof kb === 'number')
+                cmp = ka - kb;
+            else
+                cmp = String(ka).localeCompare(String(kb));
+            if (cmp !== 0)
+                return ascending ? cmp : -cmp;
+        }
+        return 0;
+    });
+}
+function evalGroupBy(op, items, scope) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = evalWithLambdaOrImplicit(op.keySelector, item, scope);
+        const keyStr = serialize(key);
+        if (!groups.has(keyStr))
+            groups.set(keyStr, { key, items: [] });
+        groups.get(keyStr).items.push(item);
+    }
+    return [...groups.values()];
+}
+function evalReduce(op, items, scope) {
+    if (items.length === 0)
+        return op.initialValue ? evaluate(op.initialValue, null, scope) : null;
+    const lambda = op.accumulator;
+    if (lambda.type !== 'Lambda' || lambda.parameters.length < 2)
+        throw new Error('reduce requires (acc, item) => expr');
+    let acc;
+    let startIdx;
+    if (op.initialValue) {
+        acc = evaluate(op.initialValue, null, scope);
+        startIdx = 0;
+    }
+    else {
+        acc = items[0];
+        startIdx = 1;
+    }
+    for (let i = startIdx; i < items.length; i++) {
+        const child = scope.child();
+        child.set(lambda.parameters[0], acc);
+        child.set(lambda.parameters[1], items[i]);
+        acc = evaluate(lambda.body, items[i], child);
+    }
+    return acc;
+}
+function evalJoin(op, leftItems, scope) {
+    const root = scope.get('$root');
+    const rightItems = toArray(evaluate(op.source, root, scope));
+    const rightLookup = new Map();
+    for (const r of rightItems) {
+        const key = serialize(evalWithLambdaOrImplicit(op.rightKey, r, scope));
+        if (!rightLookup.has(key))
+            rightLookup.set(key, []);
+        rightLookup.get(key).push(r);
+    }
+    const matchedRight = new Set();
+    const results = [];
+    for (const l of leftItems) {
+        const key = serialize(evalWithLambdaOrImplicit(op.leftKey, l, scope));
+        const matches = rightLookup.get(key);
+        if (matches) {
+            matchedRight.add(key);
+            for (const r of matches)
+                results.push(mergeJoin(l, r, op.intoAlias));
+        }
+        else if (op.mode === 'left' || op.mode === 'full') {
+            results.push(mergeJoin(l, null, op.intoAlias));
+        }
+    }
+    if (op.mode === 'right' || op.mode === 'full') {
+        for (const r of rightItems) {
+            const key = serialize(evalWithLambdaOrImplicit(op.rightKey, r, scope));
+            if (!matchedRight.has(key))
+                results.push(mergeJoin(null, r, op.intoAlias));
+        }
+    }
+    return results;
+}
+function mergeJoin(left, right, alias) {
+    const result = {};
+    if (isObject(left))
+        Object.assign(result, left);
+    if (alias) {
+        result[alias] = right;
+    }
+    else if (isObject(right)) {
+        for (const [k, v] of Object.entries(right))
+            if (!(k in result))
+                result[k] = v;
+    }
+    return result;
+}
+// ── Match ──
+function evalMatch(expr, current, scope) {
+    const input = evaluate(expr.input, current, scope);
+    return evalMatchArms(expr.arms, input, scope);
+}
+function evalMatchArms(arms, input, scope) {
+    for (const arm of arms) {
+        if (arm.pattern === null)
+            return evaluate(arm.result, input, scope);
+        const pattern = evaluate(arm.pattern, input, scope);
+        if (valuesEqual(input, pattern))
+            return evaluate(arm.result, input, scope);
+    }
+    return null;
+}
+// ── Member access / Method call / Function call / Index ──
+function evalMemberAccess(expr, current, scope) {
+    const target = evaluate(expr.target, current, scope);
+    if (isObject(target))
+        return target[expr.memberName] ?? null;
+    return null;
+}
+function evalMethodCall(expr, current, scope) {
+    const target = evaluate(expr.target, current, scope);
+    const args = expr.arguments.map(a => evaluate(a, current, scope));
+    return callBuiltin(expr.methodName, target, args, scope);
+}
+function evalFunctionCall(expr, current, scope) {
+    // Check for memoized functions
+    const funcVal = scope.get(expr.functionName);
+    if (funcVal instanceof MemoizedFunction) {
+        const args = expr.arguments.map(a => evaluate(a, current, scope));
+        return funcVal.invoke(args, current);
+    }
+    const args = expr.arguments.map(a => evaluate(a, current, scope));
+    return callBuiltin(expr.functionName, current, args, scope);
+}
+function evalIndex(expr, current, scope) {
+    const target = evaluate(expr.target, current, scope);
+    if (expr.index === null)
+        return toArray(target);
+    const idx = evaluate(expr.index, current, scope);
+    return toArray(target)[idx] ?? null;
+}
+function evalInterpolation(expr, current, scope) {
+    return expr.parts.map(p => p.type === 'Text' ? p.text : valueToString(evaluate(p.expression, current, scope))).join('');
+}
+// ── Built-in Methods ──
+function callBuiltin(name, target, args, _scope) {
+    const str = () => typeof target === 'string' ? target : valueToString(target);
+    const num = () => typeof target === 'number' ? target : Number(target) || 0;
+    const arr = () => toArray(target);
+    switch (name) {
+        // String
+        case 'toLower': {
+            if (args.length === 1 && typeof args[0] === 'number') {
+                const s = str(), pos = args[0] - 1;
+                return pos >= 0 && pos < s.length ? s.slice(0, pos) + s[pos].toLowerCase() + s.slice(pos + 1) : s;
+            }
+            return str().toLowerCase();
+        }
+        case 'toUpper': {
+            if (args.length === 1 && typeof args[0] === 'number') {
+                const s = str(), pos = args[0] - 1;
+                return pos >= 0 && pos < s.length ? s.slice(0, pos) + s[pos].toUpperCase() + s.slice(pos + 1) : s;
+            }
+            return str().toUpperCase();
+        }
+        case 'trim': return args.length > 0 ? trimChars(str(), valueToString(args[0])) : str().trim();
+        case 'trimStart': return args.length > 0 ? trimStartChars(str(), valueToString(args[0])) : str().trimStart();
+        case 'trimEnd': return args.length > 0 ? trimEndChars(str(), valueToString(args[0])) : str().trimEnd();
+        case 'left': {
+            const s = str(), n = args.length > 0 ? Number(args[0]) : 1;
+            return s.slice(0, Math.min(n, s.length));
+        }
+        case 'right': {
+            const s = str(), n = args.length > 0 ? Number(args[0]) : 1;
+            return s.slice(-Math.min(n, s.length));
+        }
+        case 'padLeft': return str().padStart(Number(args[0]), args.length > 1 ? valueToString(args[1]) : ' ');
+        case 'padRight': return str().padEnd(Number(args[0]), args.length > 1 ? valueToString(args[1]) : ' ');
+        case 'contains': return str().toLowerCase().includes(valueToString(args[0]).toLowerCase());
+        case 'startsWith': return str().toLowerCase().startsWith(valueToString(args[0]).toLowerCase());
+        case 'endsWith': return str().toLowerCase().endsWith(valueToString(args[0]).toLowerCase());
+        case 'replace': {
+            const s = str(), search = valueToString(args[0]), repl = args.length > 1 ? valueToString(args[1]) : '';
+            const caseInsensitive = args.length > 2 && isTruthy(args[2]);
+            if (caseInsensitive)
+                return s.replace(new RegExp(escapeRegex(search), 'gi'), repl);
+            return s.split(search).join(repl);
+        }
+        case 'substring': {
+            const s = str(), start = Number(args[0]);
+            return args.length > 1 ? s.substring(start, start + Number(args[1])) : s.substring(start);
+        }
+        case 'split': return str().split(valueToString(args[0]));
+        case 'length':
+            return isArray(target) ? target.length : str().length;
+        case 'toCharArray': return [...str()];
+        case 'regex': return [...str().matchAll(new RegExp(valueToString(args[0]), 'g'))].map(m => m[0]);
+        case 'urlDecode': return decodeURIComponent(str());
+        case 'urlEncode': return encodeURIComponent(str());
+        case 'sanitize': return sanitize(str());
+        case 'concat': return concatMethod(target, args);
+        // Membership
+        case 'in': {
+            const candidates = args.flatMap(a => isArray(a) ? a : [a]);
+            return candidates.some(c => valuesEqual(target, c));
+        }
+        // Object manipulation
+        case 'clone': return JSON.parse(JSON.stringify(target));
+        case 'keep': {
+            const names = new Set(args.map(a => valueToString(a)));
+            if (isObject(target))
+                return Object.fromEntries(Object.entries(target).filter(([k]) => names.has(k)));
+            if (isArray(target))
+                return target.map(item => isObject(item) ? Object.fromEntries(Object.entries(item).filter(([k]) => names.has(k))) : item);
+            return target;
+        }
+        case 'remove': {
+            const names = new Set(args.map(a => valueToString(a)));
+            if (isObject(target))
+                return Object.fromEntries(Object.entries(target).filter(([k]) => !names.has(k)));
+            if (isArray(target))
+                return target.map(item => isObject(item) ? Object.fromEntries(Object.entries(item).filter(([k]) => !names.has(k))) : item);
+            return target;
+        }
+        // Collection
+        case 'count': return isArray(target) ? target.length : 1;
+        case 'first': return isArray(target) ? target[0] ?? null : target;
+        case 'last': return isArray(target) ? target[target.length - 1] ?? null : target;
+        case 'sum': return arr().reduce((a, b) => a + Number(b), 0);
+        case 'min': return Math.min(...arr().map(Number));
+        case 'max': return Math.max(...arr().map(Number));
+        case 'index': return isArray(target) ? target.map((_, i) => i) : 0;
+        case 'take': return arr().slice(0, Number(args[0]));
+        case 'skip': return arr().slice(Number(args[0]));
+        // Null checks
+        case 'isNull': {
+            const empty = target === null || target === undefined;
+            return args.length > 0 ? (empty ? args[0] : target) : empty;
+        }
+        case 'isEmpty':
+        case 'isNullOrEmpty': {
+            const empty = target === null || target === undefined || target === '' || (isArray(target) && target.length === 0);
+            return args.length > 0 ? (empty ? args[0] : target) : empty;
+        }
+        case 'isNullOrWhiteSpace': {
+            const empty = target === null || target === undefined ||
+                (typeof target === 'string' && target.trim() === '') ||
+                (isArray(target) && target.length === 0);
+            return args.length > 0 ? (empty ? args[0] : target) : empty;
+        }
+        // Type conversion
+        case 'not': return !isTruthy(target);
+        case 'boolean': return args.length > 0 ? isTruthy(args[0]) : isTruthy(target);
+        case 'toString': {
+            if (args.length > 0 && typeof target === 'number') {
+                // Basic format support
+                return String(target);
+            }
+            return valueToString(target);
+        }
+        case 'toNumber': return typeof target === 'number' ? target : (parseFloat(str()) || 0);
+        case 'convertTo': return convertTo(target, args);
+        // Math
+        case 'round': return evalRound(num(), args);
+        case 'floor': return Math.floor(num());
+        case 'ceiling': return Math.ceil(num());
+        case 'truncate': return Math.trunc(num());
+        case 'abs': return Math.abs(num());
+        // DateTime
+        case 'add': return evalDateAdd(target, args);
+        case 'dateFormat':
+        case 'tryDateFormat': return evalDateFormat(target, args);
+        case 'toUnixTimeSeconds': return evalToUnixTime(target, args);
+        case 'now': return evalNow(args);
+        case 'utcNow':
+        case 'utcnow': return evalNow(args);
+        // Generators
+        case 'range': return Array.from({ length: Number(args[1]) }, (_, i) => i + Number(args[0]));
+        case 'newGuid':
+        case 'newguid': return crypto.randomUUID();
+        // Crypto
+        case 'hash': return evalHash(str(), args);
+        case 'rsaSign': return evalRsaSign(target, args);
+        default: throw new Error(`Unknown method '${name}'.`);
+    }
+}
+// ── Helper functions for built-ins ──
+function escapeRegex(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function trimChars(s, chars) {
+    const re = new RegExp(`^[${escapeRegex(chars)}]+|[${escapeRegex(chars)}]+$`, 'g');
+    return s.replace(re, '');
+}
+function trimStartChars(s, chars) {
+    const re = new RegExp(`^[${escapeRegex(chars)}]+`);
+    return s.replace(re, '');
+}
+function trimEndChars(s, chars) {
+    const re = new RegExp(`[${escapeRegex(chars)}]+$`);
+    return s.replace(re, '');
+}
+function sanitize(s) {
+    if (!s)
+        return s;
+    const charMap = {
+        'ß': 'ss', 'Α': 'A', 'Β': 'B', 'Γ': 'G', 'Δ': 'D', 'Ε': 'E', 'Ζ': 'Z', 'Η': 'H', 'Θ': 'Th',
+        'Ι': 'I', 'Κ': 'K', 'Λ': 'L', 'Μ': 'M', 'Ν': 'N', 'Ξ': 'X', 'Ο': 'O', 'Π': 'P',
+        'Ρ': 'R', 'Σ': 'S', 'Τ': 'T', 'Υ': 'Y', 'Φ': 'Ph', 'Χ': 'Ch', 'Ψ': 'Ps', 'Ω': 'O',
+        'α': 'a', 'β': 'b', 'γ': 'g', 'δ': 'd', 'ε': 'e', 'ζ': 'z', 'η': 'h', 'θ': 'th',
+        'ι': 'i', 'κ': 'k', 'λ': 'l', 'μ': 'm', 'ν': 'n', 'ξ': 'x', 'ο': 'o', 'π': 'p',
+        'ρ': 'r', 'σ': 's', 'τ': 't', 'υ': 'y', 'φ': 'ph', 'χ': 'ch', 'ψ': 'ps', 'ω': 'o',
+    };
+    const normalized = s.normalize('NFD');
+    let result = '';
+    for (const c of normalized) {
+        if (charMap[c])
+            result += charMap[c];
+        else if (c.charCodeAt(0) > 0x02ff)
+            continue; // skip combining diacritical marks
+        else
+            result += c;
+    }
+    return result.normalize('NFC');
+}
+function concatMethod(target, args) {
+    const sep = args.length > 0 ? valueToString(args[0]) : '|';
+    const items = toArray(target).map(valueToString);
+    for (let i = 1; i < args.length; i++) {
+        const a = args[i];
+        if (isArray(a))
+            items.push(...a.map(valueToString));
+        else
+            items.push(valueToString(a));
+    }
+    return items.join(sep);
+}
+function convertTo(target, args) {
+    const typeName = (valueToString(args[0]) ?? '').toLowerCase();
+    const s = valueToString(target);
+    switch (typeName) {
+        case 'int32':
+        case 'int':
+        case 'integer': {
+            const n = parseFloat(s);
+            return isNaN(n) ? 0 : Math.trunc(n);
+        }
+        case 'int64':
+        case 'long': {
+            const n = parseFloat(s);
+            return isNaN(n) ? 0 : Math.trunc(n);
+        }
+        case 'double':
+        case 'float':
+        case 'decimal': {
+            const n = parseFloat(s);
+            return isNaN(n) ? 0 : n;
+        }
+        case 'boolean':
+        case 'bool': {
+            const n = parseFloat(s);
+            if (!isNaN(n))
+                return n !== 0;
+            if (s.toLowerCase() === 'true')
+                return true;
+            if (s.toLowerCase() === 'false')
+                return false;
+            return s.trim() !== '';
+        }
+        case 'string': return valueToString(target);
+        default: return target;
+    }
+}
+function evalRound(value, args) {
+    let decimals = 0;
+    let mode = 'awayfromzero';
+    for (const arg of args) {
+        if (typeof arg === 'string')
+            mode = arg.toLowerCase();
+        else
+            decimals = Number(arg);
+    }
+    const factor = Math.pow(10, decimals);
+    if (mode === 'toeven') {
+        // Banker's rounding
+        const shifted = value * factor;
+        const rounded = Math.round(shifted);
+        if (Math.abs(shifted - Math.floor(shifted) - 0.5) < 1e-10) {
+            return (Math.floor(shifted) % 2 === 0 ? Math.floor(shifted) : Math.ceil(shifted)) / factor;
+        }
+        return rounded / factor;
+    }
+    // Away from zero (default)
+    return Math.round(value * factor + Number.EPSILON) / factor;
+}
+function evalDateAdd(target, args) {
+    const dateStr = valueToString(target);
+    const date = new Date(dateStr);
+    if (isNaN(date.getTime()) && typeof target === 'number') {
+        return String(target + Number(args[0]));
+    }
+    const tsStr = valueToString(args[0]);
+    const ms = parseTimeSpan(tsStr);
+    date.setTime(date.getTime() + ms);
+    return date.toISOString().replace('.000Z', 'Z');
+}
+function parseTimeSpan(s) {
+    // Format: [days.]hours:minutes:seconds
+    const parts = s.split(':');
+    let days = 0, hours = 0, minutes = 0, seconds = 0;
+    if (parts.length >= 3) {
+        const hourPart = parts[0];
+        if (hourPart.includes('.')) {
+            const [d, h] = hourPart.split('.');
+            days = parseInt(d);
+            hours = parseInt(h);
+        }
+        else {
+            hours = parseInt(hourPart);
+        }
+        minutes = parseInt(parts[1]);
+        seconds = parseFloat(parts[2]);
+    }
+    return ((days * 24 + hours) * 3600 + minutes * 60 + seconds) * 1000;
+}
+function evalDateFormat(target, args) {
+    const dateStr = valueToString(target);
+    let date;
+    if (args.length >= 2) {
+        // Two args: inputFormat, outputFormat — just parse and format
+        date = new Date(dateStr);
+    }
+    else {
+        date = new Date(dateStr);
+    }
+    if (isNaN(date.getTime()))
+        return dateStr;
+    const fmt = args.length >= 2 ? valueToString(args[1]) : valueToString(args[0]);
+    return formatDate(date, fmt);
+}
+function evalToUnixTime(target, args) {
+    let date;
+    if (args.length >= 1)
+        date = new Date(valueToString(args[0]));
+    else if (typeof target === 'string' && target)
+        date = new Date(target);
+    else
+        date = new Date();
+    return String(Math.floor(date.getTime() / 1000));
+}
+function evalNow(args) {
+    const fmt = args.length > 0 ? valueToString(args[0]) : 'yyyy-MM-ddTHH:mm:ssZ';
+    const date = new Date();
+    if (args.length >= 2) {
+        // Timezone — not easily doable in pure JS without Intl, use UTC
+        return formatDate(date, fmt);
+    }
+    return formatDate(date, fmt);
+}
+function formatDate(d, fmt) {
+    const pad = (n, w = 2) => String(n).padStart(w, '0');
+    const months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+    return fmt
+        .replace('yyyy', String(d.getUTCFullYear()))
+        .replace('MMMM', months[d.getUTCMonth()])
+        .replace('MMM', months[d.getUTCMonth()].slice(0, 3))
+        .replace('MM', pad(d.getUTCMonth() + 1))
+        .replace('dd', pad(d.getUTCDate()))
+        .replace('HH', pad(d.getUTCHours()))
+        .replace('mm', pad(d.getUTCMinutes()))
+        .replace('ss', pad(d.getUTCSeconds()))
+        .replace('Z', 'Z');
+}
+// ── Crypto (uses node:crypto — documented browser limitation) ──
+let _crypto = null;
+function getNodeCrypto() {
+    if (!_crypto) {
+        try {
+            // Dynamic import for Node.js; will fail in browsers
+            _crypto = require('node:crypto');
+        }
+        catch {
+            throw new Error('Crypto functions (hash, rsaSign) require Node.js. Not available in browser.');
+        }
+    }
+    return _crypto;
+}
+function evalHash(input, args) {
+    const len = args.length > 0 ? Number(args[0]) : 32;
+    const crypto = getNodeCrypto();
+    const fullHash = crypto.createHash('md5').update(input, 'utf8').digest('hex');
+    return fullHash.slice(0, Math.min(len, fullHash.length));
+}
+function evalRsaSign(target, args) {
+    const crypto = getNodeCrypto();
+    const data = args.length > 0 ? valueToString(args[0]) : valueToString(target);
+    const keyPem = args.length > 1 ? valueToString(args[1]) : valueToString(args[0]);
+    const keyBody = keyPem
+        .replace('-----BEGIN RSA PRIVATE KEY-----', '')
+        .replace('-----END RSA PRIVATE KEY-----', '')
+        .replace(/\n/g, '')
+        .replace(/\r/g, '');
+    const keyDer = Buffer.from(keyBody, 'base64');
+    const privateKey = crypto.createPrivateKey({ key: keyDer, format: 'der', type: 'pkcs1' });
+    const signature = crypto.sign('sha1', Buffer.from(data, 'ascii'), {
+        key: privateKey,
+        padding: crypto.constants.RSA_PKCS1_PADDING,
+    });
+    // Legacy compatibility: reverse the signature bytes
+    const reversed = Buffer.from(signature).reverse();
+    return reversed.toString('base64');
+}
+//# sourceMappingURL=evaluator.js.map