fig-tree-evaluator 1.9.0

package/build/operators/multiply.d.ts

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

package/build/operators/multiply.js

@@ -0,0 +1,29 @@
+"use strict";
+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.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);
+});
+exports.MULTIPLY = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren: logicalAnd_1.parseChildren,
+};

package/build/operators/notEqual.d.ts

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

package/build/operators/notEqual.js

@@ -0,0 +1,29 @@
+"use strict";
+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.NOT_EQUAL = void 0;
+const logicalAnd_1 = require("./logicalAnd");
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['values'];
+const operatorAliases = ['!=', '!', 'ne', 'notEqual'];
+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.some((val) => val !== values[0]);
+});
+exports.NOT_EQUAL = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren: logicalAnd_1.parseChildren,
+};

package/build/operators/objectFunctions.d.ts

@@ -0,0 +1,9 @@
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["functionPath"];
+export declare type ObjFuncNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode & {
+    args: EvaluatorNode[];
+};
+export declare const OBJECT_FUNCTIONS: OperatorObject;
+export {};

package/build/operators/objectFunctions.js

@@ -0,0 +1,38 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBJECT_FUNCTIONS = void 0;
+const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['functionPath'];
+const operatorAliases = ['objectFunctions', 'function', 'functions', 'runFunction'];
+const propertyAliases = { functionsPath: 'functionPath', arguments: 'args', variables: 'args' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const [functionPath, ...args] = (yield _operatorUtils_1.evaluateArray([expression.functionPath, ...expression.args], config));
+    const inputObject = (_b = (_a = config.options) === null || _a === void 0 ? void 0 : _a.objects) !== null && _b !== void 0 ? _b : {};
+    const func = object_property_extractor_1.default(inputObject, functionPath);
+    return yield func(...args);
+});
+const parseChildren = (expression) => {
+    const [functionPath, ...args] = expression.children;
+    return Object.assign(Object.assign({}, expression), { functionPath, args });
+};
+exports.OBJECT_FUNCTIONS = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/objectProperties.d.ts

@@ -0,0 +1,9 @@
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
+declare const requiredProperties: string[];
+export declare type ObjPropNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode & {
+    additionalObjects: object;
+};
+export declare const OBJECT_PROPERTIES: OperatorObject;
+export {};

package/build/operators/objectProperties.js

@@ -0,0 +1,44 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBJECT_PROPERTIES = void 0;
+const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['property'];
+const operatorAliases = ['objectProperties', 'objProps', 'getProperty', 'getObjProp'];
+const propertyAliases = {
+    path: 'property',
+    propertyName: 'property',
+    additional: 'additionalObjects',
+    objects: 'additionalObjects',
+};
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    const [property, additionalObjects] = (yield (0, _operatorUtils_1.evaluateArray)([expression.property, expression.additionalObjects], config));
+    config.typeChecker({ name: 'property', value: property, expectedType: 'string' }, { name: 'additionalObjects', value: additionalObjects, expectedType: ['object', 'undefined'] });
+    const inputObject = additionalObjects
+        ? Object.assign(Object.assign({}, ((_b = (_a = config.options) === null || _a === void 0 ? void 0 : _a.objects) !== null && _b !== void 0 ? _b : {})), additionalObjects) : (_d = (_c = config.options) === null || _c === void 0 ? void 0 : _c.objects) !== null && _d !== void 0 ? _d : {};
+    return (0, object_property_extractor_1.default)(inputObject, property);
+});
+const parseChildren = (expression) => {
+    const [property, fallback] = expression.children;
+    return Object.assign(Object.assign({}, expression), { property, fallback });
+};
+exports.OBJECT_PROPERTIES = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/passThru.d.ts

@@ -0,0 +1,7 @@
+import { OperatorObject, EvaluatorNode, BaseOperatorNode } from '../types';
+declare const requiredProperties: readonly ["value"];
+export declare type PassThruNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode[];
+} & BaseOperatorNode;
+export declare const PASSTHRU: OperatorObject;
+export {};

package/build/operators/passThru.js

@@ -0,0 +1,30 @@
+"use strict";
+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.PASSTHRU = void 0;
+const evaluate_1 = require("../evaluate");
+const requiredProperties = ['value'];
+const operatorAliases = ['_', 'passThru', 'pass', 'ignore', 'coerce', 'convert'];
+const propertyAliases = { _: 'value', data: 'value' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, evaluate_1.evaluatorFunction)(expression.value, config);
+});
+const parseChildren = (expression) => {
+    const [...children] = expression.children;
+    return Object.assign(Object.assign({}, expression), { value: children });
+};
+exports.PASSTHRU = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/pgSQL.d.ts

