fable 3.1.64 → 3.1.65

package/example_applications/mathematical_playground/TestSuite-AcidTest.json

@@ -0,0 +1,178 @@
+{
+	"Name": "Parser Acid Test",
+	"Description": "Stress tests for operator precedence, parenthesis handling, comparison operators, and ternary syntax. Catches common parser bugs.",
+	"Expressions":
+		[
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Multiplication before addition: 2 + 3*4 = 14",
+				"Equation": "Result = 2 + 3 * 4",
+				"ExpectedResult": "14"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Parentheses override: (2+3)*4 = 20",
+				"Equation": "Result = (2 + 3) * 4",
+				"ExpectedResult": "20"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Exponent before multiply: 2^3 * 4 = 32",
+				"Equation": "Result = 2^3 * 4",
+				"ExpectedResult": "32"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Mixed all precedences: 2^3 + 4*5 - 6/3 = 26",
+				"Equation": "Result = 2^3 + 4 * 5 - 6 / 3",
+				"ExpectedResult": "26"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Division before subtraction: 100 - 50 / 5 = 90",
+				"Equation": "Result = 100 - 50 / 5",
+				"ExpectedResult": "90"
+			},
+			{
+				"Category": "Parenthesis Nesting",
+				"Description": "Deep nesting: ((((1+2)*3)-4)/5) = 1",
+				"Equation": "Result = ((((1 + 2) * 3) - 4) / 5)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Parenthesis Nesting",
+				"Description": "Redundant parentheses: ((((42)))) = 42",
+				"Equation": "Result = ((((42))))",
+				"ExpectedResult": "42"
+			},
+			{
+				"Category": "Left-to-Right Associativity",
+				"Description": "Subtraction is left-to-right: 10 - 3 - 2 = 5",
+				"Equation": "Result = 10 - 3 - 2",
+				"ExpectedResult": "5"
+			},
+			{
+				"Category": "Left-to-Right Associativity",
+				"Description": "Division is left-to-right: 20 / 4 / 5 = 1",
+				"Equation": "Result = 20 / 4 / 5",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Negative Numbers",
+				"Description": "(-3)^2 = 9 (parenthesized negative base)",
+				"Equation": "Result = (-3)^2",
+				"ExpectedResult": "9"
+			},
+			{
+				"Category": "Negative Numbers",
+				"Description": "Addition with negative: 4 + -3 = 1",
+				"Equation": "Result = 4 + -3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Exponentiation",
+				"Description": "2^3^2 = 64 (left-to-right in this parser)",
+				"Equation": "Result = 2^3^2",
+				"ExpectedResult": "64"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Greater than true: 5 > 3 = 1",
+				"Equation": "Result = 5 > 3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Greater than false: 3 > 5 = 0",
+				"Equation": "Result = 3 > 5",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Equal true: 5 == 5 = 1",
+				"Equation": "Result = 5 == 5",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Not equal false: 5 != 5 = 0",
+				"Equation": "Result = 5 != 5",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "GTE boundary: 3 >= 3 = 1",
+				"Equation": "Result = 3 >= 3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "LTE false: 3 <= 2 = 0",
+				"Equation": "Result = 3 <= 2",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Negative comparison: (-3) < 0 = 1",
+				"Equation": "Result = (-3) < 0",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Precedence",
+				"Description": "Arithmetic before comparison: 2+3 > 1+2 = 1",
+				"Equation": "Result = 2 + 3 > 1 + 2",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "True branch: 5>3 ? 10+20 :: 30+40 = 30",
+				"Equation": "Result = 5 > 3 ? 10 + 20 :: 30 + 40",
+				"ExpectedResult": "30"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "False branch: 3>5 ? 10+20 :: 30+40 = 70",
+				"Equation": "Result = 3 > 5 ? 10 + 20 :: 30 + 40",
+				"ExpectedResult": "70"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Nested ternary: 1>0 ? (2>3 ? 100 :: 200) :: 300 = 200",
+				"Equation": "Result = 1 > 0 ? (2 > 3 ? 100 :: 200) :: 300",
+				"ExpectedResult": "200"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Ternary with variables (absolute value pattern)",
+				"Equation": "Result = X > 0 ? X :: 0 - X",
+				"ExpectedResult": "5",
+				"Data": { "X": -5 }
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Ternary with variables (positive input)",
+				"Equation": "Result = X > 0 ? X :: 0 - X",
+				"ExpectedResult": "5",
+				"Data": { "X": 5 }
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Equality comparison in ternary",
+				"Equation": "Result = 0 == 0 ? 1 :: 0",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Functions with Comparisons",
+				"Description": "Function result in comparison via variable",
+				"Equation": "Result = SUM(Vals) > 5",
+				"ExpectedResult": "1",
+				"Data": { "Vals": [1, 2, 3] }
+			},
+			{
+				"Category": "Complex Expressions",
+				"Description": "All arithmetic operators in one expression",
+				"Equation": "Result = (10 + 5) * 2 - 8 / 4 + 3^2 % 5",
+				"ExpectedResult": "37"
+			}
+		]
+}

