fable 3.0.20 → 3.0.22

package/dist/fable.js

@@ -276,7 +276,7 @@
         }).call(this);
       }).call(this, require("timers").setImmediate);
     }, {
-      "timers": 33
+      "timers": 34
     }],
     14: [function (require, module, exports) {
       'use strict';
@@ -327,6 +327,424 @@
     }],
     16: [function (require, module, exports) {}, {}],
     17: [function (require, module, exports) {
+      /**
+      * @license MIT
+      * @author <steven@velozo.com>
+      */
+
+      /**
+      * Data Arithmatic
+      *
+      * @class DataArithmatic
+      */
+      class DataArithmatic {
+        constructor() {
+          // Regular Expressions (so they don't have to be recompiled every time)
+          // These could be defined as static, but I'm not sure if that will work with browserify ... and specifically the QT browser.
+          this._Regex_formatterInsertCommas = /.{1,3}/g;
+          // Match Function:
+          // function(pMatch, pSign, pZeros, pBefore, pDecimal, pAfter)
+          // Thoughts about below:   /^([+-]?)(0*)(\d+)(\.(\d+))?$/;
+          this._Regex_formatterAddCommasToNumber = /^([-+]?)(0?)(\d+)(.?)(\d+)$/g;
+          this._Regex_formatterDollarsRemoveCommas = /,/gi;
+          this._Regex_formatterCleanNonAlpha = /[^a-z0-9]/gi;
+
+          // TODO: Potentially pull these in from a configuration.
+          // TODO: Use locale data for this if it's defaults all the way down.
+          this._Value_MoneySign_Currency = '$';
+          this._Value_NaN_Currency = '--';
+          this._Value_GroupSeparator_Number = ',';
+          this._Value_Prefix_StringHash = 'HSH';
+          this._Value_Clean_formatterCleanNonAlpha = '_';
+          this._UseEngineStringStartsWith = typeof String.prototype.startsWith === 'function';
+          this._UseEngineStringEndsWith = typeof String.prototype.endsWith === 'function';
+        }
+
+        /*************************************************************************
+         * String Manipulation and Comparison Functions
+         *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
+
+        /**
+         * Reverse a string
+         *
+         * @param {string} pString - The string to reverse
+         * @returns {string}
+         */
+        stringReverse(pString) {
+          // TODO: Benchmark if there are faster ways we want to do this with all the newer JS stuff
+          //       ... and if it will work with browserify in a clean way.
+          return pString.split('').reverse().join('');
+        }
+
+        /**
+         * Test if a string starts with a given substring.
+         *
+         * @param {*} pString
+         * @param {*} pSearchString
+         * @param {*} pStartIndex
+         * @returns {*}
+         */
+        stringStartsWith(pString, pSearchString, pStartIndex) {
+          if (this._UseEngineStringStartsWith) {
+            return pString.startsWith(pSearchString, pStartIndex);
+          } else {
+            return this.stringStartsWith_Polyfill.call(pString, pSearchString, pStartIndex);
+          }
+        }
+
+        /**
+         * Check if a string starts with a given substring.  This is a safe polyfill for the ES6 string.startsWith() function.
+         *
+         * @param {*} pSearchString - The string to search for
+         * @param {*} pStartIndex - The index to start the search at
+         * @returns {boolean}
+         */
+        stringStartsWith_Polyfill(pSearchString, pStartIndex) {
+          return this.slice(pStartIndex || 0, pSearchString.length) === pSearchString;
+        }
+
+        /**
+         * Test if a string starts with a given substring.
+         *
+         * @param {*} pString
+         * @param {*} pSearchString
+         * @param {*} pEndIndex
+         * @returns {*}
+         */
+        stringEndsWith(pString, pSearchString, pEndIndex) {
+          if (this._UseEngineStringEndsWith) {
+            return pString.endsWith(pSearchString, pEndIndex);
+          } else {
+            return this.stringEndsWith_Polyfill.call(pString, pSearchString, pEndIndex);
+          }
+        }
+
+        /**
+         * Check if a string starts with a given substring.  This is a safe polyfill for the ES6 string.startsWith() function.
+         *
+         * @param {*} pSearchString - The string to search for
+         * @param {*} pEndIndex - The index to end the search at
+         * @returns {boolean}
+         */
+        stringEndsWith_Polyfill(pSearchString, pEndIndex) {
+          // This works much better than >= because
+          // it compensates for NaN:
+          if (!(pEndIndex < this.length)) {
+            pEndIndex = this.length;
+          } else {
+            pEndIndex |= 0; // round position
+          }
+
+          return this.substr(pEndIndex - pSearchString.length, pSearchString.length) === pSearchString;
+        }
+
+        /**
+         * Generate an insecure string hash.  Not meant to be secure, just a quick way to generate a hash for a string.  This is not a cryptographic hash.  Additional warranty and disclaimer ... this is not for passwords!
+         *
+         * @param {string} pString
+         * @returns {string}
+         */
+        insecureStringHash(pString) {
+          let tmpHash = 0;
+          let tmpStringLength = pString.length;
+          let tmpCharacterIndex = 0;
+          while (tmpCharacterIndex < tmpStringLength) {
+            tmpHash = (tmpHash << 5) - tmpHash + pString.charCodeAt(tmpCharacterIndex++) | 0;
+          }
+          return "".concat(this._Value_Prefix_StringHash).concat(tmpHash);
+        }
+
+        /**
+         * Clean wrapping characters if they exist consistently around the string.  If they do not, the string is returned unchanged.
+         *
+         * @param {string} pWrapCharacter - The character expected as the wrapping character
+         * @param {string} pString - the string to clean
+         * @returns {string}
+         */
+        cleanEnclosureWrapCharacters(pWrapCharacter, pString) {
+          // # Use case from ManyFest DSL:
+          //
+          // When a boxed property is passed in, it should have quotes of some
+          // kind around it.
+          //
+          // For instance:
+          // 		MyValues['Name']
+          // 		MyValues["Age"]
+          // 		MyValues[`Cost`]
+          //
+          // This function is necessary to remove the wrapping quotes before object
+          // resolution can occur.
+          if (pString.startsWith(pWrapCharacter) && pString.endsWith(pWrapCharacter)) {
+            return pString.substring(1, pString.length - 1);
+          } else {
+            return pString;
+          }
+        }
+
+        /**
+         *
+         * @param {*} pString
+         * @returns
+         */
+        cleanNonAlphaCharacters(pString) {
+          if (typeof pString == 'string' && pString != '') {
+            return pString.replace(this._Regex_formatterCleanNonAlpha, this._Value_Clean_formatterCleanNonAlpha);
+          }
+        }
+
+        /*************************************************************************
+         * Number Formatting Functions
+         *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
+
+        /**
+         * Insert commas every 3 characters from the right.  Used by formatterAddCommasToNumber().
+         *
+         * @param {*} pString
+         * @returns {*}
+         */
+        formatterInsertCommas(pString) {
+          // Reverse, because it's easier to do things from the left, given arbitrary digit counts
+          let tmpReversed = this.stringReverse(pString);
+          // Add commas every three characters
+          let tmpReversedWithCommas = tmpReversed.match(this._Regex_formatterInsertCommas).join(',');
+          // Reverse again (back to normal direction)
+          return this.stringReverse(tmpReversedWithCommas);
+        }
+        processAddCommasToNumberRegex(pMatch, pSign, pZeros, pBefore, pDecimal, pAfter) {
+          // If there was no decimal, the last capture grabs the final digit, so
+          // we have to put it back together with the 'before' substring
+          return pSign + (pDecimal ? this.formatterInsertCommas(pBefore) + pDecimal + pAfter : this.formatterInsertCommas(pBefore + pAfter));
+        }
+
+        /**
+         * Add Commas to a Number for readability.
+         *
+         * @param {*} pNumber
+         * @returns {string}
+         */
+        formatterAddCommasToNumber(pNumber) {
+          // If the regex doesn't match, `replace` returns the string unmodified
+          return pNumber.toString().replace(this._Regex_formatterAddCommasToNumber, this.processAddCommasToNumberRegex.bind(this));
+        }
+
+        /**
+         * This will take a number and format it as a dollar string.  It will also add commas to the number.  If the number is not a number, it will return '--'.
+         *
+         * @param {*} pValue
+         * @returns {string}
+         */
+        formatterDollars(pValue) {
+          let tmpDollarAmount = parseFloat(pValue).toFixed(2);
+          if (isNaN(tmpDollarAmount)) {
+            // Try again and see if what was passed in was a dollars string.
+            if (typeof pValue == 'string') {
+              // TODO: Better rounding function?  This is a hack to get rid of the currency symbol and commas.
+              tmpDollarAmount = parseFloat(pValue.replace(this._Value_MoneySign_Currency, '').replace(this._Regex_formatterDollarsRemoveCommas, '')).toFixed(2);
+            }
+            // If we didn't get a number, return the "not a number" string.
+            if (isNaN(tmpDollarAmount)) {
+              return this._Value_NaN_Currency;
+            }
+          }
+
+          // TODO: Get locale data and use that for this stuff.
+          return "$".concat(this.formatterAddCommasToNumber(tmpDollarAmount));
+        }
+
+        /**
+         * Round a number to a certain number of digits.  If the number is not a number, it will return 0.  If no digits are specified, it will default to 2 significant digits.
+         *
+         * @param {*} pValue
+         * @param {number} pDigits
+         * @returns {string}
+         */
+        formatterRoundNumber(pValue, pDigits) {
+          let tmpDigits = typeof pDigits == 'undefined' ? 2 : pDigits;
+          let tmpValue = Number.parseFloat(pValue).toFixed(tmpDigits);
+          if (isNaN(tmpValue)) {
+            let tmpZed = 0;
+            return tmpZed.toFixed(tmpDigits);
+          } else {
+            return tmpValue;
+          }
+        }
+
+        /*************************************************************************
+         * String Tokenization Functions
+         *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
+
+        /**
+         * Return the string before the matched substring.
+         *
+         * If the substring is not found, the entire string is returned.  This only deals with the *first* match.
+         *
+         * @param {string} pString
+         * @param {string} pMatch
+         * @returns {string}
+         */
+        stringBeforeMatch(pString, pMatch) {
+          return pString.split(pMatch)[0];
+        }
+
+        /**
+         * Return the string after the matched substring.
+         *
+         * If the substring is not found, an empty string is returned.  This only deals with the *first* match.
+         *
+         * @param {string} pString
+         * @param {string} pMatch
+         * @returns {string}
+         */
+        stringAfterMatch(pString, pMatch) {
+          let tmpStringSplitLocation = pString.indexOf(pMatch);
+          if (tmpStringSplitLocation < 0 || tmpStringSplitLocation + pMatch.length >= pString.length) {
+            return '';
+          }
+          return pString.substring(tmpStringSplitLocation + pMatch.length);
+        }
+
+        /**
+         * Count the number of enclosures in a string based on the start and end characters.
+         *
+         * If no start or end characters are specified, it will default to parentheses.  If the string is not a string, it will return 0.
+         *
+         * @param {string} pString
+         * @param {string} pEnclosureStart
+         * @param {string} pEnclosureEnd
+         * @returns the count of full in the string
+         */
+        stringCountEnclosures(pString, pEnclosureStart, pEnclosureEnd) {
+          let tmpString = typeof pString == 'string' ? pString : '';
+          let tmpEnclosureStart = typeof pEnclosureStart == 'string' ? pEnclosureStart : '(';
+          let tmpEnclosureEnd = typeof pEnclosureEnd == 'string' ? pEnclosureEnd : ')';
+          let tmpEnclosureCount = 0;
+          let tmpEnclosureDepth = 0;
+          for (let i = 0; i < tmpString.length; i++) {
+            // This is the start of an enclosure
+            if (tmpString[i] == tmpEnclosureStart) {
+              if (tmpEnclosureDepth == 0) {
+                tmpEnclosureCount++;
+              }
+              tmpEnclosureDepth++;
+            } else if (tmpString[i] == tmpEnclosureEnd) {
+              tmpEnclosureDepth--;
+            }
+          }
+          return tmpEnclosureCount;
+        }
+
+        /**
+         * Get the value of the enclosure at the specified index.
+         *
+         * If the index is not a number, it will default to 0.  If the string is not a string, it will return an empty string.  If the enclosure is not found, it will return an empty string.  If the enclosure
+         *
+         * @param {string} pString
+         * @param {number} pEnclosureIndexToGet
+         * @param {string} pEnclosureStart
+         * @param {string}} pEnclosureEnd
+         * @returns {string}
+         */
+        stringGetEnclosureValueByIndex(pString, pEnclosureIndexToGet, pEnclosureStart, pEnclosureEnd) {
+          let tmpString = typeof pString == 'string' ? pString : '';
+          let tmpEnclosureIndexToGet = typeof pEnclosureIndexToGet == 'number' ? pEnclosureIndexToGet : 0;
+          let tmpEnclosureStart = typeof pEnclosureStart == 'string' ? pEnclosureStart : '(';
+          let tmpEnclosureEnd = typeof pEnclosureEnd == 'string' ? pEnclosureEnd : ')';
+          let tmpEnclosureCount = 0;
+          let tmpEnclosureDepth = 0;
+          let tmpMatchedEnclosureIndex = false;
+          let tmpEnclosedValueStartIndex = 0;
+          let tmpEnclosedValueEndIndex = 0;
+          for (let i = 0; i < tmpString.length; i++) {
+            // This is the start of an enclosure
+            if (tmpString[i] == tmpEnclosureStart) {
+              tmpEnclosureDepth++;
+
+              // Only count enclosures at depth 1, but still this parses both pairs of all of them.
+              if (tmpEnclosureDepth == 1) {
+                tmpEnclosureCount++;
+                if (tmpEnclosureIndexToGet == tmpEnclosureCount - 1) {
+                  // This is the start of *the* enclosure
+                  tmpMatchedEnclosureIndex = true;
+                  tmpEnclosedValueStartIndex = i;
+                }
+              }
+            }
+            // This is the end of an enclosure
+            else if (tmpString[i] == tmpEnclosureEnd) {
+              tmpEnclosureDepth--;
+
+              // Again, only count enclosures at depth 1, but still this parses both pairs of all of them.
+              if (tmpEnclosureDepth == 0 && tmpMatchedEnclosureIndex && tmpEnclosedValueEndIndex <= tmpEnclosedValueStartIndex) {
+                tmpEnclosedValueEndIndex = i;
+                tmpMatchedEnclosureIndex = false;
+              }
+            }
+          }
+          if (tmpEnclosureCount <= tmpEnclosureIndexToGet) {
+            // Return an empty string if the enclosure is not found
+            return '';
+          }
+          if (tmpEnclosedValueEndIndex > 0 && tmpEnclosedValueEndIndex > tmpEnclosedValueStartIndex) {
+            return tmpString.substring(tmpEnclosedValueStartIndex + 1, tmpEnclosedValueEndIndex);
+          } else {
+            return tmpString.substring(tmpEnclosedValueStartIndex + 1);
+          }
+        }
+
+        /**
+         * Remove an enclosure from a string based on the index of the enclosure.
+         *
+         * @param {string} pString
+         * @param {number} pEnclosureIndexToRemove
+         * @param {number} pEnclosureStart
+         * @param {number} pEnclosureEnd
+         * @returns {string}
+         */
+        stringRemoveEnclosureByIndex(pString, pEnclosureIndexToRemove, pEnclosureStart, pEnclosureEnd) {
+          let tmpString = typeof pString == 'string' ? pString : '';
+          let tmpEnclosureIndexToRemove = typeof pEnclosureIndexToRemove == 'number' ? pEnclosureIndexToRemove : 0;
+          let tmpEnclosureStart = typeof pEnclosureStart == 'string' ? pEnclosureStart : '(';
+          let tmpEnclosureEnd = typeof pEnclosureEnd == 'string' ? pEnclosureEnd : ')';
+          let tmpEnclosureCount = 0;
+          let tmpEnclosureDepth = 0;
+          let tmpMatchedEnclosureIndex = false;
+          let tmpEnclosureStartIndex = 0;
+          let tmpEnclosureEndIndex = 0;
+          for (let i = 0; i < tmpString.length; i++) {
+            // This is the start of an enclosure
+            if (tmpString[i] == tmpEnclosureStart) {
+              tmpEnclosureDepth++;
+              if (tmpEnclosureDepth == 1) {
+                tmpEnclosureCount++;
+                if (tmpEnclosureIndexToRemove == tmpEnclosureCount - 1) {
+                  tmpMatchedEnclosureIndex = true;
+                  tmpEnclosureStartIndex = i;
+                }
+              }
+            } else if (tmpString[i] == tmpEnclosureEnd) {
+              tmpEnclosureDepth--;
+              if (tmpEnclosureDepth == 0 && tmpMatchedEnclosureIndex && tmpEnclosureEndIndex <= tmpEnclosureStartIndex) {
+                tmpEnclosureEndIndex = i;
+                tmpMatchedEnclosureIndex = false;
+              }
+            }
+          }
+          if (tmpEnclosureCount <= tmpEnclosureIndexToRemove) {
+            return tmpString;
+          }
+          let tmpReturnString = '';
+          if (tmpEnclosureStartIndex > 1) {
+            tmpReturnString = tmpString.substring(0, tmpEnclosureStartIndex);
+          }
+          if (tmpString.length > tmpEnclosureEndIndex + 1 && tmpEnclosureEndIndex > tmpEnclosureStartIndex) {
+            tmpReturnString += tmpString.substring(tmpEnclosureEndIndex + 1);
+          }
+          return tmpReturnString;
+        }
+      }
+      module.exports = DataArithmatic;
+    }, {}],
+    18: [function (require, module, exports) {
       /**
       * Base Logger Class
       *
@@ -390,7 +808,7 @@
       }
       module.exports = BaseLogger;
     }, {}],
-    18: [function (require, module, exports) {
+    19: [function (require, module, exports) {
       /**
       * Default Logger Provider Function
       *
@@ -408,16 +826,16 @@
       };
       module.exports = getDefaultProviders();
     }, {
-      "./Fable-Log-Logger-Console.js": 20
+      "./Fable-Log-Logger-Console.js": 21
     }],
-    19: [function (require, module, exports) {
+    20: [function (require, module, exports) {
       module.exports = [{
         "loggertype": "console",
         "streamtype": "console",
         "level": "trace"
       }];
     }, {}],
-    20: [function (require, module, exports) {
+    21: [function (require, module, exports) {
       let libBaseLogger = require('./Fable-Log-BaseLogger.js');
       class ConsoleLogger extends libBaseLogger {
         constructor(pLogStreamSettings, pFableLog) {
@@ -463,9 +881,9 @@
       }
       module.exports = ConsoleLogger;
     }, {
-      "./Fable-Log-BaseLogger.js": 17
+      "./Fable-Log-BaseLogger.js": 18
     }],
-    21: [function (require, module, exports) {
+    22: [function (require, module, exports) {
       const libConsoleLog = require('./Fable-Log-Logger-Console.js');
       const libFS = require('fs');
       const libPath = require('path');
@@ -551,11 +969,11 @@
       }
       module.exports = SimpleFlatFileLogger;
     }, {
-      "./Fable-Log-Logger-Console.js": 20,
+      "./Fable-Log-Logger-Console.js": 21,
       "fs": 16,
-      "path": 28
+      "path": 29
     }],
-    22: [function (require, module, exports) {
+    23: [function (require, module, exports) {
       /**
       * Fable Logging Add-on
       *
@@ -738,13 +1156,13 @@
       module.exports.LogProviderConsole = require('./Fable-Log-Logger-Console.js');
       module.exports.LogProviderConsole = require('./Fable-Log-Logger-SimpleFlatFile.js');
     }, {
-      "./Fable-Log-BaseLogger.js": 17,
-      "./Fable-Log-DefaultProviders-Node.js": 18,
-      "./Fable-Log-DefaultStreams.json": 19,
-      "./Fable-Log-Logger-Console.js": 20,
-      "./Fable-Log-Logger-SimpleFlatFile.js": 21
+      "./Fable-Log-BaseLogger.js": 18,
+      "./Fable-Log-DefaultProviders-Node.js": 19,
+      "./Fable-Log-DefaultStreams.json": 20,
+      "./Fable-Log-Logger-Console.js": 21,
+      "./Fable-Log-Logger-SimpleFlatFile.js": 22
     }],
-    23: [function (require, module, exports) {
+    24: [function (require, module, exports) {
       module.exports = {
         "Product": "ApplicationNameHere",
         "ProductVersion": "0.0.0",
@@ -754,7 +1172,7 @@
         }]
       };
     }, {}],
-    24: [function (require, module, exports) {
+    25: [function (require, module, exports) {
       (function (process) {
         (function () {
           /**
@@ -796,9 +1214,9 @@
         }).call(this);
       }).call(this, require('_process'));
     }, {
-      "_process": 32
+      "_process": 33
     }],
-    25: [function (require, module, exports) {
+    26: [function (require, module, exports) {
       /**
       * Fable Settings Add-on
       *
@@ -944,11 +1362,11 @@
       module.exports.new = autoConstruct;
       module.exports.precedent = libPrecedent;
     }, {
-      "./Fable-Settings-Default": 23,
-      "./Fable-Settings-TemplateProcessor.js": 24,
-      "precedent": 29
+      "./Fable-Settings-Default": 24,
+      "./Fable-Settings-TemplateProcessor.js": 25,
+      "precedent": 30
     }],
-    26: [function (require, module, exports) {
+    27: [function (require, module, exports) {
       /**
       * Random Byte Generator - Browser version
       *
@@ -1001,7 +1419,7 @@
       }
       module.exports = RandomBytes;
     }, {}],
-    27: [function (require, module, exports) {
+    28: [function (require, module, exports) {
       /**
       * Fable UUID Generator
       *
@@ -1082,9 +1500,9 @@
       module.exports = FableUUID;
       module.exports.new = autoConstruct;
     }, {
-      "./Fable-UUID-Random.js": 26
+      "./Fable-UUID-Random.js": 27
     }],
-    28: [function (require, module, exports) {
+    29: [function (require, module, exports) {
       (function (process) {
         (function () {
           // 'path' module extracted from Node.js v8.11.1 (only the posix part)
@@ -1553,9 +1971,9 @@
         }).call(this);
       }).call(this, require('_process'));
     }, {
-      "_process": 32
+      "_process": 33
     }],
-    29: [function (require, module, exports) {
+    30: [function (require, module, exports) {
       /**
       * Precedent Meta-Templating
       *
@@ -1601,10 +2019,10 @@
       }
       module.exports = Precedent;
     }, {
-      "./StringParser.js": 30,
-      "./WordTree.js": 31
+      "./StringParser.js": 31,
+      "./WordTree.js": 32
     }],
-    30: [function (require, module, exports) {
+    31: [function (require, module, exports) {
       /**
       * String Parser
       *
@@ -1750,7 +2168,7 @@
       }
       module.exports = StringParser;
     }, {}],
-    31: [function (require, module, exports) {
+    32: [function (require, module, exports) {
       /**
       * Word Tree
       *
@@ -1809,7 +2227,7 @@
       }
       module.exports = WordTree;
     }, {}],
-    32: [function (require, module, exports) {
+    33: [function (require, module, exports) {
       // shim for using process in browser
       var process = module.exports = {};
 
@@ -1986,7 +2404,7 @@
         return 0;
       };
     }, {}],
-    33: [function (require, module, exports) {
+    34: [function (require, module, exports) {
       (function (setImmediate, clearImmediate) {
         (function () {
           var nextTick = require('process/browser.js').nextTick;
@@ -2060,19 +2478,19 @@
         }).call(this);
       }).call(this, require("timers").setImmediate, require("timers").clearImmediate);
     }, {
-      "process/browser.js": 32,
-      "timers": 33
+      "process/browser.js": 33,
+      "timers": 34
     }],
-    34: [function (require, module, exports) {
+    35: [function (require, module, exports) {
       var libNPMModuleWrapper = require('./Fable.js');
       if (typeof window === 'object' && !window.hasOwnProperty('Fable')) {
         window.Fable = libNPMModuleWrapper;
       }
       module.exports = libNPMModuleWrapper;
     }, {
-      "./Fable.js": 40
+      "./Fable.js": 43
     }],
-    35: [function (require, module, exports) {
+    36: [function (require, module, exports) {
       const _OperationStatePrototype = JSON.stringify({
         "Metadata": {
           "GUID": false,
@@ -2154,7 +2572,59 @@
       }
       module.exports = FableOperation;
     }, {}],
-    36: [function (require, module, exports) {
+    37: [function (require, module, exports) {
+      const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+      const libDataArithmatic = require('data-arithmatic');
+      class FableServiceDataArithmatic extends libFableServiceBase {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this.serviceType = 'DataArithmatic';
+          this._DataArithmaticLibrary = new libDataArithmatic();
+        }
+      }
+      module.exports = FableServiceDataArithmatic;
+    }, {
+      "./Fable-ServiceProviderBase.js": 42,
+      "data-arithmatic": 17
+    }],
+    38: [function (require, module, exports) {
+      const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+      const libPrecedent = require('precedent');
+      class FableServiceMetaTemplate extends libFableServiceBase {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this.serviceType = 'MetaTemplate';
+          this._MetaTemplateLibrary = new libPrecedent(this.options);
+        }
+
+        /**
+         * Add a Pattern to the Parse Tree
+         * @method addPattern
+         * @param {Object} pTree - A node on the parse tree to push the characters into
+         * @param {string} pPattern - The string to add to the tree
+         * @param {number} pIndex - callback function
+         * @return {bool} True if adding the pattern was successful
+         */
+        addPattern(pPatternStart, pPatternEnd, pParser) {
+          return this._MetaTemplateLibrary.addPattern(pPatternStart, pPatternEnd, pParser);
+        }
+
+        /**
+         * Parse a string with the existing parse tree
+         * @method parseString
+         * @param {string} pString - The string to parse
+         * @return {string} The result from the parser
+         */
+        parseString(pString) {
+          return this._MetaTemplateLibrary.parseString(pString, this.ParseTree);
+        }
+      }
+      module.exports = FableServiceMetaTemplate;
+    }, {
+      "./Fable-ServiceProviderBase.js": 42,
+      "precedent": 30
+    }],
+    39: [function (require, module, exports) {
       const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
       class FableServiceTemplate extends libFableServiceBase {
         // Underscore and lodash have a behavior, _.template, which compiles a
@@ -2235,9 +2705,83 @@
       }
       module.exports = FableServiceTemplate;
     }, {
-      "./Fable-ServiceProviderBase.js": 38
+      "./Fable-ServiceProviderBase.js": 42
     }],
