fig-tree-evaluator 2.5.0 → 2.5.2

package/build/helpers.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,43 +8,16 @@ 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.evaluateObject = exports.isObject = exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isFragmentNode = exports.isOperatorNode = exports.parseIfJson = void 0;
-var change_case_1 = require("change-case");
-var evaluate_1 = require("./evaluate");
-var _operatorUtils_1 = require("./operators/_operatorUtils");
-var parseIfJson = function (input) {
+const change_case_1 = require("change-case");
+const evaluate_1 = require("./evaluate");
+const _operatorUtils_1 = require("./operators/_operatorUtils");
+const parseIfJson = (input) => {
     if (typeof input !== 'string')
         return input;
     try {
-        var parsedInput = JSON.parse(input);
+        const parsedInput = JSON.parse(input);
         return (0, exports.isOperatorNode)(parsedInput) ? parsedInput : input;
     }
     catch (err) {
@@ -63,29 +25,19 @@ var parseIfJson = function (input) {
     }
 };
 exports.parseIfJson = parseIfJson;
-var isOperatorNode = function (input) {
-    return input instanceof Object && 'operator' in input;
-};
+const isOperatorNode = (input) => input instanceof Object && 'operator' in input;
 exports.isOperatorNode = isOperatorNode;
-var isFragmentNode = function (input) {
-    return input instanceof Object && 'fragment' in input;
-};
+const isFragmentNode = (input) => input instanceof Object && 'fragment' in input;
 exports.isFragmentNode = isFragmentNode;
-var standardiseOperatorName = function (name) {
-    var camelCaseName = (0, change_case_1.camelCase)(name);
+const standardiseOperatorName = (name) => {
+    const camelCaseName = (0, change_case_1.camelCase)(name);
     return camelCaseName ? camelCaseName : name;
 };
-var getOperatorName = function (operator, operatorAliases) {
-    return operatorAliases[standardiseOperatorName(operator)];
-};
+const getOperatorName = (operator, operatorAliases) => operatorAliases[standardiseOperatorName(operator)];
 exports.getOperatorName = getOperatorName;
-var truncateString = function (string, length) {
-    if (length === void 0) { length = 200; }
-    return string.length < length ? string : "".concat(string.slice(0, length - 2).trim(), "...");
-};
+const truncateString = (string, length = 200) => string.length < length ? string : `${string.slice(0, length - 2).trim()}...`;
 exports.truncateString = truncateString;
-var fallbackOrError = function (fallback, errorMessage, returnErrorAsString) {
-    if (returnErrorAsString === void 0) { returnErrorAsString = false; }
+const fallbackOrError = (fallback, errorMessage, returnErrorAsString = false) => {
     if (fallback !== undefined)
         return fallback;
     if (returnErrorAsString)
@@ -94,108 +46,78 @@ var fallbackOrError = function (fallback, errorMessage, returnErrorAsString) {
         throw new Error((0, exports.truncateString)(errorMessage));
 };
 exports.fallbackOrError = fallbackOrError;
-var mapPropertyAliases = function (propertyAliases, expression) {
-    return mapObjectKeys(expression, function (key) {
-        return key in propertyAliases ? propertyAliases[key] : key;
-    });
-};
+const mapPropertyAliases = (propertyAliases, expression) => mapObjectKeys(expression, (key) => key in propertyAliases ? propertyAliases[key] : key);
 exports.mapPropertyAliases = mapPropertyAliases;
-var mapObjectKeys = function (inputObj, mapFunction) {
-    var keyVals = Object.entries(inputObj);
-    var mappedKeys = keyVals.map(function (_a) {
-        var key = _a[0], value = _a[1];
-        return [mapFunction(key), value];
-    });
+const mapObjectKeys = (inputObj, mapFunction) => {
+    const keyVals = Object.entries(inputObj);
+    const mappedKeys = keyVals.map(([key, value]) => [mapFunction(key), value]);
     return Object.fromEntries(mappedKeys);
 };
-var isAliasString = function (value) { return /^\$.+/.test(value); };
-var evaluateNodeAliases = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var aliasKeys, evaluations, _a, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                aliasKeys = Object.keys(expression).filter(isAliasString);
-                if (aliasKeys.length === 0)
-                    return [2, expression];
-                evaluations = [];
-                aliasKeys.forEach(function (alias) { return evaluations.push((0, evaluate_1.evaluatorFunction)(expression[alias], config)); });
-                _a = _operatorUtils_1.zipArraysToObject;
-                _b = [aliasKeys];
-                return [4, Promise.all(evaluations)];
-            case 1: return [2, _a.apply(void 0, _b.concat([_c.sent()]))];
-        }
-    });
-}); };
+const isAliasString = (value) => /^\$.+/.test(value);
+const evaluateNodeAliases = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const aliasKeys = Object.keys(expression).filter(isAliasString);
+    if (aliasKeys.length === 0)
+        return {};
+    const evaluations = [];
+    aliasKeys.forEach((alias) => evaluations.push((0, evaluate_1.evaluatorFunction)(expression[alias], config)));
+    return (0, _operatorUtils_1.zipArraysToObject)(aliasKeys, yield Promise.all(evaluations));
+});
 exports.evaluateNodeAliases = evaluateNodeAliases;
