fig-tree-evaluator 2.7.0 → 2.8.0

package/build/operators/{buildObject.js → BUILD_OBJECT/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,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUILD_OBJECT = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['properties'];
-const operatorAliases = ['buildObject', 'build', 'object'];
-const propertyAliases = {
-    values: 'properties',
-    keyValPairs: 'properties',
-    keyValuePairs: 'properties',
-};
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
 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];
     });
-    config.typeChecker({ name: 'properties', value: expression.properties, expectedType: 'array' });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { properties: expression.properties }));
     const evaluated = expression.properties
         .filter((element) => element instanceof Object && 'key' in element && 'value' in element)
         .map(({ key, value }) => evaluatePair([key, value]));
@@ -40,9 +57,9 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { properties });
 };
 exports.BUILD_OBJECT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

package/build/operators/CONDITIONAL/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/CONDITIONAL/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 = 'Return a value based on a condition';
+const aliases = ['?', 'conditional', 'ifThen'];
+const parameters = [
+    {
+        name: 'condition',
+        description: 'The expression to check for truthiness',
+        aliases: [],
+        required: true,
+        type: 'any',
+    },
+    {
+        name: 'valueIfTrue',
+        description: 'Value to return if condition is true',
+        aliases: ['ifTrue'],
+        required: true,
+        type: 'any',
+    },
+    {
+        name: 'valueIfFalse',
+        description: 'Value to return if condition is false',
+        aliases: ['ifFalse', 'ifNot'],
+        required: true,
+        type: 'any',
+    },
+];
+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/CONDITIONAL/index.d.ts

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

package/build/operators/CONDITIONAL/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/{conditional.d.ts → CONDITIONAL/operator.d.ts}

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

package/build/operators/{conditional.js → CONDITIONAL/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,10 +33,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONDITIONAL = void 0;
-const evaluate_1 = require("../evaluate");
-const requiredProperties = ['condition', 'valueIfTrue', 'valueIfFalse'];
-const operatorAliases = ['?', 'conditional', 'ifThen'];
-const propertyAliases = { ifTrue: 'valueIfTrue', ifFalse: 'valueIfFalse', ifNot: 'valueIfFalse' };
+const evaluate_1 = require("../../evaluate");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     const condition = yield (0, evaluate_1.evaluatorFunction)(expression.condition, config);
     return !!condition
@@ -25,9 +46,9 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { condition, valueIfTrue, valueIfFalse });
 };
 exports.CONDITIONAL = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

package/build/operators/COUNT/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/COUNT/data.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Count elements in an array';
+const aliases = ['count', 'length'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'An array to count',
+        aliases: [],
+        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/COUNT/index.d.ts

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

package/build/operators/COUNT/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/COUNT/operator.d.ts

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

package/build/operators/COUNT/operator.js

@@ -0,0 +1,50 @@
+"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.COUNT = 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 = yield (0, _operatorUtils_1.evaluateArray)(expression.values, config);
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values }));
+    return values.length;
+});
+exports.COUNT = {
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};

package/build/operators/CUSTOM_FUNCTIONS/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/CUSTOM_FUNCTIONS/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 = 'Call a custom function (defined in options)';
+const aliases = [
+    'customFunctions',
+    'customFunction',
+    'objectFunctions',
+    'function',
+    'functions',
+    'runFunction',
+];
+const parameters = [
+    {
+        name: 'functionPath',
+        description: 'Path (in options.functions) to the required function',
+        aliases: ['functionsPath', 'functionName', 'funcName', 'path', 'name'],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'args',
+        description: 'Arguments for the function',
+        aliases: ['arguments', 'variables'],
+        required: false,
+        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/CUSTOM_FUNCTIONS/index.d.ts

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

package/build/operators/CUSTOM_FUNCTIONS/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/{customFunctions.d.ts → CUSTOM_FUNCTIONS/operator.d.ts}

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

package/build/operators/{customFunctions.js → CUSTOM_FUNCTIONS/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) {
@@ -14,28 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CUSTOM_FUNCTIONS = void 0;
 const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['functionPath'];
-const operatorAliases = [
-    'customFunctions',
-    'customFunction',
-    'objectFunctions',
-    'function',
-    'functions',
-    'runFunction',
-];
-const propertyAliases = {
-    functionsPath: 'functionPath',
-    functionName: 'functionPath',
-    funcName: 'functionPath',
-    path: 'functionPath',
-    arguments: 'args',
-    variables: 'args',
-};
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d;
     const [functionPath, ...args] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, ...(expression.args || [])], config));
-    config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { functionPath, args }));
     const { data, functions } = config.options;
     const func = ((_b = (_a = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _a !== void 0 ? _a : (0, object_property_extractor_1.default)(data, functionPath, null)) !== null && _b !== void 0 ? _b : (0, object_property_extractor_1.default)(config.options, functionPath));
     const shouldUseCache = (_d = (_c = expression.useCache) !== null && _c !== void 0 ? _c : config.options.useCache) !== null && _d !== void 0 ? _d : false;
@@ -49,9 +56,9 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { functionPath, args });
 };
 exports.CUSTOM_FUNCTIONS = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

package/build/operators/DIVIDE/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/DIVIDE/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 = 'Divide one numerical value by another';
+const aliases = ['/', 'divide', '÷'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Array of values - 1st element will be divided by the first',
+        aliases: [],
+        required: false,
+        type: 'array',
+    },
+    {
+        name: 'dividend',
+        description: 'The number that will be divided',
+        aliases: ['divide'],
+        required: false,
+        type: 'number',
+    },
+    {
+        name: 'divisor',
+        description: 'The number that dividend will be divided by',
+        aliases: ['by', 'divideBy'],
+        required: false,
+        type: 'number',
+    },
+    {
+        name: 'output',
+        description: 'Whether to output a quotient, remainder or decimal',
+        aliases: [],
+        required: false,
+        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/DIVIDE/index.d.ts

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

package/build/operators/DIVIDE/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/{divide.d.ts → DIVIDE/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 DivisionNodeWithProps extends BaseOperatorNode {
     dividend: EvaluatorNode;
     divisor: EvaluatorNode;

package/build/operators/DIVIDE/operator.js

@@ -0,0 +1,62 @@
+"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.DIVIDE = 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, dividend, divisor, output] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.dividend, expression.divisor, expression.output], config));
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, dividend, divisor, output }));
+    const vals = values !== null && values !== void 0 ? values : [dividend, divisor];
+    if (vals.length < 2)
+        throw new Error('- Not enough values provided');
+    if (!vals[1])
+        throw new Error('Division by zero!');
+    switch (output) {
+        case 'quotient':
+            return Math.floor(vals[0] / vals[1]);
+        case 'remainder':
+            return vals[0] % vals[1];
+        default:
+            return vals[0] / vals[1];
+    }
+});
+exports.DIVIDE = {
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};

package/build/operators/EQUAL/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/EQUAL/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 = 'Test multiple values are equal';
+const aliases = ['=', 'eq', 'equal', 'equals'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Array of values to check for equality',
+        aliases: [],
+        required: true,
+        type: 'array',
+    },
+    {
+        name: 'nullEqualsUndefined',
+        description: 'Whether a null value should be considered equal to an undefined value',
+        aliases: [],
+        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/EQUAL/index.d.ts

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