fable 3.0.47 → 3.0.49

package/gulpfile-config.json

@@ -5,7 +5,7 @@
 
 	"LibraryOutputFolder": "./dist/",
 
-	"LibraryUniminifiedFileName": "fable.compatible.js",
+	"LibraryUniminifiedFileName": "fable.js",
 
-	"LibraryMinifiedFileName": "fable.compatible.min.js"
+	"LibraryMinifiedFileName": "fable.min.js"
 }

package/gulpfile.js

@@ -131,7 +131,7 @@ libGulp.task('minified',
 		.pipe(libVinylBuffer())
 		.pipe(libSourcemaps.init({loadMaps: true}))
 				// Add transformation tasks to the pipeline here.
-				.pipe(libBabel())
+				.pipe(libBabel({"presets": ["@babel/preset-env"]}))
 				.pipe(libTerser())
 				.on('error', libGulpUtil.log)
 		.pipe(libSourcemaps.write('./'))
@@ -152,7 +152,7 @@ libGulp.task('debug',
 		return tmpBrowserify.bundle()
 			.pipe(libVinylSourceStream(_CONFIG.LibraryUniminifiedFileName))
 			.pipe(libVinylBuffer())
-					.pipe(libBabel())
+					.pipe(libBabel({"presets": ["@babel/preset-env"]}))
 					.on('error', libGulpUtil.log)
 			.pipe(libGulp.dest(_CONFIG.LibraryOutputFolder));
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.47",
+  "version": "3.0.49",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {

package/source/Fable-ServiceManager.js

@@ -54,6 +54,25 @@ class FableService extends libFableServiceBase.CoreServiceProviderBase
 		this.instantiateServiceProvider(pServiceType, {}, `${pServiceType}-Default`);
 	}
 
+	// Some servicds expect to be overloaded / customized class.
+	instantiateServiceProviderFromPrototype(pServiceType, pOptions, pCustomServiceHash, pServicePrototype)
+	{
+		// Instantiate the service
+		let tmpService = new pServicePrototype(this.fable, pOptions, pCustomServiceHash);
+
+		// Add the service to the service map
+		this.services[pServiceType][tmpService.Hash] = tmpService;
+
+		// If this is the first service of this type, make it the default
+		if (!this.defaultServices.hasOwnProperty(pServiceType))
+		{
+			this.setDefaultServiceInstantiation(pServiceType, tmpService.Hash)
+		}
+
+		return tmpService;
+	}
+
+
 	instantiateServiceProvider(pServiceType, pOptions, pCustomServiceHash)
 	{
 		// Instantiate the service

package/source/services/Fable-Service-MetaTemplate/MetaTemplate-StringParser.js

@@ -1,5 +1,5 @@
 /**
-* MetaTemplate String Parser
+* String Parser
 * @author      Steven Velozo <steven@velozo.com>
 * @description Parse a string, properly processing each matched token in the word tree.
 */
@@ -32,33 +32,13 @@ class StringParser
 			Output: '',
 			OutputBuffer: '',
 
-			Pattern: false,
+			Pattern: {},
 
 			PatternMatch: false,
-			PatternMatchOutputBuffer: ''
+			PatternMatchEnd: false
 		});
 	}
 