-var replaceAliasNodeValues = function (value, _a) {
-    var _b;
-    var resolvedAliasNodes = _a.resolvedAliasNodes;
+const replaceAliasNodeValues = (value, { resolvedAliasNodes }) => {
+    var _a;
     if (typeof value !== 'string' || !isAliasString(value))
         return value;
-    return (_b = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _b !== void 0 ? _b : value;
+    return (_a = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _a !== void 0 ? _a : value;
 };
 exports.replaceAliasNodeValues = replaceAliasNodeValues;
-var checkRequiredNodes = function (requiredProps, expression) {
-    var missingProps = requiredProps.filter(function (prop) { return !(prop in expression); });
+const checkRequiredNodes = (requiredProps, expression) => {
+    const missingProps = requiredProps.filter((prop) => !(prop in expression));
     if (missingProps.length === 0)
         return false;
     if (!('children' in expression))
-        return "Missing properties: ".concat(missingProps);
+        return `Missing properties: ${missingProps}`;
     return false;
 };
 exports.checkRequiredNodes = checkRequiredNodes;
-var mergeOptions = function (origOptions, newOptions) {
-    var combinedOptions = __assign(__assign({}, origOptions), newOptions);
+const mergeOptions = (origOptions, newOptions) => {
+    const combinedOptions = Object.assign(Object.assign({}, origOptions), newOptions);
     if (origOptions.data || newOptions.data)
-        combinedOptions.data = __assign(__assign({}, origOptions.data), newOptions.data);
+        combinedOptions.data = Object.assign(Object.assign({}, origOptions.data), newOptions.data);
     if (origOptions.functions || newOptions.functions)
-        combinedOptions.functions = __assign(__assign({}, origOptions.functions), newOptions.functions);
+        combinedOptions.functions = Object.assign(Object.assign({}, origOptions.functions), newOptions.functions);
     if (origOptions.fragments || newOptions.fragments)
-        combinedOptions.fragments = __assign(__assign({}, origOptions.fragments), newOptions.fragments);
+        combinedOptions.fragments = Object.assign(Object.assign({}, origOptions.fragments), newOptions.fragments);
     if (origOptions.headers || newOptions.headers)
-        combinedOptions.headers = __assign(__assign({}, origOptions.headers), newOptions.headers);
+        combinedOptions.headers = Object.assign(Object.assign({}, origOptions.headers), newOptions.headers);
     return combinedOptions;
 };
 exports.mergeOptions = mergeOptions;
 exports.convertOutputMethods = {
-    number: function (value) { return extractNumber(value); },
-    string: function (value) { return String(value); },
-    array: function (value) { return (Array.isArray(value) ? value : [value]); },
-    boolean: function (value) { return Boolean(value); },
-    bool: function (value) { return Boolean(value); },
+    number: (value) => extractNumber(value),
+    string: (value) => String(value),
+    array: (value) => (Array.isArray(value) ? value : [value]),
+    boolean: (value) => Boolean(value),
+    bool: (value) => Boolean(value),
 };
-var errorMessage = function (err) { return err.message; };
+const errorMessage = (err) => err.message;
 exports.errorMessage = errorMessage;
-var extractNumber = function (input) {
+const extractNumber = (input) => {
     if (typeof input !== 'string')
         return Number.isNaN(Number(input)) ? input : Number(input);
-    var pattern = new RegExp(/-?\d*\.?\d+/gm);
-    var numberMatch = input.match(pattern);
+    const pattern = new RegExp(/-?\d*\.?\d+/gm);
+    const numberMatch = input.match(pattern);
     if (!numberMatch)
         return 0;
     return Number(numberMatch[0]);
 };
-var isObject = function (input) {
-    return typeof input === 'object' && input !== null && !Array.isArray(input);
-};
+const isObject = (input) => typeof input === 'object' && input !== null && !Array.isArray(input);
 exports.isObject = isObject;
-var evaluateObject = function (input, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var newObjectEntries, result;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!(0, exports.isObject)(input))
-                    return [2, input];
-                newObjectEntries = [];
-                Object.entries(input).forEach(function (_a) {
-                    var key = _a[0], value = _a[1];
-                    return newObjectEntries.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
-                });
-                return [4, Promise.all(newObjectEntries)];
-            case 1:
-                result = _a.sent();
-                return [2, (0, _operatorUtils_1.singleArrayToObject)(result)];
-        }
-    });
-}); };
+const evaluateObject = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(0, exports.isObject)(input))
+        return input;
+    const newObjectEntries = [];
+    Object.entries(input).forEach(([key, value]) => newObjectEntries.push(key, (0, evaluate_1.evaluatorFunction)(value, config)));
+    const result = yield Promise.all(newObjectEntries);
+    return (0, _operatorUtils_1.singleArrayToObject)(result);
+});
 exports.evaluateObject = evaluateObject;