package/example_applications/mathematical_playground/TestSuite-Identities.json

@@ -0,0 +1,147 @@
+{
+	"Name": "Mathematical Identities",
+	"Description": "Classic mathematical identities from NIST DLMF and standard references. Tests correctness of trig, logarithmic, and algebraic operations.",
+	"Expressions":
+		[
+			{
+				"Category": "Pythagorean Identity",
+				"Description": "sin^2(30) + cos^2(30) = 1",
+				"Equation": "Result = ROUND(sin(rad(30))^2 + cos(rad(30))^2, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Pythagorean Identity",
+				"Description": "sin^2(45) + cos^2(45) = 1",
+				"Equation": "Result = ROUND(sin(rad(45))^2 + cos(rad(45))^2, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Pythagorean Identity",
+				"Description": "sin^2(60) + cos^2(60) = 1",
+				"Equation": "Result = ROUND(sin(rad(60))^2 + cos(rad(60))^2, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Double Angle Formula",
+				"Description": "2*sin(30)*cos(30) = sin(60)",
+				"Equation": "Result = ROUND(2 * sin(rad(30)) * cos(rad(30)), 10)",
+				"ExpectedResult": "0.8660254038"
+			},
+			{
+				"Category": "Double Angle Formula",
+				"Description": "sin(60) directly for comparison",
+				"Equation": "Result = ROUND(sin(rad(60)), 10)",
+				"ExpectedResult": "0.8660254038"
+			},
+			{
+				"Category": "Tangent Identity",
+				"Description": "tan(45) = 1",
+				"Equation": "Result = ROUND(tan(rad(45)), 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "sqrt(x)^2 = x (within rounding)",
+				"Equation": "Result = ROUND(sqrt(7)^2, 10)",
+				"ExpectedResult": "7"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "sqrt(144) = 12 (perfect square)",
+				"Equation": "Result = sqrt(144)",
+				"ExpectedResult": "12"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "x^0 = 1 for any nonzero x",
+				"Equation": "Result = 5^0",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "x^1 = x",
+				"Equation": "Result = 7^1",
+				"ExpectedResult": "7"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "x^2 * x^3 = x^5 (exponent addition)",
+				"Equation": "Result = 2^2 * 2^3",
+				"ExpectedResult": "32"
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "(a+b)(a-b) = a^2 - b^2 (difference of squares)",
+				"Equation": "Result = (A + B) * (A - B)",
+				"ExpectedResult": "40",
+				"Data": { "A": 7, "B": 3 }
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "a^2 - b^2 directly for comparison",
+				"Equation": "Result = A^2 - B^2",
+				"ExpectedResult": "40",
+				"Data": { "A": 7, "B": 3 }
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "(a+b)^2 = a^2 + 2ab + b^2",
+				"Equation": "Result = (3 + 4)^2",
+				"ExpectedResult": "49"
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "a^2 + 2ab + b^2 directly for comparison",
+				"Equation": "Result = 3^2 + 2 * 3 * 4 + 4^2",
+				"ExpectedResult": "49"
+			},
+			{
+				"Category": "Reciprocal Identity",
+				"Description": "1/(1/x) = x (within rounding)",
+				"Equation": "Result = ROUND(1 / (1 / 7), 10)",
+				"ExpectedResult": "7"
+			},
+			{
+				"Category": "Constants",
+				"Description": "Pi starts with 3.14159265",
+				"Equation": "Result = ROUND(pi(), 8)",
+				"ExpectedResult": "3.14159265"
+			},
+			{
+				"Category": "Constants",
+				"Description": "Euler's number starts with 2.71828183",
+				"Equation": "Result = ROUND(euler(), 8)",
+				"ExpectedResult": "2.71828183"
+			},
+			{
+				"Category": "Logarithmic Identity",
+				"Description": "log(1) = 0",
+				"Equation": "Result = log(1)",
+				"ExpectedResult": "0.000000000"
+			},
+			{
+				"Category": "Logarithmic Identity",
+				"Description": "exp(0) = 1",
+				"Equation": "Result = exp(0)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Additive Identity",
+				"Description": "x + 0 = x",
+				"Equation": "Result = 42 + 0",
+				"ExpectedResult": "42"
+			},
+			{
+				"Category": "Multiplicative Identity",
+				"Description": "x * 1 = x",
+				"Equation": "Result = 42 * 1",
+				"ExpectedResult": "42"
+			},
+			{
+				"Category": "Multiplicative Zero",
+				"Description": "x * 0 = 0",
+				"Equation": "Result = 42 * 0",
+				"ExpectedResult": "0"
+			}
+		]
+}