-    37: [function (require, module, exports) {
+    40: [function (require, module, exports) {
+      const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+
+      // TODO: These are still pretty big -- consider the smaller polyfills
+      const libAsyncWaterfall = require('async.waterfall');
+      const libAsyncEachLimit = require('async.eachlimit');
+      class FableServiceUtility extends libFableServiceBase {
+        // Underscore and lodash have a behavior, _.template, which compiles a
+        // string-based template with code snippets into simple executable pieces,
+        // with the added twist of returning a precompiled function ready to go.
+        //
+        // NOTE: This does not implement underscore escape expressions
+        // NOTE: This does not implement underscore magic browser variable assignment
+        //
+        // This is an implementation of that.
+        // TODO: Make this use precedent, add configuration, add debugging.
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this.templates = {};
+
+          // These two functions are used extensively throughout
+          this.waterfall = libAsyncWaterfall;
+          this.eachLimit = libAsyncEachLimit;
+        }
+
+        // Underscore and lodash have a behavior, _.extend, which merges objects.
+        // Now that es6 gives us this, use the native thingy.
+        extend(pDestinationObject) {
+          for (var _len = arguments.length, pSourceObjects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            pSourceObjects[_key - 1] = arguments[_key];
+          }
+          return Object.assign(pDestinationObject, ...pSourceObjects);
+        }
+
+        // Underscore and lodash have a behavior, _.template, which compiles a
+        // string-based template with code snippets into simple executable pieces,
+        // with the added twist of returning a precompiled function ready to go.
+        template(pTemplateText, pData) {
+          let tmpTemplate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Template');
+          return tmpTemplate.buildTemplateFunction(pTemplateText, pData);
+        }
+
+        // Build a template function from a template hash, and, register it with the service provider
+        buildHashedTemplate(pTemplateHash, pTemplateText, pData) {
+          let tmpTemplate = this.fable.serviceManager.instantiateServiceProvider('Template', {}, pTemplateHash);
+          this.templates[pTemplateHash] = tmpTemplate.buildTemplateFunction(pTemplateText, pData);
+          return this.templates[pTemplateHash];
+        }
+
+        // This is a safe, modern version of chunk from underscore
+        // Algorithm pulled from a mix of these two polyfills:
+        // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_chunk
+        // https://youmightnotneed.com/lodash
+        // This implementation was most tolerant in browsers.  Uglify can fix the rest.
+        chunk(pInput, pChunkSize, pChunkCache) {
+          let tmpInputArray = [...pInput];
+          // Note lodash defaults to 1, underscore defaults to 0
+          let tmpChunkSize = typeof pChunkSize == 'number' ? pChunkSize : 0;
+          let tmpChunkCache = typeof pChunkCache != 'undefined' ? pChunkCache : [];
+          if (tmpChunkSize <= 0) {
+            return tmpChunkCache;
+          }
+          while (tmpInputArray.length) {
+            tmpChunkCache.push(tmpInputArray.splice(0, tmpChunkSize));
+          }
+          return tmpChunkCache;
+        }
+      }
+      module.exports = FableServiceUtility;
+    }, {
+      "./Fable-ServiceProviderBase.js": 42,
+      "async.eachlimit": 1,
+      "async.waterfall": 15
+    }],
+    41: [function (require, module, exports) {
       /**
       * Fable Application Services Management
       * @license MIT
@@ -2304,9 +2848,9 @@
       module.exports = FableService;
       module.exports.ServiceProviderBase = libFableServiceBase;
     }, {
-      "./Fable-ServiceProviderBase.js": 38
+      "./Fable-ServiceProviderBase.js": 42
     }],
-    38: [function (require, module, exports) {
+    42: [function (require, module, exports) {
       /**
       * Fable Service Base
       * @license MIT
@@ -2324,69 +2868,7 @@
       }
       module.exports = FableServiceProviderBase;
     }, {}],
-    39: [function (require, module, exports) {
-      // TODO: These are still pretty big -- consider the smaller polyfills
-      const libAsyncWaterfall = require('async.waterfall');
-      const libAsyncEachLimit = require('async.eachlimit');
-      class FableUtility {
-        constructor(pFable) {
-          this.fable = pFable;
-          this.templates = {};
-
-          // These two functions are used extensively throughout
-          this.waterfall = libAsyncWaterfall;
-          this.eachLimit = libAsyncEachLimit;
-        }
-
-        // Underscore and lodash have a behavior, _.extend, which merges objects.
-        // Now that es6 gives us this, use the native thingy.
-        extend(pDestinationObject) {
-          for (var _len = arguments.length, pSourceObjects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-            pSourceObjects[_key - 1] = arguments[_key];
-          }
-          return Object.assign(pDestinationObject, ...pSourceObjects);
-        }
-
-        // Underscore and lodash have a behavior, _.template, which compiles a
-        // string-based template with code snippets into simple executable pieces,
-        // with the added twist of returning a precompiled function ready to go.
-        template(pTemplateText, pData) {
-          let tmpTemplate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Template');
-          return tmpTemplate.buildTemplateFunction(pTemplateText, pData);
-        }
-
-        // Build a template function from a template hash, and, register it with the service provider
-        buildHashedTemplate(pTemplateHash, pTemplateText, pData) {
-          let tmpTemplate = this.fable.serviceManager.instantiateServiceProvider('Template', {}, pTemplateHash);
-          this.templates[pTemplateHash] = tmpTemplate.buildTemplateFunction(pTemplateText, pData);
-          return this.templates[pTemplateHash];
-        }
-
-        // This is a safe, modern version of chunk from underscore
-        // Algorithm pulled from a mix of these two polyfills:
-        // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_chunk
-        // https://youmightnotneed.com/lodash
-        // This implementation was most tolerant in browsers.  Uglify can fix the rest.
-        chunk(pInput, pChunkSize, pChunkCache) {
-          let tmpInputArray = [...pInput];
-          // Note lodash defaults to 1, underscore defaults to 0
-          let tmpChunkSize = typeof pChunkSize == 'number' ? pChunkSize : 0;
-          let tmpChunkCache = typeof pChunkCache != 'undefined' ? pChunkCache : [];
-          if (tmpChunkSize <= 0) {
-            return tmpChunkCache;
-          }
-          while (tmpInputArray.length) {
-            tmpChunkCache.push(tmpInputArray.splice(0, tmpChunkSize));
-          }
-          return tmpChunkCache;
-        }
-      }
-      module.exports = FableUtility;
-    }, {
-      "async.eachlimit": 1,
-      "async.waterfall": 15
-    }],
-    40: [function (require, module, exports) {
+    43: [function (require, module, exports) {
       /**
       * Fable Application Services Support Library
       * @license MIT
@@ -2395,9 +2877,11 @@
       const libFableSettings = require('fable-settings');
       const libFableUUID = require('fable-uuid');
       const libFableLog = require('fable-log');
-      const libFableUtility = require('./Fable-Utility.js');
       const libFableServiceManager = require('./Fable-ServiceManager.js');
+      const libFableServiceDataArithmatic = require('./Fable-Service-DataArithmatic.js');
       const libFableServiceTemplate = require('./Fable-Service-Template.js');
+      const libFableServiceMetaTemplate = require('./Fable-Service-MetaTemplate.js');
+      const libFableServiceUtility = require('./Fable-Service-Utility.js');
       const libFableOperation = require('./Fable-Operation.js');
       class Fable {
         constructor(pSettings) {
@@ -2409,9 +2893,6 @@
           this.log = new libFableLog(this.settingsManager.settings);
           this.log.initialize();
 
-          // Built-in utility belt functions
-          this.Utility = new libFableUtility(this);
-
           // Built-in dependencies
           this.Dependencies = {
             precedent: libFableSettings.precedent
@@ -2420,7 +2901,23 @@
           // Location for Operation state
           this.Operations = {};
           this.serviceManager = new libFableServiceManager(this);
+
+          // Initialize and instantiate the default baked-in Data Arithmatic service
+          this.serviceManager.addServiceType('DataArithmatic', libFableServiceDataArithmatic);
+          this.fable.serviceManager.instantiateServiceProvider('DataArithmatic', {}, 'Default-Service-DataArithmatic');
+          // This service is passing through the data arithmatic library
+          this.DataArithmatic = this.serviceManager.defaultServices.DataArithmatic._DataArithmaticLibrary;
+
+          // Initialize the template service
           this.serviceManager.addServiceType('Template', libFableServiceTemplate);
+
+          // Initialize the metatemplate service
+          this.serviceManager.addServiceType('MetaTemplate', libFableServiceMetaTemplate);
+
+          // Initialize and instantiate the default baked-in Utility service
+          this.serviceManager.addServiceType('Utility', libFableServiceUtility);
+          this.fable.serviceManager.instantiateServiceProvider('Utility', {}, 'Default-Service-Utility');
+          this.Utility = this.serviceManager.defaultServices.Utility;
           this.services = this.serviceManager.services;
           this.defaultServices = this.serviceManager.defaultServices;
         }
@@ -2462,13 +2959,15 @@
       module.exports.ServiceProviderBase = libFableServiceManager.ServiceProviderBase;
       module.exports.precedent = libFableSettings.precedent;
     }, {
-      "./Fable-Operation.js": 35,
-      "./Fable-Service-Template.js": 36,
-      "./Fable-ServiceManager.js": 37,
-      "./Fable-Utility.js": 39,
-      "fable-log": 22,
-      "fable-settings": 25,
-      "fable-uuid": 27
+      "./Fable-Operation.js": 36,
+      "./Fable-Service-DataArithmatic.js": 37,
+      "./Fable-Service-MetaTemplate.js": 38,
+      "./Fable-Service-Template.js": 39,
+      "./Fable-Service-Utility.js": 40,
+      "./Fable-ServiceManager.js": 41,
+      "fable-log": 23,
+      "fable-settings": 26,
+      "fable-uuid": 28
     }]
-  }, {}, [34])(34);
+  }, {}, [35])(35);
 });