-	/**
-	 * Assign a node of the parser tree to be the next potential match.
-	 * If the node has a PatternEnd property, it is a valid match and supercedes the last valid match (or becomes the initial match).
-	 * @method assignNode
-	 * @param {Object} pNode - A node on the parse tree to assign
-	 * @param {Object} pParserState - The state object for the current parsing task
-	 * @private
-	 */
-	assignNode (pNode, pParserState)
-	{
-		pParserState.PatternMatch = pNode;
-
-		// If the pattern has a END we can assume it has a parse function...
-		if (pParserState.PatternMatch.hasOwnProperty('PatternEnd'))
-		{
-			// ... this is the legitimate start of a pattern.
-			pParserState.Pattern = pParserState.PatternMatch;
-		}
-	}
-
 	/**
 	 * Append a character to the output buffer in the parser state.
 	 * This output buffer is used when a potential match is being explored, or a match is being explored.
@@ -84,80 +64,124 @@ class StringParser
 		pParserState.OutputBuffer = '';
 	}
 
+	resetOutputBuffer (pParserState)
+	{
+		// Flush the output buffer.
+		this.flushOutputBuffer(pParserState);
+		// End pattern mode
+		pParserState.Pattern = false;
+		pParserState.PatternStartNode = false;
+		pParserState.StartPatternMatchComplete = false;
+		pParserState.EndPatternMatchBegan = false;
+		pParserState.PatternMatch = false;
+
+		return true;
+	}
+
 	/**
-	 * Check if the pattern has ended.  If it has, properly flush the buffer and start looking for new patterns.
-	 * @method checkPatternEnd
+	 * Parse a character in the buffer.
+	 * @method parseCharacter
+	 * @param {string} pCharacter - The character to append
 	 * @param {Object} pParserState - The state object for the current parsing task
 	 * @private
 	 */
-	checkPatternEnd (pParserState, pData)
+	parseCharacter (pCharacter, pParserState, pData)
 	{
-		if ((pParserState.OutputBuffer.length >= pParserState.Pattern.PatternEnd.length+pParserState.Pattern.PatternStart.length) &&
-			(pParserState.OutputBuffer.substr(-pParserState.Pattern.PatternEnd.length) === pParserState.Pattern.PatternEnd))
+		// If we are already in a pattern match traversal
+		if (pParserState.PatternMatch)
 		{
-			// ... this is the end of a pattern, cut off the end tag and parse it.
-			// Trim the start and end tags off the output buffer now
-			if (pParserState.Pattern.isAsync)
+			// If the pattern is still matching the start and we haven't passed the buffer
+			if (!pParserState.StartPatternMatchComplete && pParserState.Pattern.hasOwnProperty(pCharacter))
 			{
-				console.log(`Precedent ERROR: Async template detected for pattern ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd} but the template engine is being run in non-async mode.`);
-				this.OutputBuffer = '';
-				// Flush the output buffer.
-				this.flushOutputBuffer(pParserState);
-				// End pattern mode
-				pParserState.Pattern = false;
-				pParserState.PatternMatch = false;
+				pParserState.Pattern = pParserState.Pattern[pCharacter];
+				this.appendOutputBuffer(pCharacter, pParserState);
 			}
-			else
+			else if (pParserState.EndPatternMatchBegan)
 			{
-				pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)), pData);
-				// Flush the output buffer.
-				this.flushOutputBuffer(pParserState);
-				// End pattern mode
-				pParserState.Pattern = false;
-				pParserState.PatternMatch = false;
+				if (pParserState.Pattern.PatternEnd.hasOwnProperty(pCharacter))
+				{
+					// This leaf has a PatternEnd tree, so we will wait until that end is met.
+					pParserState.Pattern = pParserState.Pattern.PatternEnd[pCharacter];
+					// Flush the output buffer.
+					this.appendOutputBuffer(pCharacter, pParserState);
+					// If this last character is the end of the pattern, parse it.
+					if (pParserState.Pattern.hasOwnProperty('Parse'))
+					{
+						// Run the function
+						pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStartString.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStartString.length+pParserState.Pattern.PatternEndString.length)), pData);
+						return this.resetOutputBuffer(pParserState);
+					}
+				}
+				else if (pParserState.PatternStartNode.PatternEnd.hasOwnProperty(pCharacter))
+				{
+					// We broke out of the end -- see if this is a new start of the end.
+					pParserState.Pattern = pParserState.PatternStartNode.PatternEnd[pCharacter];
+					this.appendOutputBuffer(pCharacter, pParserState);
+				}
+				else
+				{
+					pParserState.EndPatternMatchBegan = false;
+					this.appendOutputBuffer(pCharacter, pParserState);
+				}
 			}
