fable 3.1.63 → 3.1.64

package/docs/services/expression-parser.md

@@ -264,6 +264,65 @@ parser.solve('Result = MONTECARLO SAMPLECOUNT 5000 VAR x PT x -3 PT x 3 VAR y PT
     {}, {}, manifest, dest);
 ```
 
+### MULTIROWMAP Expressions
+
+Iterate over an array of objects (rows) with multi-row lookback and lookahead. Each variable can reference the current row or any row at a relative offset, with configurable defaults for out-of-bounds access.
+
+```javascript
+// Syntax:
+// Result = MULTIROWMAP ROWS FROM <address>
+//   [SERIESSTART <n>] [SERIESSTEP <n>]
+//   VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <value>]
+//   ... : <expression>
+
+// Basic: compute area from each row's Width and Height
+parser.solve('Areas = MULTIROWMAP ROWS FROM Rows VAR w FROM Width VAR h FROM Height : w * h',
+    { Rows: [{Width:10,Height:20}, {Width:30,Height:40}] }, {}, manifest, dest);
+// dest.Areas === ['200', '1200']
+
+// Previous row lookback (day-over-day change)
+parser.solve('Change = MULTIROWMAP ROWS FROM Prices VAR Today FROM Close VAR Yesterday FROM Close OFFSET -1 DEFAULT 0 : Today - Yesterday',
+    data, {}, manifest, dest);
+
+// Two-row lookback (Fibonacci verification)
+parser.solve('Check = MULTIROWMAP ROWS FROM FibRows VAR Cur FROM Fib VAR P1 FROM Fib OFFSET -1 DEFAULT 0 VAR P2 FROM Fib OFFSET -2 DEFAULT 0 : Cur - (P1 + P2)',
+    data, {}, manifest, dest);
+
+// Forward lookback (next row reference)
+parser.solve('NextDiff = MULTIROWMAP ROWS FROM Rows VAR Cur FROM Value VAR Next FROM Value OFFSET 1 DEFAULT 0 : Next - Cur',
+    data, {}, manifest, dest);
+
+// Central difference (both directions)
+parser.solve('Deriv = MULTIROWMAP ROWS FROM Rows VAR Prev FROM Value OFFSET -1 DEFAULT 0 VAR Next FROM Value OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+    data, {}, manifest, dest);
+
+// SERIESSTART: skip initial rows (start from row 2)
+parser.solve('MA = MULTIROWMAP ROWS FROM Prices SERIESSTART 2 VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+    data, {}, manifest, dest);
+
+// Negative SERIESSTART: start from 2 rows before end
+parser.solve('LastTwo = MULTIROWMAP ROWS FROM Rows SERIESSTART -2 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+
+// SERIESSTEP -1: iterate backwards
+parser.solve('Reversed = MULTIROWMAP ROWS FROM Rows SERIESSTART -1 SERIESSTEP -1 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+
+// SERIESSTEP 2: every other row
+parser.solve('Sampled = MULTIROWMAP ROWS FROM Rows SERIESSTEP 2 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+```
+
+**Available variables in MULTIROWMAP expressions:**
+- `stepIndex` — iteration counter (0, 1, 2, ...)
+- `rowIndex` — actual array index of the current row
+- Any VAR-mapped variable names
+
+**OFFSET values:**
+- `0` (default) — current row
+- `-1` — previous row, `-2` — two rows back, `-3` — three back, etc.
+- `1` — next row, `2` — two ahead, etc.
+
 ### ITERATIVESERIES
 
 Run cumulative computations over arrays:

package/example_applications/mathematical_playground/AppData.json

@@ -22,5 +22,40 @@
 	"BezierYValues": [0, 1, 4, 9, 16],
 
 	"SalesMonths": [1, 2, 3, 4, 5, 6],
-	"SalesRevenue": [150, 200, 250, 310, 350, 400]
+	"SalesRevenue": [150, 200, 250, 310, 350, 400],
+
+	"FibonacciRows": [
+		{ "Fib": 0 },
+		{ "Fib": 1 },
+		{ "Fib": 1 },
+		{ "Fib": 2 },
+		{ "Fib": 3 },
+		{ "Fib": 5 },
+		{ "Fib": 8 },
+		{ "Fib": 13 },
+		{ "Fib": 21 },
+		{ "Fib": 34 }
+	],
+
+	"StockPrices": [
+		{ "Date": "2025-01-01", "Close": 100.00, "Volume": 5000 },
+		{ "Date": "2025-01-02", "Close": 102.50, "Volume": 6200 },
+		{ "Date": "2025-01-03", "Close": 101.00, "Volume": 4800 },
+		{ "Date": "2025-01-06", "Close": 105.00, "Volume": 7100 },
+		{ "Date": "2025-01-07", "Close": 108.50, "Volume": 8300 },
+		{ "Date": "2025-01-08", "Close": 107.00, "Volume": 5500 },
+		{ "Date": "2025-01-09", "Close": 110.00, "Volume": 6800 },
+		{ "Date": "2025-01-10", "Close": 112.50, "Volume": 7200 }
+	],
+
+	"TemperatureReadings": [
+		{ "Hour": 0, "Temp": 58.0 },
+		{ "Hour": 3, "Temp": 55.5 },
+		{ "Hour": 6, "Temp": 54.0 },
+		{ "Hour": 9, "Temp": 60.5 },
+		{ "Hour": 12, "Temp": 68.0 },
+		{ "Hour": 15, "Temp": 72.5 },
+		{ "Hour": 18, "Temp": 67.0 },
+		{ "Hour": 21, "Temp": 61.5 }
+	]
 }

package/example_applications/mathematical_playground/Math-Solver-Harness.js

@@ -115,4 +115,111 @@ console.log(`  Intercept (baseline): ${tmpSlopeInterceptResults.TrendIntercept}`
 _ExpressionParser.solve('Month7Prediction = TrendIntercept + TrendSlope * 7', tmpSlopeInterceptResults, tmpSlopeInterceptResults, false, tmpSlopeInterceptResults);
 console.log(`  Predicted month 7 revenue: ${tmpSlopeInterceptResults.Month7Prediction}`);
 
+/* * * * * * * * * * * * * * * * *
+ *
+ * MULTIROWMAP: Multi-Row Lookback Series Solver
+ *
+ * MULTIROWMAP lets you iterate over an array of objects (rows) and reference
+ * values from the current row, previous rows, and even future rows.
+ *
+ * Syntax:
+ *   Result = MULTIROWMAP ROWS FROM <address>
+ *     [SERIESSTART <n>]
+ *     [SERIESSTEP <n>]
+ *     VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <value>]
+ *     ...
+ *     : <expression>
+ *
+ * OFFSET 0 (default) = current row
+ * OFFSET -1 = previous row, OFFSET -2 = two rows back, etc.
+ * OFFSET 1 = next row, OFFSET 2 = two rows ahead, etc.
+ * DEFAULT provides a fallback when the referenced row is out of bounds.
+ * SERIESSTART controls which row index to start iterating from (negative counts from end).
+ * SERIESSTEP controls the iteration step (default 1, use -1 to go backwards).
+ *
+ */
+_Fable.log.info(`Beginning MULTIROWMAP Exercises....`);
+
+let tmpMultiRowResults = {};
+
+// --- Example 1: Fibonacci Verification ---
+// Verify that each value in a Fibonacci sequence equals the sum of the two previous values
+_ExpressionParser.solve(
+	'FibCheck = MULTIROWMAP ROWS FROM FibonacciRows VAR Current FROM Fib VAR Prev1 FROM Fib OFFSET -1 DEFAULT 0 VAR Prev2 FROM Fib OFFSET -2 DEFAULT 0 : Current - (Prev1 + Prev2)',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nFibonacci verification (should be 0 from row 2 onward):`);
+console.log(`  FibCheck: [${tmpMultiRowResults.FibCheck.join(', ')}]`);
+
+// --- Example 2: Stock Price Day-over-Day Change ---
+// Calculate the daily price change for a stock
+_ExpressionParser.solve(
+	'DailyChange = MULTIROWMAP ROWS FROM StockPrices VAR Today FROM Close VAR Yesterday FROM Close OFFSET -1 DEFAULT 0 : Today - Yesterday',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nStock daily price change:`);
+console.log(`  DailyChange: [${tmpMultiRowResults.DailyChange.join(', ')}]`);
+
+// --- Example 3: 3-Period Moving Average ---
+// Compute a 3-day moving average of stock closing prices
+_ExpressionParser.solve(
+	'MA3 = MULTIROWMAP ROWS FROM StockPrices VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\n3-period moving average of stock prices:`);
+console.log(`  MA3: [${tmpMultiRowResults.MA3.join(', ')}]`);
+
+// --- Example 4: Forward-Looking (Next Row Reference) ---
+// For each temperature reading, compute the difference to the next reading
+_ExpressionParser.solve(
+	'TempChange = MULTIROWMAP ROWS FROM TemperatureReadings VAR Current FROM Temp VAR Next FROM Temp OFFSET 1 DEFAULT 0 : Next - Current',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature change to next reading (forward lookback):`);
+console.log(`  TempChange: [${tmpMultiRowResults.TempChange.join(', ')}]`);
+
+// --- Example 5: Central Difference (Both Directions) ---
+// Approximate the derivative using central difference: (next - prev) / 2
+_ExpressionParser.solve(
+	'TempDerivative = MULTIROWMAP ROWS FROM TemperatureReadings VAR Prev FROM Temp OFFSET -1 DEFAULT 0 VAR Next FROM Temp OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature central difference derivative:`);
+console.log(`  TempDerivative: [${tmpMultiRowResults.TempDerivative.join(', ')}]`);
+
+// --- Example 6: Second Derivative (Two-Row Lookback) ---
+// Approximate the second derivative: current - 2*prev + twoprev
+_ExpressionParser.solve(
+	'TempAcceleration = MULTIROWMAP ROWS FROM TemperatureReadings VAR Current FROM Temp VAR Prev FROM Temp OFFSET -1 DEFAULT 0 VAR TwoBack FROM Temp OFFSET -2 DEFAULT 0 : Current - 2 * Prev + TwoBack',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature second derivative (acceleration):`);
+console.log(`  TempAcceleration: [${tmpMultiRowResults.TempAcceleration.join(', ')}]`);
+
+// --- Example 7: SERIESSTART - Skip Initial Rows ---
+// Start the moving average from row 2 so all three periods have valid data
+_ExpressionParser.solve(
+	'MA3Valid = MULTIROWMAP ROWS FROM StockPrices SERIESSTART 2 VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\n3-period MA starting from row 2 (all periods valid):`);
+console.log(`  MA3Valid: [${tmpMultiRowResults.MA3Valid.join(', ')}]`);
+
+// --- Example 8: SERIESSTEP -1 - Iterate Backwards ---
+// Read stock prices in reverse chronological order
+_ExpressionParser.solve(
+	'ReversePrices = MULTIROWMAP ROWS FROM StockPrices SERIESSTART -1 SERIESSTEP -1 VAR Price FROM Close : Price + 0',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nStock prices in reverse order:`);
+console.log(`  ReversePrices: [${tmpMultiRowResults.ReversePrices.join(', ')}]`);
+
+// --- Example 9: SERIESSTEP 2 - Every Other Row ---
+// Sample every other temperature reading
+_ExpressionParser.solve(
+	'EveryOtherTemp = MULTIROWMAP ROWS FROM TemperatureReadings SERIESSTEP 2 VAR t FROM Temp : t + 0',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nEvery other temperature reading:`);
+console.log(`  EveryOtherTemp: [${tmpMultiRowResults.EveryOtherTemp.join(', ')}]`);
+
+// --- Example 10: Three-Row Lookback with Multiple Properties ---
+// Weighted volume change: compare current volume to 3 days ago, scaled by price ratio
+_ExpressionParser.solve(
+	'WeightedVolChange = MULTIROWMAP ROWS FROM StockPrices VAR CurVol FROM Volume VAR CurPrice FROM Close VAR OldVol FROM Volume OFFSET -3 DEFAULT 0 VAR OldPrice FROM Close OFFSET -3 DEFAULT 1 : (CurVol - OldVol) * (CurPrice / OldPrice)',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nWeighted volume change (3-day lookback with price ratio):`);
+console.log(`  WeightedVolChange: [${tmpMultiRowResults.WeightedVolChange.join(', ')}]`);
+
 console.log('QED');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.63",
+  "version": "3.1.64",
   "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,6 +189,156 @@ 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;
+	}
+
 	parseDirectives(pResultObject)
 	{
 		let tmpResults = (typeof(pResultObject) === 'object') ? pResultObject : { ExpressionParserLog: [] };
@@ -258,6 +409,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.js

@@ -456,6 +456,149 @@ class FableServiceExpressionParser extends libFableServiceBase
 
 			return tmpValueArray;
 		}
+		else if (tmpResultsObject.SolverDirectives.Code == 'MULTIROWMAP')
+		{
+			// MULTIROWMAP iterates over an array of objects (rows), allowing each expression to reference
+			// the current row and any number of previous/future rows via configurable offsets.
+			// Optional SERIESSTART and SERIESSTEP control which rows are iterated and in what direction.
+			const tmpDirectiveValues = tmpResultsObject.SolverDirectives.Values;
+			const tmpDirectiveValueKeys = tmpResultsObject.SolverDirectives.ValueKeys;
+			const tmpRowsAddress = tmpResultsObject.SolverDirectives.RowsAddress;
+			let tmpValueArray = [];
+
+			// Resolve the rows array from the data source
+			let tmpRows = null;
+			if (tmpRowsAddress)
+			{
+				tmpRows = tmpManifest.getValueByHash(tmpDataSourceObject, tmpRowsAddress);
+			}
+
+			if (!Array.isArray(tmpRows) || tmpRows.length < 1)
+			{
+				tmpResultsObject.ExpressionParserLog.push(`ExpressionParser.solve detected invalid MULTIROWMAP directive parameters.  ROWS FROM address must resolve to a non-empty array.`);
+				this.log.warn(tmpResultsObject.ExpressionParserLog[tmpResultsObject.ExpressionParserLog.length-1]);
+				return undefined;
+			}
+
+			// Resolve SeriesStart: default to 0 (first row).  Negative values count from end.
+			let tmpSeriesStart = 0;
+			if (tmpResultsObject.SolverDirectives.SeriesStart !== null)
+			{
+				tmpSeriesStart = parseInt(tmpResultsObject.SolverDirectives.SeriesStart);
+				if (isNaN(tmpSeriesStart))
+				{
+					// Try to resolve as a variable from the data source
+					let tmpStartToken = this.fable.ExpressionParser.Postfix.getTokenContainerObject(tmpResultsObject.SolverDirectives.SeriesStart, 'Token.Symbol');
+					this.substituteValuesInTokenizedObjects([tmpStartToken], tmpDataSourceObject, tmpResultsObject, tmpManifest);
+					if (tmpStartToken.Resolved)
+					{
+						tmpSeriesStart = parseInt(tmpStartToken.Value);
+					}
+					if (isNaN(tmpSeriesStart))
+					{
+						tmpSeriesStart = 0;
+					}
+				}
+			}
+			// Handle negative start (count from end)
+			if (tmpSeriesStart < 0)
+			{
+				tmpSeriesStart = tmpRows.length + tmpSeriesStart;
+			}
+			// Clamp to valid range
+			tmpSeriesStart = Math.max(0, Math.min(tmpSeriesStart, tmpRows.length - 1));
+
+			// Resolve SeriesStep: default to 1
+			let tmpSeriesStep = 1;
+			if (tmpResultsObject.SolverDirectives.SeriesStep !== null)
+			{
+				tmpSeriesStep = parseInt(tmpResultsObject.SolverDirectives.SeriesStep);
+				if (isNaN(tmpSeriesStep))
+				{
+					// Try to resolve as a variable from the data source
+					let tmpStepToken = this.fable.ExpressionParser.Postfix.getTokenContainerObject(tmpResultsObject.SolverDirectives.SeriesStep, 'Token.Symbol');
+					this.substituteValuesInTokenizedObjects([tmpStepToken], tmpDataSourceObject, tmpResultsObject, tmpManifest);
+					if (tmpStepToken.Resolved)
+					{
+						tmpSeriesStep = parseInt(tmpStepToken.Value);
+					}
+					if (isNaN(tmpSeriesStep))
+					{
+						tmpSeriesStep = 1;
+					}
+				}
+			}
+			if (tmpSeriesStep === 0)
+			{
+				tmpResultsObject.ExpressionParserLog.push(`ExpressionParser.solve detected invalid MULTIROWMAP directive parameters.  SERIESSTEP cannot be zero.`);
+				this.log.warn(tmpResultsObject.ExpressionParserLog[tmpResultsObject.ExpressionParserLog.length-1]);
+				return undefined;
+			}
+
+			let tmpStepCounter = 0;
+			for (let i = tmpSeriesStart; (tmpSeriesStep > 0) ? (i < tmpRows.length) : (i >= 0); i += tmpSeriesStep)
+			{
+				// Build the data source for this iteration with the mapped variables
+				let tmpRowStepDataSourceObject = Object.assign({}, tmpDataSourceObject);
+				tmpRowStepDataSourceObject.stepIndex = tmpStepCounter;
+				tmpRowStepDataSourceObject.rowIndex = i;
+
+				for (let j = 0; j < tmpDirectiveValueKeys.length; j++)
+				{
+					const tmpVariableKey = tmpDirectiveValueKeys[j];
+					const tmpVariableDescription = tmpDirectiveValues[tmpVariableKey];
+					const tmpTargetRowIndex = i + tmpVariableDescription.RowOffset;
+
+					// Check if the target row index is within bounds
+					if (tmpTargetRowIndex < 0 || tmpTargetRowIndex >= tmpRows.length)
+					{
+						// Out of bounds -- use the default value
+						tmpRowStepDataSourceObject[tmpVariableKey] = tmpVariableDescription.Default;
+					}
+					else
+					{
+						const tmpTargetRow = tmpRows[tmpTargetRowIndex];
+						if (tmpVariableDescription.Property === null)
+						{
+							// No property specified, use the whole row
+							tmpRowStepDataSourceObject[tmpVariableKey] = tmpTargetRow;
+						}
+						else
+						{
+							// Look up the property on the target row
+							let tmpValue = tmpManifest.getValueByHash(tmpTargetRow, tmpVariableDescription.Property);
+							if (tmpValue == null)
+							{
+								tmpValue = tmpVariableDescription.Default;
+							}
+							tmpRowStepDataSourceObject[tmpVariableKey] = tmpValue;
+						}
+					}
+				}
+
+				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpRowStepDataSourceObject, tmpResultsObject, tmpManifest);
+
+				tmpValueArray.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, tmpManifest) );
+
+				for (let j = 0; j < tmpMutatedValues.length; j++)
+				{
+					tmpMutatedValues[j].Resolved = false;
+				}
+
+				tmpStepCounter++;
+			}
+
+			// Do the assignment
+			let tmpAssignmentManifestHash = tmpResultsObject.PostfixedAssignmentAddress;
+			if ((tmpResultsObject.OriginalRawTokens[1] === '=') && (typeof(tmpResultsObject.OriginalRawTokens[0]) === 'string') && (tmpResultsObject.OriginalRawTokens[0].length > 0))
+			{
+				tmpAssignmentManifestHash = tmpResultsObject.OriginalRawTokens[0];
+			}
+
+			tmpManifest.setValueByHash(tmpDataDestinationObject, tmpAssignmentManifestHash, tmpValueArray);
+
+			return tmpValueArray;
+		}
 		else if (tmpResultsObject.SolverDirectives.Code == 'MONTECARLO')
 		{
 			const [ tmpSampleCount ] = this._prepareDirectiveParameters([

package/test/ExpressionParser_tests.js

@@ -1384,5 +1384,774 @@ suite
 							);
 					}
 				);
+			suite
+				(
+					'Multi-Row Map Expressions',
+					function ()
+					{
+						test
+							(
+								'Test basic MULTIROWMAP with current row',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Width: 10, Height: 20 },
+											{ Width: 30, Height: 40 },
+											{ Width: 50, Height: 60 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Simple: reference current row values (OFFSET 0 is default)
+									let tmpResult = _Parser.solve(
+										'Areas = MULTIROWMAP ROWS FROM Rows VAR w FROM Width VAR h FROM Height : w * h',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(3);
+									Expect(tmpResult[0]).to.equal('200');
+									Expect(tmpResult[1]).to.equal('1200');
+									Expect(tmpResult[2]).to.equal('3000');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with previous row lookback (OFFSET -1)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 100 },
+											{ Value: 200 },
+											{ Value: 300 },
+											{ Value: 400 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Reference the current row and the previous row's value
+									let tmpResult = _Parser.solve(
+										'Deltas = MULTIROWMAP ROWS FROM Rows VAR Current FROM Value OFFSET 0 VAR Previous FROM Value OFFSET -1 DEFAULT 0 : Current - Previous',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(4);
+									// Row 0: 100 - 0 (default) = 100
+									Expect(tmpResult[0]).to.equal('100');
+									// Row 1: 200 - 100 = 100
+									Expect(tmpResult[1]).to.equal('100');
+									// Row 2: 300 - 200 = 100
+									Expect(tmpResult[2]).to.equal('100');
+									// Row 3: 400 - 300 = 100
+									Expect(tmpResult[3]).to.equal('100');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with two-row lookback (OFFSET -2)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 5 },
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 35 },
+											{ Value: 55 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Second derivative: current - 2*previous + two-back
+									let tmpResult = _Parser.solve(
+										'SecondDeriv = MULTIROWMAP ROWS FROM Rows VAR Current FROM Value OFFSET 0 VAR Prev FROM Value OFFSET -1 DEFAULT 0 VAR TwoBack FROM Value OFFSET -2 DEFAULT 0 : Current - 2 * Prev + TwoBack',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									// Row 0: 5 - 2*0 + 0 = 5
+									Expect(tmpResult[0]).to.equal('5');
+									// Row 1: 10 - 2*5 + 0 = 0
+									Expect(tmpResult[1]).to.equal('0');
+									// Row 2: 20 - 2*10 + 5 = 5
+									Expect(tmpResult[2]).to.equal('5');
+									// Row 3: 35 - 2*20 + 10 = 5
+									Expect(tmpResult[3]).to.equal('5');
+									// Row 4: 55 - 2*35 + 20 = 5
+									Expect(tmpResult[4]).to.equal('5');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with three-row lookback (OFFSET -3)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 1 },
+											{ Value: 2 },
+											{ Value: 4 },
+											{ Value: 8 },
+											{ Value: 16 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Sum of current + three rows back
+									let tmpResult = _Parser.solve(
+										'ThreeBackSum = MULTIROWMAP ROWS FROM Rows VAR Current FROM Value VAR ThreeBack FROM Value OFFSET -3 DEFAULT 0 : Current + ThreeBack',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									// Row 0: 1 + 0 (default, no row at -3) = 1
+									Expect(tmpResult[0]).to.equal('1');
+									// Row 1: 2 + 0 (default, no row at -2) = 2
+									Expect(tmpResult[1]).to.equal('2');
+									// Row 2: 4 + 0 (default, no row at -1) = 4
+									Expect(tmpResult[2]).to.equal('4');
+									// Row 3: 8 + 1 (row 0) = 9
+									Expect(tmpResult[3]).to.equal('9');
+									// Row 4: 16 + 2 (row 1) = 18
+									Expect(tmpResult[4]).to.equal('18');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP Fibonacci sequence',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									// Fibonacci: each row = sum of two previous rows
+									// Seed: first two rows have the starting values
+									let tmpDataSourceObject = {
+										FibRows: [
+											{ Fib: 0 },
+											{ Fib: 1 },
+											{ Fib: 1 },
+											{ Fib: 2 },
+											{ Fib: 3 },
+											{ Fib: 5 },
+											{ Fib: 8 },
+											{ Fib: 13 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Verify: for each row, check that Current == Prev1 + Prev2 (except seed rows)
+									let tmpResult = _Parser.solve(
+										'FibCheck = MULTIROWMAP ROWS FROM FibRows VAR Current FROM Fib VAR Prev1 FROM Fib OFFSET -1 DEFAULT 0 VAR Prev2 FROM Fib OFFSET -2 DEFAULT 0 : Current - (Prev1 + Prev2)',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(8);
+									// Row 0: 0 - (0 + 0) = 0 (seed)
+									Expect(tmpResult[0]).to.equal('0');
+									// Row 1: 1 - (0 + 0) = 1 (seed)
+									Expect(tmpResult[1]).to.equal('1');
+									// Row 2 onwards should all be 0 since each is the sum of previous two
+									Expect(tmpResult[2]).to.equal('0');
+									Expect(tmpResult[3]).to.equal('0');
+									Expect(tmpResult[4]).to.equal('0');
+									Expect(tmpResult[5]).to.equal('0');
+									Expect(tmpResult[6]).to.equal('0');
+									Expect(tmpResult[7]).to.equal('0');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with custom default values',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Use negative default for previous row
+									let tmpResult = _Parser.solve(
+										'WithDefaults = MULTIROWMAP ROWS FROM Rows VAR Current FROM Value VAR Previous FROM Value OFFSET -1 DEFAULT -1 : Current + Previous',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(3);
+									// Row 0: 10 + (-1) = 9
+									Expect(tmpResult[0]).to.equal('9');
+									// Row 1: 20 + 10 = 30
+									Expect(tmpResult[1]).to.equal('30');
+									// Row 2: 30 + 20 = 50
+									Expect(tmpResult[2]).to.equal('50');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with multiple properties from same row offset',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Measurements: [
+											{ Width: 10, Height: 5, Depth: 2 },
+											{ Width: 20, Height: 10, Depth: 4 },
+											{ Width: 30, Height: 15, Depth: 6 },
+											{ Width: 40, Height: 20, Depth: 8 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Compare volume change: current volume minus previous volume
+									let tmpResult = _Parser.solve(
+										'VolumeDelta = MULTIROWMAP ROWS FROM Measurements VAR w FROM Width VAR h FROM Height VAR d FROM Depth VAR pw FROM Width OFFSET -1 DEFAULT 0 VAR ph FROM Height OFFSET -1 DEFAULT 0 VAR pd FROM Depth OFFSET -1 DEFAULT 0 : (w * h * d) - (pw * ph * pd)',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(4);
+									// Row 0: (10*5*2) - (0*0*0) = 100 - 0 = 100
+									Expect(tmpResult[0]).to.equal('100');
+									// Row 1: (20*10*4) - (10*5*2) = 800 - 100 = 700
+									Expect(tmpResult[1]).to.equal('700');
+									// Row 2: (30*15*6) - (20*10*4) = 2700 - 800 = 1900
+									Expect(tmpResult[2]).to.equal('1900');
+									// Row 3: (40*20*8) - (30*15*6) = 6400 - 2700 = 3700
+									Expect(tmpResult[3]).to.equal('3700');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with stepIndex variable',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 100 },
+											{ Value: 200 },
+											{ Value: 300 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Use stepIndex (row index) in the expression
+									let tmpResult = _Parser.solve(
+										'Indexed = MULTIROWMAP ROWS FROM Rows VAR v FROM Value : v + stepIndex * 1000',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(3);
+									Expect(tmpResult[0]).to.equal('100');
+									Expect(tmpResult[1]).to.equal('1200');
+									Expect(tmpResult[2]).to.equal('2300');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP moving average',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Prices: [
+											{ Close: 100 },
+											{ Close: 110 },
+											{ Close: 105 },
+											{ Close: 115 },
+											{ Close: 120 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// 3-period moving average: (current + prev + two-back) / 3
+									let tmpResult = _Parser.solve(
+										'MA3 = MULTIROWMAP ROWS FROM Prices VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									// Row 2 onwards has three valid values for a true 3-period MA
+									// Row 2: (105 + 110 + 100) / 3 = 105
+									Expect(tmpResult[2]).to.equal('105');
+									// Row 3: (115 + 105 + 110) / 3 = 110
+									Expect(tmpResult[3]).to.equal('110');
+									// Row 4: (120 + 115 + 105) / 3 = 113.33...
+									Expect(Number(tmpResult[4])).to.be.closeTo(113.333, 0.01);
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP returns undefined for invalid rows address',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {};
+									let tmpDataDestinationObject = {};
+
+									// No valid rows
+									let tmpResult = _Parser.solve(
+										'Bad = MULTIROWMAP ROWS FROM NonExistent VAR v FROM Value : v + 1',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.undefined;
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with forward row lookback (positive OFFSET)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+											{ Value: 50 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Look ahead: current value minus next row's value
+									let tmpResult = _Parser.solve(
+										'ForwardDelta = MULTIROWMAP ROWS FROM Rows VAR Current FROM Value VAR Next FROM Value OFFSET 1 DEFAULT 0 : Next - Current',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									// Row 0: 20 - 10 = 10
+									Expect(tmpResult[0]).to.equal('10');
+									// Row 1: 30 - 20 = 10
+									Expect(tmpResult[1]).to.equal('10');
+									// Row 2: 40 - 30 = 10
+									Expect(tmpResult[2]).to.equal('10');
+									// Row 3: 50 - 40 = 10
+									Expect(tmpResult[3]).to.equal('10');
+									// Row 4: 0 (default) - 50 = -50
+									Expect(tmpResult[4]).to.equal('-50');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with forward lookback two rows ahead (OFFSET 2)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 1 },
+											{ Value: 2 },
+											{ Value: 3 },
+											{ Value: 4 },
+											{ Value: 5 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Look two ahead
+									let tmpResult = _Parser.solve(
+										'TwoAhead = MULTIROWMAP ROWS FROM Rows VAR Current FROM Value VAR Future FROM Value OFFSET 2 DEFAULT 99 : Future + Current',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									// Row 0: 3 + 1 = 4
+									Expect(tmpResult[0]).to.equal('4');
+									// Row 1: 4 + 2 = 6
+									Expect(tmpResult[1]).to.equal('6');
+									// Row 2: 5 + 3 = 8
+									Expect(tmpResult[2]).to.equal('8');
+									// Row 3: 99 (default) + 4 = 103
+									Expect(tmpResult[3]).to.equal('103');
+									// Row 4: 99 (default) + 5 = 104
+									Expect(tmpResult[4]).to.equal('104');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with SERIESSTART to skip initial rows',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 100 },
+											{ Value: 200 },
+											{ Value: 300 },
+											{ Value: 400 },
+											{ Value: 500 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Start from row 2
+									let tmpResult = _Parser.solve(
+										'FromRow2 = MULTIROWMAP ROWS FROM Rows SERIESSTART 2 VAR v FROM Value : v + 0',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(3);
+									Expect(tmpResult[0]).to.equal('300');
+									Expect(tmpResult[1]).to.equal('400');
+									Expect(tmpResult[2]).to.equal('500');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with negative SERIESSTART (count from end)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+											{ Value: 50 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Start from 2 rows before the end
+									let tmpResult = _Parser.solve(
+										'LastTwo = MULTIROWMAP ROWS FROM Rows SERIESSTART -2 VAR v FROM Value : v + 0',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(2);
+									Expect(tmpResult[0]).to.equal('40');
+									Expect(tmpResult[1]).to.equal('50');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with SERIESSTEP -1 (iterate backwards)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+											{ Value: 50 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Iterate backwards from the last row
+									let tmpResult = _Parser.solve(
+										'Reversed = MULTIROWMAP ROWS FROM Rows SERIESSTART -1 SERIESSTEP -1 VAR v FROM Value : v + 0',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									Expect(tmpResult[0]).to.equal('50');
+									Expect(tmpResult[1]).to.equal('40');
+									Expect(tmpResult[2]).to.equal('30');
+									Expect(tmpResult[3]).to.equal('20');
+									Expect(tmpResult[4]).to.equal('10');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with SERIESSTEP 2 (skip every other row)',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+											{ Value: 50 },
+											{ Value: 60 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Every other row
+									let tmpResult = _Parser.solve(
+										'EveryOther = MULTIROWMAP ROWS FROM Rows SERIESSTEP 2 VAR v FROM Value : v + 0',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(3);
+									Expect(tmpResult[0]).to.equal('10');
+									Expect(tmpResult[1]).to.equal('30');
+									Expect(tmpResult[2]).to.equal('50');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP backwards with lookback still works',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Going backwards, previous row (OFFSET -1) means the row with a LOWER index
+									// which is actually the next row in reverse iteration order
+									let tmpResult = _Parser.solve(
+										'BackwardsWithLook = MULTIROWMAP ROWS FROM Rows SERIESSTART -1 SERIESSTEP -1 VAR Current FROM Value VAR Prev FROM Value OFFSET -1 DEFAULT 0 : Current - Prev',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(4);
+									// Row 3 (first in reverse): 40 - 30 = 10
+									Expect(tmpResult[0]).to.equal('10');
+									// Row 2: 30 - 20 = 10
+									Expect(tmpResult[1]).to.equal('10');
+									// Row 1: 20 - 10 = 10
+									Expect(tmpResult[2]).to.equal('10');
+									// Row 0: 10 - 0 (default) = 10
+									Expect(tmpResult[3]).to.equal('10');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with SERIESSTART and SERIESSTEP combined',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+											{ Value: 50 },
+											{ Value: 60 },
+											{ Value: 70 },
+											{ Value: 80 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Start at row 1, step by 3
+									let tmpResult = _Parser.solve(
+										'SteppedStart = MULTIROWMAP ROWS FROM Rows SERIESSTART 1 SERIESSTEP 3 VAR v FROM Value : v + 0',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									// Rows: 1, 4, 7 => Values: 20, 50, 80
+									Expect(tmpResult.length).to.equal(3);
+									Expect(tmpResult[0]).to.equal('20');
+									Expect(tmpResult[1]).to.equal('50');
+									Expect(tmpResult[2]).to.equal('80');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with both forward and backward lookback simultaneously',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 10 },
+											{ Value: 20 },
+											{ Value: 30 },
+											{ Value: 40 },
+											{ Value: 50 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// Central difference: (next - previous) / 2
+									let tmpResult = _Parser.solve(
+										'CentralDiff = MULTIROWMAP ROWS FROM Rows VAR Prev FROM Value OFFSET -1 DEFAULT 0 VAR Next FROM Value OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(5);
+									// Row 0: (20 - 0) / 2 = 10
+									Expect(tmpResult[0]).to.equal('10');
+									// Row 1: (30 - 10) / 2 = 10
+									Expect(tmpResult[1]).to.equal('10');
+									// Row 2: (40 - 20) / 2 = 10
+									Expect(tmpResult[2]).to.equal('10');
+									// Row 3: (50 - 30) / 2 = 10
+									Expect(tmpResult[3]).to.equal('10');
+									// Row 4: (0 - 40) / 2 = -20
+									Expect(tmpResult[4]).to.equal('-20');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP with rowIndex and stepIndex variables',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [
+											{ Value: 100 },
+											{ Value: 200 },
+											{ Value: 300 },
+											{ Value: 400 },
+											{ Value: 500 },
+										]
+									};
+									let tmpDataDestinationObject = {};
+
+									// With SERIESSTART, rowIndex is the actual array index, stepIndex is the iteration count
+									let tmpResult = _Parser.solve(
+										'IndexTest = MULTIROWMAP ROWS FROM Rows SERIESSTART 2 VAR v FROM Value : v + rowIndex * 1000 + stepIndex',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.an('array');
+									Expect(tmpResult.length).to.equal(3);
+									// stepIndex=0, rowIndex=2: 300 + 2000 + 0 = 2300
+									Expect(tmpResult[0]).to.equal('2300');
+									// stepIndex=1, rowIndex=3: 400 + 3000 + 1 = 3401
+									Expect(tmpResult[1]).to.equal('3401');
+									// stepIndex=2, rowIndex=4: 500 + 4000 + 2 = 4502
+									Expect(tmpResult[2]).to.equal('4502');
+
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test MULTIROWMAP SERIESSTEP zero returns undefined',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+									let tmpManifest = testFable.newManyfest();
+
+									let tmpDataSourceObject = {
+										Rows: [{ Value: 1 }]
+									};
+									let tmpDataDestinationObject = {};
+
+									let tmpResult = _Parser.solve(
+										'BadStep = MULTIROWMAP ROWS FROM Rows SERIESSTEP 0 VAR v FROM Value : v + 0',
+										tmpDataSourceObject, {}, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpResult).to.be.undefined;
+
+									return fDone();
+								}
+							);
+					}
+				);
 		}
 	);