fig-tree-evaluator 2.6.0 → 2.8.0

package/build/operators/POST/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/POST/operator.d.ts

@@ -0,0 +1,2 @@
+import { OperatorObject } from '../../types';
+export declare const POST: OperatorObject;

package/build/operators/{postRequest.js → POST/operator.js}

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -10,16 +33,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.POST = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const getRequest_1 = require("./getRequest");
-const requiredProperties = ['url'];
-const operatorAliases = ['post'];
-const propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
+const _operatorUtils_1 = require("../_operatorUtils");
+const operator_1 = require("../GET/operator");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d;
     const [urlObj, data, returnProperty, headers] = (yield (0, _operatorUtils_1.evaluateArray)([expression.url, expression.parameters, expression.returnProperty, expression.headers], config));
     const { url, headers: headersObj } = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null };
-    config.typeChecker({ name: 'url', value: url, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'data', value: data, expectedType: ['object', 'undefined'] }, { name: 'returnProperty', value: returnProperty, expectedType: ['string', 'undefined'] });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { url, headers, data, returnProperty }), { name: 'headers', value: headersObj, expectedType: ['object', 'null'] });
     const baseUrl = (_a = config.options.baseEndpoint) !== null && _a !== void 0 ? _a : '';
     const httpHeaders = Object.assign(Object.assign(Object.assign({}, (_b = config.options) === null || _b === void 0 ? void 0 : _b.headers), headersObj), headers);
     const shouldUseCache = (_d = (_c = expression.useCache) !== null && _c !== void 0 ? _c : config.options.useCache) !== null && _d !== void 0 ? _d : true;
@@ -35,9 +56,9 @@ const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, funct
     return result;
 });
 exports.POST = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
-    parseChildren: getRequest_1.parseChildrenGET,
+    parseChildren: operator_1.parseChildrenGET,
 };

package/build/operators/REGEX/data.d.ts

@@ -0,0 +1,5 @@
+import { OperatorData } from '../../types';
+export declare const requiredProperties: string[];
+export declare const propertyAliases: Record<string, string>;
+declare const operatorData: OperatorData;
+export default operatorData;

package/build/operators/REGEX/data.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Compare a string against a regex pattern';
+const aliases = ['regex', 'patternMatch', 'regexp', 'matchPattern'];
+const parameters = [
+    {
+        name: 'testString',
+        description: 'The string to test',
+        aliases: ['string', 'value'],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'pattern',
+        description: 'The regular expression pattern',
+        aliases: ['regex', 'regexp', 'regExp', 're'],
+        required: true,
+        type: 'string',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

package/build/operators/REGEX/index.d.ts

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/REGEX/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/{regex.d.ts → REGEX/operator.d.ts}

@@ -1,7 +1,6 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["testString", "pattern"];
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../../types';
+import { requiredProperties } from './data';
 export type RegexNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode;
 export declare const REGEX: OperatorObject;
-export {};

package/build/operators/{regex.js → REGEX/operator.js}

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -10,21 +33,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGEX = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const helpers_1 = require("../helpers");
-const requiredProperties = ['testString', 'pattern'];
-const operatorAliases = ['regex', 'patternMatch', 'regexp', 'matchPattern'];
-const propertyAliases = {
-    string: 'testString',
-    value: 'testString',
-    regex: 'pattern',
-    regexp: 'pattern',
-    regExp: 'pattern',
-    re: 'pattern',
-};
+const _operatorUtils_1 = require("../_operatorUtils");
+const helpers_1 = require("../../helpers");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     const [testString, pattern] = (yield (0, _operatorUtils_1.evaluateArray)([expression.testString, expression.pattern], config));
-    config.typeChecker({ name: 'testString', value: testString, expectedType: 'string' }, { name: 'pattern', value: pattern, expectedType: 'string' });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { testString, pattern }));
     try {
         const re = new RegExp(pattern);
         return re.test(testString);
@@ -38,9 +52,9 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { testString, pattern });
 };
 exports.REGEX = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

package/build/operators/SPLIT/data.d.ts

@@ -0,0 +1,5 @@
+import { OperatorData } from '../../types';
+export declare const requiredProperties: string[];
+export declare const propertyAliases: Record<string, string>;
+declare const operatorData: OperatorData;
+export default operatorData;

package/build/operators/SPLIT/data.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Split a string into an array';
+const aliases = ['split', 'arraySplit'];
+const parameters = [
+    {
+        name: 'value',
+        description: 'The string to be split',
+        aliases: ['string'],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'delimiter',
+        description: 'The value to split the string on (default is white space)',
+        aliases: ['separator'],
+        required: false,
+        type: 'string',
+    },
+    {
+        name: 'trimWhiteSpace',
+        description: 'Whether to trim white space from around the resulting elements (default: true)',
+        aliases: ['trim', 'trimWhitespace'],
+        required: false,
+        type: 'boolean',
+    },
+    {
+        name: 'excludeTrailing',
+        description: 'If the input string ends in a delimiter, there will be an additional blank element if this value is false (default: true)',
+        aliases: ['removeTrailing', 'excludeTrailingDelimiter'],
+        required: false,
+        type: 'boolean',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

package/build/operators/SPLIT/index.d.ts

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/SPLIT/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/{split.d.ts → SPLIT/operator.d.ts}

@@ -1,5 +1,5 @@
-import { OperatorObject, EvaluatorNode, BaseOperatorNode } from '../types';
-declare const requiredProperties: readonly ["value"];
+import { OperatorObject, EvaluatorNode, BaseOperatorNode } from '../../types';
+import { requiredProperties } from './data';
 export type SplitNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode & {
@@ -8,4 +8,3 @@ export type SplitNode = {
     excludeTrailing: EvaluatorNode;
 };
 export declare const SPLIT: OperatorObject;
-export {};

package/build/operators/{split.js → SPLIT/operator.js}

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -10,17 +33,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SPLIT = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['value'];
-const operatorAliases = ['split', 'arraySplit'];
-const propertyAliases = {
-    string: 'value',
-    separator: 'delimiter',
-    trim: 'trimWhiteSpace',
-    trimWhitespace: 'trimWhiteSpace',
-    removeTrailing: 'excludeTrailing',
-    excludeTrailingDelimiter: 'excludeTrailing',
-};
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
 const DEFAULT_DELIMITER = ' ';
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c;
@@ -30,7 +44,12 @@ const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, funct
         (_b = expression.trimWhiteSpace) !== null && _b !== void 0 ? _b : true,
         (_c = expression.excludeTrailing) !== null && _c !== void 0 ? _c : true,
     ], config));
