precedent 1.0.13 → 1.0.15

package/package.json

@@ -1,67 +1,52 @@
 {
-  "name": "precedent",
-  "version": "1.0.13",
-  "description": "Precedent Meta-Templating",
-  "main": "source/Precedent.js",
-  "bin": {
-    "precedent": "./bin/Precedent"
-  },
-  "scripts": {
-    "start": "node source/Precedent.js",
-    "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
-    "test": "./node_modules/.bin/mocha -u tdd -R spec",
-    "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/precedent:local",
-    "docker-dev-run": "docker run -it -d --name precedent-dev -p 127.0.0.1:12340:8080 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/precedent\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/precedent:local",
-    "build": "./node_modules/.bin/gulp build",
-    "build-compatible": "GULP_CUSTOM_BUILD_TARGET=compatible ./node_modules/.bin/gulp build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/stevenvelozo/precedent.git"
-  },
-  "keywords": [
-    "logging"
-  ],
-  "author": "Steven Velozo <steven@velozo.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/stevenvelozo/precedent/issues"
-  },
-  "mocha": {
-    "diff": true,
-    "extension": [
-      "js"
+    "name": "precedent",
+    "version": "1.0.15",
+    "description": "Precedent Meta-Templating",
+    "main": "source/Precedent.js",
+    "bin": {
+        "precedent": "./bin/Precedent"
+    },
+    "scripts": {
+        "start": "node source/Precedent.js",
+        "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
+        "test": "./node_modules/.bin/mocha -u tdd -R spec",
+        "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/precedent:local",
+        "docker-dev-run": "docker run -it -d --name precedent-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/precedent\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" precedent-image:local",
+        "build": "npx quack build",
+        "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t precedent-image:local",
+        "docker-dev-shell": "docker exec -it precedent-dev /bin/bash"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/stevenvelozo/precedent.git"
+    },
+    "keywords": [
+        "logging"
     ],
-    "package": "./package.json",
-    "reporter": "spec",
-    "slow": "75",
-    "timeout": "5000",
-    "ui": "tdd",
-    "watch-files": [
-      "source/**/*.js",
-      "test/**/*.js"
-    ],
-    "watch-ignore": [
-      "lib/vendor"
-    ]
-  },
-  "devDependencies": {
-    "@babel/core": "^7.21.5",
-    "@babel/preset-env": "^7.21.5",
-    "browserify": "^17.0.0",
-    "chai": "4.3.7",
-    "gulp": "^4.0.2",
-    "gulp-babel": "^8.0.0",
-    "gulp-env": "^0.4.0",
-    "gulp-sourcemaps": "^3.0.0",
-    "gulp-terser": "^2.1.0",
-    "gulp-util": "^3.0.8",
-    "mocha": "10.2.0",
-    "nyc": "^15.1.0",
-    "vinyl-buffer": "^1.0.1",
-    "vinyl-source-stream": "^2.0.0"
-  },
-  "dependencies": {
-    "async": "^3.2.4"
-  }
+    "author": "Steven Velozo <steven@velozo.com>",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/stevenvelozo/precedent/issues"
+    },
+    "mocha": {
+        "diff": true,
+        "extension": [
+            "js"
+        ],
+        "package": "./package.json",
+        "reporter": "spec",
+        "slow": "75",
+        "timeout": "5000",
+        "ui": "tdd",
+        "watch-files": [
+            "source/**/*.js",
+            "test/**/*.js"
+        ],
+        "watch-ignore": [
+            "lib/vendor"
+        ]
+    },
+    "devDependencies": {
+        "quackage": "^1.0.14"
+    }
 }

package/source/Precedent.js

@@ -37,11 +37,6 @@ class Precedent
 		return this.WordTree.addPattern(pPatternStart, pPatternEnd, pParser);
 	}
 
