fable 3.0.18 → 3.0.21

package/dist/fable.js

@@ -1,3 +1,5 @@
+"use strict";
+
 (function (f) {
   if (typeof exports === "object" && typeof module !== "undefined") {
     module.exports = f();
@@ -264,7 +266,7 @@
           'use strict';
 
           var _setImmediate = typeof setImmediate === 'function' && setImmediate;
-          var fallback = function (fn) {
+          var fallback = function fallback(fn) {
             setTimeout(fn, 0);
           };
           module.exports = function setImmediate(fn) {
@@ -274,7 +276,7 @@
         }).call(this);
       }).call(this, require("timers").setImmediate);
     }, {
-      "timers": 33
+      "timers": 34
     }],
     14: [function (require, module, exports) {
       'use strict';
@@ -325,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
       *
@@ -388,7 +808,7 @@
       }
       module.exports = BaseLogger;
     }, {}],
-    18: [function (require, module, exports) {
+    19: [function (require, module, exports) {
       /**
       * Default Logger Provider Function
       *
@@ -406,23 +826,23 @@
       };
       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) {
           super(pLogStreamSettings);
           this._ShowTimeStamps = this._Settings.hasOwnProperty('showtimestamps') ? this._Settings.showtimestamps == true : true;
           this._FormattedTimeStamps = this._Settings.hasOwnProperty('formattedtimestamps') ? this._Settings.formattedtimestamps == true : true;
-          this._ContextMessage = this._Settings.hasOwnProperty('Context') ? `(${this._Settings.Context})` : pFableLog._Settings.hasOwnProperty('Product') ? `(${pFableLog._Settings.Product})` : 'Unnamed_Log_Context';
+          this._ContextMessage = this._Settings.hasOwnProperty('Context') ? "(".concat(this._Settings.Context, ")") : pFableLog._Settings.hasOwnProperty('Product') ? "(".concat(pFableLog._Settings.Product, ")") : 'Unnamed_Log_Context';
 
           // Allow the user to decide what gets output to the console
           this._OutputLogLinesToConsole = this._Settings.hasOwnProperty('outputloglinestoconsole') ? this._Settings.outputloglinestoconsole : true;
@@ -431,7 +851,7 @@
           // Precompute the prefix for each level
           this.prefixCache = {};
           for (let i = 0; i <= this.levels.length; i++) {
-            this.prefixCache[this.levels[i]] = `[${this.levels[i]}] ${this._ContextMessage}: `;
+            this.prefixCache[this.levels[i]] = "[".concat(this.levels[i], "] ").concat(this._ContextMessage, ": ");
             if (this._ShowTimeStamps) {
               // If there is a timestamp we need a to prepend space before the prefixcache string, since the timestamp comes first
               this.prefixCache[this.levels[i]] = ' ' + this.prefixCache[this.levels[i]];
@@ -445,7 +865,7 @@
           } else if (this._ShowTimeStamps) {
             tmpTimeStamp = +new Date();
           }
-          let tmpLogLine = `${tmpTimeStamp}${this.prefixCache[pLevel]}${pLogText}`;
+          let tmpLogLine = "".concat(tmpTimeStamp).concat(this.prefixCache[pLevel]).concat(pLogText);
           if (this._OutputLogLinesToConsole) {
             console.log(tmpLogLine);
           }
@@ -461,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');
@@ -472,7 +892,7 @@
           super(pLogStreamSettings, pFableLog);
 
           // If a path isn't provided for the logfile, it tries to use the ProductName or Context
-          this.logFileRawPath = this._Settings.hasOwnProperty('path') ? this._Settings.path : `./${this._ContextMessage}.log`;
+          this.logFileRawPath = this._Settings.hasOwnProperty('path') ? this._Settings.path : "./".concat(this._ContextMessage, ".log");
           this.logFilePath = libPath.normalize(this.logFileRawPath);
           this.logFileStreamOptions = this._Settings.hasOwnProperty('fileStreamoptions') ? this._Settings.fileStreamOptions : {
             "flags": "a",
@@ -519,9 +939,9 @@
             let tmpConstructedBufferOutputString = '';
             for (let i = 0; i < tmpLineStrings.length; i++) {
               // TODO: Windows Newline?   ....... yo no se!
-              tmpConstructedBufferOutputString += `${tmpLineStrings[i]}\n`;
+              tmpConstructedBufferOutputString += "".concat(tmpLineStrings[i], "\n");
               if (tmpObjectStrings[i] !== false) {
-                tmpConstructedBufferOutputString += `${tmpObjectStrings[i]}\n`;
+                tmpConstructedBufferOutputString += "".concat(tmpObjectStrings[i], "\n");
               }
             }
             if (!this.fileWriter.write(tmpConstructedBufferOutputString, 'utf8')) {
@@ -549,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
       *
@@ -672,7 +1092,7 @@
               level: 'info'
             }, this._StreamDefinitions[i]);
             if (!this._Providers.hasOwnProperty(tmpStreamDefinition.loggertype)) {
-              console.log(`Error initializing log stream: bad loggertype in stream definition ${JSON.stringify(tmpStreamDefinition)}`);
+              console.log("Error initializing log stream: bad loggertype in stream definition ".concat(JSON.stringify(tmpStreamDefinition)));
             } else {
               this.addLogger(new this._Providers[tmpStreamDefinition.loggertype](tmpStreamDefinition, this), tmpStreamDefinition.level);
             }
@@ -686,7 +1106,7 @@
         logTime(pMessage, pDatum) {
           let tmpMessage = typeof pMessage !== 'undefined' ? pMessage : 'Time';
           let tmpTime = new Date();
-          this.info(`${tmpMessage} ${tmpTime} (epoch ${+tmpTime})`, pDatum);
+          this.info("".concat(tmpMessage, " ").concat(tmpTime, " (epoch ").concat(+tmpTime, ")"), pDatum);
         }
 
         // Get a timestamp
@@ -703,7 +1123,7 @@
           let tmpMessage = typeof pMessage !== 'undefined' ? pMessage : 'Time Measurement';
           let tmpDatum = typeof pDatum === 'object' ? pDatum : {};
           let tmpEndTime = +new Date();
-          this.info(`${tmpMessage} logged at (epoch ${+tmpEndTime}) took (${pTimeDelta}ms)`, pDatum);
+          this.info("".concat(tmpMessage, " logged at (epoch ").concat(+tmpEndTime, ") took (").concat(pTimeDelta, "ms)"), pDatum);
         }
         logTimeDeltaHuman(pTimeDelta, pMessage, pDatum) {
           let tmpMessage = typeof pMessage !== 'undefined' ? pMessage : 'Time Measurement';
@@ -716,7 +1136,7 @@
           tmpSeconds = tmpSeconds < 10 ? "0" + tmpSeconds : tmpSeconds;
           tmpMinutes = tmpMinutes < 10 ? "0" + tmpMinutes : tmpMinutes;
           tmpHours = tmpHours < 10 ? "0" + tmpHours : tmpHours;
-          this.info(`${tmpMessage} logged at (epoch ${+tmpEndTime}) took (${pTimeDelta}ms) or (${tmpHours}:${tmpMinutes}:${tmpSeconds}.${tmpMs})`, pDatum);
+          this.info("".concat(tmpMessage, " logged at (epoch ").concat(+tmpEndTime, ") took (").concat(pTimeDelta, "ms) or (").concat(tmpHours, ":").concat(tmpMinutes, ":").concat(tmpSeconds, ".").concat(tmpMs, ")"), pDatum);
         }
         logTimeDeltaRelative(pStartTime, pMessage, pDatum) {
           this.logTimeDelta(this.getTimeDelta(pStartTime), pMessage, pDatum);
@@ -736,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",
@@ -752,7 +1172,7 @@
         }]
       };
     }, {}],
-    24: [function (require, module, exports) {
+    25: [function (require, module, exports) {
       (function (process) {
         (function () {
           /**
@@ -794,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
       *
@@ -942,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
       *
@@ -999,7 +1419,7 @@
       }
       module.exports = RandomBytes;
     }, {}],
-    27: [function (require, module, exports) {
+    28: [function (require, module, exports) {
       /**
       * Fable UUID Generator
       *
@@ -1080,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)
@@ -1551,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
       *
@@ -1563,8 +1983,8 @@
       *
       * @description Process text streams, parsing out meta-template expressions.
       */
-      var libWordTree = require(`./WordTree.js`);
-      var libStringParser = require(`./StringParser.js`);
+      var libWordTree = require("./WordTree.js");
+      var libStringParser = require("./StringParser.js");
       class Precedent {
         /**
          * Precedent Constructor
@@ -1599,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
       *
@@ -1748,7 +2168,7 @@
       }
       module.exports = StringParser;
     }, {}],
-    31: [function (require, module, exports) {
+    32: [function (require, module, exports) {
       /**
       * Word Tree
       *
@@ -1807,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 = {};
 
@@ -1984,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;
@@ -2058,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": 42
     }],
-    35: [function (require, module, exports) {
+    36: [function (require, module, exports) {
       const _OperationStatePrototype = JSON.stringify({
         "Metadata": {
           "GUID": false,
@@ -2112,13 +2532,13 @@
           return this;
         }
         writeOperationLog(pLogLevel, pLogText, pLogObject) {
-          this.state.Log.push(`${new Date().toUTCString()} [${pLogLevel}]: ${pLogText}`);
+          this.state.Log.push("".concat(new Date().toUTCString(), " [").concat(pLogLevel, "]: ").concat(pLogText));
           if (typeof pLogObject == 'object') {
             this.state.Log.push(JSON.stringify(pLogObject));
           }
         }
         writeOperationErrors(pLogText, pLogObject) {
-          this.state.Errors.push(`${pLogText}`);
+          this.state.Errors.push("".concat(pLogText));
           if (typeof pLogObject == 'object') {
             this.state.Errors.push(JSON.stringify(pLogObject));
           }
@@ -2152,7 +2572,22 @@
       }
       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": 41,
+      "data-arithmatic": 17
+    }],
+    38: [function (require, module, exports) {
       const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
       class FableServiceTemplate extends libFableServiceBase {
         // Underscore and lodash have a behavior, _.template, which compiles a
@@ -2212,14 +2647,14 @@
           // For now this is being kept in a weird form ... this is to mimic the old
           // underscore code until this is rewritten using precedent.
           this.TemplateSource = "__p+='" + pTemplateText.replace(this.Matchers.Escaper, pMatch => {
-            return `\\${this.templateEscapes[pMatch]}`;
+            return "\\".concat(this.templateEscapes[pMatch]);
           }).replace(this.Matchers.Interpolate || this.Matchers.GuaranteedNonMatch, (pMatch, pCode) => {
-            return `'+\n(${decodeURIComponent(pCode)})+\n'`;
+            return "'+\n(".concat(decodeURIComponent(pCode), ")+\n'");
           }).replace(this.Matchers.Evaluate || this.Matchers.GuaranteedNonMatch, (pMatch, pCode) => {
-            return `';\n${decodeURIComponent(pCode)}\n;__p+='`;
-          }) + `';\n`;
-          this.TemplateSource = `with(pTemplateDataObject||{}){\n${this.TemplateSource}}\n`;
-          this.TemplateSource = `var __p='';var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n${this.TemplateSource}return __p;\n`;
+            return "';\n".concat(decodeURIComponent(pCode), "\n;__p+='");
+          }) + "';\n";
+          this.TemplateSource = "with(pTemplateDataObject||{}){\n".concat(this.TemplateSource, "}\n");
+          this.TemplateSource = "var __p='';var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n".concat(this.TemplateSource, "return __p;\n");
           this.renderFunction = new Function('pTemplateDataObject', this.TemplateSource);
           if (typeof pData != 'undefined') {
             return this.renderFunction(pData);
@@ -2233,9 +2668,83 @@
       }
       module.exports = FableServiceTemplate;
     }, {
-      "./Fable-ServiceProviderBase.js": 38
+      "./Fable-ServiceProviderBase.js": 41
     }],
-    37: [function (require, module, exports) {
+    39: [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": 41,
+      "async.eachlimit": 1,
+      "async.waterfall": 15
+    }],
+    40: [function (require, module, exports) {
       /**
       * Fable Application Services Management
       * @license MIT
@@ -2302,9 +2811,9 @@
       module.exports = FableService;
       module.exports.ServiceProviderBase = libFableServiceBase;
     }, {
-      "./Fable-ServiceProviderBase.js": 38
+      "./Fable-ServiceProviderBase.js": 41
     }],
-    38: [function (require, module, exports) {
+    41: [function (require, module, exports) {
       /**
       * Fable Service Base
       * @license MIT
@@ -2317,71 +2826,12 @@
           this.options = typeof pOptions === 'object' ? pOptions : {};
           this.serviceType = 'Unknown';
           this.UUID = pFable.getUUID();
-          this.Hash = typeof pServiceHash === 'string' ? pServiceHash : `${this.UUID}`;
+          this.Hash = typeof pServiceHash === 'string' ? pServiceHash : "".concat(this.UUID);
         }
       }
       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, ...pSourceObjects) {
-          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) {
+    42: [function (require, module, exports) {
       /**
       * Fable Application Services Support Library
       * @license MIT
@@ -2390,9 +2840,10 @@
       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 libFableServiceUtility = require('./Fable-Service-Utility.js');
       const libFableOperation = require('./Fable-Operation.js');
       class Fable {
         constructor(pSettings) {
@@ -2404,9 +2855,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
@@ -2415,7 +2863,20 @@
           // 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 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;
         }
@@ -2457,13 +2918,14 @@
       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-Template.js": 38,
+      "./Fable-Service-Utility.js": 39,
+      "./Fable-ServiceManager.js": 40,
+      "fable-log": 23,
+      "fable-settings": 26,
+      "fable-uuid": 28
     }]
-  }, {}, [34])(34);
+  }, {}, [35])(35);
 });