-		}
-	}
-
-	checkPatternEndAsync (pParserState, pData, fCallback)
-	{
-		if ((pParserState.OutputBuffer.length >= pParserState.Pattern.PatternEnd.length+pParserState.Pattern.PatternStart.length) &&
-			(pParserState.OutputBuffer.substr(-pParserState.Pattern.PatternEnd.length) === pParserState.Pattern.PatternEnd))
-		{
-			// ... this is the end of a pattern, cut off the end tag and parse it.
-			// Trim the start and end tags off the output buffer now
-			if (pParserState.Pattern.isAsync)
+			else if (pParserState.Pattern.hasOwnProperty('PatternEnd'))
 			{
-				return pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)), pData,
-					(pError, pAsyncOutput) =>
+				if (!pParserState.StartPatternMatchComplete)
+				{
+					pParserState.StartPatternMatchComplete = true;
+					pParserState.PatternStartNode = pParserState.Pattern;
+				}
+
+				this.appendOutputBuffer(pCharacter, pParserState);
+
+				if (pParserState.Pattern.PatternEnd.hasOwnProperty(pCharacter))
+				{
+					// This is the first character of the end pattern.
+					pParserState.EndPatternMatchBegan = true;
+					// This leaf has a PatternEnd tree, so we will wait until that end is met.
+					pParserState.Pattern = pParserState.Pattern.PatternEnd[pCharacter];
+					// If this last character is the end of the pattern, parse it.
+					if (pParserState.Pattern.hasOwnProperty('Parse'))
 					{
-						if (pError)
+						if (pParserState.Pattern.isAsync)
 						{
-							console.log(`Precedent ERROR: Async template error happened parsing ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd}: ${pError}`);
+							this.log.error(`MetaTemplate: The pattern ${pParserState.Pattern.PatternStartString} is asynchronous and cannot be used in a synchronous parser.`);
+							this.resetOutputBuffer(pParserState);
 						}
-
-						pParserState.OutputBuffer = pAsyncOutput;
-						// Flush the output buffer.
-						this.flushOutputBuffer(pParserState);
-						// End pattern mode
-						pParserState.Pattern = false;
-						pParserState.PatternMatch = false;
-
-						return fCallback();
-					});
+						else
+						{
+							// Run the t*mplate function
+							pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStartString.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStartString.length+pParserState.Pattern.PatternEndString.length)), pData);
+							return this.resetOutputBuffer(pParserState);
+						}
+					}
+				}
 			}
 			else
 			{
-				pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStart.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStart.length+pParserState.Pattern.PatternEnd.length)), pData);
-				// Flush the output buffer.
-				this.flushOutputBuffer(pParserState);
-				// End pattern mode
-				pParserState.Pattern = false;
-				pParserState.PatternMatch = false;
+				// We are in a pattern start but didn't match one; reset and start trying again from this character.
+				this.resetOutputBuffer(pParserState);
 			}
 		}
-
-		return fCallback();
+		// If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....
+		if (!pParserState.PatternMatch)
+		{
+			// This may be the start of a new pattern....
+			if (pParserState.ParseTree.hasOwnProperty(pCharacter))
+			{
+				// ... assign the root node as the matched node.
+				this.resetOutputBuffer(pParserState);
+				this.appendOutputBuffer(pCharacter, pParserState);
+				pParserState.Pattern = pParserState.ParseTree[pCharacter];
+				pParserState.PatternMatch = true;
+				return true;
+			}
+			else
+			{
+				this.appendOutputBuffer(pCharacter, pParserState);
+			}
+		}
+		return false;
 	}
 
 	/**
@@ -167,70 +191,139 @@ class StringParser
 	 * @param {Object} pParserState - The state object for the current parsing task
 	 * @private
 	 */