@@ -0,0 +1,24 @@
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["query"];
+export declare type PGNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode & {
+    values?: EvaluatorNode[];
+    type?: 'string';
+};
+export interface PGConnection {
+    query: (expression: {
+        text: string;
+        values?: any[];
+        rowMode?: string;
+    }) => Promise<QueryResult>;
+}
+interface QueryRowResult {
+    [columns: string]: any;
+}
+export interface QueryResult {
+    rows: QueryRowResult[];
+    error?: string;
+}
+export declare const PG_SQL: OperatorObject;
+export {};

package/build/operators/pgSQL.js

@@ -0,0 +1,66 @@
+"use strict";
+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.PG_SQL = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['query'];
+const operatorAliases = ['pgSql', 'sql', 'postgres', 'pg', 'pgDb'];
+const propertyAliases = { replacements: 'values' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const [query, ...values] = (yield (0, _operatorUtils_1.evaluateArray)([expression.query, ...(expression.values || [])], config));
+    config.typeChecker({ name: 'query', value: query, expectedType: 'string' }, { name: 'values', value: values, expectedType: 'array' });
+    if (!((_a = config.options) === null || _a === void 0 ? void 0 : _a.pgConnection))
+        throw new Error('No Postgres database connection provided');
+    try {
+        return yield processPgSQL([query, ...values], config.options.pgConnection, expression === null || expression === void 0 ? void 0 : expression.type);
+    }
+    catch (err) {
+        throw err;
+    }
+});
+const parseChildren = (expression) => {
+    const [query, ...values] = expression.children;
+    return Object.assign(Object.assign({}, expression), { query, values });
+};
+const processPgSQL = (queryArray, connection, queryType) => __awaiter(void 0, void 0, void 0, function* () {
+    const expression = {
+        text: queryArray[0],
+        values: queryArray.slice(1),
+        rowMode: queryType ? 'array' : '',
+    };
+    try {
+        const res = yield connection.query(expression);
+        if (res === null || res === void 0 ? void 0 : res.error)
+            throw new Error(res.error);
+        switch (queryType) {
+            case 'array':
+                return res.rows.flat();
+            case 'string':
+                return res.rows.flat().join(' ');
+            case 'number':
+                const result = res.rows.flat();
+                return Number.isNaN(Number(result)) ? result : Number(result);
+            default:
+                return res.rows;
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+});
+exports.PG_SQL = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/plus.d.ts

@@ -0,0 +1,10 @@
+import { OperatorObject, EvaluatorNode } from '../types';
+import { BasicExtendedNode } from './logicalAnd';
+declare const requiredProperties: readonly ["values"];
+export declare type AdditionNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BasicExtendedNode & {
+    type?: 'string' | 'array';
+};
+export declare const PLUS: OperatorObject;
+export {};

package/build/operators/plus.js

@@ -0,0 +1,39 @@
+"use strict";
+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.PLUS = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const logicalAnd_1 = require("./logicalAnd");
+const requiredProperties = ['values'];
+const operatorAliases = ['+', 'plus', 'add', 'concat', 'join', 'merge'];
+const propertyAliases = {};
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    if (expression.values.length === 0)
+        return expression.values;
+    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
+    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+    if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'string')
+        return values.reduce((acc, child) => acc.concat(child), '');
+    if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'array')
+        return values.reduce((acc, child) => acc.concat(child), []);
+    if (values.every((child) => typeof child === 'string' || Array.isArray(child)))
+        return values.reduce((acc, child) => acc.concat(child));
+    if (values.every((child) => child instanceof Object && !Array.isArray(child)))
+        return values.reduce((acc, child) => (Object.assign(Object.assign({}, acc), child)), {});
+    return values.reduce((acc, child) => acc + child);
+});
+exports.PLUS = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren: logicalAnd_1.parseChildren,
+};

package/build/operators/postRequest.d.ts

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

package/build/operators/postRequest.js

@@ -0,0 +1,39 @@
+"use strict";
+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.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 evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    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'] });
+    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 response = yield (0, _operatorUtils_1.axiosRequest)({
+        url: (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url),
+        data,
+        headers: httpHeaders,
+        method: 'post',
+    });
+    return (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty);
+});
+exports.POST = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren: getRequest_1.parseChildrenGET,
+};