-	addPatternAsync(pPatternStart, pPatternEnd, pParserPromise)
-	{
-		return this.WordTree.addPatternAsync(pPatternStart, pPatternEnd, pParserPromise);
-	}
-
 	/**
 	 * Parse a string with the existing parse tree
 	 * @method parseString
@@ -49,9 +44,9 @@ class Precedent
 	 * @param {object} pData - Data to pass in as the second argument
 	 * @return {string} The result from the parser
 	 */
-	parseString(pString, pData, fCallback)
+	parseString(pString, pData)
 	{
-		return this.StringParser.parseString(pString, this.ParseTree, pData, fCallback);
+		return this.StringParser.parseString(pString, this.ParseTree, pData);
 	}
 }
 

package/source/StringParser.js

@@ -1,15 +1,9 @@
 /**
 * String Parser
-*
-* @license     MIT
-*
 * @author      Steven Velozo <steven@velozo.com>
-*
 * @description Parse a string, properly processing each matched token in the word tree.
 */
 
-let libAsync = require('async');
-
 class StringParser
 {
 	/**
@@ -37,33 +31,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.
@@ -89,80 +63,18 @@ class StringParser
 		pParserState.OutputBuffer = '';
 	}
 
-	/**
-	 * Check if the pattern has ended.  If it has, properly flush the buffer and start looking for new patterns.
-	 * @method checkPatternEnd
-	 * @param {Object} pParserState - The state object for the current parsing task
-	 * @private
-	 */
-	checkPatternEnd (pParserState, pData)
-	{
-		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)
-			{
-				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;
-			}
-			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;
-			}
-		}
-	}
-
-	checkPatternEndAsync (pParserState, pData, fCallback)
+	resetOutputBuffer (pParserState)
 	{
-		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)
-			{
-				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 (pError)
-						{
-							console.log(`Precedent ERROR: Async template error happened parsing ${pParserState.Pattern.PatternStart} ... ${pParserState.Pattern.PatternEnd}: ${pError}`);
-						}
-
-						pParserState.OutputBuffer = pAsyncOutput;
-						// Flush the output buffer.
-						this.flushOutputBuffer(pParserState);
-						// End pattern mode
-						pParserState.Pattern = false;
-						pParserState.PatternMatch = false;
-
-						return fCallback();
-					});
-			}
-			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;
-			}
-		}
-
-		return fCallback();
+		// 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;
 	}
 
 	/**
@@ -174,68 +86,93 @@ class StringParser
 	 */
 	parseCharacter (pCharacter, pParserState, pData)
 	{
-		// (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))
+		// If we are already in a pattern match traversal
+		if (pParserState.PatternMatch)
 		{
-			// ... 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 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'))
+					{
+						// 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);
+				}
 			}
-		}
-		// (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'))
+					{
+						// 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
+			{
+				// We are in a pattern start but didn't match one; reset and start trying again from this character.
+				this.resetOutputBuffer(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 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;
+				return 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 false;
 	}
 
 	/**
@@ -244,42 +181,19 @@ class StringParser
 	 * @param {string} pString - The string to parse.
 	 * @param {Object} pParseTree - The parse tree to begin parsing from (usually root)
 	 * @param {Object} pData - The data to pass to the function as a second parameter
-	 * @param {function} fCallback - The callback function to call when the parse is complete
 	 */
-	parseString (pString, pParseTree, pData, fCallback)
+	parseString (pString, pParseTree, pData)
 	{
-		if (typeof(fCallback) !== 'function')
-		{
-			let tmpParserState = this.newParserState(pParseTree);
+		let tmpParserState = this.newParserState(pParseTree);
 
-			for (var i = 0; i < pString.length; i++)
-			{
-				// TODO: This is not fast.
-				this.parseCharacter(pString[i], tmpParserState, pData, fCallback);
-			}
-
-			this.flushOutputBuffer(tmpParserState);
-
-			return tmpParserState.Output;
-		}
-		else
+		for (var i = 0; i < pString.length; i++)
 		{
-			// This is the async mode
-			let tmpParserState = this.newParserState(pParseTree);
+			this.parseCharacter(pString[i], tmpParserState, pData);
+		}
 
-			libAsync.eachSeries(pString,
-				(pCharacter, fCharacterCallback) =>
-				{
-					this.parseCharacterAsync(pCharacter, tmpParserState, pData, fCharacterCallback);
-				},
-				(pError) =>
-				{
-					// Flush the remaining data
-					this.flushOutputBuffer(tmpParserState);
-					fCallback(pError, tmpParserState.Output);
-				});
+		this.flushOutputBuffer(tmpParserState);
 
-		}
+		return tmpParserState.Output;
 	}
 }
 