-	parseCharacter (pCharacter, pParserState, pData)
+	parseCharacterAsync (pCharacter, pParserState, pData, fCallback)
 	{
-		// (1) If we aren't in a pattern match, and we aren't potentially matching, and this may be the start of a new pattern....
-		if (!pParserState.PatternMatch && pParserState.ParseTree.hasOwnProperty(pCharacter))
-		{
-			// ... assign the node as the matched node.
-			this.assignNode(pParserState.ParseTree[pCharacter], pParserState);
-			this.appendOutputBuffer(pCharacter, pParserState);
-		}
-		// (2) If we are in a pattern match (actively seeing if this is part of a new pattern token)
-		else if (pParserState.PatternMatch)
+		// If we are already in a pattern match traversal
+		if (pParserState.PatternMatch)
 		{
-			// If the pattern has a subpattern with this key
-			if (pParserState.PatternMatch.hasOwnProperty(pCharacter))
+			// If the pattern is still matching the start and we haven't passed the buffer
+			if (!pParserState.StartPatternMatchComplete && pParserState.Pattern.hasOwnProperty(pCharacter))
 			{
-				// Continue matching patterns.
-				this.assignNode(pParserState.PatternMatch[pCharacter], pParserState);
+				pParserState.Pattern = pParserState.Pattern[pCharacter];
+				this.appendOutputBuffer(pCharacter, pParserState);
 			}
-			this.appendOutputBuffer(pCharacter, pParserState);
-			if (pParserState.Pattern)
+			else if (pParserState.EndPatternMatchBegan)
 			{
-				// ... Check if this is the end of the pattern (if we are matching a valid pattern)...
-				this.checkPatternEnd(pParserState, pData);
+				if (pParserState.Pattern.PatternEnd.hasOwnProperty(pCharacter))
+				{
+					// This leaf has a PatternEnd tree, so we will wait until that end is met.
+					pParserState.Pattern = pParserState.Pattern.PatternEnd[pCharacter];
+					// Flush the output buffer.
+					this.appendOutputBuffer(pCharacter, pParserState);
+					// If this last character is the end of the pattern, parse it.
+					if (pParserState.Pattern.hasOwnProperty('Parse'))
+					{
+						// ... this is the end of a pattern, cut off the end tag and parse it.
+						// Trim the start and end tags off the output buffer now
+						if (pParserState.Pattern.isAsync)
+						{
+							// Run the function
+							return pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStartString.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStartString.length+pParserState.Pattern.PatternEndString.length)), pData,
+								(pError, pAsyncOutput) =>
+								{
+									if (pError)
+									{
+										console.log(`Precedent ERROR: Async template error happened parsing ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd}: ${pError}`);
+									}
+
+									pParserState.OutputBuffer = pAsyncOutput;
+									this.resetOutputBuffer(pParserState);
+									return fCallback();
+								});
+						}
+						else
+						{
+							// Run the t*mplate function
+							pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStartString.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStartString.length+pParserState.Pattern.PatternEndString.length)), pData);
+							this.resetOutputBuffer(pParserState);
+							return fCallback();
+						}
+					}
+				}
+				else if (pParserState.PatternStartNode.PatternEnd.hasOwnProperty(pCharacter))
+				{
+					// We broke out of the end -- see if this is a new start of the end.
+					pParserState.Pattern = pParserState.PatternStartNode.PatternEnd[pCharacter];
+					this.appendOutputBuffer(pCharacter, pParserState);
+				}
+				else
+				{
+					pParserState.EndPatternMatchBegan = false;
+					this.appendOutputBuffer(pCharacter, pParserState);
+				}
 			}
