fable 3.1.63 → 3.1.65

package/example_applications/mathematical_playground/TestSuite-Spreadsheet.json

@@ -0,0 +1,198 @@
+{
+	"Name": "Spreadsheet Function Conformance",
+	"Description": "Excel/OpenFormula-compatible function tests. Verifies statistical, rounding, and regression functions against known reference values.",
+	"Expressions":
+		[
+			{
+				"Category": "Aggregation",
+				"Description": "SUM of five values",
+				"Equation": "Result = SUM(Vals)",
+				"ExpectedResult": "150",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "AVG of five values",
+				"Equation": "Result = AVG(Vals)",
+				"ExpectedResult": "30",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MEAN is equivalent to AVG",
+				"Equation": "Result = MEAN(Vals)",
+				"ExpectedResult": "30",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MEDIAN of odd-count dataset",
+				"Equation": "Result = MEDIAN(Vals)",
+				"ExpectedResult": "30",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MEDIAN of even-count dataset (average of middle two)",
+				"Equation": "Result = MEDIAN(Vals)",
+				"ExpectedResult": "25",
+				"Data": { "Vals": [10, 20, 30, 40] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MEDIAN of single element",
+				"Equation": "Result = MEDIAN(Vals)",
+				"ExpectedResult": "42",
+				"Data": { "Vals": [42] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MIN of dataset",
+				"Equation": "Result = MIN(Vals)",
+				"ExpectedResult": "10",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MAX of dataset",
+				"Equation": "Result = MAX(Vals)",
+				"ExpectedResult": "50",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MAX of identical values",
+				"Equation": "Result = MAX(Vals)",
+				"ExpectedResult": "5",
+				"Data": { "Vals": [5, 5, 5] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "MIN of single element",
+				"Equation": "Result = MIN(Vals)",
+				"ExpectedResult": "42",
+				"Data": { "Vals": [42] }
+			},
+			{
+				"Category": "Aggregation",
+				"Description": "COUNT of dataset",
+				"Equation": "Result = COUNT(Vals)",
+				"ExpectedResult": "5",
+				"Data": { "Vals": [10, 20, 30, 40, 50] }
+			},
+			{
+				"Category": "Variance and Standard Deviation",
+				"Description": "Sample variance (VAR) — Excel reference: 2,4,4,4,5,5,7,9 = 4.571429",
+				"Equation": "Result = ROUND(VAR(Vals), 4)",
+				"ExpectedResult": "4.5714",
+				"Data": { "Vals": [2, 4, 4, 4, 5, 5, 7, 9] }
+			},
+			{
+				"Category": "Variance and Standard Deviation",
+				"Description": "Population variance (VARP) — Excel reference: 2,4,4,4,5,5,7,9 = 4",
+				"Equation": "Result = VARP(Vals)",
+				"ExpectedResult": "4",
+				"Data": { "Vals": [2, 4, 4, 4, 5, 5, 7, 9] }
+			},
+			{
+				"Category": "Variance and Standard Deviation",
+				"Description": "Sample standard deviation (STDEV) — Excel reference: 2.138090",
+				"Equation": "Result = ROUND(STDEV(Vals), 4)",
+				"ExpectedResult": "2.1381",
+				"Data": { "Vals": [2, 4, 4, 4, 5, 5, 7, 9] }
+			},
+			{
+				"Category": "Variance and Standard Deviation",
+				"Description": "Population standard deviation (STDEVP) — Excel reference: 2",
+				"Equation": "Result = STDEVP(Vals)",
+				"ExpectedResult": "2",
+				"Data": { "Vals": [2, 4, 4, 4, 5, 5, 7, 9] }
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ROUND to nearest integer",
+				"Equation": "Result = ROUND(3.14159)",
+				"ExpectedResult": "3"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ROUND half-up: 2.5 rounds to 3",
+				"Equation": "Result = ROUND(2.5)",
+				"ExpectedResult": "3"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ROUND to 1 decimal place",
+				"Equation": "Result = ROUND(2.55, 1)",
+				"ExpectedResult": "2.6"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ROUND to 2 decimal places",
+				"Equation": "Result = ROUND(3.14159, 2)",
+				"ExpectedResult": "3.14"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ROUND to 4 decimal places",
+				"Equation": "Result = ROUND(3.14159, 4)",
+				"ExpectedResult": "3.1416"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "TOFIXED pads with zeros",
+				"Equation": "Result = TOFIXED(3.1, 4)",
+				"ExpectedResult": "3.1000"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ABS of negative number",
+				"Equation": "Result = ABS(-5)",
+				"ExpectedResult": "5"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "ABS of positive number (identity)",
+				"Equation": "Result = ABS(5)",
+				"ExpectedResult": "5"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "FLOOR rounds down",
+				"Equation": "Result = FLOOR(3.7)",
+				"ExpectedResult": "3"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "FLOOR of negative rounds toward negative infinity",
+				"Equation": "Result = FLOOR(-3.2)",
+				"ExpectedResult": "-4"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "CEIL rounds up",
+				"Equation": "Result = CEIL(3.2)",
+				"ExpectedResult": "4"
+			},
+			{
+				"Category": "Rounding",
+				"Description": "CEIL of negative rounds toward zero",
+				"Equation": "Result = CEIL(-3.7)",
+				"ExpectedResult": "-3"
+			},
+			{
+				"Category": "Linear Regression",
+				"Description": "SLOPE of perfect linear data y=2x (slope=2)",
+				"Equation": "Result = SLOPE(Y, X)",
+				"ExpectedResult": "2",
+				"Data": { "Y": [2, 4, 6, 8, 10], "X": [1, 2, 3, 4, 5] }
+			},
+			{
+				"Category": "Linear Regression",
+				"Description": "INTERCEPT of perfect linear data y=2x (intercept=0)",
+				"Equation": "Result = INTERCEPT(Y, X)",
+				"ExpectedResult": "0",
+				"Data": { "Y": [2, 4, 6, 8, 10], "X": [1, 2, 3, 4, 5] }
+			}
+		]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.63",
+  "version": "3.1.65",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -8,6 +8,7 @@
     "coverage": "npx quack coverage",
     "test": "npx quack test",
     "build": "npx quack build",
+    "prepublishOnly": "npx quack build",
     "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t fable-image:local",
     "docker-dev-run": "docker run -it -d --name fable-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" fable-image:local",
     "docker-dev-shell": "docker exec -it fable-dev /bin/bash",
@@ -50,7 +51,7 @@
   },
   "homepage": "https://github.com/stevenvelozo/fable",
   "devDependencies": {
-    "quackage": "^1.0.58"
+    "quackage": "^1.0.59"
   },
   "dependencies": {
     "async.eachlimit": "^0.5.2",

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ExpressionTokenizer-DirectiveMutation.js

@@ -13,6 +13,7 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 				'SERIES': { Name: 'Series', Code: 'SERIES', From: null, To: null, Step: null },
 				'MONTECARLO': { Name: 'Monte Carlo Simulation', SampleCount: '1', Code: 'MONTECARLO', Values: {} },
 				'MAP': { Name: 'Map', Code: 'MAP', Values: {}, ValueKeys: [] },
+				'MULTIROWMAP': { Name: 'Multi-Row Map', Code: 'MULTIROWMAP', RowsAddress: null, SeriesStart: null, SeriesStep: null, Values: {}, ValueKeys: [] },
 			});
 
 		this.defaultDirective = this.directiveTypes.SOLVE;
@@ -84,7 +85,7 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 						let tmpVariableToken = pTokens[i + 1];
 						if (typeof(tmpVariableToken) === 'string' && (tmpVariableToken.length > 0))
 						{
-							tmpNewMonteCarloDirectiveDescription.Values[tmpVariableToken] = 
+							tmpNewMonteCarloDirectiveDescription.Values[tmpVariableToken] =
 							{
 								Token: tmpVariableToken,
 								Easing: 'Linear', // could be parametric, logarithmic, bezier, uniform, normal, etc.
@@ -169,7 +170,7 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 						if (typeof(tmpVariableToken) === 'string' && (tmpVariableToken.length > 0))
 						{
 							tmpNewMapDirectiveDescription.ValueKeys.push(tmpVariableToken);
-							tmpNewMapDirectiveDescription.Values[tmpVariableToken] = 
+							tmpNewMapDirectiveDescription.Values[tmpVariableToken] =
 							{
 								Token: tmpVariableToken,
 								Address: pTokens[i + 3],
@@ -188,10 +189,303 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 		return tmpNewMapDirectiveDescription;
 	}
 
+	parseMultiRowMapDirective(pTokens)
+	{
+		// Parse MULTIROWMAP directive tokens.
+		// Syntax: MULTIROWMAP ROWS FROM <address> [SERIESSTART <n>] [SERIESSTEP <n>] VAR <name> FROM <property> OFFSET <n> DEFAULT <defaultValue> ...
+		// OFFSET defaults to 0 (current row) if not specified.
+		// DEFAULT defaults to '0' if not specified.
+		// OFFSET 0 = current row, OFFSET -1 = previous row, OFFSET -2 = two rows back, etc.
+		// Positive OFFSET values look forward (e.g., OFFSET 1 = next row, OFFSET 2 = two rows ahead).
+		// SERIESSTART defaults to 0 (first row). Negative values count from the end (e.g., -2 = second-to-last row).
+		// SERIESSTEP defaults to 1. Use -1 to iterate backwards through rows.
+		let tmpNewDirectiveDescription = JSON.parse(JSON.stringify(this.directiveTypes.MULTIROWMAP));
+
+		for (let i = 0; i < pTokens.length; i++)
+		{
+			let tmpToken = pTokens[i].toUpperCase();
+			switch(tmpToken)
+			{
+				case 'ROWS':
+					// Expect ROWS FROM <address>
+					if (((i + 2) < pTokens.length) && (pTokens[i + 1].toUpperCase() === 'FROM'))
+					{
+						tmpNewDirectiveDescription.RowsAddress = pTokens[i + 2];
+						i = i + 2;
+					}
+					break;
+
+				case 'SERIESSTART':
+					if ((i + 1) < pTokens.length)
+					{
+						// Handle negative values which get tokenized as separate - and number tokens
+						let tmpStartValue = pTokens[i + 1];
+						if ((tmpStartValue === '-') && ((i + 2) < pTokens.length))
+						{
+							tmpStartValue = '-' + pTokens[i + 2];
+							i = i + 2;
+						}
+						else
+						{
+							i = i + 1;
+						}
+						tmpNewDirectiveDescription.SeriesStart = tmpStartValue;
+					}
+					break;
+
+				case 'SERIESSTEP':
+					if ((i + 1) < pTokens.length)
+					{
+						// Handle negative values which get tokenized as separate - and number tokens
+						let tmpStepValue = pTokens[i + 1];
+						if ((tmpStepValue === '-') && ((i + 2) < pTokens.length))
+						{
+							tmpStepValue = '-' + pTokens[i + 2];
+							i = i + 2;
+						}
+						else
+						{
+							i = i + 1;
+						}
+						tmpNewDirectiveDescription.SeriesStep = tmpStepValue;
+					}
+					break;
+
+				case 'VARIABLE':
+				case 'VAR':
+				case 'V':
+					// Expect: VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <defaultValue>]
+					if (((i + 3) < pTokens.length) && (pTokens[i + 2].toUpperCase() === 'FROM'))
+					{
+						let tmpVariableName = pTokens[i + 1];
+						let tmpProperty = pTokens[i + 3];
+
+						if (typeof(tmpVariableName) === 'string' && (tmpVariableName.length > 0))
+						{
+							let tmpVariableDescriptor = {
+								Token: tmpVariableName,
+								Property: tmpProperty,
+								RowOffset: 0,
+								Default: '0',
+							};
+
+							let tmpCurrentIndex = i + 3;
+
+							// Scan forward for OFFSET and DEFAULT in any order
+							while (tmpCurrentIndex + 1 < pTokens.length)
+							{
+								let tmpNextToken = pTokens[tmpCurrentIndex + 1].toUpperCase();
+								if (tmpNextToken === 'OFFSET')
+								{
+									if (tmpCurrentIndex + 2 < pTokens.length)
+									{
+										// Handle negative offsets which get tokenized as separate - and number tokens
+										let tmpOffsetValue = pTokens[tmpCurrentIndex + 2];
+										if ((tmpOffsetValue === '-') && (tmpCurrentIndex + 3 < pTokens.length))
+										{
+											tmpOffsetValue = '-' + pTokens[tmpCurrentIndex + 3];
+											tmpCurrentIndex = tmpCurrentIndex + 3;
+										}
+										else
+										{
+											tmpCurrentIndex = tmpCurrentIndex + 2;
+										}
+										tmpVariableDescriptor.RowOffset = parseInt(tmpOffsetValue);
+										if (isNaN(tmpVariableDescriptor.RowOffset))
+										{
+											tmpVariableDescriptor.RowOffset = 0;
+										}
+									}
+								}
+								else if (tmpNextToken === 'DEFAULT')
+								{
+									if (tmpCurrentIndex + 2 < pTokens.length)
+									{
+										// Handle negative defaults which get tokenized as separate - and number tokens
+										let tmpDefaultValue = pTokens[tmpCurrentIndex + 2];
+										if ((tmpDefaultValue === '-') && (tmpCurrentIndex + 3 < pTokens.length))
+										{
+											tmpDefaultValue = '-' + pTokens[tmpCurrentIndex + 3];
+											tmpCurrentIndex = tmpCurrentIndex + 3;
+										}
+										else
+										{
+											tmpCurrentIndex = tmpCurrentIndex + 2;
+										}
+										tmpVariableDescriptor.Default = tmpDefaultValue;
+									}
+								}
+								else
+								{
+									// Not a recognized sub-keyword for this variable; stop scanning
+									break;
+								}
+							}
+
+							i = tmpCurrentIndex;
+
+							tmpNewDirectiveDescription.ValueKeys.push(tmpVariableName);
+							tmpNewDirectiveDescription.Values[tmpVariableName] = tmpVariableDescriptor;
+						}
+					}
+					break;
+
+				default:
+					// Ignore other tokens
+					break;
+			}
+		}
+
+		return tmpNewDirectiveDescription;
+	}
+
+	rewriteTernaryOperators(pResultObject)
+	{
+		let tmpTokens = pResultObject.RawTokens;
+
+		// Scan right-to-left so nested ternaries (innermost first) are handled correctly.
+		for (let i = tmpTokens.length - 1; i >= 0; i--)
+		{
+			if (tmpTokens[i] !== '?')
+			{
+				continue;
+			}
+
+			// Found a ? token at index i.
+			// Walk left to find the start of the condition expression.
+			// The condition starts after the previous comma, open parenthesis, assignment operator, or beginning of tokens.
+			let tmpConditionStart = 0;
+			let tmpParenDepth = 0;
+			for (let j = i - 1; j >= 0; j--)
+			{
+				if (tmpTokens[j] === ')')
+				{
+					tmpParenDepth++;
+				}
+				else if (tmpTokens[j] === '(')
+				{
+					if (tmpParenDepth > 0)
+					{
+						tmpParenDepth--;
+					}
+					else
+					{
+						// We hit an unmatched open paren — condition starts after it
+						tmpConditionStart = j + 1;
+						break;
+					}
+				}
+				else if (tmpParenDepth === 0)
+				{
+					let tmpTokenDescriptor = this.ExpressionParser.tokenMap[tmpTokens[j]];
+					if (tmpTokenDescriptor && (tmpTokenDescriptor.Type === 'Assignment' || tmpTokens[j] === ','))
+					{
+						tmpConditionStart = j + 1;
+						break;
+					}
+				}
+			}
+
+			// Walk right from ? to find the matching :: at the same parenthesis depth.
+			let tmpSeparatorIndex = -1;
+			tmpParenDepth = 0;
+			for (let j = i + 1; j < tmpTokens.length; j++)
+			{
+				if (tmpTokens[j] === '(')
+				{
+					tmpParenDepth++;
+				}
+				else if (tmpTokens[j] === ')')
+				{
+					if (tmpParenDepth > 0)
+					{
+						tmpParenDepth--;
+					}
+					else
+					{
+						// Hit closing paren at our depth — no :: found in this group
+						break;
+					}
+				}
+				else if (tmpTokens[j] === '::' && tmpParenDepth === 0)
+				{
+					tmpSeparatorIndex = j;
+					break;
+				}
+			}
+
+			if (tmpSeparatorIndex === -1)
+			{
+				pResultObject.ExpressionParserLog.push(`ExpressionParser.rewriteTernaryOperators found a ? at token index ${i} with no matching :: separator.`);
+				this.log.warn(pResultObject.ExpressionParserLog[pResultObject.ExpressionParserLog.length - 1]);
+				continue;
+			}
+
+			// Walk right from :: to find the end of the false branch.
+			// The false branch ends at the next comma, close parenthesis, or end of tokens at the same depth.
+			let tmpFalseBranchEnd = tmpTokens.length;
+			tmpParenDepth = 0;
+			for (let j = tmpSeparatorIndex + 1; j < tmpTokens.length; j++)
+			{
+				if (tmpTokens[j] === '(')
+				{
+					tmpParenDepth++;
+				}
+				else if (tmpTokens[j] === ')')
+				{
+					if (tmpParenDepth > 0)
+					{
+						tmpParenDepth--;
+					}
+					else
+					{
+						// Unmatched close paren — false branch ends here
+						tmpFalseBranchEnd = j;
+						break;
+					}
+				}
+				else if (tmpParenDepth === 0)
+				{
+					if (tmpTokens[j] === ',')
+					{
+						tmpFalseBranchEnd = j;
+						break;
+					}
+				}
+			}
+
+			// Extract the three segments
+			let tmpConditionTokens = tmpTokens.slice(tmpConditionStart, i);
+			let tmpTrueBranchTokens = tmpTokens.slice(i + 1, tmpSeparatorIndex);
+			let tmpFalseBranchTokens = tmpTokens.slice(tmpSeparatorIndex + 1, tmpFalseBranchEnd);
+
+			// Build the replacement: ternary((condition), trueBranch, falseBranch)
+			// The condition is wrapped in its own parentheses to ensure correct
+			// precedence grouping when arithmetic appears on both sides of a comparison.
+			let tmpReplacementTokens = ['ternary', '(', '('];
+			tmpReplacementTokens = tmpReplacementTokens.concat(tmpConditionTokens);
+			tmpReplacementTokens.push(')');
+			tmpReplacementTokens.push(',');
+			tmpReplacementTokens = tmpReplacementTokens.concat(tmpTrueBranchTokens);
+			tmpReplacementTokens.push(',');
+			tmpReplacementTokens = tmpReplacementTokens.concat(tmpFalseBranchTokens);
+			tmpReplacementTokens.push(')');
+
+			// Splice the replacement into the token array
+			tmpTokens.splice(tmpConditionStart, tmpFalseBranchEnd - tmpConditionStart, ...tmpReplacementTokens);
+
+			// Adjust i to re-scan from the start of what we just inserted (in case of nested ternaries in the condition)
+			i = tmpConditionStart;
+		}
+	}
+
 	parseDirectives(pResultObject)
 	{
 		let tmpResults = (typeof(pResultObject) === 'object') ? pResultObject : { ExpressionParserLog: [] };
 
+		// Rewrite ternary operators before directive parsing
+		this.rewriteTernaryOperators(tmpResults);
+
 		tmpResults.SolverDirectives = this.defaultDirective;
 		tmpResults.SolverDirectiveTokens = [];
 
@@ -258,6 +552,9 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 						case 'MAP':
 							tmpResults.SolverDirectives = this.parseMapDirective(tmpResults.SolverDirectiveTokens);
 							break;
+						case 'MULTIROWMAP':
+							tmpResults.SolverDirectives = this.parseMultiRowMapDirective(tmpResults.SolverDirectiveTokens);
+							break;
 						default:
 							// No further parsing needed
 							break;

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ExpressionTokenizer.js

@@ -215,7 +215,7 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 						{
 							if (tmpCurrentToken.length > 0)
 							{
-								tmpResults.RawTokens.push(tmpTokenKey);
+								tmpResults.RawTokens.push(tmpCurrentToken);
 							}
 							tmpCurrentToken = '';
 							tmpCurrentTokenType = false;

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-FunctionMap.json

@@ -285,6 +285,11 @@
 		"Address": "fable.Logic.when"
 	},
 
+	"ternary": {
+		"Name": "numeric-aware ternary selection (used by ? :: operator desugaring)",
+		"Address": "fable.Logic.ternary"
+	},
+
 	"entryinset": {
 		"Name": "Entry in Set",
 		"Address": "fable.Math.entryInSet"
@@ -465,10 +470,6 @@
 		"Address": "fable.Math.interceptPrecise"
 	},
 
-	"polynomialregression": {
-		"Name": "Perform an nth degree Polynomial Regression on a Set of X and Y Values",
-		"Address": "fable.Math.polynomialRegression"
-	},
 	"leastsquares": {
 		"Name": "Perform a Least Squares Regression on a Set of Independent Variable Vectors and a Dependent Variable Vector",
 		"Address": "fable.Math.leastSquares"

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-TokenMap.json

@@ -46,7 +46,7 @@
 			"Name": "Set Concatenate",
 			"Token": ",",
 			"Function": "fable.Math.setConcatenate",
-			"Precedence": 5,
+			"Precedence": 6,
 			"Type": "Operator"
 		},
 
@@ -99,5 +99,69 @@
 			"Function": "fable.Math.subtractPrecise",
 			"Precedence": 4,
 			"Type": "Operator"
+		},
+
+	">":
+		{
+			"Name": "Greater Than",
+			"Token": ">",
+			"Function": "fable.Math.greaterThanOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	">=":
+		{
+			"Name": "Greater Than or Equal",
+			"Token": ">=",
+			"Function": "fable.Math.greaterThanOrEqualOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"<":
+		{
+			"Name": "Less Than",
+			"Token": "<",
+			"Function": "fable.Math.lessThanOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"<=":
+		{
+			"Name": "Less Than or Equal",
+			"Token": "<=",
+			"Function": "fable.Math.lessThanOrEqualOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"==":
+		{
+			"Name": "Equal",
+			"Token": "==",
+			"Function": "fable.Math.equalOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"!=":
+		{
+			"Name": "Not Equal",
+			"Token": "!=",
+			"Function": "fable.Math.notEqualOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+
+	"?":
+		{
+			"Name": "Ternary Condition",
+			"Token": "?",
+			"Precedence": 0,
+			"Type": "Ternary"
+		},
+	"::":
+		{
+			"Name": "Ternary Separator",
+			"Token": "::",
+			"Precedence": 0,
+			"Type": "Ternary"
 		}
 }