package/build/operators/regex.d.ts

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

package/build/operators/regex.js

@@ -0,0 +1,46 @@
+"use strict";
+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.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 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' });
+    try {
+        const re = new RegExp(pattern);
+        return re.test(testString);
+    }
+    catch (err) {
+        throw new Error('Regex error:' + (0, helpers_1.errorMessage)(err));
+    }
+});
+const parseChildren = (expression) => {
+    const [testString, pattern] = expression.children;
+    return Object.assign(Object.assign({}, expression), { testString, pattern });
+};
+exports.REGEX = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/split.d.ts

@@ -0,0 +1,11 @@
+import { OperatorObject, EvaluatorNode, BaseOperatorNode } from '../types';
+declare const requiredProperties: readonly ["value"];
+export declare type SplitNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode & {
+    delimiter?: EvaluatorNode;
+    trimWhiteSpace: EvaluatorNode;
+    excludeTrailing: EvaluatorNode;
+};
+export declare const SPLIT: OperatorObject;
+export {};

package/build/operators/split.js

@@ -0,0 +1,51 @@
+"use strict";
+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.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 DEFAULT_DELIMITER = ' ';
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const [value, delimiter, trimWhiteSpace, excludeTrailing] = (yield (0, _operatorUtils_1.evaluateArray)([
+        expression.value,
+        (_a = expression.delimiter) !== null && _a !== void 0 ? _a : DEFAULT_DELIMITER,
+        (_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' });
+    let splitValues = value.split(delimiter);
+    if (trimWhiteSpace)
+        splitValues = splitValues.map((val) => val.trim());
+    if (excludeTrailing && splitValues[splitValues.length - 1] === '')
+        splitValues.pop();
+    return splitValues;
+});
+const parseChildren = (expression) => {
+    const [value, delimiter = DEFAULT_DELIMITER] = expression.children;
+    return Object.assign(Object.assign({}, expression), { value, delimiter });
+};
+exports.SPLIT = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/stringSubstitution.d.ts

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

package/build/operators/stringSubstitution.js

@@ -0,0 +1,40 @@
+"use strict";
+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.STRING_SUBSTITUTION = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['string', 'substitutions'];
+const operatorAliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
+const propertyAliases = { replacements: 'substitutions' };
+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' });
+    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);
+    const replacementsObj = (0, _operatorUtils_1.zipArraysToObject)(Array.from(uniqueParameters), substitutions);
+    return string
+        .split(regex)
+        .map((fragment) => (fragment in replacementsObj ? replacementsObj[fragment] : fragment))
+        .join('');
+});
+const parseChildren = (expression) => {
+    const [string, ...substitutions] = expression.children;
+    return Object.assign(Object.assign({}, expression), { string, substitutions });
+};
+exports.STRING_SUBSTITUTION = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/subtract.d.ts

@@ -0,0 +1,9 @@
+import { BasicExtendedNode } from './logicalAnd';
+import { EvaluatorNode, OperatorObject, BaseOperatorNode } from '../types';
+interface SubtractionNodeWithProps extends BaseOperatorNode {
+    subtract: EvaluatorNode;
+    from: EvaluatorNode;
+}
+export declare type SubtractionNode = BasicExtendedNode & SubtractionNodeWithProps;
+export declare const SUBTRACT: OperatorObject;
+export {};

package/build/operators/subtract.js

@@ -0,0 +1,32 @@
+"use strict";
+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 logicalAnd_1 = require("./logicalAnd");
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = [];
+const operatorAliases = ['-', 'subtract', 'minus', 'takeaway'];
+const propertyAliases = { subtractFrom: 'from' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const values = (yield (0, _operatorUtils_1.evaluateArray)((_a = expression.values) !== null && _a !== void 0 ? _a : [expression.from, expression.subtract], config));
+    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+    if (values.length < 2)
+        throw new Error('- Not enough values provided');
+    return values[0] - values[1];
+});
+exports.SUBTRACT = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren: logicalAnd_1.parseChildren,
+};

package/build/typeCheck.d.ts

@@ -0,0 +1,9 @@
+declare type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object';
+export declare type TypeCheckInput = {
+    value: unknown;
+    name?: string;
+    not?: boolean;
+    expectedType: ExpectedType | ExpectedType[];
+};
+export declare const typeCheck: (...args: TypeCheckInput[]) => true | string;
+export {};