-		}
-		// (3) If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....
-		else
-		{
-			pParserState.Output += pCharacter;
-		}
-	}
+			else if (pParserState.Pattern.hasOwnProperty('PatternEnd'))
+			{
+				if (!pParserState.StartPatternMatchComplete)
+				{
+					pParserState.StartPatternMatchComplete = true;
+					pParserState.PatternStartNode = pParserState.Pattern;
+				}
 
-	parseCharacterAsync (pCharacter, pParserState, pData, fCallback)
-	{
-		// (1) If we aren't in a pattern match, and we aren't potentially matching, and this may be the start of a new pattern....
-		if (!pParserState.PatternMatch && pParserState.ParseTree.hasOwnProperty(pCharacter))
-		{
-			// ... assign the node as the matched node.
-			this.assignNode(pParserState.ParseTree[pCharacter], pParserState);
-			this.appendOutputBuffer(pCharacter, pParserState);
+				this.appendOutputBuffer(pCharacter, pParserState);
+
+				if (pParserState.Pattern.PatternEnd.hasOwnProperty(pCharacter))
+				{
+					// This is the first character of the end pattern.
+					pParserState.EndPatternMatchBegan = true;
+					// This leaf has a PatternEnd tree, so we will wait until that end is met.
+					pParserState.Pattern = pParserState.Pattern.PatternEnd[pCharacter];
+					// If this last character is the end of the pattern, parse it.
+					if (pParserState.Pattern.hasOwnProperty('Parse'))
+					{
+						// ... this is the end of a pattern, cut off the end tag and parse it.
+						// Trim the start and end tags off the output buffer now
+						if (pParserState.Pattern.isAsync)
+						{
+							// Run the function
+							return pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStartString.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStartString.length+pParserState.Pattern.PatternEndString.length)), pData,
+								(pError, pAsyncOutput) =>
+								{
+									if (pError)
+									{
+										console.log(`Precedent ERROR: Async template error happened parsing ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd}: ${pError}`);
+									}
+
+									pParserState.OutputBuffer = pAsyncOutput;
+									this.resetOutputBuffer(pParserState);
+									return fCallback();
+								});
+						}
+						else
+						{
+							// Run the t*mplate function
+							pParserState.OutputBuffer = pParserState.Pattern.Parse(pParserState.OutputBuffer.substr(pParserState.Pattern.PatternStartString.length, pParserState.OutputBuffer.length - (pParserState.Pattern.PatternStartString.length+pParserState.Pattern.PatternEndString.length)), pData);
+							this.resetOutputBuffer(pParserState);
+							return fCallback();
+						}
+					}
+				}
+			}
+			else
+			{
+				// We are in a pattern start but didn't match one; reset and start trying again from this character.
+				this.resetOutputBuffer(pParserState);
+				return fCallback();
+			}
 		}
-		// (2) If we are in a pattern match (actively seeing if this is part of a new pattern token)
-		else if (pParserState.PatternMatch)
+		// If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....
+		if (!pParserState.PatternMatch)
 		{
-			// If the pattern has a subpattern with this key
-			if (pParserState.PatternMatch.hasOwnProperty(pCharacter))
+			// This may be the start of a new pattern....
+			if (pParserState.ParseTree.hasOwnProperty(pCharacter))
 			{
-				// Continue matching patterns.
-				this.assignNode(pParserState.PatternMatch[pCharacter], pParserState);
+				// ... assign the root node as the matched node.
+				this.resetOutputBuffer(pParserState);
+				this.appendOutputBuffer(pCharacter, pParserState);
+				pParserState.Pattern = pParserState.ParseTree[pCharacter];
+				pParserState.PatternMatch = true;
 			}
-			this.appendOutputBuffer(pCharacter, pParserState);
-			if (pParserState.Pattern)
+			else
 			{
-				// ... Check if this is the end of the pattern (if we are matching a valid pattern)...
-				return this.checkPatternEndAsync(pParserState, pData, fCallback);
+				this.appendOutputBuffer(pCharacter, pParserState);
 			}
 		}
