precedent 1.0.14 → 1.0.15

package/.babelrc

@@ -0,0 +1,5 @@
+{
+    "presets": [
+        "@babel/preset-env"
+    ]
+}

package/dist/precedent.compatible.js

@@ -1,5 +1,13 @@
+"use strict";
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 (function (f) {
-  if (typeof exports === "object" && typeof module !== "undefined") {
+  if ((typeof exports === "undefined" ? "undefined" : _typeof(exports)) === "object" && typeof module !== "undefined") {
     module.exports = f();
   } else if (typeof define === "function" && define.amd) {
     define([], f);
@@ -45,20 +53,6 @@
     return r;
   }()({
     1: [function (require, module, exports) {
-      /**
-      * Simple browser shim loader - assign the npm module to a window global automatically
-      *
-      * @author <steven@velozo.com>
-      */
-      var libNPMModuleWrapper = require('./Precedent.js');
-      if (typeof window == 'object' && !window.hasOwnProperty('Precedent')) {
-        window.Precedent = libNPMModuleWrapper;
-      }
-      module.exports = libNPMModuleWrapper;
-    }, {
-      "./Precedent.js": 2
-    }],
-    2: [function (require, module, exports) {
       /**
       * Precedent Meta-Templating
       *
@@ -68,13 +62,14 @@
       *
       * @description Process text streams, parsing out meta-template expressions.
       */
-      var libWordTree = require(`./WordTree.js`);
-      var libStringParser = require(`./StringParser.js`);
-      class Precedent {
+      var libWordTree = require("./WordTree.js");
+      var libStringParser = require("./StringParser.js");
+      var Precedent = /*#__PURE__*/function () {
         /**
          * Precedent Constructor
          */
-        constructor() {
+        function Precedent() {
+          _classCallCheck(this, Precedent);
           this.WordTree = new libWordTree();
           this.StringParser = new libStringParser();
           this.ParseTree = this.WordTree.ParseTree;
@@ -88,38 +83,45 @@
          * @param {number} pIndex - callback function
          * @return {bool} True if adding the pattern was successful
          */
-        addPattern(pPatternStart, pPatternEnd, pParser) {
-          return this.WordTree.addPattern(pPatternStart, pPatternEnd, pParser);
-        }
+        _createClass(Precedent, [{
+          key: "addPattern",
+          value: function addPattern(pPatternStart, pPatternEnd, pParser) {
+            return this.WordTree.addPattern(pPatternStart, pPatternEnd, pParser);
+          }
 
-        /**
-         * Parse a string with the existing parse tree
-         * @method parseString
-         * @param {string} pString - The string to parse
-         * @param {object} pData - Data to pass in as the second argument
-         * @return {string} The result from the parser
-         */
-        parseString(pString, pData) {
-          return this.StringParser.parseString(pString, this.ParseTree, pData);
-        }
-      }
+          /**
+           * Parse a string with the existing parse tree
+           * @method parseString
+           * @param {string} pString - The string to parse
+           * @param {object} pData - Data to pass in as the second argument
+           * @return {string} The result from the parser
+           */
+        }, {
+          key: "parseString",
+          value: function parseString(pString, pData) {
+            return this.StringParser.parseString(pString, this.ParseTree, pData);
+          }
+        }]);
+        return Precedent;
+      }();
       module.exports = Precedent;
     }, {
-      "./StringParser.js": 3,
-      "./WordTree.js": 4
+      "./StringParser.js": 2,
+      "./WordTree.js": 3
     }],
-    3: [function (require, module, exports) {
+    2: [function (require, module, exports) {
       /**
       * String Parser
       * @author      Steven Velozo <steven@velozo.com>
       * @description Parse a string, properly processing each matched token in the word tree.
       */
-
-      class StringParser {
+      var StringParser = /*#__PURE__*/function () {
         /**
          * StringParser Constructor
          */
-        constructor() {}
+        function StringParser() {
+          _classCallCheck(this, StringParser);
+        }
 
         /**
          * Create a fresh parsing state object to work with.
@@ -128,141 +130,170 @@
          * @return {Object} A new parser state object for running a character parser on
          * @private
          */
-        newParserState(pParseTree) {
-          return {
-            ParseTree: pParseTree,
-            Asynchronous: false,
-            Output: '',
-            OutputBuffer: '',
-            Pattern: false,
-            PatternMatch: false,
-            PatternMatchOutputBuffer: ''
-          };
-        }
-
-        /**
-         * 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;
+        _createClass(StringParser, [{
+          key: "newParserState",
+          value: function newParserState(pParseTree) {
+            return {
+              ParseTree: pParseTree,
+              Asynchronous: false,
+              Output: '',
+              OutputBuffer: '',
+              Pattern: {},
+              PatternMatch: false,
+              PatternMatchEnd: false
+            };
           }
-        }
-
-        /**
-         * 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.
-         * @method appendOutputBuffer
-         * @param {string} pCharacter - The character to append
-         * @param {Object} pParserState - The state object for the current parsing task
-         * @private
-         */
-        appendOutputBuffer(pCharacter, pParserState) {
-          pParserState.OutputBuffer += pCharacter;
-        }
 
-        /**
-         * Flush the output buffer to the output and clear it.
-         * @method flushOutputBuffer
-         * @param {Object} pParserState - The state object for the current parsing task
-         * @private
-         */
-        flushOutputBuffer(pParserState) {
-          pParserState.Output += pParserState.OutputBuffer;
-          pParserState.OutputBuffer = '';
-        }
+          /**
+           * 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.
+           * @method appendOutputBuffer
+           * @param {string} pCharacter - The character to append
+           * @param {Object} pParserState - The state object for the current parsing task
+           * @private
+           */
+        }, {
+          key: "appendOutputBuffer",
+          value: function appendOutputBuffer(pCharacter, pParserState) {
+            pParserState.OutputBuffer += pCharacter;
+          }
 
-        /**
-         * 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
-            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 to the output and clear it.
+           * @method flushOutputBuffer
+           * @param {Object} pParserState - The state object for the current parsing task
+           * @private
+           */
+        }, {
+          key: "flushOutputBuffer",
+          value: function flushOutputBuffer(pParserState) {
+            pParserState.Output += pParserState.OutputBuffer;
+            pParserState.OutputBuffer = '';
+          }
+        }, {
+          key: "resetOutputBuffer",
+          value: function 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;
           }
-        }
 
-        /**
-         * 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
-         */
-        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)) {
-            // ... 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)) {
-              // Continue matching patterns.
-              this.assignNode(pParserState.PatternMatch[pCharacter], pParserState);
+          /**
+           * 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
+           */
+        }, {
+          key: "parseCharacter",
+          value: function parseCharacter(pCharacter, pParserState, pData) {
+            // If we are already in a pattern match traversal
+            if (pParserState.PatternMatch) {
+              // If the pattern is still matching the start and we haven't passed the buffer
+              if (!pParserState.StartPatternMatchComplete && pParserState.Pattern.hasOwnProperty(pCharacter)) {
+                pParserState.Pattern = pParserState.Pattern[pCharacter];
+                this.appendOutputBuffer(pCharacter, pParserState);
+              } else if (pParserState.EndPatternMatchBegan) {
+                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);
+                }
+              } else if (pParserState.Pattern.hasOwnProperty('PatternEnd')) {
+                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')) {
+                    // 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);
+              }
             }
-            this.appendOutputBuffer(pCharacter, pParserState);
-            if (pParserState.Pattern) {
-              // ... Check if this is the end of the pattern (if we are matching a valid pattern)...
-              this.checkPatternEnd(pParserState, pData);
+            // 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;
           }
-          // (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;
-          }
-        }
 
-        /**
-         * Parse a string for matches, and process any template segments that occur.
-         * @method parseString
-         * @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
-         */
-        parseString(pString, pParseTree, pData) {
-          let tmpParserState = this.newParserState(pParseTree);
-          for (var i = 0; i < pString.length; i++) {
-            this.parseCharacter(pString[i], tmpParserState, pData);
+          /**
+           * Parse a string for matches, and process any template segments that occur.
+           * @method parseString
+           * @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
+           */
+        }, {
+          key: "parseString",
+          value: function parseString(pString, pParseTree, pData) {
+            var tmpParserState = this.newParserState(pParseTree);
+            for (var i = 0; i < pString.length; i++) {
+              this.parseCharacter(pString[i], tmpParserState, pData);
+            }
+            this.flushOutputBuffer(tmpParserState);
+            return tmpParserState.Output;
           }
-          this.flushOutputBuffer(tmpParserState);
-          return tmpParserState.Output;
-        }
-      }
+        }]);
+        return StringParser;
+      }();
       module.exports = StringParser;
     }, {}],
-    4: [function (require, module, exports) {
+    3: [function (require, module, exports) {
       /**
       * Word Tree
       * @author      Steven Velozo <steven@velozo.com>
       * @description Create a tree (directed graph) of Javascript objects, one character per object.
       */
-
-      class WordTree {
+      var WordTree = /*#__PURE__*/function () {
         /**
          * WordTree Constructor
          */
-        constructor() {
+        function WordTree() {
+          _classCallCheck(this, WordTree);
           this.ParseTree = {};
         }
 
@@ -271,39 +302,77 @@
          * @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) {
-          if (!pTree.hasOwnProperty(pPattern[pIndex])) pTree[pPattern[pIndex]] = {};
-          return pTree[pPattern[pIndex]];
-        }
+        _createClass(WordTree, [{
+          key: "addChild",
+          value: function addChild(pTree, pPattern) {
+            if (!pTree.hasOwnProperty(pPattern)) {
+              pTree[pPattern] = {};
+            }
+            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
-         */
-        addPattern(pPatternStart, pPatternEnd, pParser) {
-          if (pPatternStart.length < 1) return false;
-          if (typeof pPatternEnd === 'string' && pPatternEnd.length < 1) return false;
-          let tmpLeaf = this.ParseTree;
+          /**
+           * 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
+           */
+        }, {
+          key: "addEndChild",
+          value: function addEndChild(pTree, pPattern) {
+            if (!pTree.hasOwnProperty('PatternEnd')) {
+              pTree.PatternEnd = {};
+            }
+            pTree.PatternEnd[pPattern] = {};
+            return pTree.PatternEnd[pPattern];
+          }
 
-          // 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;
-          } : pData => {
-            return pData;
-          };
-          return true;
-        }
-      }
+          /** 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 {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
+           */
+        }, {
+          key: "addPattern",
+          value: function addPattern(pPatternStart, pPatternEnd, fParser) {
+            if (pPatternStart.length < 1) {
+              return false;
+            }
+            if (typeof pPatternEnd === 'string' && pPatternEnd.length < 1) {
+              return false;
+            }
+            var tmpLeaf = this.ParseTree;
+
+            // Add the tree of leaves iteratively
+            for (var i = 0; i < pPatternStart.length; i++) {
+              tmpLeaf = this.addChild(tmpLeaf, pPatternStart[i], i);
+            }
+            if (!tmpLeaf.hasOwnProperty('PatternEnd')) {
+              tmpLeaf.PatternEnd = {};
+            }
+            var tmpPatternEnd = typeof pPatternEnd === 'string' ? pPatternEnd : pPatternStart;
+            for (var _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' ? function () {
+              return fParser;
+            } : function (pData) {
+              return pData;
+            };
+            return true;
+          }
+        }]);
+        return WordTree;
+      }();
       module.exports = WordTree;
     }, {}]
   }, {}, [1])(1);

package/dist/precedent.compatible.min.js

@@ -1,4 +1,4 @@
-!function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).Precedent=t()}}((function(){return function t(e,r,n){function a(s,f){if(!r[s]){if(!e[s]){var o="function"==typeof require&&require;if(!f&&o)return o(s,!0);if(u)return u(s,!0);var i=new Error("Cannot find module '"+s+"'");throw i.code="MODULE_NOT_FOUND",i}var P=r[s]={exports:{}};e[s][0].call(P.exports,(function(t){return a(e[s][1][t]||t)}),P,P.exports,t,e,r,n)}return r[s].exports}for(var u="function"==typeof require&&require,s=0;s<n.length;s++)a(n[s]);return a}({1:[function(t,e,r){var n=t("./Precedent.js");"object"!=typeof window||window.hasOwnProperty("Precedent")||(window.Precedent=n),e.exports=n},{"./Precedent.js":2}],2:[function(t,e,r){
+"use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _defineProperties(t,e){for(var r=0;r<e.length;r++){var n=e[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,_toPropertyKey(n.key),n)}}function _createClass(t,e,r){return e&&_defineProperties(t.prototype,e),r&&_defineProperties(t,r),Object.defineProperty(t,"prototype",{writable:!1}),t}function _toPropertyKey(t){var e=_toPrimitive(t,"string");return"symbol"===_typeof(e)?e:String(e)}function _toPrimitive(t,e){if("object"!==_typeof(t)||null===t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var n=r.call(t,e||"default");if("object"!==_typeof(n))return n;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===e?String:Number)(t)}function _typeof(t){return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},_typeof(t)}!function(t){if("object"===("undefined"==typeof exports?"undefined":_typeof(exports))&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).Precedent=t()}}((function(){return function t(e,r,n){function a(f,i){if(!r[f]){if(!e[f]){var o="function"==typeof require&&require;if(!i&&o)return o(f,!0);if(u)return u(f,!0);var s=new Error("Cannot find module '"+f+"'");throw s.code="MODULE_NOT_FOUND",s}var p=r[f]={exports:{}};e[f][0].call(p.exports,(function(t){return a(e[f][1][t]||t)}),p,p.exports,t,e,r,n)}return r[f].exports}for(var u="function"==typeof require&&require,f=0;f<n.length;f++)a(n[f]);return a}({1:[function(t,e,r){
 /**
       * Precedent Meta-Templating
       *
@@ -8,5 +8,5 @@
       *
       * @description Process text streams, parsing out meta-template expressions.
       */
-var n=t("./WordTree.js"),a=t("./StringParser.js");e.exports=class{constructor(){this.WordTree=new n,this.StringParser=new a,this.ParseTree=this.WordTree.ParseTree}addPattern(t,e,r){return this.WordTree.addPattern(t,e,r)}parseString(t,e){return this.StringParser.parseString(t,this.ParseTree,e)}}},{"./StringParser.js":3,"./WordTree.js":4}],3:[function(t,e,r){e.exports=class{constructor(){}newParserState(t){return{ParseTree:t,Asynchronous:!1,Output:"",OutputBuffer:"",Pattern:!1,PatternMatch:!1,PatternMatchOutputBuffer:""}}assignNode(t,e){e.PatternMatch=t,e.PatternMatch.hasOwnProperty("PatternEnd")&&(e.Pattern=e.PatternMatch)}appendOutputBuffer(t,e){e.OutputBuffer+=t}flushOutputBuffer(t){t.Output+=t.OutputBuffer,t.OutputBuffer=""}checkPatternEnd(t,e){t.OutputBuffer.length>=t.Pattern.PatternEnd.length+t.Pattern.PatternStart.length&&t.OutputBuffer.substr(-t.Pattern.PatternEnd.length)===t.Pattern.PatternEnd&&(t.OutputBuffer=t.Pattern.Parse(t.OutputBuffer.substr(t.Pattern.PatternStart.length,t.OutputBuffer.length-(t.Pattern.PatternStart.length+t.Pattern.PatternEnd.length)),e),this.flushOutputBuffer(t),t.Pattern=!1,t.PatternMatch=!1)}parseCharacter(t,e,r){!e.PatternMatch&&e.ParseTree.hasOwnProperty(t)?(this.assignNode(e.ParseTree[t],e),this.appendOutputBuffer(t,e)):e.PatternMatch?(e.PatternMatch.hasOwnProperty(t)&&this.assignNode(e.PatternMatch[t],e),this.appendOutputBuffer(t,e),e.Pattern&&this.checkPatternEnd(e,r)):e.Output+=t}parseString(t,e,r){let n=this.newParserState(e);for(var a=0;a<t.length;a++)this.parseCharacter(t[a],n,r);return this.flushOutputBuffer(n),n.Output}}},{}],4:[function(t,e,r){e.exports=class{constructor(){this.ParseTree={}}addChild(t,e,r){return t.hasOwnProperty(e[r])||(t[e[r]]={}),t[e[r]]}addPattern(t,e,r){if(t.length<1)return!1;if("string"==typeof e&&e.length<1)return!1;let n=this.ParseTree;for(var a=0;a<t.length;a++)n=this.addChild(n,t,a);return n.PatternStart=t,n.PatternEnd="string"==typeof e&&e.length>0?e:t,n.Parse="function"==typeof r?r:"string"==typeof r?()=>r:t=>t,!0}}},{}]},{},[1])(1)}));
+var n=t("./WordTree.js"),a=t("./StringParser.js"),u=function(){function t(){_classCallCheck(this,t),this.WordTree=new n,this.StringParser=new a,this.ParseTree=this.WordTree.ParseTree}return _createClass(t,[{key:"addPattern",value:function(t,e,r){return this.WordTree.addPattern(t,e,r)}},{key:"parseString",value:function(t,e){return this.StringParser.parseString(t,this.ParseTree,e)}}]),t}();e.exports=u},{"./StringParser.js":2,"./WordTree.js":3}],2:[function(t,e,r){var n=function(){function t(){_classCallCheck(this,t)}return _createClass(t,[{key:"newParserState",value:function(t){return{ParseTree:t,Asynchronous:!1,Output:"",OutputBuffer:"",Pattern:{},PatternMatch:!1,PatternMatchEnd:!1}}},{key:"appendOutputBuffer",value:function(t,e){e.OutputBuffer+=t}},{key:"flushOutputBuffer",value:function(t){t.Output+=t.OutputBuffer,t.OutputBuffer=""}},{key:"resetOutputBuffer",value:function(t){return this.flushOutputBuffer(t),t.Pattern=!1,t.PatternStartNode=!1,t.StartPatternMatchComplete=!1,t.EndPatternMatchBegan=!1,t.PatternMatch=!1,!0}},{key:"parseCharacter",value:function(t,e,r){if(e.PatternMatch)if(!e.StartPatternMatchComplete&&e.Pattern.hasOwnProperty(t))e.Pattern=e.Pattern[t],this.appendOutputBuffer(t,e);else if(e.EndPatternMatchBegan)if(e.Pattern.PatternEnd.hasOwnProperty(t)){if(e.Pattern=e.Pattern.PatternEnd[t],this.appendOutputBuffer(t,e),e.Pattern.hasOwnProperty("Parse"))return e.OutputBuffer=e.Pattern.Parse(e.OutputBuffer.substr(e.Pattern.PatternStartString.length,e.OutputBuffer.length-(e.Pattern.PatternStartString.length+e.Pattern.PatternEndString.length)),r),this.resetOutputBuffer(e)}else e.PatternStartNode.PatternEnd.hasOwnProperty(t)?(e.Pattern=e.PatternStartNode.PatternEnd[t],this.appendOutputBuffer(t,e)):(e.EndPatternMatchBegan=!1,this.appendOutputBuffer(t,e));else if(e.Pattern.hasOwnProperty("PatternEnd")){if(e.StartPatternMatchComplete||(e.StartPatternMatchComplete=!0,e.PatternStartNode=e.Pattern),this.appendOutputBuffer(t,e),e.Pattern.PatternEnd.hasOwnProperty(t)&&(e.EndPatternMatchBegan=!0,e.Pattern=e.Pattern.PatternEnd[t],e.Pattern.hasOwnProperty("Parse")))return e.OutputBuffer=e.Pattern.Parse(e.OutputBuffer.substr(e.Pattern.PatternStartString.length,e.OutputBuffer.length-(e.Pattern.PatternStartString.length+e.Pattern.PatternEndString.length)),r),this.resetOutputBuffer(e)}else this.resetOutputBuffer(e);if(!e.PatternMatch){if(e.ParseTree.hasOwnProperty(t))return this.resetOutputBuffer(e),this.appendOutputBuffer(t,e),e.Pattern=e.ParseTree[t],e.PatternMatch=!0,!0;this.appendOutputBuffer(t,e)}return!1}},{key:"parseString",value:function(t,e,r){for(var n=this.newParserState(e),a=0;a<t.length;a++)this.parseCharacter(t[a],n,r);return this.flushOutputBuffer(n),n.Output}}]),t}();e.exports=n},{}],3:[function(t,e,r){var n=function(){function t(){_classCallCheck(this,t),this.ParseTree={}}return _createClass(t,[{key:"addChild",value:function(t,e){return t.hasOwnProperty(e)||(t[e]={}),t[e]}},{key:"addEndChild",value:function(t,e){return t.hasOwnProperty("PatternEnd")||(t.PatternEnd={}),t.PatternEnd[e]={},t.PatternEnd[e]}},{key:"addPattern",value:function(t,e,r){if(t.length<1)return!1;if("string"==typeof e&&e.length<1)return!1;for(var n=this.ParseTree,a=0;a<t.length;a++)n=this.addChild(n,t[a],a);n.hasOwnProperty("PatternEnd")||(n.PatternEnd={});for(var u="string"==typeof e?e:t,f=0;f<u.length;f++)n=this.addEndChild(n,u[f],f);return n.PatternStartString=t,n.PatternEndString=u,n.Parse="function"==typeof r?r:"string"==typeof r?function(){return r}:function(t){return t},!0}}]),t}();e.exports=n},{}]},{},[1])(1)}));
 //# sourceMappingURL=precedent.compatible.min.js.map