package/build/index.js

@@ -24,6 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateExpression = void 0;
-var FigTreeEvaluator_1 = __importStar(require("./FigTreeEvaluator"));
+const FigTreeEvaluator_1 = __importStar(require("./FigTreeEvaluator"));
 Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return FigTreeEvaluator_1.evaluateExpression; } });
 exports.default = FigTreeEvaluator_1.default;

package/build/operators/_operatorUtils.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,88 +8,53 @@ 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.axiosRequest = exports.joinUrlParts = exports.isFullUrl = exports.extractAndSimplify = exports.simplifyObject = exports.singleArrayToObject = exports.zipArraysToObject = exports.evaluateArray = void 0;
-var axios_1 = __importDefault(require("axios"));
-var extract_1 = __importDefault(require("object-property-extractor/build/extract"));
-var evaluate_1 = require("../evaluate");
-var typeCheck_1 = require("../typeCheck");
-var evaluateArray = function (nodes, params) { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!!Array.isArray(nodes)) return [3, 2];
-                return [4, (0, evaluate_1.evaluatorFunction)(nodes, params)];
-            case 1: return [2, (_a.sent())];
-            case 2: return [4, Promise.all(nodes.map(function (node) { return (0, evaluate_1.evaluatorFunction)(node, params); }))];
-            case 3: return [2, _a.sent()];
-        }
-    });
-}); };
+const axios_1 = __importDefault(require("axios"));
+const extract_1 = __importDefault(require("object-property-extractor/build/extract"));
+const evaluate_1 = require("../evaluate");
+const typeCheck_1 = require("../typeCheck");
+const evaluateArray = (nodes, params) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!Array.isArray(nodes))
+        return (yield (0, evaluate_1.evaluatorFunction)(nodes, params));
+    return yield Promise.all(nodes.map((node) => (0, evaluate_1.evaluatorFunction)(node, params)));
+});
 exports.evaluateArray = evaluateArray;