-		// (3) If we aren't in a pattern match or pattern, and this isn't the start of a new pattern (RAW mode)....
-		else
-		{
-			pParserState.Output += pCharacter;
-		}
-
-		return fCallback(null);
+		return fCallback();
 	}
 
 	/**
@@ -261,6 +354,7 @@ class StringParser
 		{
 			// This is the async mode
 			let tmpParserState = this.newParserState(pParseTree);
+			tmpParserState.Asynchronous = true;
 
 			this.eachLimit(pString, 1,
 				(pCharacter, fCharacterCallback) =>

package/source/services/Fable-Service-MetaTemplate/MetaTemplate-WordTree.js

@@ -1,5 +1,5 @@
 /**
-* MetaTemplate Word Tree
+* Word Tree
 * @author      Steven Velozo <steven@velozo.com>
 * @description Create a tree (directed graph) of Javascript objects, one character per object.
 */
@@ -19,78 +19,101 @@ class WordTree
 	 * @method addChild
 	 * @param {Object} pTree - A parse tree to push the characters into
 	 * @param {string} pPattern - The string to add to the tree
-	 * @param {number} pIndex - The index of the character in the pattern
 	 * @returns {Object} The resulting leaf node that was added (or found)
 	 * @private
 	 */
-	addChild (pTree, pPattern, pIndex)
+	addChild (pTree, pPattern)
 	{
-		if (!pTree.hasOwnProperty(pPattern[pIndex]))
-			pTree[pPattern[pIndex]] = {};
+		if (!pTree.hasOwnProperty(pPattern))
+		{
+			pTree[pPattern] = {};
+		}
 
-		return pTree[pPattern[pIndex]];
+		return pTree[pPattern];
+	}
+
+	/**
+	 * Add a child character to a Parse Tree PatternEnd subtree
+	 * @method addChild
+	 * @param {Object} pTree - A parse tree to push the characters into
+	 * @param {string} pPattern - The string to add to the tree
+	 * @returns {Object} The resulting leaf node that was added (or found)
+	 * @private
+	 */
+	addEndChild (pTree, pPattern)
+	{
+		if (!pTree.hasOwnProperty('PatternEnd'))
+		{
+			pTree.PatternEnd = {};
+		}
+
+		pTree.PatternEnd[pPattern] = {};
+
+		return pTree.PatternEnd[pPattern];
 	}
 
 	/** Add a Pattern to the Parse Tree
 	 * @method addPattern
 	 * @param {Object} pPatternStart - The starting string for the pattern (e.g. "${")
 	 * @param {string} pPatternEnd - The ending string for the pattern (e.g. "}")
-	 * @param {number} pParser - The function to parse if this is the matched pattern, once the Pattern End is met.  If this is a string, a simple replacement occurs.
+	 * @param {function} fParser - The function to parse if this is the matched pattern, once the Pattern End is met.  If this is a string, a simple replacement occurs.
 	 * @return {bool} True if adding the pattern was successful
 	 */
-	addPattern (pPatternStart, pPatternEnd, pParser)
+	addPattern (pPatternStart, pPatternEnd, fParser)
 	{
 		if (pPatternStart.length < 1)
+		{
 			return false;
+		}
 
 		if ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length < 1))
+		{
 			return false;
+		}
 
 		let tmpLeaf = this.ParseTree;
 
 		// Add the tree of leaves iteratively
 		for (var i = 0; i < pPatternStart.length; i++)
-			tmpLeaf = this.addChild(tmpLeaf, pPatternStart, i);
-
-		tmpLeaf.PatternStart = pPatternStart;
-		tmpLeaf.PatternEnd = ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length > 0)) ? pPatternEnd : pPatternStart;
-		tmpLeaf.Parse = (typeof(pParser) === 'function') ? pParser :
-						(typeof(pParser) === 'string') ? () => { return pParser; } :
+		{
+			tmpLeaf = this.addChild(tmpLeaf, pPatternStart[i], i);
+		}
+
+		if (!tmpLeaf.hasOwnProperty('PatternEnd'))
+		{
+			tmpLeaf.PatternEnd = {};
+		}
+
+		let tmpPatternEnd = (typeof(pPatternEnd) === 'string') ? pPatternEnd : pPatternStart;
+		for (let i = 0; i < tmpPatternEnd.length; i++)
+		{
+			tmpLeaf = this.addEndChild(tmpLeaf, tmpPatternEnd[i], i);
+		}
+
+		tmpLeaf.PatternStartString = pPatternStart;
+		tmpLeaf.PatternEndString = tmpPatternEnd;
+		tmpLeaf.Parse = (typeof(fParser) === 'function') ? fParser :
+						(typeof(fParser) === 'string') ? () => { return fParser; } :
 						(pData) => { return pData; };