package/example_applications/mathematical_playground/TestSuite-Precision.json

@@ -0,0 +1,127 @@
+{
+	"Name": "Numeric Precision Stress Tests",
+	"Description": "Tests that catch IEEE 754 floating-point errors. The expression parser uses big.js for arbitrary precision, so these should all pass cleanly.",
+	"Expressions":
+		[
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "0.1 + 0.2 = 0.3 (classic IEEE 754 failure)",
+				"Equation": "Result = 0.1 + 0.2",
+				"ExpectedResult": "0.3"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "0.3 - 0.1 = 0.2",
+				"Equation": "Result = 0.3 - 0.1",
+				"ExpectedResult": "0.2"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "0.7 + 0.1 = 0.8",
+				"Equation": "Result = 0.7 + 0.1",
+				"ExpectedResult": "0.8"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "-0.1 + -0.2 = -0.3",
+				"Equation": "Result = -0.1 + -0.2",
+				"ExpectedResult": "-0.3"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "1.0 - 0.9 - 0.1 = 0 (catastrophic cancellation)",
+				"Equation": "Result = 1.0 - 0.9 - 0.1",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Large Numbers",
+				"Description": "Large integer multiplication",
+				"Equation": "Result = 99999999999999 * 99999999999999",
+				"ExpectedResult": "9.999999999999800000000000001e+27"
+			},
+			{
+				"Category": "Large Numbers",
+				"Description": "Large integer addition",
+				"Equation": "Result = 123456789012345 + 987654321098765",
+				"ExpectedResult": "1111111110111110"
+			},
+			{
+				"Category": "Large Numbers",
+				"Description": "2^53 exact (JavaScript MAX_SAFE_INTEGER + 1)",
+				"Equation": "Result = 2^53",
+				"ExpectedResult": "9007199254740992"
+			},
+			{
+				"Category": "Small Number Precision",
+				"Description": "Subtraction preserving small difference",
+				"Equation": "Result = 1000000.001 - 1000000",
+				"ExpectedResult": "0.001"
+			},
+			{
+				"Category": "Small Number Precision",
+				"Description": "Very small number multiplication",
+				"Equation": "Result = 0.000001 * 0.000001",
+				"ExpectedResult": "1e-12"
+			},
+			{
+				"Category": "Division Precision",
+				"Description": "1/3 * 3 approaches 1 (repeating decimal)",
+				"Equation": "Result = ROUND(1 / 3 * 3, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Division Precision",
+				"Description": "Large number / same number = 1 (within rounding)",
+				"Equation": "Result = ROUND(1000000 / 7 * 7, 10)",
+				"ExpectedResult": "1000000"
+			},
+			{
+				"Category": "Division Precision",
+				"Description": "1 / 1000000 = 0.000001",
+				"Equation": "Result = 1 / 1000000",
+				"ExpectedResult": "0.000001"
+			},
+			{
+				"Category": "Chained Operations",
+				"Description": "Add then subtract should cancel exactly",
+				"Equation": "Result = ((((1 + 0.0001) - 0.0001) * 10000) / 10000)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Modulus",
+				"Description": "10 % 3 = 1",
+				"Equation": "Result = 10 % 3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Modulus",
+				"Description": "7.5 % 2.5 = 0 (exact division)",
+				"Equation": "Result = 7.5 % 2.5",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Power Precision",
+				"Description": "3^7 = 2187",
+				"Equation": "Result = 3^7",
+				"ExpectedResult": "2187"
+			},
+			{
+				"Category": "Power Precision",
+				"Description": "10^10 = 10000000000",
+				"Equation": "Result = 10^10",
+				"ExpectedResult": "10000000000"
+			},
+			{
+				"Category": "Negative Number Precision",
+				"Description": "(-1)^2 = 1",
+				"Equation": "Result = (-1)^2",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Negative Number Precision",
+				"Description": "(-2) * (-3) = 6",
+				"Equation": "Result = (-2) * (-3)",
+				"ExpectedResult": "6"
+			}
+		]
+}

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.64",
+  "version": "3.1.65",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {