fig-tree-evaluator 2.5.0 → 2.5.2

package/README.md

@@ -4,10 +4,10 @@
 
 **FigTree Evaluator** is a module to evaluate JSON-structured expression trees. 
 
-A typical use case would be for evaluating **configuration** files, where you need to store dynamic values or arbitrary logic without allowing users to inject executable code (perhaps in a .json file, say). Use cases could include: 
+A typical use case would be for evaluating **configuration** files, where you need to store dynamic values or arbitrary logic without allowing users to inject executable code (perhaps in a .json file, say). Examples could include: 
 
 - a [form-builder app](https://github.com/openmsupply/conforma-web-app) might need to allow complex conditional logic for form element visibility based on previous responses, or for validation beyond what is available in standard validation libraries.
-- configure a [decision tree](https://en.wikipedia.org/wiki/Decision_tree) to implement branching logic. (See examples in `20_match.test.ts`)
+- configure a [decision tree](https://en.wikipedia.org/wiki/Decision_tree) to implement branching logic. (See implementation in `20_match.test.ts`)
 - extend [JSON Forms](https://jsonforms.io) with more complex logic and dynamic lookups: https://github.com/CarlosNZ/jsonforms-with-figtree-demo
 
 A range of built-in operators are available, from simple logic, arithmetic and string manipulation, to data fetching from local sources or remote APIs.
@@ -156,7 +156,7 @@ The `options` parameter is an object with the following available properties (al
 - `allowJSONStringInput` -- the evaluator is expecting the input expression to be a javascript object. However, it will also accept JSON strings if this option is set to `true`. We have to perform additional logic on every evaluation input to determine if a string is a JSON expression or a standard string, so this is skipped by default for performance reasons. However, if you want to send (for example) user input directly to the evaluator without running it through your own `JSON.parse()`, then enable this option.
 - `skipRuntimeTypeCheck` -- we perform comprehensive type checking at runtime to ensure that each operator only performs its operation on valid inputs. If type checking fails, we throw an error detailing the explicit problem. However, if `skipRuntimeTypeCheck` is set to `true`, then all inputs are passed to the operator regardless, and any errors will come from whatever standard javascript errors might be encountered (e.g. trying to pass a primitive value when an array is expected => `.map is not a function`)
 - `nullEqualsUndefined` -- this only affects the [`equal`/`notEqual` operators](#equal) (see there for more detail). 
-- `evaluateFullObject` -- by default, FigTree expects the root of an input expression to be an [Operator Node](#operator-nodes), and if not, will return the input unmodified. However, you may have cases where the evaluation expressions are deep within a larger structure (such as a JSON schema, for example). In this case, you can set `evaluateFullObject` to `true` and the evaluator will find *any* operator nodes within the structure and evaluate them in place.
+- `evaluateFullObject` -- by default, FigTree expects the root of an input expression to be an [Operator Node](#operator-nodes), and if not, will return the input unmodified. However, you may have cases where the evaluation expressions are deep within a larger structure (such as a JSON schema, for example). In this case, you can set `evaluateFullObject` to `true` and the evaluator will find *any* operator nodes within the structure and evaluate them within the object tree.
 - `useCache` -- caches the results from certain operators to avoid repeated network requests with the same input values. By default, this is set to `true`, and it can be overridden for specific nodes. See [Memoization/Caching section](#caching-memoization) for more detail
 - `maxCacheSize` -- the maximum number of results that will be held in the aforementioned cache (default: `50`)
 
@@ -199,7 +199,7 @@ For example, the following two representations are equivalent `conditional` oper
 ```js
 {
     operator: "?", // conditional (alias)
-    condition: 1 + 1 ==== 2
+    condition: 1 + 1 ==== 2,
     valueIfTrue: "True output",
     valueIfFalse: "False output"
 }
@@ -1521,7 +1521,7 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 - **v2.2.2**: Option to evaluate whole object if operator nodes are deep within it (#64)
 - **v2.2.1**: More efficient branch evaluation for condition/match operators (#63)
 - **v2.2.0**:
-  - New "[Match](#match) operator (#61)
+  - New "[Match](#match)" operator (#61)
   - Fix for regex incompatibility with Safari (#60)
 - **v2.1.5**: Demo updates (no changes to core evaluator)
 - **v2.1.4**: Upgrade dependencies

package/build/FigTreeEvaluator.js

@@ -31,101 +31,58 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateExpression = void 0;
-var evaluate_1 = require("./evaluate");
-var typeCheck_1 = require("./typeCheck");
-var _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
-var operators = __importStar(require("./operators"));
-var helpers_1 = require("./helpers");
-var cache_1 = __importDefault(require("./cache"));
-var pkg = require('../package.json');
-var FigTreeEvaluator = (function () {
-    function FigTreeEvaluator(options) {
-        if (options === void 0) { options = {}; }
-        this.typeChecker = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var result = typeCheck_1.typeCheck.apply(void 0, args);
+const evaluate_1 = require("./evaluate");
+const typeCheck_1 = require("./typeCheck");
+const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+const operators = __importStar(require("./operators"));
+const helpers_1 = require("./helpers");
+const cache_1 = __importDefault(require("./cache"));
+const pkg = require('../package.json');
+class FigTreeEvaluator {
+    constructor(options = {}) {
+        this.typeChecker = (...args) => {
+            const result = (0, typeCheck_1.typeCheck)(...args);
             if (result === true)
                 return;
             throw new Error(result);
         };
-        this.getVersion = function () { return pkg.version; };
+        this.getVersion = () => pkg.version;
         this.options = standardiseOptionNames(options);
         this.operators = operators;
         this.operatorAliases = _operatorAliases_json_1.default;
         this.cache = new cache_1.default(options.maxCacheSize);
     }
-    FigTreeEvaluator.prototype.evaluate = function (expression, options) {
-        if (options === void 0) { options = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var currentOptions;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        currentOptions = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
-                        if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
-                            this.cache.setMax(currentOptions.maxCacheSize);
-                        return [4, (0, evaluate_1.evaluatorFunction)(expression, {
-                                options: currentOptions,
-                                operators: this.operators,
-                                operatorAliases: this.operatorAliases,
-                                typeChecker: currentOptions.skipRuntimeTypeCheck ? function () { } : this.typeChecker,
-                                resolvedAliasNodes: {},
-                                cache: this.cache,
-                            })];
-                    case 1: return [2, _a.sent()];
-                }
+    evaluate(expression, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentOptions = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
+            if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
+                this.cache.setMax(currentOptions.maxCacheSize);
+            return yield (0, evaluate_1.evaluatorFunction)(expression, {
+                options: currentOptions,
+                operators: this.operators,
+                operatorAliases: this.operatorAliases,
+                typeChecker: currentOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
+                resolvedAliasNodes: {},
+                cache: this.cache,
             });
         });
-    };
-    FigTreeEvaluator.prototype.getOptions = function () {
+    }
+    getOptions() {
         return this.options;
-    };
-    FigTreeEvaluator.prototype.updateOptions = function (options) {
+    }
+    updateOptions(options) {
         this.options = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
-    };
-    return FigTreeEvaluator;
-}());
+    }
+}
 exports.default = FigTreeEvaluator;
-var evaluateExpression = function (expression, options) {
-    return new FigTreeEvaluator(options).evaluate(expression);
-};
+const evaluateExpression = (expression, options) => new FigTreeEvaluator(options).evaluate(expression);
 exports.evaluateExpression = evaluateExpression;
-var standardiseOptionNames = function (options) {
+const standardiseOptionNames = (options) => {
     if ('objects' in options) {
         options.data = options.objects;
         delete options.objects;

package/build/cache.js

@@ -8,88 +8,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var MAX_CACHED_ITEMS = 50;
-var FigTreeCache = (function () {
-    function FigTreeCache(maxSize) {
-        var _this = this;
-        this.useCache = function (shouldUseCache, action) {
-            var args = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                args[_i - 2] = arguments[_i];
+const MAX_CACHED_ITEMS = 50;
+class FigTreeCache {
+    constructor(maxSize) {
+        this.useCache = (shouldUseCache, action, ...args) => __awaiter(this, void 0, void 0, function* () {
+            if (!shouldUseCache)
+                return yield action(...args);
+            const key = stringifyInput(args);
+            if (key in this.store) {
+                this.queue = this.queue.filter((val) => val !== key);
+                this.queue.unshift(key);
+                return this.store[key];
             }
-            return __awaiter(_this, void 0, void 0, function () {
-                var key, result, keysToRemove;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!!shouldUseCache) return [3, 2];
-                            return [4, action.apply(void 0, args)];
-                        case 1: return [2, _a.sent()];
-                        case 2:
-                            key = stringifyInput(args);
-                            if (key in this.store) {
-                                this.queue = this.queue.filter(function (val) { return val !== key; });
-                                this.queue.unshift(key);
-                                return [2, this.store[key]];
-                            }
-                            return [4, action.apply(void 0, args)];
-                        case 3:
-                            result = _a.sent();
-                            this.store[key] = result;
-                            if (this.queue.length >= this.maxSize) {
-                                keysToRemove = this.queue.slice(this.maxSize - 1);
-                                keysToRemove.forEach(function (key) { return delete _this.store[key]; });
-                                this.queue = this.queue.slice(0, this.maxSize - 1);
-                            }
-                            this.queue.unshift(key);
-                            return [2, result];
-                    }
-                });
-            });
-        };
-        this.getMax = function () { return _this.maxSize; };
-        this.setMax = function (size) {
-            _this.maxSize = size;
+            const result = yield action(...args);
+            this.store[key] = result;
+            if (this.queue.length >= this.maxSize) {
+                const keysToRemove = this.queue.slice(this.maxSize - 1);
+                keysToRemove.forEach((key) => delete this.store[key]);
+                this.queue = this.queue.slice(0, this.maxSize - 1);
+            }
+            this.queue.unshift(key);
+            return result;
+        });
+        this.getMax = () => this.maxSize;
+        this.setMax = (size) => {
+            this.maxSize = size;
         };
         this.store = {};
         this.queue = [];
         this.maxSize = maxSize !== null && maxSize !== void 0 ? maxSize : MAX_CACHED_ITEMS;
     }
-    return FigTreeCache;
-}());
+}
 exports.default = FigTreeCache;
-var stringifyInput = function (args) {
-    return args.reduce(function (outputString, arg, index) {
-        var part = typeof arg === 'object' ? JSON.stringify(arg) : arg;
-        return index === 0 ? "".concat(part) : "".concat(outputString, "_").concat(part);
+const stringifyInput = (args) => {
+    return args.reduce((outputString, arg, index) => {
+        const part = typeof arg === 'object' ? JSON.stringify(arg) : arg;
+        return index === 0 ? `${part}` : `${outputString}_${part}`;
     }, '');
 };

package/build/evaluate.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,155 +8,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluatorFunction = void 0;
-var _operatorUtils_1 = require("./operators/_operatorUtils");
-var helpers_1 = require("./helpers");
-var evaluatorFunction = function (input, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var options, operators, operatorAliases, expression, isOperator, isFragment, _a, fallback, returnErrorAsString, _b, fragment, parameters, fragmentReplacement, _c, operator, _d, _e, requiredProperties, propertyAliases, evaluate, parseChildren, _f, _g, validationError, _h, _j, _k, result, err_1, _l, outputType, evaluatedOutputType, _m, err_2, _o;
-    var _p, _q, _r;
-    return __generator(this, function (_s) {
-        switch (_s.label) {
-            case 0:
-                options = config.options, operators = config.operators, operatorAliases = config.operatorAliases;
-                expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
-                if (!Array.isArray(expression)) return [3, 2];
-                return [4, (0, _operatorUtils_1.evaluateArray)(expression, config)];
-            case 1:
-                expression = _s.sent();
-                _s.label = 2;
-            case 2:
-                isOperator = (0, helpers_1.isOperatorNode)(expression);
-                isFragment = (0, helpers_1.isFragmentNode)(expression);
-                if (!(options.evaluateFullObject && !isOperator && !isFragment)) return [3, 4];
-                _a = helpers_1.replaceAliasNodeValues;
-                return [4, (0, helpers_1.evaluateObject)(expression, config)];
-            case 3: return [2, _a.apply(void 0, [_s.sent(), config])];
-            case 4:
-                if (!isOperator && !isFragment) {
-                    if (options.supportDeprecatedValueNodes && (0, helpers_1.isObject)(expression) && 'value' in expression)
-                        return [2, expression.value];
-                    return [2, (0, helpers_1.replaceAliasNodeValues)(expression, config)];
-                }
-                fallback = expression.fallback;
-                returnErrorAsString = (_p = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _p !== void 0 ? _p : false;
-                if (!isFragment) return [3, 8];
-                return [4, (0, _operatorUtils_1.evaluateArray)([expression.fragment, expression.parameters], config)];
-            case 5:
-                _b = (_s.sent()), fragment = _b[0], parameters = _b[1];
-                fragmentReplacement = (_q = options === null || options === void 0 ? void 0 : options.fragments) === null || _q === void 0 ? void 0 : _q[fragment];
-                if (!(fragmentReplacement === undefined)) return [3, 7];
-                _c = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 6: return [2, _c.apply(void 0, [_s.sent(), "Fragment not defined: ".concat(fragment), returnErrorAsString])];
-            case 7:
-                if (!(0, helpers_1.isOperatorNode)(fragmentReplacement))
-                    return [2, fragmentReplacement];
-                expression = __assign(__assign(__assign({}, expression), fragmentReplacement), parameters);
-                delete expression.fragment;
-                delete expression.parameters;
-                _s.label = 8;
-            case 8:
-                _s.trys.push([8, 29, , 31]);
-                operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
-                if (!!operator) return [3, 10];
-                _d = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 9: return [2, _d.apply(void 0, [_s.sent(), "Invalid operator: ".concat(expression.operator), returnErrorAsString])];
-            case 10:
-                _e = operators[operator], requiredProperties = _e.requiredProperties, propertyAliases = _e.propertyAliases, evaluate = _e.evaluate, parseChildren = _e.parseChildren;
-                expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
-                _f = config;
-                _g = [__assign({}, config.resolvedAliasNodes)];
-                return [4, (0, helpers_1.evaluateNodeAliases)(expression, config)];
-            case 11:
-                _f.resolvedAliasNodes = __assign.apply(void 0, _g.concat([(_s.sent())]));
-                validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
-                if (!validationError) return [3, 13];
-                _h = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 12: return [2, _h.apply(void 0, [_s.sent(), "Operator: ".concat(operator, "\n- ").concat(validationError), returnErrorAsString])];
-            case 13:
-                if (!('children' in expression)) return [3, 19];
-                if (!!Array.isArray(expression.children)) return [3, 15];
-                _j = expression;
-                return [4, (0, exports.evaluatorFunction)(expression.children, config)];
-            case 14:
-                _j.children = _s.sent();
-                _s.label = 15;
-            case 15:
-                if (!!Array.isArray(expression.children)) return [3, 17];
-                _k = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 16: return [2, _k.apply(void 0, [_s.sent(), "Operator: ".concat(operator, "\n- Property \"children\" is not of type: array"), returnErrorAsString])];
-            case 17: return [4, parseChildren(expression, config)];
-            case 18:
-                expression = _s.sent();
-                _s.label = 19;
-            case 19:
-                result = void 0;
-                _s.label = 20;
-            case 20:
-                _s.trys.push([20, 22, , 24]);
-                return [4, evaluate(expression, config)];
-            case 21:
-                result = _s.sent();
-                return [3, 24];
-            case 22:
-                err_1 = _s.sent();
-                _l = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(expression.fallback, config)];
-            case 23:
-                result = _l.apply(void 0, [_s.sent(), "Operator: ".concat(operator, "\n").concat((0, helpers_1.errorMessage)(err_1)), returnErrorAsString]);
-                return [3, 24];
-            case 24:
-                outputType = (_r = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _r !== void 0 ? _r : expression === null || expression === void 0 ? void 0 : expression.type;
-                if (!outputType)
-                    return [2, result];
-                return [4, (0, exports.evaluatorFunction)(outputType, config)];
-            case 25:
-                evaluatedOutputType = (_s.sent());
-                if (!!(evaluatedOutputType in helpers_1.convertOutputMethods)) return [3, 27];
-                _m = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 26: return [2, _m.apply(void 0, [_s.sent(), "Operator: ".concat(operator, "\n- Invalid output type: ").concat(evaluatedOutputType), returnErrorAsString])];
-            case 27: return [2, helpers_1.convertOutputMethods[evaluatedOutputType](result)];
-            case 28: return [3, 31];
-            case 29:
-                err_2 = _s.sent();
-                _o = helpers_1.fallbackOrError;
-                return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 30: return [2, _o.apply(void 0, [_s.sent(), (0, helpers_1.errorMessage)(err_2),
-                    returnErrorAsString])];
-            case 31: return [2];
+const _operatorUtils_1 = require("./operators/_operatorUtils");
+const helpers_1 = require("./helpers");
+const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const { options, operators, operatorAliases } = config;
+    let expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
+    if (Array.isArray(expression)) {
+        expression = yield (0, _operatorUtils_1.evaluateArray)(expression, config);
+    }
+    const isOperator = (0, helpers_1.isOperatorNode)(expression);
+    const isFragment = (0, helpers_1.isFragmentNode)(expression);
+    if (options.evaluateFullObject && !isOperator && !isFragment)
+        return (0, helpers_1.replaceAliasNodeValues)(yield (0, helpers_1.evaluateObject)(expression, config), config);
+    if (!isOperator && !isFragment) {
+        if (options.supportDeprecatedValueNodes && (0, helpers_1.isObject)(expression) && 'value' in expression)
+            return expression.value;
+        return (0, helpers_1.replaceAliasNodeValues)(expression, config);
+    }
+    const { fallback } = expression;
+    const returnErrorAsString = (_a = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _a !== void 0 ? _a : false;
+    if (isFragment) {
+        const [fragment, parameters] = (yield (0, _operatorUtils_1.evaluateArray)([expression.fragment, expression.parameters], config));
+        const fragmentReplacement = (_b = options === null || options === void 0 ? void 0 : options.fragments) === null || _b === void 0 ? void 0 : _b[fragment];
+        if (fragmentReplacement === undefined)
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Fragment not defined: ${fragment}`, returnErrorAsString);
+        if (!(0, helpers_1.isOperatorNode)(fragmentReplacement))
+            return fragmentReplacement;
+        expression = Object.assign(Object.assign(Object.assign({}, expression), fragmentReplacement), parameters);
+        delete expression.fragment;
+        delete expression.parameters;
+    }
+    try {
+        const operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
+        if (!operator)
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Invalid operator: ${expression.operator}`, returnErrorAsString);
+        const { requiredProperties, propertyAliases, evaluate, parseChildren } = operators[operator];
+        expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
+        config.resolvedAliasNodes = Object.assign(Object.assign({}, config.resolvedAliasNodes), (yield (0, helpers_1.evaluateNodeAliases)(expression, config)));
+        const validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
+        if (validationError)
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- ${validationError}`, returnErrorAsString);
+        if ('children' in expression) {
+            if (!Array.isArray(expression.children))
+                expression.children = yield (0, exports.evaluatorFunction)(expression.children, config);
+            if (!Array.isArray(expression.children))
+                return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Property "children" is not of type: array`, returnErrorAsString);
+            expression = yield parseChildren(expression, config);
         }
-    });
-}); };
+        let result;
+        try {
+            result = yield evaluate(expression, config);
+        }
+        catch (err) {
+            result = (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(expression.fallback, config), `Operator: ${operator}\n${(0, helpers_1.errorMessage)(err)}`, returnErrorAsString);
+        }
+        const outputType = (_c = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _c !== void 0 ? _c : expression === null || expression === void 0 ? void 0 : expression.type;
+        if (!outputType)
+            return result;
+        const evaluatedOutputType = (yield (0, exports.evaluatorFunction)(outputType, config));
+        if (!(evaluatedOutputType in helpers_1.convertOutputMethods))
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Invalid output type: ${evaluatedOutputType}`, returnErrorAsString);
+        else {
+            return helpers_1.convertOutputMethods[evaluatedOutputType](result);
+        }
+    }
+    catch (err) {
+        return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), (0, helpers_1.errorMessage)(err), returnErrorAsString);
+    }
+});
 exports.evaluatorFunction = evaluatorFunction;