-		tmpLeaf.isPromise = false;
 
-		return true;
+		return tmpLeaf;
 	}
 
-	/** Add a Pattern to the Parse Tree (asynchronous)
+
+	/** Add a Pattern to the Parse Tree
 	 * @method addPattern
 	 * @param {Object} pPatternStart - The starting string for the pattern (e.g. "${")
 	 * @param {string} pPatternEnd - The ending string for the pattern (e.g. "}")
-	 * @param {number} pParserAsync - The function (with an asynchronous callback) to parse if this is the matched pattern, once the Pattern End is met.  If this is a string, a simple replacement occurs.
+	 * @param {function} fParser - The function to parse if this is the matched pattern, once the Pattern End is met.  If this is a string, a simple replacement occurs.
 	 * @return {bool} True if adding the pattern was successful
 	 */
-	addPatternAsync (pPatternStart, pPatternEnd, pParserAsync)
+	addPatternAsync (pPatternStart, pPatternEnd, fParser)
 	{
-		if (pPatternStart.length < 1)
-			return false;
-
-		if ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length < 1))
-			return false;
-
-		let tmpLeaf = this.ParseTree;
-
-		// Add the tree of leaves iteratively
-		for (var i = 0; i < pPatternStart.length; i++)
-			tmpLeaf = this.addChild(tmpLeaf, pPatternStart, i);
-
-		tmpLeaf.PatternStart = pPatternStart;
-		tmpLeaf.PatternEnd = ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length > 0)) ? pPatternEnd : pPatternStart;
-		tmpLeaf.Parse = (typeof(pParserAsync) === 'function') ? pParserAsync :
-						(typeof(pParserAsync) === 'string') ? (pHash, pData, fCallback) => { fCallback(pParserPromise); } :
-						(pHash, pData, fCallback) => { return fCallback(pHash); };
-		tmpLeaf.isAsync = true;
-
-		return true;
+		let tmpLeaf = this.addPattern(pPatternStart, pPatternEnd, fParser);
+		if (tmpLeaf)
+		{
+			tmpLeaf.isAsync = true;
+		}
 	}
 }
 

package/test/FableServiceManager_tests.js

@@ -138,8 +138,11 @@ suite
                         testFable.serviceManager.addServiceType('SimpleService', SimpleService);
 
                         let tmpService = testFable.serviceManager.instantiateServiceProviderWithoutRegistration('SimpleService', {SomeOption: true}, 'SimpleService-99');
+                        let tmpServiceFromPrototype = testFable.serviceManager.instantiateServiceProviderFromPrototype('SimpleService', {SomeOption: true}, 'SimpleService-100', SimpleService);
 
                         Expect(testFable.services.SimpleService['SimpleService-99']).to.be.an('undefined');
+                        Expect(testFable.services.SimpleService['SimpleService-100']).to.be.an('object');
+                        Expect(tmpServiceFromPrototype).to.be.an('object');
 
                         Expect(tmpService).to.be.an('object');
                     }

package/test/MetaTemplating_tests.js

@@ -198,9 +198,6 @@ suite
 							'Match this <<> and this <<here> please.',
 							'Match this MEDIUM_MATCH and this MEDIUM_MATCH please.',
 
-							'Match this <<EXTRA> and this <<here> please.',
-							'Match this MEDIUM_MATCH and this MEDIUM_MATCH please.',
-
 							'Match this <<EXTRALONG> and this <<here> please.',
 							'Match this EXTRA_LONG_MATCH and this MEDIUM_MATCH please.',