package/source/WordTree.js

@@ -1,10 +1,6 @@
 /**
 * Word Tree
-*
-* @license     MIT
-*
 * @author      Steven Velozo <steven@velozo.com>
-*
 * @description Create a tree (directed graph) of Javascript objects, one character per object.
 */
 
@@ -23,76 +19,82 @@ 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 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.
-	 * @return {bool} True if adding the pattern was successful
+	/**
+	 * 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
 	 */
-	addPattern (pPatternStart, pPatternEnd, pParser)
+	addEndChild (pTree, pPattern)
 	{
-		if (pPatternStart.length < 1)
-			return false;
+		if (!pTree.hasOwnProperty('PatternEnd'))
+		{
+			pTree.PatternEnd = {};
+		}
 
-		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);
+		pTree.PatternEnd[pPattern] = {};
 
-		tmpLeaf.PatternStart = pPatternStart;
-		tmpLeaf.PatternEnd = ((typeof(pPatternEnd) === 'string') && (pPatternEnd.length > 0)) ? pPatternEnd : pPatternStart;
-		tmpLeaf.Parse = (typeof(pParser) === 'function') ? pParser :
-						(typeof(pParser) === 'string') ? () => { return pParser; } :
-						(pData) => { return pData; };
-		tmpLeaf.isPromise = false;
-
-		return true;
+		return pTree.PatternEnd[pPattern];
 	}
 
-	/** 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)
+	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(pParserAsync) === 'function') ? pParserAsync :
-						(typeof(pParserAsync) === 'string') ? (pHash, pData, fCallback) => { fCallback(pParserPromise); } :
-						(pHash, pData, fCallback) => { return fCallback(pHash); };
-		tmpLeaf.isAsync = true;
+		{
+			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; };
 
 		return true;
 	}

package/test/Precedent_tests.js

@@ -30,12 +30,6 @@ var configPrecedent = (pModule) =>
 	pModule.addPattern('<^', '^>', (pHash, pData)=>{return `hash of [${pHash}] from pData is ${pData[pHash]}`});
 	// This just escapes out pairs of $
 	pModule.addPattern('$');
-
-	pModule.addPatternAsync('<%Async', '%>', 
-		(pHash, pData, fCallback)=>
-		{
-			return fCallback(null, `ASYNC DATA IS [${pHash}]`);
-		});
 };
 
 suite
@@ -159,23 +153,6 @@ suite
 					}
 				);
 				test
-				(
-					'Async Function',
-					(fDone) =>
-					{
-						var tmpTestString = 'The <^SomeValue^> pData and Async <%AsyncThe Funny String%> up in here and a $comment$ as well.';
-						var tmpExpectedResult = 'The hash of [SomeValue] from pData is AirbornLight pData up in here and a comment as well.';
-						var testPrecedent = loadPrecedentModule();
-						configPrecedent(testPrecedent);
-						var	tmpResult = testPrecedent.parseString(tmpTestString, {SomeValue:'AirbornLight'}, 
-							(pError, pValue) =>
-							{
-								Expect(pValue).to.equal('The hash of [SomeValue] from pData is AirbornLight pData and Async ASYNC DATA IS [The Funny String] up in here and a comment as well.');
-								return fDone();
-							});
-					}
-				);
-				test
 				(
 					'Bad pattern start parameter...',
 					(fDone) =>
@@ -214,9 +191,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.',
 

package/.browserslistrc_compatible

@@ -1 +0,0 @@
-> 0.01%

package/.browserslistrc_default

@@ -1 +0,0 @@
-since 2018