-var zipArraysToObject = function (keys, values) {
-    var pairs = keys.map(function (key, index) { return [key, values[index]]; });
+const zipArraysToObject = (keys, values) => {
+    const pairs = keys.map((key, index) => [key, values[index]]);
     return Object.fromEntries(pairs);
 };
 exports.zipArraysToObject = zipArraysToObject;
-var singleArrayToObject = function (elements) {
+const singleArrayToObject = (elements) => {
     if (elements.length % 2 !== 0)
         throw new Error('Even number of children required to make key/value pairs');
-    var keys = elements.filter(function (_, index) { return index % 2 === 0; });
-    var result = typeCheck_1.typeCheck.apply(void 0, keys.map(function (key) { return ({
+    const keys = elements.filter((_, index) => index % 2 === 0);
+    const result = (0, typeCheck_1.typeCheck)(...keys.map((key) => ({
         value: key,
         expectedType: ['string', 'number', 'boolean'],
-    }); }));
+    })));
     if (result !== true)
         throw new Error(result);
-    var values = elements.filter(function (_, index) { return index % 2 === 1; });
-    var output = {};
-    keys.forEach(function (key, index) {
+    const values = elements.filter((_, index) => index % 2 === 1);
+    const output = {};
+    keys.forEach((key, index) => {
         output[key] = values[index];
     });
     return output;
 };
 exports.singleArrayToObject = singleArrayToObject;
-var simplifyObject = function (item) {
+const simplifyObject = (item) => {
     return item instanceof Object && Object.keys(item).length === 1 ? Object.values(item)[0] : item;
 };
 exports.simplifyObject = simplifyObject;
-var extractAndSimplify = function (data, returnProperty, fallback) {
-    if (fallback === void 0) { fallback = undefined; }
+const extractAndSimplify = (data, returnProperty, fallback = undefined) => {
     try {
-        var selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
+        const selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
         if (Array.isArray(selectedProperty))
-            return selectedProperty.map(function (item) { return (0, exports.simplifyObject)(item); });
+            return selectedProperty.map((item) => (0, exports.simplifyObject)(item));
         if (returnProperty) {
             if (selectedProperty === null)
                 return null;
@@ -113,53 +67,38 @@ var extractAndSimplify = function (data, returnProperty, fallback) {
     }
 };
 exports.extractAndSimplify = extractAndSimplify;
-var isFullUrl = function (url) { return /^https?:\/\/.+/.test(url); };
+const isFullUrl = (url) => /^https?:\/\/.+/.test(url);
 exports.isFullUrl = isFullUrl;
-var joinUrlParts = function () {
-    var urls = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        urls[_i] = arguments[_i];
-    }
-    return urls.reduce(function (acc, curr, index) {
-        var startSliceIndex = curr[0] === '/' ? 1 : 0;
-        var endSliceIndex = curr.slice(-1) === '/' ? -1 : undefined;
-        var newPart = curr.slice(startSliceIndex, endSliceIndex);
+const joinUrlParts = (...urls) => {
+    return urls.reduce((acc, curr, index) => {
+        const startSliceIndex = curr[0] === '/' ? 1 : 0;
+        const endSliceIndex = curr.slice(-1) === '/' ? -1 : undefined;
+        const newPart = curr.slice(startSliceIndex, endSliceIndex);
         if (newPart === '')
             return acc;
         return acc + (index === 0 ? '' : '/') + newPart;
     }, '');
 };
 exports.joinUrlParts = joinUrlParts;
-var axiosRequest = function (_a) {
-    var url = _a.url, _b = _a.params, params = _b === void 0 ? {} : _b, _c = _a.data, data = _c === void 0 ? {} : _c, _d = _a.headers, headers = _d === void 0 ? {} : _d, _e = _a.method, method = _e === void 0 ? 'get' : _e;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var response, err_1;
-        var _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0:
-                    _g.trys.push([0, 2, , 3]);
-                    return [4, (0, axios_1.default)({
-                            method: method,
-                            url: url,
-                            headers: __assign({ 'Content-Type': 'application/json', Accept: 'application/json' }, headers),
-                            params: params,
-                            data: data,
-                        })];
-                case 1:
-                    response = _g.sent();
-                    return [2, response.data];
-                case 2:
-                    err_1 = _g.sent();
-                    if (axios_1.default.isAxiosError(err_1)) {
-                        if (!(err_1 === null || err_1 === void 0 ? void 0 : err_1.response))
-                            throw new Error('Network Error');
-                        console.log((_f = err_1.response) === null || _f === void 0 ? void 0 : _f.data);
-                    }
-                    throw err_1;
-                case 3: return [2];
-            }
+const axiosRequest = ({ url, params = {}, data = {}, headers = {}, method = 'get', }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const response = yield (0, axios_1.default)({
+            method,
+            url,
+            headers: Object.assign({ 'Content-Type': 'application/json', Accept: 'application/json' }, headers),
+            params,
+            data,
         });
-    });
-};
+        return response.data;
+    }
+    catch (err) {
+        if (axios_1.default.isAxiosError(err)) {
+            if (!(err === null || err === void 0 ? void 0 : err.response))
+                throw new Error('Network Error');
+            console.log((_a = err.response) === null || _a === void 0 ? void 0 : _a.data);
+        }
+        throw err;
+    }
+});
 exports.axiosRequest = axiosRequest;

package/build/operators/buildObject.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,88 +8,41 @@ 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.BUILD_OBJECT = void 0;
-var _operatorUtils_1 = require("./_operatorUtils");
-var requiredProperties = ['properties'];
-var operatorAliases = ['buildObject', 'build', 'object'];
-var propertyAliases = {
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['properties'];
+const operatorAliases = ['buildObject', 'build', 'object'];
+const propertyAliases = {
     values: 'properties',
     keyValPairs: 'properties',
     keyValuePairs: 'properties',
 };
-var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var evaluatePair, evaluated, _a, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                evaluatePair = function (nodes) { return __awaiter(void 0, void 0, void 0, function () {
-                    var _a, key, value;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(nodes, config)];
-                            case 1:
-                                _a = (_b.sent()), key = _a[0], value = _a[1];
-                                config.typeChecker({ name: 'key', value: key, expectedType: ['string', 'number', 'boolean'] });
-                                return [2, [key, value]];
-                        }
-                    });
-                }); };
-                config.typeChecker({ name: 'properties', value: expression.properties, expectedType: 'array' });
-                evaluated = expression.properties
-                    .filter(function (element) {
-                    return element instanceof Object && 'key' in element && 'value' in element;
-                })
-                    .map(function (_a) {
-                    var key = _a.key, value = _a.value;
-                    return evaluatePair([key, value]);
-                });
-                _b = (_a = Object).fromEntries;
-                return [4, Promise.all(evaluated)];
-            case 1: return [2, _b.apply(_a, [_c.sent()])];
-        }
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const evaluatePair = (nodes) => __awaiter(void 0, void 0, void 0, function* () {
+        const [key, value] = (yield (0, _operatorUtils_1.evaluateArray)(nodes, config));
+        config.typeChecker({ name: 'key', value: key, expectedType: ['string', 'number', 'boolean'] });
+        return [key, value];
     });
-}); };
-var parseChildren = function (expression) {
-    var elements = expression.children;
+    config.typeChecker({ name: 'properties', value: expression.properties, expectedType: 'array' });
+    const evaluated = expression.properties
+        .filter((element) => element instanceof Object && 'key' in element && 'value' in element)
+        .map(({ key, value }) => evaluatePair([key, value]));
+    return Object.fromEntries(yield Promise.all(evaluated));
+});
+const parseChildren = (expression) => {
+    const elements = expression.children;
     if (elements.length % 2 !== 0)
         throw new Error('Even number of children required to make key/value pairs');
-    var keys = elements.filter(function (_, index) { return index % 2 === 0; });
-    var values = elements.filter(function (_, index) { return index % 2 === 1; });
-    var properties = keys.map(function (key, index) { return ({ key: key, value: values[index] }); });
-    return __assign(__assign({}, expression), { properties: properties });
+    const keys = elements.filter((_, index) => index % 2 === 0);
+    const values = elements.filter((_, index) => index % 2 === 1);
+    const properties = keys.map((key, index) => ({ key, value: values[index] }));
+    return Object.assign(Object.assign({}, expression), { properties });
 };
 exports.BUILD_OBJECT = {
-    requiredProperties: requiredProperties,
-    operatorAliases: operatorAliases,
-    propertyAliases: propertyAliases,
-    evaluate: evaluate,
-    parseChildren: parseChildren,
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
 };