fig-tree-evaluator 2.2.1 → 2.2.2

package/build/operators/lessThan.js

@@ -8,28 +8,62 @@ 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.LESS_THAN = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const logicalAnd_1 = require("./logicalAnd");
-const requiredProperties = ['values'];
-const operatorAliases = ['<', 'lessThan', 'lower', 'smaller'];
-const aliasExtensions = [{ '<=': { strict: false } }];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [values, strict = true] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.strict], config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    if (values.length < 2)
-        throw new Error('- Not enough values provided');
-    const [first, second] = values;
-    if (first === second && !strict)
-        return true;
-    return first < second;
-});
+var _operatorUtils_1 = require("./_operatorUtils");
+var logicalAnd_1 = require("./logicalAnd");
+var requiredProperties = ['values'];
+var operatorAliases = ['<', 'lessThan', 'lower', 'smaller'];
+var aliasExtensions = [{ '<=': { strict: false } }];
+var propertyAliases = {};
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, values, _b, strict, first, second;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.values, expression.strict], config)];
+            case 1:
+                _a = (_c.sent()), values = _a[0], _b = _a[1], strict = _b === void 0 ? true : _b;
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                if (values.length < 2)
+                    throw new Error('- Not enough values provided');
+                first = values[0], second = values[1];
+                if (first === second && !strict)
+                    return [2, true];
+                return [2, first < second];
+        }
+    });
+}); };
 exports.LESS_THAN = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: logicalAnd_1.parseChildren,
 };

package/build/operators/logicalAnd.js

@@ -1,4 +1,15 @@
 "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) {
@@ -8,26 +19,60 @@ 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.AND = exports.parseChildren = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['and', '&', '&&'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.reduce((acc, val) => acc && !!val, true);
-});
-const parseChildren = (expression) => {
-    const values = expression.children;
-    return Object.assign(Object.assign({}, expression), { values });
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['values'];
+var operatorAliases = ['and', '&', '&&'];
+var propertyAliases = {};
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var values;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(expression.values, config)];
+            case 1:
+                values = (_a.sent());
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                return [2, values.reduce(function (acc, val) { return acc && !!val; }, true)];
+        }
+    });
+}); };
+var parseChildren = function (expression) {
+    var values = expression.children;
+    return __assign(__assign({}, expression), { values: values });
 };
 exports.parseChildren = parseChildren;
 exports.AND = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: exports.parseChildren,
 };

package/build/operators/logicalOr.js

@@ -8,22 +8,56 @@ 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.OR = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['or', '|', '||'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.reduce((acc, val) => acc || !!val, false);
-});
+var logicalAnd_1 = require("./logicalAnd");
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['values'];
+var operatorAliases = ['or', '|', '||'];
+var propertyAliases = {};
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var values;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(expression.values, config)];
+            case 1:
+                values = (_a.sent());
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                return [2, values.reduce(function (acc, val) { return acc || !!val; }, false)];
+        }
+    });
+}); };
 exports.OR = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: logicalAnd_1.parseChildren,
 };

package/build/operators/match.js

@@ -1,4 +1,15 @@
 "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) {
@@ -8,46 +19,98 @@ 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.MATCH = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const evaluate_1 = require("../evaluate");
-const helpers_1 = require("../helpers");
-const requiredProperties = ['matchExpression'];
-const operatorAliases = ['match', 'switch'];
-const propertyAliases = { arms: 'branches', cases: 'branches', match: 'matchExpression' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const matchExpression = (yield (0, evaluate_1.evaluatorFunction)(expression.matchExpression, config));
-    const branches = expression.branches;
-    config.typeChecker({
-        name: 'matchExpression',
-        value: matchExpression,
-        expectedType: ['string', 'number', 'boolean'],
-    }, {
-        name: 'branches',
-        value: branches,
-        expectedType: ['object', 'array', 'undefined'],
+var _operatorUtils_1 = require("./_operatorUtils");
+var evaluate_1 = require("../evaluate");
+var helpers_1 = require("../helpers");
+var requiredProperties = ['matchExpression'];
+var operatorAliases = ['match', 'switch'];
+var propertyAliases = { arms: 'branches', cases: 'branches', match: 'matchExpression' };
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var matchExpression, branches, branchObject;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, (0, evaluate_1.evaluatorFunction)(expression.matchExpression, config)];
+            case 1:
+                matchExpression = (_a.sent());
+                branches = expression.branches;
+                config.typeChecker({
+                    name: 'matchExpression',
+                    value: matchExpression,
+                    expectedType: ['string', 'number', 'boolean'],
+                }, {
+                    name: 'branches',
+                    value: branches,
+                    expectedType: ['object', 'array', 'undefined'],
+                });
+                branchObject = Array.isArray(branches) ? (0, _operatorUtils_1.singleArrayToObject)(branches) : branches !== null && branches !== void 0 ? branches : {};
+                if (!(0, helpers_1.isOperatorNode)(branchObject)) return [3, 3];
+                return [4, (0, evaluate_1.evaluatorFunction)(branchObject, config)];
+            case 2:
+                branchObject = _a.sent();
+                _a.label = 3;
+            case 3:
+                if (!(matchExpression in branchObject)) return [3, 5];
+                return [4, (0, evaluate_1.evaluatorFunction)(branchObject[matchExpression], config)];
+            case 4: return [2, _a.sent()];
+            case 5:
+                if (!('fallback' in branchObject)) return [3, 7];
+                return [4, (0, evaluate_1.evaluatorFunction)(branchObject.fallback, config)];
+            case 6: return [2, _a.sent()];
+            case 7:
+                if (!(matchExpression in expression)) return [3, 9];
+                return [4, (0, evaluate_1.evaluatorFunction)(expression[matchExpression], config)];
+            case 8: return [2, _a.sent()];
+            case 9: throw new Error("No match found for ".concat(matchExpression));
+        }
+    });
+}); };
+var parseChildren = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, matchExpression, elements, branches, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = expression.children, matchExpression = _a[0], elements = _a.slice(1);
+                _b = _operatorUtils_1.singleArrayToObject;
+                return [4, (0, _operatorUtils_1.evaluateArray)(elements, config)];
+            case 1:
+                branches = _b.apply(void 0, [_c.sent()]);
+                return [2, __assign(__assign({}, expression), { matchExpression: matchExpression, branches: branches })];
+        }
     });
-    let branchObject = Array.isArray(branches) ? (0, _operatorUtils_1.singleArrayToObject)(branches) : branches !== null && branches !== void 0 ? branches : {};
-    if ((0, helpers_1.isOperatorNode)(branchObject))
-        branchObject = yield (0, evaluate_1.evaluatorFunction)(branchObject, config);
-    if (matchExpression in branchObject)
-        return yield (0, evaluate_1.evaluatorFunction)(branchObject[matchExpression], config);
-    if ('fallback' in branchObject)
-        return yield (0, evaluate_1.evaluatorFunction)(branchObject.fallback, config);
-    if (matchExpression in expression)
-        return yield (0, evaluate_1.evaluatorFunction)(expression[matchExpression], config);
-    throw new Error(`No match found for ${matchExpression}`);
-});
-const parseChildren = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [matchExpression, ...elements] = expression.children;
-    const branches = (0, _operatorUtils_1.singleArrayToObject)(yield (0, _operatorUtils_1.evaluateArray)(elements, config));
-    return Object.assign(Object.assign({}, expression), { matchExpression, branches });
-});
+}); };
 exports.MATCH = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };

package/build/operators/multiply.js

@@ -8,22 +8,56 @@ 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.MULTIPLY = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['*', 'x', 'multiply', 'times'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.reduce((acc, number) => acc * number);
-});
+var logicalAnd_1 = require("./logicalAnd");
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['values'];
+var operatorAliases = ['*', 'x', 'multiply', 'times'];
+var propertyAliases = {};
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var values;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(expression.values, config)];
+            case 1:
+                values = (_a.sent());
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                return [2, values.reduce(function (acc, number) { return acc * number; })];
+        }
+    });
+}); };
 exports.MULTIPLY = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: logicalAnd_1.parseChildren,
 };

package/build/operators/notEqual.js

@@ -8,31 +8,65 @@ 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.NOT_EQUAL = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const lite_1 = require("dequal/lite");
-const requiredProperties = ['values'];
-const operatorAliases = ['!=', '!', 'ne', 'notEqual'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const [values, nullMatch] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.nullEqualsUndefined], config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    const nullEqualsUndefined = nullMatch !== undefined
-        ? nullMatch
-        : ((_a = config.options) === null || _a === void 0 ? void 0 : _a.nullEqualsUndefined) !== undefined
-            ? config.options.nullEqualsUndefined
-            : false;
-    if (nullEqualsUndefined && (values[0] === null || values[0] === undefined))
-        return values.some((value) => value === null && value === undefined);
-    return values.some((val) => !(0, lite_1.dequal)(val, values[0]));
-});
+var logicalAnd_1 = require("./logicalAnd");
+var _operatorUtils_1 = require("./_operatorUtils");
+var lite_1 = require("dequal/lite");
+var requiredProperties = ['values'];
+var operatorAliases = ['!=', '!', 'ne', 'notEqual'];
+var propertyAliases = {};
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, values, nullMatch, nullEqualsUndefined;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.values, expression.nullEqualsUndefined], config)];
+            case 1:
+                _a = (_c.sent()), values = _a[0], nullMatch = _a[1];
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                nullEqualsUndefined = nullMatch !== undefined
+                    ? nullMatch
+                    : ((_b = config.options) === null || _b === void 0 ? void 0 : _b.nullEqualsUndefined) !== undefined
+                        ? config.options.nullEqualsUndefined
+                        : false;
+                if (nullEqualsUndefined && (values[0] === null || values[0] === undefined))
+                    return [2, values.some(function (value) { return value === null && value === undefined; })];
+                return [2, values.some(function (val) { return !(0, lite_1.dequal)(val, values[0]); })];
+        }
+    });
+}); };
 exports.NOT_EQUAL = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: logicalAnd_1.parseChildren,
 };