-    config.typeChecker({ name: 'value', value: value, expectedType: 'string' }, { name: 'delimiter', value: delimiter, expectedType: 'string' }, { name: 'trimWhiteSpace', value: trimWhiteSpace, expectedType: 'boolean' }, { name: 'excludeTrailing', value: excludeTrailing, expectedType: 'boolean' });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
+        value,
+        delimiter,
+        trimWhiteSpace,
+        excludeTrailing,
+    }));
     let splitValues = value.split(delimiter);
     if (trimWhiteSpace)
         splitValues = splitValues.map((val) => val.trim());
@@ -43,9 +62,9 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { value, delimiter });
 };
 exports.SPLIT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

package/build/operators/STRING_SUBSTITUTION/data.d.ts

@@ -0,0 +1,5 @@
+import { OperatorData } from '../../types';
+export declare const requiredProperties: string[];
+export declare const propertyAliases: Record<string, string>;
+declare const operatorData: OperatorData;
+export default operatorData;

package/build/operators/STRING_SUBSTITUTION/data.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Replace values in a string using simple parameter substitution';
+const aliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
+const parameters = [
+    {
+        name: 'string',
+        description: 'A parameterised (%1, %2) string where the parameters are to be replaced',
+        aliases: [],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'substitutions',
+        description: 'An array of substitution values for the parameterised string',
+        aliases: ['replacements'],
+        required: true,
+        type: 'array',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

package/build/operators/STRING_SUBSTITUTION/index.d.ts

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/STRING_SUBSTITUTION/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/{stringSubstitution.d.ts → STRING_SUBSTITUTION/operator.d.ts}

@@ -1,7 +1,6 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["string", "substitutions"];
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../../types';
+import { requiredProperties } from './data';
 export type StringSubNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode;
 export declare const STRING_SUBSTITUTION: OperatorObject;
-export {};

package/build/operators/{stringSubstitution.js → STRING_SUBSTITUTION/operator.js}

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -10,14 +33,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STRING_SUBSTITUTION = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['string', 'substitutions'];
-const operatorAliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
-const propertyAliases = { replacements: 'substitutions' };
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     const [string, ...substitutions] = (yield (0, _operatorUtils_1.evaluateArray)([expression.string, ...expression.substitutions], config));
-    config.typeChecker({ name: 'string', value: string, expectedType: 'string' });
-    config.typeChecker({ name: 'substitutions', value: substitutions, expectedType: 'array' });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { string, substitutions }));
     const regex = /(%[\d]+)/g;
     const parameters = (string.match(regex) || []).sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)));
     const uniqueParameters = new Set(parameters);
@@ -32,9 +52,9 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { string, substitutions });
 };
 exports.STRING_SUBSTITUTION = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

package/build/operators/SUBTRACT/data.d.ts

@@ -0,0 +1,5 @@
+import { OperatorData } from '../../types';
+export declare const requiredProperties: string[];
+export declare const propertyAliases: Record<string, string>;
+declare const operatorData: OperatorData;
+export default operatorData;

package/build/operators/SUBTRACT/data.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Subtract one numerical value from another';
+const aliases = ['-', 'subtract', 'minus', 'takeaway'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Array of values - 2nd element will be subtracted from the first',
+        aliases: [],
+        required: false,
+        type: 'array',
+    },
+    {
+        name: 'from',
+        description: 'Numerical value that will be subtracted from',
+        aliases: ['subtractFrom'],
+        required: false,
+        type: 'number',
+    },
+    {
+        name: 'subtract',
+        description: 'Numerical value to subtract',
+        aliases: [],
+        required: false,
+        type: 'number',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

package/build/operators/SUBTRACT/index.d.ts

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/SUBTRACT/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/{subtract.d.ts → SUBTRACT/operator.d.ts}

@@ -1,5 +1,5 @@
-import { BasicExtendedNode } from './logicalAnd';
-import { EvaluatorNode, OperatorObject, BaseOperatorNode } from '../types';
+import { BasicExtendedNode } from '../AND/operator';
+import { EvaluatorNode, OperatorObject, BaseOperatorNode } from '../../types';
 interface SubtractionNodeWithProps extends BaseOperatorNode {
     subtract: EvaluatorNode;
     from: EvaluatorNode;

package/build/operators/SUBTRACT/operator.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBTRACT = void 0;
+const operator_1 = require("../AND/operator");
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const [values, from, subtract] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.from, expression.subtract], config));
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, from, subtract }));
+    const vals = values !== null && values !== void 0 ? values : [from, subtract];
+    if (vals.length < 2)
+        throw new Error('- Not enough values provided');
+    return vals[0] - vals[1];
+});
+exports.SUBTRACT = {
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};