orator 3.0.10 → 4.0.0

package/dist/orator.js

@@ -1,3 +1,13 @@
+"use strict";
+
+const _excluded = ["version", "host"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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 (f) {
   if (typeof exports === "object" && typeof module !== "undefined") {
     module.exports = f();
@@ -507,7 +517,7 @@
         }).call(this);
       }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
     }, {
-      "object-assign": 36,
+      "object-assign": 23,
       "util/": 4
     }],
     2: [function (require, module, exports) {
@@ -528,7 +538,7 @@
         // old school shim for old browsers
         module.exports = function inherits(ctor, superCtor) {
           ctor.super_ = superCtor;
-          var TempCtor = function () {};
+          var TempCtor = function TempCtor() {};
           TempCtor.prototype = superCtor.prototype;
           ctor.prototype = new TempCtor();
           ctor.prototype.constructor = ctor;
@@ -1046,736 +1056,69 @@
       }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
     }, {
       "./support/isBuffer": 3,
-      "_process": 37,
+      "_process": 24,
       "inherits": 2
     }],
     5: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = asyncify;
-      var _initialParams = require('./internal/initialParams.js');
-      var _initialParams2 = _interopRequireDefault(_initialParams);
-      var _setImmediate = require('./internal/setImmediate.js');
-      var _setImmediate2 = _interopRequireDefault(_setImmediate);
-      var _wrapAsync = require('./internal/wrapAsync.js');
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
-
-      /**
-       * Take a sync function and make it async, passing its return value to a
-       * callback. This is useful for plugging sync functions into a waterfall,
-       * series, or other async functions. Any arguments passed to the generated
-       * function will be passed to the wrapped function (except for the final
-       * callback argument). Errors thrown will be passed to the callback.
-       *
-       * If the function passed to `asyncify` returns a Promise, that promises's
-       * resolved/rejected state will be used to call the callback, rather than simply
-       * the synchronous return value.
-       *
-       * This also means you can asyncify ES2017 `async` functions.
-       *
-       * @name asyncify
-       * @static
-       * @memberOf module:Utils
-       * @method
-       * @alias wrapSync
-       * @category Util
-       * @param {Function} func - The synchronous function, or Promise-returning
-       * function to convert to an {@link AsyncFunction}.
-       * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be
-       * invoked with `(args..., callback)`.
-       * @example
-       *
-       * // passing a regular synchronous function
-       * async.waterfall([
-       *     async.apply(fs.readFile, filename, "utf8"),
-       *     async.asyncify(JSON.parse),
-       *     function (data, next) {
-       *         // data is the result of parsing the text.
-       *         // If there was a parsing error, it would have been caught.
-       *     }
-       * ], callback);
-       *
-       * // passing a function returning a promise
-       * async.waterfall([
-       *     async.apply(fs.readFile, filename, "utf8"),
-       *     async.asyncify(function (contents) {
-       *         return db.model.create(contents);
-       *     }),
-       *     function (model, next) {
-       *         // `model` is the instantiated model object.
-       *         // If there was an error, this function would be skipped.
-       *     }
-       * ], callback);
-       *
-       * // es2017 example, though `asyncify` is not needed if your JS environment
-       * // supports async functions out of the box
-       * var q = async.queue(async.asyncify(async function(file) {
-       *     var intermediateStep = await processFile(file);
-       *     return await somePromise(intermediateStep)
-       * }));
-       *
-       * q.push(files);
-       */
-      function asyncify(func) {
-        if ((0, _wrapAsync.isAsync)(func)) {
-          return function (...args /*, callback*/) {
-            const callback = args.pop();
-            const promise = func.apply(this, args);
-            return handlePromise(promise, callback);
-          };
-        }
-        return (0, _initialParams2.default)(function (args, callback) {
-          var result;
-          try {
-            result = func.apply(this, args);
-          } catch (e) {
-            return callback(e);
-          }
-          // if result is Promise object
-          if (result && typeof result.then === 'function') {
-            return handlePromise(result, callback);
-          } else {
-            callback(null, result);
-          }
-        });
-      }
-      function handlePromise(promise, callback) {
-        return promise.then(value => {
-          invokeCallback(callback, null, value);
-        }, err => {
-          invokeCallback(callback, err && err.message ? err : new Error(err));
-        });
-      }
-      function invokeCallback(callback, error, value) {
-        try {
-          callback(error, value);
-        } catch (err) {
-          (0, _setImmediate2.default)(e => {
-            throw e;
-          }, err);
-        }
-      }
-      module.exports = exports['default'];
-    }, {
-      "./internal/initialParams.js": 13,
-      "./internal/setImmediate.js": 18,
-      "./internal/wrapAsync.js": 19
-    }],
-    6: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      var _eachOfLimit2 = require('./internal/eachOfLimit.js');
-      var _eachOfLimit3 = _interopRequireDefault(_eachOfLimit2);
-      var _wrapAsync = require('./internal/wrapAsync.js');
-      var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-      var _awaitify = require('./internal/awaitify.js');
-      var _awaitify2 = _interopRequireDefault(_awaitify);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
-
-      /**
-       * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
-       * time.
-       *
-       * @name eachOfLimit
-       * @static
-       * @memberOf module:Collections
-       * @method
-       * @see [async.eachOf]{@link module:Collections.eachOf}
-       * @alias forEachOfLimit
-       * @category Collection
-       * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
-       * @param {number} limit - The maximum number of async operations at a time.
-       * @param {AsyncFunction} iteratee - An async function to apply to each
-       * item in `coll`. The `key` is the item's key, or index in the case of an
-       * array.
-       * Invoked with (item, key, callback).
-       * @param {Function} [callback] - A callback which is called when all
-       * `iteratee` functions have finished, or an error occurs. Invoked with (err).
-       * @returns {Promise} a promise, if a callback is omitted
-       */
-      function eachOfLimit(coll, limit, iteratee, callback) {
-        return (0, _eachOfLimit3.default)(limit)(coll, (0, _wrapAsync2.default)(iteratee), callback);
-      }
-      exports.default = (0, _awaitify2.default)(eachOfLimit, 4);
-      module.exports = exports['default'];
-    }, {
-      "./internal/awaitify.js": 9,
-      "./internal/eachOfLimit.js": 11,
-      "./internal/wrapAsync.js": 19
-    }],
-    7: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      var _eachOfLimit = require('./eachOfLimit.js');
-      var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-      var _awaitify = require('./internal/awaitify.js');
-      var _awaitify2 = _interopRequireDefault(_awaitify);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
-
       /**
-       * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.
-       *
-       * @name eachOfSeries
-       * @static
-       * @memberOf module:Collections
-       * @method
-       * @see [async.eachOf]{@link module:Collections.eachOf}
-       * @alias forEachOfSeries
-       * @category Collection
-       * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
-       * @param {AsyncFunction} iteratee - An async function to apply to each item in
-       * `coll`.
-       * Invoked with (item, key, callback).
-       * @param {Function} [callback] - A callback which is called when all `iteratee`
-       * functions have finished, or an error occurs. Invoked with (err).
-       * @returns {Promise} a promise, if a callback is omitted
-       */
-      function eachOfSeries(coll, iteratee, callback) {
-        return (0, _eachOfLimit2.default)(coll, 1, iteratee, callback);
-      }
-      exports.default = (0, _awaitify2.default)(eachOfSeries, 3);
-      module.exports = exports['default'];
-    }, {
-      "./eachOfLimit.js": 6,
-      "./internal/awaitify.js": 9
-    }],
-    8: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = asyncEachOfLimit;
-      var _breakLoop = require('./breakLoop.js');
-      var _breakLoop2 = _interopRequireDefault(_breakLoop);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
+      * Fable Core Pre-initialization Service Base
+      *
+      * For a couple services, we need to be able to instantiate them before the Fable object is fully initialized.
+      * This is a base class for those services.
+      *
+      * @author <steven@velozo.com>
+      */
 
-      // for async generators
-      function asyncEachOfLimit(generator, limit, iteratee, callback) {
-        let done = false;
-        let canceled = false;
-        let awaiting = false;
-        let running = 0;
-        let idx = 0;
-        function replenish() {
-          //console.log('replenish')
-          if (running >= limit || awaiting || done) return;
-          //console.log('replenish awaiting')
-          awaiting = true;
-          generator.next().then(({
-            value,
-            done: iterDone
-          }) => {
-            //console.log('got value', value)
-            if (canceled || done) return;
-            awaiting = false;
-            if (iterDone) {
-              done = true;
-              if (running <= 0) {
-                //console.log('done nextCb')
-                callback(null);
-              }
-              return;
-            }
-            running++;
-            iteratee(value, idx, iterateeCallback);
-            idx++;
-            replenish();
-          }).catch(handleError);
-        }
-        function iterateeCallback(err, result) {
-          //console.log('iterateeCallback')
-          running -= 1;
-          if (canceled) return;
-          if (err) return handleError(err);
-          if (err === false) {
-            done = true;
-            canceled = true;
-            return;
-          }
-          if (result === _breakLoop2.default || done && running <= 0) {
-            done = true;
-            //console.log('done iterCb')
-            return callback(null);
-          }
-          replenish();
-        }
-        function handleError(err) {
-          if (canceled) return;
-          awaiting = false;
-          done = true;
-          callback(err);
-        }
-        replenish();
-      }
-      module.exports = exports['default'];
-    }, {
-      "./breakLoop.js": 10
-    }],
-    9: [function (require, module, exports) {
-      'use strict';
+      class FableCoreServiceProviderBase {
+        constructor(pOptions, pServiceHash) {
+          this.fable = false;
+          this.options = typeof pOptions === 'object' ? pOptions : {};
+          this.serviceType = 'Unknown';
 
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = awaitify;
-      // conditionally promisify a function.
-      // only return a promise if a callback is omitted
-      function awaitify(asyncFn, arity = asyncFn.length) {
-        if (!arity) throw new Error('arity is undefined');
-        function awaitable(...args) {
-          if (typeof args[arity - 1] === 'function') {
-            return asyncFn.apply(this, args);
-          }
-          return new Promise((resolve, reject) => {
-            args[arity - 1] = (err, ...cbArgs) => {
-              if (err) return reject(err);
-              resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
-            };
-            asyncFn.apply(this, args);
-          });
+          // The hash will be a non-standard UUID ... the UUID service uses this base class!
+          this.UUID = "CORESVC-".concat(Math.floor(Math.random() * (99999 - 10000) + 10000));
+          this.Hash = typeof pServiceHash === 'string' ? pServiceHash : "".concat(this.UUID);
         }
-        return awaitable;
-      }
-      module.exports = exports['default'];
-    }, {}],
-    10: [function (require, module, exports) {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      // A temporary value used to identify if the loop should be broken.
-      // See #1064, #1293
-      const breakLoop = {};
-      exports.default = breakLoop;
-      module.exports = exports["default"];
-    }, {}],
-    11: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      var _once = require('./once.js');
-      var _once2 = _interopRequireDefault(_once);
-      var _iterator = require('./iterator.js');
-      var _iterator2 = _interopRequireDefault(_iterator);
-      var _onlyOnce = require('./onlyOnce.js');
-      var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-      var _wrapAsync = require('./wrapAsync.js');
-      var _asyncEachOfLimit = require('./asyncEachOfLimit.js');
-      var _asyncEachOfLimit2 = _interopRequireDefault(_asyncEachOfLimit);
-      var _breakLoop = require('./breakLoop.js');
-      var _breakLoop2 = _interopRequireDefault(_breakLoop);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
-      exports.default = limit => {
-        return (obj, iteratee, callback) => {
-          callback = (0, _once2.default)(callback);
-          if (limit <= 0) {
-            throw new RangeError('concurrency limit cannot be less than 1');
-          }
-          if (!obj) {
-            return callback(null);
-          }
-          if ((0, _wrapAsync.isAsyncGenerator)(obj)) {
-            return (0, _asyncEachOfLimit2.default)(obj, limit, iteratee, callback);
-          }
-          if ((0, _wrapAsync.isAsyncIterable)(obj)) {
-            return (0, _asyncEachOfLimit2.default)(obj[Symbol.asyncIterator](), limit, iteratee, callback);
-          }
-          var nextElem = (0, _iterator2.default)(obj);
-          var done = false;
-          var canceled = false;
-          var running = 0;
-          var looping = false;
-          function iterateeCallback(err, value) {
-            if (canceled) return;
-            running -= 1;
-            if (err) {
-              done = true;
-              callback(err);
-            } else if (err === false) {
-              done = true;
-              canceled = true;
-            } else if (value === _breakLoop2.default || done && running <= 0) {
-              done = true;
-              return callback(null);
-            } else if (!looping) {
-              replenish();
-            }
-          }
-          function replenish() {
-            looping = true;
-            while (running < limit && !done) {
-              var elem = nextElem();
-              if (elem === null) {
-                done = true;
-                if (running <= 0) {
-                  callback(null);
-                }
-                return;
-              }
-              running += 1;
-              iteratee(elem.value, elem.key, (0, _onlyOnce2.default)(iterateeCallback));
-            }
-            looping = false;
-          }
-          replenish();
-        };
-      };
-      module.exports = exports['default'];
-    }, {
-      "./asyncEachOfLimit.js": 8,
-      "./breakLoop.js": 10,
-      "./iterator.js": 15,
-      "./once.js": 16,
-      "./onlyOnce.js": 17,
-      "./wrapAsync.js": 19
-    }],
-    12: [function (require, module, exports) {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = function (coll) {
-        return coll[Symbol.iterator] && coll[Symbol.iterator]();
-      };
-      module.exports = exports["default"];
-    }, {}],
-    13: [function (require, module, exports) {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = function (fn) {
-        return function (...args /*, callback*/) {
-          var callback = args.pop();
-          return fn.call(this, args, callback);
-        };
-      };
-      module.exports = exports["default"];
-    }, {}],
-    14: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = isArrayLike;
-      function isArrayLike(value) {
-        return value && typeof value.length === 'number' && value.length >= 0 && value.length % 1 === 0;
-      }
-      module.exports = exports['default'];
-    }, {}],
-    15: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = createIterator;
-      var _isArrayLike = require('./isArrayLike.js');
-      var _isArrayLike2 = _interopRequireDefault(_isArrayLike);
-      var _getIterator = require('./getIterator.js');
-      var _getIterator2 = _interopRequireDefault(_getIterator);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
-      function createArrayIterator(coll) {
-        var i = -1;
-        var len = coll.length;
-        return function next() {
-          return ++i < len ? {
-            value: coll[i],
-            key: i
-          } : null;
-        };
-      }
-      function createES2015Iterator(iterator) {
-        var i = -1;
-        return function next() {
-          var item = iterator.next();
-          if (item.done) return null;
-          i++;
-          return {
-            value: item.value,
-            key: i
-          };
-        };
-      }
-      function createObjectIterator(obj) {
-        var okeys = obj ? Object.keys(obj) : [];
-        var i = -1;
-        var len = okeys.length;
-        return function next() {
-          var key = okeys[++i];
-          if (key === '__proto__') {
-            return next();
-          }
-          return i < len ? {
-            value: obj[key],
-            key
-          } : null;
-        };
-      }
-      function createIterator(coll) {
-        if ((0, _isArrayLike2.default)(coll)) {
-          return createArrayIterator(coll);
+        // After fable is initialized, it would be expected to be wired in as a normal service.
+        connectFable(pFable) {
+          this.fable = pFable;
+          return true;
         }
-        var iterator = (0, _getIterator2.default)(coll);
-        return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);
-      }
-      module.exports = exports['default'];
-    }, {
-      "./getIterator.js": 12,
-      "./isArrayLike.js": 14
-    }],
-    16: [function (require, module, exports) {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = once;
-      function once(fn) {
-        function wrapper(...args) {
-          if (fn === null) return;
-          var callFn = fn;
-          fn = null;
-          callFn.apply(this, args);
-        }
-        Object.assign(wrapper, fn);
-        return wrapper;
-      }
-      module.exports = exports["default"];
-    }, {}],
-    17: [function (require, module, exports) {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.default = onlyOnce;
-      function onlyOnce(fn) {
-        return function (...args) {
-          if (fn === null) throw new Error("Callback was already called.");
-          var callFn = fn;
-          fn = null;
-          callFn.apply(this, args);
-        };
       }
-      module.exports = exports["default"];
+      _defineProperty(FableCoreServiceProviderBase, "isFableService", true);
+      module.exports = FableCoreServiceProviderBase;
     }, {}],
-    18: [function (require, module, exports) {
-      (function (process, setImmediate) {
-        (function () {
-          'use strict';
+    6: [function (require, module, exports) {
+      /**
+      * Fable Service Base
+      * @author <steven@velozo.com>
+      */
 
-          Object.defineProperty(exports, "__esModule", {
-            value: true
-          });
-          exports.fallback = fallback;
-          exports.wrap = wrap;
-          /* istanbul ignore file */
-
-          var hasQueueMicrotask = exports.hasQueueMicrotask = typeof queueMicrotask === 'function' && queueMicrotask;
-          var hasSetImmediate = exports.hasSetImmediate = typeof setImmediate === 'function' && setImmediate;
-          var hasNextTick = exports.hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';
-          function fallback(fn) {
-            setTimeout(fn, 0);
-          }
-          function wrap(defer) {
-            return (fn, ...args) => defer(() => fn(...args));
-          }
-          var _defer;
-          if (hasQueueMicrotask) {
-            _defer = queueMicrotask;
-          } else if (hasSetImmediate) {
-            _defer = setImmediate;
-          } else if (hasNextTick) {
-            _defer = process.nextTick;
+      class FableServiceProviderBase {
+        constructor(pFable, pOptions, pServiceHash) {
+          this.fable = pFable;
+          this.options = typeof pOptions === 'object' ? pOptions : typeof pFable === 'object' && !pFable.isFable ? pFable : {};
+          this.serviceType = 'Unknown';
+          if (typeof pFable.getUUID == 'function') {
+            this.UUID = pFable.getUUID();
           } else {
-            _defer = fallback;
+            this.UUID = "NoFABLESVC-".concat(Math.floor(Math.random() * (99999 - 10000) + 10000));
           }
-          exports.default = wrap(_defer);
-        }).call(this);
-      }).call(this, require('_process'), require("timers").setImmediate);
-    }, {
-      "_process": 37,
-      "timers": 44
-    }],
-    19: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.isAsyncIterable = exports.isAsyncGenerator = exports.isAsync = undefined;
-      var _asyncify = require('../asyncify.js');
-      var _asyncify2 = _interopRequireDefault(_asyncify);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
-      function isAsync(fn) {
-        return fn[Symbol.toStringTag] === 'AsyncFunction';
-      }
-      function isAsyncGenerator(fn) {
-        return fn[Symbol.toStringTag] === 'AsyncGenerator';
-      }
-      function isAsyncIterable(obj) {
-        return typeof obj[Symbol.asyncIterator] === 'function';
-      }
-      function wrapAsync(asyncFn) {
-        if (typeof asyncFn !== 'function') throw new Error('expected a function');
-        return isAsync(asyncFn) ? (0, _asyncify2.default)(asyncFn) : asyncFn;
-      }
-      exports.default = wrapAsync;
-      exports.isAsync = isAsync;
-      exports.isAsyncGenerator = isAsyncGenerator;
-      exports.isAsyncIterable = isAsyncIterable;
-    }, {
-      "../asyncify.js": 5
-    }],
-    20: [function (require, module, exports) {
-      'use strict';
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      var _once = require('./internal/once.js');
-      var _once2 = _interopRequireDefault(_once);
-      var _onlyOnce = require('./internal/onlyOnce.js');
-      var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-      var _wrapAsync = require('./internal/wrapAsync.js');
-      var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-      var _awaitify = require('./internal/awaitify.js');
-      var _awaitify2 = _interopRequireDefault(_awaitify);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : {
-          default: obj
-        };
-      }
+          this.Hash = typeof pServiceHash === 'string' ? pServiceHash : "".concat(this.UUID);
 
-      /**
-       * Runs the `tasks` array of functions in series, each passing their results to
-       * the next in the array. However, if any of the `tasks` pass an error to their
-       * own callback, the next function is not executed, and the main `callback` is
-       * immediately called with the error.
-       *
-       * @name waterfall
-       * @static
-       * @memberOf module:ControlFlow
-       * @method
-       * @category Control Flow
-       * @param {Array} tasks - An array of [async functions]{@link AsyncFunction}
-       * to run.
-       * Each function should complete with any number of `result` values.
-       * The `result` values will be passed as arguments, in order, to the next task.
-       * @param {Function} [callback] - An optional callback to run once all the
-       * functions have completed. This will be passed the results of the last task's
-       * callback. Invoked with (err, [results]).
-       * @returns {Promise} a promise, if a callback is omitted
-       * @example
-       *
-       * async.waterfall([
-       *     function(callback) {
-       *         callback(null, 'one', 'two');
-       *     },
-       *     function(arg1, arg2, callback) {
-       *         // arg1 now equals 'one' and arg2 now equals 'two'
-       *         callback(null, 'three');
-       *     },
-       *     function(arg1, callback) {
-       *         // arg1 now equals 'three'
-       *         callback(null, 'done');
-       *     }
-       * ], function (err, result) {
-       *     // result now equals 'done'
-       * });
-       *
-       * // Or, with named functions:
-       * async.waterfall([
-       *     myFirstFunction,
-       *     mySecondFunction,
-       *     myLastFunction,
-       * ], function (err, result) {
-       *     // result now equals 'done'
-       * });
-       * function myFirstFunction(callback) {
-       *     callback(null, 'one', 'two');
-       * }
-       * function mySecondFunction(arg1, arg2, callback) {
-       *     // arg1 now equals 'one' and arg2 now equals 'two'
-       *     callback(null, 'three');
-       * }
-       * function myLastFunction(arg1, callback) {
-       *     // arg1 now equals 'three'
-       *     callback(null, 'done');
-       * }
-       */
-      function waterfall(tasks, callback) {
-        callback = (0, _once2.default)(callback);
-        if (!Array.isArray(tasks)) return callback(new Error('First argument to waterfall must be an array of functions'));
-        if (!tasks.length) return callback();
-        var taskIndex = 0;
-        function nextTask(args) {
-          var task = (0, _wrapAsync2.default)(tasks[taskIndex++]);
-          task(...args, (0, _onlyOnce2.default)(next));
-        }
-        function next(err, ...args) {
-          if (err === false) return;
-          if (err || taskIndex === tasks.length) {
-            return callback(err, ...args);
-          }
-          nextTask(args);
-        }
-        nextTask([]);
+          // Pull back a few things
+          this.log = this.fable.log;
+          this.servicesMap = this.fable.servicesMap;
+          this.services = this.fable.services;
+        }
       }
-      exports.default = (0, _awaitify2.default)(waterfall);
-      module.exports = exports['default'];
+      _defineProperty(FableServiceProviderBase, "isFableService", true);
+      module.exports = FableServiceProviderBase;
+      module.exports.CoreServiceProviderBase = require('./Fable-ServiceProviderBase-Preinit.js');
     }, {
-      "./internal/awaitify.js": 9,
-      "./internal/once.js": 16,
-      "./internal/onlyOnce.js": 17,
-      "./internal/wrapAsync.js": 19
+      "./Fable-ServiceProviderBase-Preinit.js": 5
     }],
-    21: [function (require, module, exports) {
+    7: [function (require, module, exports) {
       'use strict';
 
       var UTF8_ACCEPT = 12;
@@ -1851,7 +1194,7 @@
       }
       module.exports = decodeURIComponent;
     }, {}],
-    22: [function (require, module, exports) {
+    8: [function (require, module, exports) {
       'use strict';
 
       // do not edit .js files directly - edit src/index.jst
@@ -1884,7 +1227,7 @@
         return a !== a && b !== b;
       };
     }, {}],
-    23: [function (require, module, exports) {
+    9: [function (require, module, exports) {
       "use strict";
 
       const parse = require("./parse");
@@ -1905,10 +1248,10 @@
       module.exports.parse = parse;
       module.exports.stringify = stringify;
     }, {
-      "./parse": 25,
-      "./stringify": 26
+      "./parse": 11,
+      "./stringify": 12
     }],
-    24: [function (require, module, exports) {
+    10: [function (require, module, exports) {
       // This file is taken from Node.js project.
       // Full implementation can be found from https://github.com/nodejs/node/blob/main/lib/internal/querystring.js
 
@@ -1998,12 +1341,12 @@
         encodeString
       };
     }, {}],
-    25: [function (require, module, exports) {
+    11: [function (require, module, exports) {
       "use strict";
 
       const fastDecode = require("fast-decode-uri-component");
       const plusRegex = /\+/g;
-      const Empty = function () {};
+      const Empty = function Empty() {};
       Empty.prototype = Object.create(null);
 
       /**
@@ -2116,9 +1459,9 @@
       }
       module.exports = parse;
     }, {
-      "fast-decode-uri-component": 21
+      "fast-decode-uri-component": 7
     }],
-    26: [function (require, module, exports) {
+    12: [function (require, module, exports) {
       "use strict";
 
       const {
@@ -2181,318 +1524,9 @@
       }
       module.exports = stringify;
     }, {
-      "./internals/querystring": 24
+      "./internals/querystring": 10
     }],
-    27: [function (require, module, exports) {
-      'use strict';
-
-      const HandlerStorage = require('./handler_storage');
-      const NODE_TYPES = {
-        STATIC: 0,
-        PARAMETRIC: 1,
-        WILDCARD: 2
-      };
-      class Node {
-        constructor() {
-          this.handlerStorage = new HandlerStorage();
-        }
-      }
-      class ParentNode extends Node {
-        constructor() {
-          super();
-          this.staticChildren = {};
-        }
-        findStaticMatchingChild(path, pathIndex) {
-          const staticChild = this.staticChildren[path.charAt(pathIndex)];
-          if (staticChild === undefined || !staticChild.matchPrefix(path, pathIndex)) {
-            return null;
-          }
-          return staticChild;
-        }
-        createStaticChild(path) {
-          if (path.length === 0) {
-            return this;
-          }
-          let staticChild = this.staticChildren[path.charAt(0)];
-          if (staticChild) {
-            let i = 1;
-            for (; i < staticChild.prefix.length; i++) {
-              if (path.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {
-                staticChild = staticChild.split(this, i);
-                break;
-              }
-            }
-            return staticChild.createStaticChild(path.slice(i));
-          }
-          const label = path.charAt(0);
-          this.staticChildren[label] = new StaticNode(path);
-          return this.staticChildren[label];
-        }
-      }
-      class StaticNode extends ParentNode {
-        constructor(prefix) {
-          super();
-          this.prefix = prefix;
-          this.wildcardChild = null;
-          this.parametricChildren = [];
-          this.kind = NODE_TYPES.STATIC;
-          this._compilePrefixMatch();
-        }
-        createParametricChild(regex, staticSuffix) {
-          const regexpSource = regex && regex.source;
-          let parametricChild = this.parametricChildren.find(child => {
-            const childRegexSource = child.regex && child.regex.source;
-            return childRegexSource === regexpSource;
-          });
-          if (parametricChild) {
-            return parametricChild;
-          }
-          parametricChild = new ParametricNode(regex, staticSuffix);
-          this.parametricChildren.push(parametricChild);
-          this.parametricChildren.sort((child1, child2) => {
-            if (!child1.isRegex) return 1;
-            if (!child2.isRegex) return -1;
-            if (child1.staticSuffix === null) return 1;
-            if (child2.staticSuffix === null) return -1;
-            if (child2.staticSuffix.endsWith(child1.staticSuffix)) return 1;
-            if (child1.staticSuffix.endsWith(child2.staticSuffix)) return -1;
-            return 0;
-          });
-          return parametricChild;
-        }
-        createWildcardChild() {
-          if (this.wildcardChild) {
-            return this.wildcardChild;
-          }
-          this.wildcardChild = new WildcardNode();
-          return this.wildcardChild;
-        }
-        split(parentNode, length) {
-          const parentPrefix = this.prefix.slice(0, length);
-          const childPrefix = this.prefix.slice(length);
-          this.prefix = childPrefix;
-          this._compilePrefixMatch();
-          const staticNode = new StaticNode(parentPrefix);
-          staticNode.staticChildren[childPrefix.charAt(0)] = this;
-          parentNode.staticChildren[parentPrefix.charAt(0)] = staticNode;
-          return staticNode;
-        }
-        getNextNode(path, pathIndex, nodeStack, paramsCount) {
-          let node = this.findStaticMatchingChild(path, pathIndex);
-          let parametricBrotherNodeIndex = 0;
-          if (node === null) {
-            if (this.parametricChildren.length === 0) {
-              return this.wildcardChild;
-            }
-            node = this.parametricChildren[0];
-            parametricBrotherNodeIndex = 1;
-          }
-          if (this.wildcardChild !== null) {
-            nodeStack.push({
-              paramsCount,
-              brotherPathIndex: pathIndex,
-              brotherNode: this.wildcardChild
-            });
-          }
-          for (let i = this.parametricChildren.length - 1; i >= parametricBrotherNodeIndex; i--) {
-            nodeStack.push({
-              paramsCount,
-              brotherPathIndex: pathIndex,
-              brotherNode: this.parametricChildren[i]
-            });
-          }
-          return node;
-        }
-        _compilePrefixMatch() {
-          if (this.prefix.length === 1) {
-            this.matchPrefix = () => true;
-            return;
-          }
-          const lines = [];
-          for (let i = 1; i < this.prefix.length; i++) {
-            const charCode = this.prefix.charCodeAt(i);
-            lines.push(`path.charCodeAt(i + ${i}) === ${charCode}`);
-          }
-          this.matchPrefix = new Function('path', 'i', `return ${lines.join(' && ')}`); // eslint-disable-line
-        }
-      }
-
-      class ParametricNode extends ParentNode {
-        constructor(regex, staticSuffix) {
-          super();
-          this.isRegex = !!regex;
-          this.regex = regex || null;
-          this.staticSuffix = staticSuffix || null;
-          this.kind = NODE_TYPES.PARAMETRIC;
-        }
-        getNextNode(path, pathIndex) {
-          return this.findStaticMatchingChild(path, pathIndex);
-        }
-      }
-      class WildcardNode extends Node {
-        constructor() {
-          super();
-          this.kind = NODE_TYPES.WILDCARD;
-        }
-        getNextNode() {
-          return null;
-        }
-      }
-      module.exports = {
-        StaticNode,
-        ParametricNode,
-        WildcardNode,
-        NODE_TYPES
-      };
-    }, {
-      "./handler_storage": 28
-    }],
-    28: [function (require, module, exports) {
-      'use strict';
-
-      class HandlerStorage {
-        constructor() {
-          this.unconstrainedHandler = null; // optimized reference to the handler that will match most of the time
-          this.constraints = [];
-          this.handlers = []; // unoptimized list of handler objects for which the fast matcher function will be compiled
-          this.constrainedHandlerStores = null;
-        }
-
-        // This is the hot path for node handler finding -- change with care!
-        getMatchingHandler(derivedConstraints) {
-          if (derivedConstraints === undefined) {
-            return this.unconstrainedHandler;
-          }
-          return this._getHandlerMatchingConstraints(derivedConstraints);
-        }
-        addHandler(handler, params, store, constrainer, constraints) {
-          const handlerObject = {
-            handler,
-            params,
-            constraints,
-            store: store || null,
-            _createParamsObject: this._compileCreateParamsObject(params)
-          };
-          if (Object.keys(constraints).length === 0) {
-            this.unconstrainedHandler = handlerObject;
-          }
-          for (const constraint of Object.keys(constraints)) {
-            if (!this.constraints.includes(constraint)) {
-              if (constraint === 'version') {
-                // always check the version constraint first as it is the most selective
-                this.constraints.unshift(constraint);
-              } else {
-                this.constraints.push(constraint);
-              }
-            }
-          }
-          if (this.handlers.length >= 32) {
-            throw new Error('find-my-way supports a maximum of 32 route handlers per node when there are constraints, limit reached');
-          }
-          this.handlers.push(handlerObject);
-          // Sort the most constrained handlers to the front of the list of handlers so they are tested first.
-          this.handlers.sort((a, b) => Object.keys(a.constraints).length - Object.keys(b.constraints).length);
-          this._compileGetHandlerMatchingConstraints(constrainer, constraints);
-        }
-        _compileCreateParamsObject(params) {
-          const lines = [];
-          for (let i = 0; i < params.length; i++) {
-            lines.push(`'${params[i]}': paramsArray[${i}]`);
-          }
-          return new Function('paramsArray', `return {${lines.join(',')}}`); // eslint-disable-line
-        }
-
-        _getHandlerMatchingConstraints() {
-          return null;
-        }
-
-        // Builds a store object that maps from constraint values to a bitmap of handler indexes which pass the constraint for a value
-        // So for a host constraint, this might look like { "fastify.io": 0b0010, "google.ca": 0b0101 }, meaning the 3rd handler is constrainted to fastify.io, and the 2nd and 4th handlers are constrained to google.ca.
-        // The store's implementation comes from the strategies provided to the Router.
-        _buildConstraintStore(store, constraint) {
-          for (let i = 0; i < this.handlers.length; i++) {
-            const handler = this.handlers[i];
-            const constraintValue = handler.constraints[constraint];
-            if (constraintValue !== undefined) {
-              let indexes = store.get(constraintValue) || 0;
-              indexes |= 1 << i; // set the i-th bit for the mask because this handler is constrained by this value https://stackoverflow.com/questions/1436438/how-do-you-set-clear-and-toggle-a-single-bit-in-javascrip
-              store.set(constraintValue, indexes);
-            }
-          }
-        }
-
-        // Builds a bitmask for a given constraint that has a bit for each handler index that is 0 when that handler *is* constrained and 1 when the handler *isnt* constrainted. This is opposite to what might be obvious, but is just for convienience when doing the bitwise operations.
-        _constrainedIndexBitmask(constraint) {
-          let mask = 0;
-          for (let i = 0; i < this.handlers.length; i++) {
-            const handler = this.handlers[i];
-            const constraintValue = handler.constraints[constraint];
-            if (constraintValue !== undefined) {
-              mask |= 1 << i;
-            }
-          }
-          return ~mask;
-        }
-
-        // Compile a fast function to match the handlers for this node
-        // The function implements a general case multi-constraint matching algorithm.
-        // The general idea is this: we have a bunch of handlers, each with a potentially different set of constraints, and sometimes none at all. We're given a list of constraint values and we have to use the constraint-value-comparison strategies to see which handlers match the constraint values passed in.
-        // We do this by asking each constraint store which handler indexes match the given constraint value for each store. Trickily, the handlers that a store says match are the handlers constrained by that store, but handlers that aren't constrained at all by that store could still match just fine. So, each constraint store can only describe matches for it, and it won't have any bearing on the handlers it doesn't care about. For this reason, we have to ask each stores which handlers match and track which have been matched (or not cared about) by all of them.
-        // We use bitmaps to represent these lists of matches so we can use bitwise operations to implement this efficiently. Bitmaps are cheap to allocate, let us implement this masking behaviour in one CPU instruction, and are quite compact in memory. We start with a bitmap set to all 1s representing every handler that is a match candidate, and then for each constraint, see which handlers match using the store, and then mask the result by the mask of handlers that that store applies to, and bitwise AND with the candidate list. Phew.
-        // We consider all this compiling function complexity to be worth it, because the naive implementation that just loops over the handlers asking which stores match is quite a bit slower.
-        _compileGetHandlerMatchingConstraints(constrainer) {
-          this.constrainedHandlerStores = {};
-          for (const constraint of this.constraints) {
-            const store = constrainer.newStoreForConstraint(constraint);
-            this.constrainedHandlerStores[constraint] = store;
-            this._buildConstraintStore(store, constraint);
-          }
-          const lines = [];
-          lines.push(`
-    let candidates = ${(1 << this.handlers.length) - 1}
-    let mask, matches
-    `);
-          for (const constraint of this.constraints) {
-            // Setup the mask for indexes this constraint applies to. The mask bits are set to 1 for each position if the constraint applies.
-            lines.push(`
-      mask = ${this._constrainedIndexBitmask(constraint)}
-      value = derivedConstraints.${constraint}
-      `);
-
-            // If there's no constraint value, none of the handlers constrained by this constraint can match. Remove them from the candidates.
-            // If there is a constraint value, get the matching indexes bitmap from the store, and mask it down to only the indexes this constraint applies to, and then bitwise and with the candidates list to leave only matching candidates left.
-            const strategy = constrainer.strategies[constraint];
-            const matchMask = strategy.mustMatchWhenDerived ? 'matches' : '(matches | mask)';
-            lines.push(`
-      if (value === undefined) {
-        candidates &= mask
-      } else {
-        matches = this.constrainedHandlerStores.${constraint}.get(value) || 0
-        candidates &= ${matchMask}
-      }
-      if (candidates === 0) return null;
-      `);
-          }
-
-          // There are some constraints that can be derived and marked as "must match", where if they are derived, they only match routes that actually have a constraint on the value, like the SemVer version constraint.
-          // An example: a request comes in for version 1.x, and this node has a handler that matches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.
-          // This function is used by Nodes with handlers to match when they don't have any constrained routes to exclude request that do have must match derived constraints present.
-          for (const constraint in constrainer.strategies) {
-            const strategy = constrainer.strategies[constraint];
-            if (strategy.mustMatchWhenDerived && !this.constraints.includes(constraint)) {
-              lines.push(`if (derivedConstraints.${constraint} !== undefined) return null`);
-            }
-          }
-
-          // Return the first handler who's bit is set in the candidates https://stackoverflow.com/questions/18134985/how-to-find-index-of-first-set-bit
-          lines.push('return this.handlers[Math.floor(Math.log2(candidates))]');
-          this._getHandlerMatchingConstraints = new Function('derivedConstraints', lines.join('\n')); // eslint-disable-line
-        }
-      }
-
-      module.exports = HandlerStorage;
-    }, {}],
-    29: [function (require, module, exports) {
+    13: [function (require, module, exports) {
       'use strict';
 
       /*
@@ -2524,17 +1558,15 @@
       const isRegexSafe = require('safe-regex2');
       const deepEqual = require('fast-deep-equal');
       const {
-        flattenNode,
-        compressFlattenedNode,
-        prettyPrintFlattenedNode,
-        prettyPrintRoutesArray
+        prettyPrintTree
       } = require('./lib/pretty-print');
       const {
         StaticNode,
         NODE_TYPES
-      } = require('./custom_node');
+      } = require('./lib/node');
       const Constrainer = require('./lib/constrainer');
       const httpMethods = require('./lib/http-methods');
+      const httpMethodStrategy = require('./lib/strategies/http-method');
       const {
         safeDecodeURI,
         safeDecodeURIComponent
@@ -2552,6 +1584,7 @@
           return new Router(opts);
         }
         opts = opts || {};
+        this._opts = opts;
         if (opts.defaultRoute) {
           assert(typeof opts.defaultRoute === 'function', 'The default route must be a function');
           this.defaultRoute = opts.defaultRoute;
@@ -2581,10 +1614,9 @@
         this.ignoreDuplicateSlashes = opts.ignoreDuplicateSlashes || false;
         this.maxParamLength = opts.maxParamLength || 100;
         this.allowUnsafeRegex = opts.allowUnsafeRegex || false;
+        this.constrainer = new Constrainer(opts.constraints);
         this.routes = [];
         this.trees = {};
-        this.constrainer = new Constrainer(opts.constraints);
-        this._routesPatterns = {};
       }
       Router.prototype.on = function on(method, path, opts, handler, store) {
         if (typeof opts === 'function') {
@@ -2620,19 +1652,12 @@
         }
         const methods = Array.isArray(method) ? method : [method];
         for (const method of methods) {
+          assert(typeof method === 'string', 'Method should be a string');
+          assert(httpMethods.includes(method), "Method '".concat(method, "' is not an http method."));
           this._on(method, path, opts, handler, store, route);
-          this.routes.push({
-            method,
-            path,
-            opts,
-            handler,
-            store
-          });
         }
       };
       Router.prototype._on = function _on(method, path, opts, handler, store) {
-        assert(typeof method === 'string', 'Method should be a string');
-        assert(httpMethods.includes(method), `Method '${method}' is not an http method.`);
         let constraints = {};
         if (opts.constraints !== undefined) {
           assert(typeof opts.constraints === 'object' && opts.constraints !== null, 'Constraints should be an object');
@@ -2647,9 +1672,9 @@
         // Boot the tree for this method if it doesn't exist yet
         if (this.trees[method] === undefined) {
           this.trees[method] = new StaticNode('/');
-          this._routesPatterns[method] = [];
         }
-        if (path === '*' && this.trees[method].prefix.length !== 0) {
+        let pattern = path;
+        if (pattern === '*' && this.trees[method].prefix.length !== 0) {
           const currentRoot = this.trees[method];
           this.trees[method] = new StaticNode('');
           this.trees[method].staticChildren['/'] = currentRoot;
@@ -2657,16 +1682,16 @@
         let currentNode = this.trees[method];
         let parentNodePathIndex = currentNode.prefix.length;
         const params = [];
-        for (let i = 0; i <= path.length; i++) {
-          if (path.charCodeAt(i) === 58 && path.charCodeAt(i + 1) === 58) {
+        for (let i = 0; i <= pattern.length; i++) {
+          if (pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) === 58) {
             // It's a double colon
             i++;
             continue;
           }
-          const isParametricNode = path.charCodeAt(i) === 58 && path.charCodeAt(i + 1) !== 58;
-          const isWildcardNode = path.charCodeAt(i) === 42;
-          if (isParametricNode || isWildcardNode || i === path.length && i !== parentNodePathIndex) {
-            let staticNodePath = path.slice(parentNodePathIndex, i);
+          const isParametricNode = pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) !== 58;
+          const isWildcardNode = pattern.charCodeAt(i) === 42;
+          if (isParametricNode || isWildcardNode || i === pattern.length && i !== parentNodePathIndex) {
+            let staticNodePath = pattern.slice(parentNodePathIndex, i);
             if (!this.caseSensitive) {
               staticNodePath = staticNodePath.toLowerCase();
             }
@@ -2680,19 +1705,19 @@
             const regexps = [];
             let lastParamStartIndex = i + 1;
             for (let j = lastParamStartIndex;; j++) {
-              const charCode = path.charCodeAt(j);
+              const charCode = pattern.charCodeAt(j);
               const isRegexParam = charCode === 40;
               const isStaticPart = charCode === 45 || charCode === 46;
-              const isEndOfNode = charCode === 47 || j === path.length;
+              const isEndOfNode = charCode === 47 || j === pattern.length;
               if (isRegexParam || isStaticPart || isEndOfNode) {
-                const paramName = path.slice(lastParamStartIndex, j);
+                const paramName = pattern.slice(lastParamStartIndex, j);
                 params.push(paramName);
                 isRegexNode = isRegexNode || isRegexParam || isStaticPart;
                 if (isRegexParam) {
-                  const endOfRegexIndex = getClosingParenthensePosition(path, j);
-                  const regexString = path.slice(j, endOfRegexIndex + 1);
+                  const endOfRegexIndex = getClosingParenthensePosition(pattern, j);
+                  const regexString = pattern.slice(j, endOfRegexIndex + 1);
                   if (!this.allowUnsafeRegex) {
-                    assert(isRegexSafe(new RegExp(regexString)), `The regex '${regexString}' is not safe!`);
+                    assert(isRegexSafe(new RegExp(regexString)), "The regex '".concat(regexString, "' is not safe!"));
                   }
                   regexps.push(trimRegExpStartAndEnd(regexString));
                   j = endOfRegexIndex + 1;
@@ -2700,27 +1725,28 @@
                   regexps.push('(.*?)');
                 }
                 const staticPartStartIndex = j;
-                for (; j < path.length; j++) {
-                  const charCode = path.charCodeAt(j);
+                for (; j < pattern.length; j++) {
+                  const charCode = pattern.charCodeAt(j);
                   if (charCode === 47) break;
                   if (charCode === 58) {
-                    const nextCharCode = path.charCodeAt(j + 1);
+                    const nextCharCode = pattern.charCodeAt(j + 1);
                     if (nextCharCode === 58) j++;else break;
                   }
                 }
-                let staticPart = path.slice(staticPartStartIndex, j);
+                let staticPart = pattern.slice(staticPartStartIndex, j);
                 if (staticPart) {
                   staticPart = staticPart.split('::').join(':');
                   staticPart = staticPart.split('%').join('%25');
                   regexps.push(escapeRegExp(staticPart));
                 }
                 lastParamStartIndex = j + 1;
-                if (isEndOfNode || path.charCodeAt(j) === 47 || j === path.length) {
+                if (isEndOfNode || pattern.charCodeAt(j) === 47 || j === pattern.length) {
                   const nodePattern = isRegexNode ? '()' + staticPart : staticPart;
-                  path = path.slice(0, i + 1) + nodePattern + path.slice(j);
+                  const nodePath = pattern.slice(i, j);
+                  pattern = pattern.slice(0, i + 1) + nodePattern + pattern.slice(j);
                   i += nodePattern.length;
                   const regex = isRegexNode ? new RegExp('^' + regexps.join('') + '$') : null;
-                  currentNode = currentNode.createParametricChild(regex, staticPart || null);
+                  currentNode = currentNode.createParametricChild(regex, staticPart || null, nodePath);
                   parentNodePathIndex = i + 1;
                   break;
                 }
@@ -2731,28 +1757,34 @@
             params.push('*');
             currentNode = currentNode.createWildcardChild();
             parentNodePathIndex = i + 1;
-            if (i !== path.length - 1) {
+            if (i !== pattern.length - 1) {
               throw new Error('Wildcard must be the last character in the route');
             }
           }
         }
         if (!this.caseSensitive) {
-          path = path.toLowerCase();
+          pattern = pattern.toLowerCase();
         }
-        if (path === '*') {
-          path = '/*';
+        if (pattern === '*') {
+          pattern = '/*';
         }
-        for (const existRoute of this._routesPatterns[method]) {
-          if (existRoute.path === path && deepEqual(existRoute.constraints, constraints)) {
-            throw new Error(`Method '${method}' already declared for route '${path}' with constraints '${JSON.stringify(constraints)}'`);
+        for (const existRoute of this.routes) {
+          const routeConstraints = existRoute.opts.constraints || {};
+          if (existRoute.method === method && existRoute.pattern === pattern && deepEqual(routeConstraints, constraints)) {
+            throw new Error("Method '".concat(method, "' already declared for route '").concat(pattern, "' with constraints '").concat(JSON.stringify(constraints), "'"));
           }
         }
-        this._routesPatterns[method].push({
+        const route = {
+          method,
           path,
+          pattern,
           params,
-          constraints
-        });
-        currentNode.handlerStorage.addHandler(handler, params, store, this.constrainer, constraints);
+          opts,
+          handler,
+          store
+        };
+        this.routes.push(route);
+        currentNode.addRoute(route, this.constrainer);
       };
       Router.prototype.hasConstraintStrategy = function (strategyName) {
         return this.constrainer.hasConstraintStrategy(strategyName);
@@ -2764,7 +1796,6 @@
       Router.prototype.reset = function reset() {
         this.trees = {};
         this.routes = [];
-        this._routesPatterns = {};
       };
       Router.prototype.off = function off(method, path, constraints) {
         // path validation
@@ -2798,7 +1829,7 @@
       Router.prototype._off = function _off(method, path, constraints) {
         // method validation
         assert(typeof method === 'string', 'Method should be a string');
-        assert(httpMethods.includes(method), `Method '${method}' is not an http method.`);
+        assert(httpMethods.includes(method), "Method '".concat(method, "' is not an http method."));
         function matcherWithoutConstraints(route) {
           return method !== route.method || path !== route.path;
         }
@@ -2877,7 +1908,7 @@
         const pathLen = path.length;
         const brothersNodesStack = [];
         while (true) {
-          if (pathIndex === pathLen) {
+          if (pathIndex === pathLen && currentNode.isLeafNode) {
             const handle = currentNode.handlerStorage.getMatchingHandler(derivedConstraints);
             if (handle !== null) {
               return {
@@ -2954,13 +1985,6 @@
             store
           } = route;
           this._on(method, path, opts, handler, store);
-          this.routes.push({
-            method,
-            path,
-            opts,
-            handler,
-            store
-          });
         }
       };
       Router.prototype._defaultRoute = function (req, res, ctx) {
@@ -2982,22 +2006,40 @@
           store: null
         };
       };
-      Router.prototype.prettyPrint = function (opts = {}) {
-        opts.commonPrefix = opts.commonPrefix === undefined ? true : opts.commonPrefix; // default to original behaviour
-        if (!opts.commonPrefix) return prettyPrintRoutesArray.call(this, this.routes, opts);
-        const root = {
-          prefix: '/',
-          nodes: [],
-          children: {}
-        };
-        for (const method in this.trees) {
-          const node = this.trees[method];
-          if (node) {
-            flattenNode(root, node, method);
-          }
+      Router.prototype.prettyPrint = function () {
+        let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        const method = options.method;
+        options.buildPrettyMeta = this.buildPrettyMeta.bind(this);
+        let tree = null;
+        if (method === undefined) {
+          const _this$constrainer$str = this.constrainer.strategies,
+            {
+              version,
+              host
+            } = _this$constrainer$str,
+            constraints = _objectWithoutProperties(_this$constrainer$str, _excluded);
+          constraints[httpMethodStrategy.name] = httpMethodStrategy;
+          const mergedRouter = new Router(_objectSpread(_objectSpread({}, this._opts), {}, {
+            constraints
+          }));
+          const mergedRoutes = this.routes.map(route => {
+            const constraints = _objectSpread(_objectSpread({}, route.opts.constraints), {}, {
+              [httpMethodStrategy.name]: route.method
+            });
+            return _objectSpread(_objectSpread({}, route), {}, {
+              method: 'MERGED',
+              opts: {
+                constraints
+              }
+            });
+          });
+          mergedRouter._rebuild(mergedRoutes);
+          tree = mergedRouter.trees.MERGED;
+        } else {
+          tree = this.trees[method];
         }
-        compressFlattenedNode(root);
-        return prettyPrintFlattenedNode.call(this, root, '', true, opts);
+        if (tree == null) return '(empty tree)';
+        return prettyPrintTree(tree, options);
       };
       for (var i in httpMethods) {
         /* eslint no-prototype-builtins: "off" */
@@ -3065,17 +2107,18 @@
         return Object.assign({}, route.store);
       }
     }, {
-      "./custom_node": 27,
-      "./lib/constrainer": 30,
-      "./lib/http-methods": 31,
-      "./lib/pretty-print": 32,
-      "./lib/url-sanitizer": 35,
+      "./lib/constrainer": 14,
+      "./lib/http-methods": 16,
+      "./lib/node": 17,
+      "./lib/pretty-print": 18,
+      "./lib/strategies/http-method": 21,
+      "./lib/url-sanitizer": 22,
       "assert": 1,
-      "fast-deep-equal": 22,
-      "fast-querystring": 23,
-      "safe-regex2": 38
+      "fast-deep-equal": 8,
+      "fast-querystring": 9,
+      "safe-regex2": 25
     }],
-    30: [function (require, module, exports) {
+    14: [function (require, module, exports) {
       'use strict';
 
       const acceptVersionStrategy = require('./strategies/accept-version');
@@ -3112,10 +2155,10 @@
           assert(strategy.storage && typeof strategy.storage === 'function', 'strategy.storage function is required.');
           assert(strategy.deriveConstraint && typeof strategy.deriveConstraint === 'function', 'strategy.deriveConstraint function is required.');
           if (this.strategies[strategy.name] && this.strategies[strategy.name].isCustom) {
-            throw new Error(`There already exists a custom constraint with the name ${strategy.name}.`);
+            throw new Error("There already exists a custom constraint with the name ".concat(strategy.name, "."));
           }
           if (this.isStrategyUsed(strategy.name)) {
-            throw new Error(`There already exists a route with ${strategy.name} constraint.`);
+            throw new Error("There already exists a route with ".concat(strategy.name, " constraint."));
           }
           strategy.isCustom = true;
           strategy.isAsync = strategy.deriveConstraint.length === 3;
@@ -3156,7 +2199,7 @@
         }
         newStoreForConstraint(constraint) {
           if (!this.strategies[constraint]) {
-            throw new Error(`No strategy registered for constraint key ${constraint}`);
+            throw new Error("No strategy registered for constraint key ".concat(constraint));
           }
           return this.strategies[constraint].storage();
         }
@@ -3168,7 +2211,7 @@
             }
             const strategy = this.strategies[key];
             if (!strategy) {
-              throw new Error(`No strategy registered for constraint key ${key}`);
+              throw new Error("No strategy registered for constraint key ".concat(key));
             }
             if (strategy.validate) {
               strategy.validate(value);
@@ -3215,7 +2258,7 @@
                 throw new Error('unknown non-custom strategy for compiling constraint derivation function');
               }
             } else {
-              lines.push(`  ${strategy.name}: this.strategies.${key}.deriveConstraint(req, ctx),`);
+              lines.push("  ".concat(strategy.name, ": this.strategies.").concat(key, ".deriveConstraint(req, ctx),"));
             }
           }
           lines.push('}');
@@ -3225,30 +2268,359 @@
 
       module.exports = Constrainer;
     }, {
-      "./strategies/accept-host": 33,
-      "./strategies/accept-version": 34,
+      "./strategies/accept-host": 19,
+      "./strategies/accept-version": 20,
       "assert": 1
     }],
-    31: [function (require, module, exports) {
+    15: [function (require, module, exports) {
+      'use strict';
+
+      const httpMethodStrategy = require('./strategies/http-method');
+      class HandlerStorage {
+        constructor() {
+          this.unconstrainedHandler = null; // optimized reference to the handler that will match most of the time
+          this.constraints = [];
+          this.handlers = []; // unoptimized list of handler objects for which the fast matcher function will be compiled
+          this.constrainedHandlerStores = null;
+        }
+
+        // This is the hot path for node handler finding -- change with care!
+        getMatchingHandler(derivedConstraints) {
+          if (derivedConstraints === undefined) {
+            return this.unconstrainedHandler;
+          }
+          return this._getHandlerMatchingConstraints(derivedConstraints);
+        }
+        addHandler(constrainer, route) {
+          const params = route.params;
+          const constraints = route.opts.constraints || {};
+          const handlerObject = {
+            params,
+            constraints,
+            handler: route.handler,
+            store: route.store || null,
+            _createParamsObject: this._compileCreateParamsObject(params)
+          };
+          const constraintsNames = Object.keys(constraints);
+          if (constraintsNames.length === 0) {
+            this.unconstrainedHandler = handlerObject;
+          }
+          for (const constraint of constraintsNames) {
+            if (!this.constraints.includes(constraint)) {
+              if (constraint === 'version') {
+                // always check the version constraint first as it is the most selective
+                this.constraints.unshift(constraint);
+              } else {
+                this.constraints.push(constraint);
+              }
+            }
+          }
+          const isMergedTree = constraintsNames.includes(httpMethodStrategy.name);
+          if (!isMergedTree && this.handlers.length >= 32) {
+            throw new Error('find-my-way supports a maximum of 32 route handlers per node when there are constraints, limit reached');
+          }
+          this.handlers.push(handlerObject);
+          // Sort the most constrained handlers to the front of the list of handlers so they are tested first.
+          this.handlers.sort((a, b) => Object.keys(a.constraints).length - Object.keys(b.constraints).length);
+          if (!isMergedTree) {
+            this._compileGetHandlerMatchingConstraints(constrainer, constraints);
+          }
+        }
+        _compileCreateParamsObject(params) {
+          const lines = [];
+          for (let i = 0; i < params.length; i++) {
+            lines.push("'".concat(params[i], "': paramsArray[").concat(i, "]"));
+          }
+          return new Function('paramsArray', "return {".concat(lines.join(','), "}")); // eslint-disable-line
+        }
+
+        _getHandlerMatchingConstraints() {
+          return null;
+        }
+
+        // Builds a store object that maps from constraint values to a bitmap of handler indexes which pass the constraint for a value
+        // So for a host constraint, this might look like { "fastify.io": 0b0010, "google.ca": 0b0101 }, meaning the 3rd handler is constrainted to fastify.io, and the 2nd and 4th handlers are constrained to google.ca.
+        // The store's implementation comes from the strategies provided to the Router.
+        _buildConstraintStore(store, constraint) {
+          for (let i = 0; i < this.handlers.length; i++) {
+            const handler = this.handlers[i];
+            const constraintValue = handler.constraints[constraint];
+            if (constraintValue !== undefined) {
+              let indexes = store.get(constraintValue) || 0;
+              indexes |= 1 << i; // set the i-th bit for the mask because this handler is constrained by this value https://stackoverflow.com/questions/1436438/how-do-you-set-clear-and-toggle-a-single-bit-in-javascrip
+              store.set(constraintValue, indexes);
+            }
+          }
+        }
+
+        // Builds a bitmask for a given constraint that has a bit for each handler index that is 0 when that handler *is* constrained and 1 when the handler *isnt* constrainted. This is opposite to what might be obvious, but is just for convienience when doing the bitwise operations.
+        _constrainedIndexBitmask(constraint) {
+          let mask = 0;
+          for (let i = 0; i < this.handlers.length; i++) {
+            const handler = this.handlers[i];
+            const constraintValue = handler.constraints[constraint];
+            if (constraintValue !== undefined) {
+              mask |= 1 << i;
+            }
+          }
+          return ~mask;
+        }
+
+        // Compile a fast function to match the handlers for this node
+        // The function implements a general case multi-constraint matching algorithm.
+        // The general idea is this: we have a bunch of handlers, each with a potentially different set of constraints, and sometimes none at all. We're given a list of constraint values and we have to use the constraint-value-comparison strategies to see which handlers match the constraint values passed in.
+        // We do this by asking each constraint store which handler indexes match the given constraint value for each store. Trickily, the handlers that a store says match are the handlers constrained by that store, but handlers that aren't constrained at all by that store could still match just fine. So, each constraint store can only describe matches for it, and it won't have any bearing on the handlers it doesn't care about. For this reason, we have to ask each stores which handlers match and track which have been matched (or not cared about) by all of them.
+        // We use bitmaps to represent these lists of matches so we can use bitwise operations to implement this efficiently. Bitmaps are cheap to allocate, let us implement this masking behaviour in one CPU instruction, and are quite compact in memory. We start with a bitmap set to all 1s representing every handler that is a match candidate, and then for each constraint, see which handlers match using the store, and then mask the result by the mask of handlers that that store applies to, and bitwise AND with the candidate list. Phew.
+        // We consider all this compiling function complexity to be worth it, because the naive implementation that just loops over the handlers asking which stores match is quite a bit slower.
+        _compileGetHandlerMatchingConstraints(constrainer) {
+          this.constrainedHandlerStores = {};
+          for (const constraint of this.constraints) {
+            const store = constrainer.newStoreForConstraint(constraint);
+            this.constrainedHandlerStores[constraint] = store;
+            this._buildConstraintStore(store, constraint);
+          }
+          const lines = [];
+          lines.push("\n    let candidates = ".concat((1 << this.handlers.length) - 1, "\n    let mask, matches\n    "));
+          for (const constraint of this.constraints) {
+            // Setup the mask for indexes this constraint applies to. The mask bits are set to 1 for each position if the constraint applies.
+            lines.push("\n      mask = ".concat(this._constrainedIndexBitmask(constraint), "\n      value = derivedConstraints.").concat(constraint, "\n      "));
+
+            // If there's no constraint value, none of the handlers constrained by this constraint can match. Remove them from the candidates.
+            // If there is a constraint value, get the matching indexes bitmap from the store, and mask it down to only the indexes this constraint applies to, and then bitwise and with the candidates list to leave only matching candidates left.
+            const strategy = constrainer.strategies[constraint];
+            const matchMask = strategy.mustMatchWhenDerived ? 'matches' : '(matches | mask)';
+            lines.push("\n      if (value === undefined) {\n        candidates &= mask\n      } else {\n        matches = this.constrainedHandlerStores.".concat(constraint, ".get(value) || 0\n        candidates &= ").concat(matchMask, "\n      }\n      if (candidates === 0) return null;\n      "));
+          }
+
+          // There are some constraints that can be derived and marked as "must match", where if they are derived, they only match routes that actually have a constraint on the value, like the SemVer version constraint.
+          // An example: a request comes in for version 1.x, and this node has a handler that matches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.
+          // This function is used by Nodes with handlers to match when they don't have any constrained routes to exclude request that do have must match derived constraints present.
+          for (const constraint in constrainer.strategies) {
+            const strategy = constrainer.strategies[constraint];
+            if (strategy.mustMatchWhenDerived && !this.constraints.includes(constraint)) {
+              lines.push("if (derivedConstraints.".concat(constraint, " !== undefined) return null"));
+            }
+          }
+
+          // Return the first handler who's bit is set in the candidates https://stackoverflow.com/questions/18134985/how-to-find-index-of-first-set-bit
+          lines.push('return this.handlers[Math.floor(Math.log2(candidates))]');
+          this._getHandlerMatchingConstraints = new Function('derivedConstraints', lines.join('\n')); // eslint-disable-line
+        }
+      }
+
+      module.exports = HandlerStorage;
+    }, {
+      "./strategies/http-method": 21
+    }],
+    16: [function (require, module, exports) {
       'use strict';
 
       // defined by Node.js http module, a snapshot from Node.js 18.12.0
       const httpMethods = ['ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'];
       module.exports = httpMethods;
     }, {}],
-    32: [function (require, module, exports) {
+    17: [function (require, module, exports) {
       'use strict';
 
-      /* eslint-disable no-multi-spaces */
-      const indent = '    ';
-      const branchIndent = '│   ';
-      const midBranchIndent = '├── ';
-      const endBranchIndent = '└── ';
-      const wildcardDelimiter = '*';
-      const pathDelimiter = '/';
-      const pathRegExp = /(?=\/)/;
-      /* eslint-enable */
+      const HandlerStorage = require('./handler-storage');
+      const NODE_TYPES = {
+        STATIC: 0,
+        PARAMETRIC: 1,
+        WILDCARD: 2
+      };
+      class Node {
+        constructor() {
+          this.isLeafNode = false;
+          this.routes = null;
+          this.handlerStorage = null;
+        }
+        addRoute(route, constrainer) {
+          if (this.routes === null) {
+            this.routes = [];
+          }
+          if (this.handlerStorage === null) {
+            this.handlerStorage = new HandlerStorage();
+          }
+          this.isLeafNode = true;
+          this.routes.push(route);
+          this.handlerStorage.addHandler(constrainer, route);
+        }
+      }
+      class ParentNode extends Node {
+        constructor() {
+          super();
+          this.staticChildren = {};
+        }
+        findStaticMatchingChild(path, pathIndex) {
+          const staticChild = this.staticChildren[path.charAt(pathIndex)];
+          if (staticChild === undefined || !staticChild.matchPrefix(path, pathIndex)) {
+            return null;
+          }
+          return staticChild;
+        }
+        createStaticChild(path) {
+          if (path.length === 0) {
+            return this;
+          }
+          let staticChild = this.staticChildren[path.charAt(0)];
+          if (staticChild) {
+            let i = 1;
+            for (; i < staticChild.prefix.length; i++) {
+              if (path.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {
+                staticChild = staticChild.split(this, i);
+                break;
+              }
+            }
+            return staticChild.createStaticChild(path.slice(i));
+          }
+          const label = path.charAt(0);
+          this.staticChildren[label] = new StaticNode(path);
+          return this.staticChildren[label];
+        }
+      }
+      class StaticNode extends ParentNode {
+        constructor(prefix) {
+          super();
+          this.prefix = prefix;
+          this.wildcardChild = null;
+          this.parametricChildren = [];
+          this.kind = NODE_TYPES.STATIC;
+          this._compilePrefixMatch();
+        }
+        createParametricChild(regex, staticSuffix, nodePath) {
+          const regexpSource = regex && regex.source;
+          let parametricChild = this.parametricChildren.find(child => {
+            const childRegexSource = child.regex && child.regex.source;
+            return childRegexSource === regexpSource;
+          });
+          if (parametricChild) {
+            parametricChild.nodePaths.add(nodePath);
+            return parametricChild;
+          }
+          parametricChild = new ParametricNode(regex, staticSuffix, nodePath);
+          this.parametricChildren.push(parametricChild);
+          this.parametricChildren.sort((child1, child2) => {
+            if (!child1.isRegex) return 1;
+            if (!child2.isRegex) return -1;
+            if (child1.staticSuffix === null) return 1;
+            if (child2.staticSuffix === null) return -1;
+            if (child2.staticSuffix.endsWith(child1.staticSuffix)) return 1;
+            if (child1.staticSuffix.endsWith(child2.staticSuffix)) return -1;
+            return 0;
+          });
+          return parametricChild;
+        }
+        createWildcardChild() {
+          if (this.wildcardChild) {
+            return this.wildcardChild;
+          }
+          this.wildcardChild = new WildcardNode();
+          return this.wildcardChild;
+        }
+        split(parentNode, length) {
+          const parentPrefix = this.prefix.slice(0, length);
+          const childPrefix = this.prefix.slice(length);
+          this.prefix = childPrefix;
+          this._compilePrefixMatch();
+          const staticNode = new StaticNode(parentPrefix);
+          staticNode.staticChildren[childPrefix.charAt(0)] = this;
+          parentNode.staticChildren[parentPrefix.charAt(0)] = staticNode;
+          return staticNode;
+        }
+        getNextNode(path, pathIndex, nodeStack, paramsCount) {
+          let node = this.findStaticMatchingChild(path, pathIndex);
+          let parametricBrotherNodeIndex = 0;
+          if (node === null) {
+            if (this.parametricChildren.length === 0) {
+              return this.wildcardChild;
+            }
+            node = this.parametricChildren[0];
+            parametricBrotherNodeIndex = 1;
+          }
+          if (this.wildcardChild !== null) {
+            nodeStack.push({
+              paramsCount,
+              brotherPathIndex: pathIndex,
+              brotherNode: this.wildcardChild
+            });
+          }
+          for (let i = this.parametricChildren.length - 1; i >= parametricBrotherNodeIndex; i--) {
+            nodeStack.push({
+              paramsCount,
+              brotherPathIndex: pathIndex,
+              brotherNode: this.parametricChildren[i]
+            });
+          }
+          return node;
+        }
+        _compilePrefixMatch() {
+          if (this.prefix.length === 1) {
+            this.matchPrefix = () => true;
+            return;
+          }
+          const lines = [];
+          for (let i = 1; i < this.prefix.length; i++) {
+            const charCode = this.prefix.charCodeAt(i);
+            lines.push("path.charCodeAt(i + ".concat(i, ") === ").concat(charCode));
+          }
+          this.matchPrefix = new Function('path', 'i', "return ".concat(lines.join(' && '))); // eslint-disable-line
+        }
+      }
 
+      class ParametricNode extends ParentNode {
+        constructor(regex, staticSuffix, nodePath) {
+          super();
+          this.isRegex = !!regex;
+          this.regex = regex || null;
+          this.staticSuffix = staticSuffix || null;
+          this.kind = NODE_TYPES.PARAMETRIC;
+          this.nodePaths = new Set([nodePath]);
+        }
+        getNextNode(path, pathIndex) {
+          return this.findStaticMatchingChild(path, pathIndex);
+        }
+      }
+      class WildcardNode extends Node {
+        constructor() {
+          super();
+          this.kind = NODE_TYPES.WILDCARD;
+        }
+        getNextNode() {
+          return null;
+        }
+      }
+      module.exports = {
+        StaticNode,
+        ParametricNode,
+        WildcardNode,
+        NODE_TYPES
+      };
+    }, {
+      "./handler-storage": 15
+    }],
+    18: [function (require, module, exports) {
+      'use strict';
+
+      const deepEqual = require('fast-deep-equal');
+      const httpMethodStrategy = require('./strategies/http-method');
+      const treeDataSymbol = Symbol('treeData');
+      function printObjectTree(obj) {
+        let parentPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+        let tree = '';
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i];
+          const value = obj[key];
+          const isLast = i === keys.length - 1;
+          const nodePrefix = isLast ? '└── ' : '├── ';
+          const childPrefix = isLast ? '    ' : '│   ';
+          const nodeData = value[treeDataSymbol] || '';
+          const prefixedNodeData = nodeData.split('\n').join('\n' + parentPrefix + childPrefix);
+          tree += parentPrefix + nodePrefix + key + prefixedNodeData + '\n';
+          tree += printObjectTree(value, parentPrefix + childPrefix);
+        }
+        return tree;
+      }
       function parseFunctionName(fn) {
         let fName = fn.name || '';
         fName = fName.replace('bound', '').trim();
@@ -3261,293 +2633,117 @@
         if (typeof meta === 'function') return parseFunctionName(meta);
         return meta;
       }
-      function buildMetaObject(route, metaArray) {
-        const out = {};
-        const cleanMeta = this.buildPrettyMeta(route);
-        if (!Array.isArray(metaArray)) metaArray = cleanMeta ? Reflect.ownKeys(cleanMeta) : [];
-        metaArray.forEach(m => {
-          const metaKey = typeof m === 'symbol' ? m.toString() : m;
-          if (cleanMeta && cleanMeta[m]) {
-            out[metaKey] = parseMeta(cleanMeta[m]);
-          }
-        });
-        return out;
+      function getRouteMetaData(route, options) {
+        if (!options.includeMeta) return {};
+        const metaDataObject = options.buildPrettyMeta(route);
+        const filteredMetaData = {};
+        let includeMetaKeys = options.includeMeta;
+        if (!Array.isArray(includeMetaKeys)) {
+          includeMetaKeys = Reflect.ownKeys(metaDataObject);
+        }
+        for (const metaKey of includeMetaKeys) {
+          if (!Object.prototype.hasOwnProperty.call(metaDataObject, metaKey)) continue;
+          const serializedKey = metaKey.toString();
+          const metaValue = metaDataObject[metaKey];
+          if (metaValue !== undefined && metaValue !== null) {
+            const serializedValue = JSON.stringify(parseMeta(metaValue));
+            filteredMetaData[serializedKey] = serializedValue;
+          }
+        }
+        return filteredMetaData;
       }
-      function prettyPrintRoutesArray(routeArray, opts = {}) {
-        if (!this.buildPrettyMeta) throw new Error('buildPrettyMeta not defined');
-        opts.includeMeta = opts.includeMeta || null; // array of meta objects to display
-        const mergedRouteArray = [];
-        let tree = '';
-        routeArray.sort((a, b) => {
-          if (!a.path || !b.path) return 0;
-          return a.path.localeCompare(b.path);
-        });
-
-        // merge alike paths
-        for (let i = 0; i < routeArray.length; i++) {
-          const route = routeArray[i];
-          const pathExists = mergedRouteArray.find(r => route.path === r.path);
-          if (pathExists) {
-            // path already declared, add new method and break out of loop
-            pathExists.handlers.push({
-              method: route.method,
-              opts: route.opts.constraints || undefined,
-              meta: opts.includeMeta ? buildMetaObject.call(this, route, opts.includeMeta) : null
-            });
-            continue;
-          }
-          const routeHandler = {
-            method: route.method,
-            opts: route.opts.constraints || undefined,
-            meta: opts.includeMeta ? buildMetaObject.call(this, route, opts.includeMeta) : null
-          };
-          mergedRouteArray.push({
-            path: route.path,
-            methods: [route.method],
-            opts: [route.opts],
-            handlers: [routeHandler]
-          });
+      function serializeMetaData(metaData) {
+        let serializedMetaData = '';
+        for (const [key, value] of Object.entries(metaData)) {
+          serializedMetaData += "\n\u2022 (".concat(key, ") ").concat(value);
         }
-
-        // insert root level path if none defined
-        if (!mergedRouteArray.filter(r => r.path === pathDelimiter).length) {
-          const rootPath = {
-            path: pathDelimiter,
-            truncatedPath: '',
-            methods: [],
-            opts: [],
-            handlers: [{}]
-          };
-
-          // if wildcard route exists, insert root level after wildcard
-          if (mergedRouteArray.filter(r => r.path === wildcardDelimiter).length) {
-            mergedRouteArray.splice(1, 0, rootPath);
-          } else {
-            mergedRouteArray.unshift(rootPath);
-          }
-        }
-
-        // build tree
-        const routeTree = buildRouteTree(mergedRouteArray);
-
-        // draw tree
-        routeTree.forEach((rootBranch, idx) => {
-          tree += drawBranch(rootBranch, null, idx === routeTree.length - 1, false, true);
-          tree += '\n'; // newline characters inserted at beginning of drawing function to allow for nested paths
-        });
-
-        return tree;
+        return serializedMetaData;
       }
-      function buildRouteTree(mergedRouteArray) {
-        const result = [];
-        const temp = {
-          result
-        };
-        mergedRouteArray.forEach((route, idx) => {
-          let splitPath = route.path.split(pathRegExp);
 
-          // add preceding slash for proper nesting
-          if (splitPath[0] !== pathDelimiter) {
-            // handle wildcard route
-            if (splitPath[0] !== wildcardDelimiter) splitPath = [pathDelimiter, splitPath[0].slice(1), ...splitPath.slice(1)];
+      // get original merged tree node route
+      function normalizeRoute(route) {
+        const constraints = _objectSpread({}, route.opts.constraints);
+        const method = constraints[httpMethodStrategy.name];
+        delete constraints[httpMethodStrategy.name];
+        return _objectSpread(_objectSpread({}, route), {}, {
+          method,
+          opts: {
+            constraints
           }
-
-          // build tree
-          splitPath.reduce((acc, path, pidx) => {
-            if (!acc[path]) {
-              acc[path] = {
-                result: []
-              };
-              const pathSeg = {
-                path,
-                children: acc[path].result
-              };
-              if (pidx === splitPath.length - 1) pathSeg.handlers = route.handlers;
-              acc.result.push(pathSeg);
-            }
-            return acc[path];
-          }, temp);
         });
-
-        // unfold root object from array
-        return result;
       }
-      function drawBranch(pathSeg, prefix, endBranch, noPrefix, rootBranch) {
-        let branch = '';
-        if (!noPrefix && !rootBranch) branch += '\n';
-        if (!noPrefix) branch += `${prefix || ''}${endBranch ? endBranchIndent : midBranchIndent}`;
-        branch += `${pathSeg.path}`;
-        if (pathSeg.handlers) {
-          const flatHandlers = pathSeg.handlers.reduce((acc, curr) => {
-            const match = acc.findIndex(h => JSON.stringify(h.opts) === JSON.stringify(curr.opts));
-            if (match !== -1) {
-              acc[match].method = [acc[match].method, curr.method].join(', ');
-            } else {
-              acc.push(curr);
-            }
-            return acc;
-          }, []);
-          flatHandlers.forEach((handler, idx) => {
-            if (idx > 0) branch += `${noPrefix ? '' : prefix || ''}${endBranch ? indent : branchIndent}${pathSeg.path}`;
-            branch += ` (${handler.method || '-'})`;
-            if (handler.opts && JSON.stringify(handler.opts) !== '{}') branch += ` ${JSON.stringify(handler.opts)}`;
-            if (handler.meta) {
-              Reflect.ownKeys(handler.meta).forEach((m, hidx) => {
-                branch += `\n${noPrefix ? '' : prefix || ''}${endBranch ? indent : branchIndent}`;
-                branch += `• (${m}) ${JSON.stringify(handler.meta[m])}`;
-              });
-            }
-            if (flatHandlers.length > 1 && idx !== flatHandlers.length - 1) branch += '\n';
-          });
-        } else {
-          if (pathSeg.children.length > 1) branch += ' (-)';
-        }
-        if (!noPrefix) prefix = `${prefix || ''}${endBranch ? indent : branchIndent}`;
-        pathSeg.children.forEach((child, idx) => {
-          const endBranch = idx === pathSeg.children.length - 1;
-          const skipPrefix = !pathSeg.handlers && pathSeg.children.length === 1;
-          branch += drawBranch(child, prefix, endBranch, skipPrefix);
-        });
-        return branch;
+      function serializeRoute(route) {
+        let serializedRoute = " (".concat(route.method, ")");
+        const constraints = route.opts.constraints || {};
+        if (Object.keys(constraints).length !== 0) {
+          serializedRoute += ' ' + JSON.stringify(constraints);
+        }
+        serializedRoute += serializeMetaData(route.metaData);
+        return serializedRoute;
       }
-      function prettyPrintFlattenedNode(flattenedNode, prefix, tail, opts) {
-        if (!this.buildPrettyMeta) throw new Error('buildPrettyMeta not defined');
-        opts.includeMeta = opts.includeMeta || null; // array of meta items to display
-        let paramName = '';
-        const printHandlers = [];
-        for (const {
-          node,
-          method
-        } of flattenedNode.nodes) {
-          for (const handler of node.handlerStorage.handlers) {
-            printHandlers.push({
-              method,
-              ...handler
-            });
-          }
-        }
-        if (printHandlers.length) {
-          printHandlers.forEach((handler, index) => {
-            let suffix = `(${handler.method || '-'})`;
-            if (Object.keys(handler.constraints).length > 0) {
-              suffix += ' ' + JSON.stringify(handler.constraints);
-            }
-            let name = '';
-            // find locations of parameters in prefix
-            const paramIndices = flattenedNode.prefix.split('').map((ch, idx) => ch === ':' ? idx : null).filter(idx => idx !== null);
-            if (paramIndices.length) {
-              let prevLoc = 0;
-              paramIndices.forEach((loc, idx) => {
-                // find parameter in prefix
-                name += flattenedNode.prefix.slice(prevLoc, loc + 1);
-                // insert parameters
-                name += handler.params[handler.params.length - paramIndices.length + idx];
-                if (idx === paramIndices.length - 1) name += flattenedNode.prefix.slice(loc + 1);
-                prevLoc = loc + 1;
-              });
-            } else {
-              // there are no parameters, return full object
-              name = flattenedNode.prefix;
+      function mergeSimilarRoutes(routes) {
+        return routes.reduce((mergedRoutes, route) => {
+          for (const nodeRoute of mergedRoutes) {
+            if (deepEqual(route.opts.constraints, nodeRoute.opts.constraints) && deepEqual(route.metaData, nodeRoute.metaData)) {
+              nodeRoute.method += ', ' + route.method;
+              return mergedRoutes;
             }
-            if (index === 0) {
-              paramName += `${name} ${suffix}`;
-            } else {
-              paramName += `\n${prefix}${tail ? indent : branchIndent}${name} ${suffix}`;
-            }
-            if (opts.includeMeta) {
-              const meta = buildMetaObject.call(this, handler, opts.includeMeta);
-              Object.keys(meta).forEach((m, hidx) => {
-                paramName += `\n${prefix || ''}${tail ? indent : branchIndent}`;
-                paramName += `• (${m}) ${JSON.stringify(meta[m])}`;
-              });
-            }
-          });
-        } else {
-          paramName = flattenedNode.prefix;
-        }
-        let tree = `${prefix}${tail ? endBranchIndent : midBranchIndent}${paramName}\n`;
-        prefix = `${prefix}${tail ? indent : branchIndent}`;
-        const labels = Object.keys(flattenedNode.children);
-        for (let i = 0; i < labels.length; i++) {
-          const child = flattenedNode.children[labels[i]];
-          tree += prettyPrintFlattenedNode.call(this, child, prefix, i === labels.length - 1, opts);
-        }
-        return tree;
-      }
-      function flattenNode(flattened, node, method) {
-        if (node.handlerStorage.handlers.length !== 0) {
-          flattened.nodes.push({
-            method,
-            node
-          });
-        }
-        if (node.parametricChildren && node.parametricChildren[0]) {
-          if (!flattened.children[':']) {
-            flattened.children[':'] = {
-              prefix: ':',
-              nodes: [],
-              children: {}
-            };
           }
-          flattenNode(flattened.children[':'], node.parametricChildren[0], method);
+          mergedRoutes.push(route);
+          return mergedRoutes;
+        }, []);
+      }
+      function serializeNode(node, prefix, options) {
+        let routes = node.routes;
+        if (options.method === undefined) {
+          routes = routes.map(normalizeRoute);
+        }
+        routes = routes.map(route => {
+          route.metaData = getRouteMetaData(route, options);
+          return route;
+        });
+        if (options.method === undefined) {
+          routes = mergeSimilarRoutes(routes);
         }
-        if (node.wildcardChild) {
-          if (!flattened.children['*']) {
-            flattened.children['*'] = {
-              prefix: '*',
-              nodes: [],
-              children: {}
-            };
+        return routes.map(serializeRoute).join("\n".concat(prefix));
+      }
+      function buildObjectTree(node, tree, prefix, options) {
+        if (node.isLeafNode || options.commonPrefix !== false) {
+          prefix = prefix || '(empty root node)';
+          tree = tree[prefix] = {};
+          if (node.isLeafNode) {
+            tree[treeDataSymbol] = serializeNode(node, prefix, options);
           }
-          flattenNode(flattened.children['*'], node.wildcardChild, method);
+          prefix = '';
         }
         if (node.staticChildren) {
           for (const child of Object.values(node.staticChildren)) {
-            // split on the slash separator but use a regex to lookahead and not actually match it, preserving it in the returned string segments
-            const childPrefixSegments = child.prefix.split(pathRegExp);
-            let cursor = flattened;
-            let parent;
-            for (const segment of childPrefixSegments) {
-              parent = cursor;
-              cursor = cursor.children[segment];
-              if (!cursor) {
-                cursor = {
-                  prefix: segment,
-                  nodes: [],
-                  children: {}
-                };
-                parent.children[segment] = cursor;
-              }
-            }
-            flattenNode(cursor, child, method);
+            buildObjectTree(child, tree, prefix + child.prefix, options);
+          }
+        }
+        if (node.parametricChildren) {
+          for (const child of Object.values(node.parametricChildren)) {
+            const childPrefix = Array.from(child.nodePaths).join('|');
+            buildObjectTree(child, tree, prefix + childPrefix, options);
           }
         }
+        if (node.wildcardChild) {
+          buildObjectTree(node.wildcardChild, tree, '*', options);
+        }
       }
-      function compressFlattenedNode(flattenedNode) {
-        const childKeys = Object.keys(flattenedNode.children);
-        if (flattenedNode.nodes.length === 0 && childKeys.length === 1) {
-          const child = flattenedNode.children[childKeys[0]];
-          if (child.nodes.length <= 1) {
-            compressFlattenedNode(child);
-            flattenedNode.nodes = child.nodes;
-            flattenedNode.prefix += child.prefix;
-            flattenedNode.children = child.children;
-            return flattenedNode;
-          }
-        }
-        for (const key of Object.keys(flattenedNode.children)) {
-          compressFlattenedNode(flattenedNode.children[key]);
-        }
-        return flattenedNode;
+      function prettyPrintTree(root, options) {
+        const objectTree = {};
+        buildObjectTree(root, objectTree, root.prefix, options);
+        return printObjectTree(objectTree);
       }
       module.exports = {
-        flattenNode,
-        compressFlattenedNode,
-        prettyPrintFlattenedNode,
-        prettyPrintRoutesArray
+        prettyPrintTree
       };
-    }, {}],
-    33: [function (require, module, exports) {
+    }, {
+      "./strategies/http-method": 21,
+      "fast-deep-equal": 8
+    }],
+    19: [function (require, module, exports) {
       'use strict';
 
       const assert = require('assert');
@@ -3589,7 +2785,7 @@
     }, {
       "assert": 1
     }],
-    34: [function (require, module, exports) {
+    20: [function (require, module, exports) {
       'use strict';
 
       const assert = require('assert');
@@ -3619,14 +2815,14 @@
         }
         if (minor >= (this.maxMinors[major] || 0)) {
           this.maxMinors[major] = minor;
-          this.store[`${major}.x`] = store;
-          this.store[`${major}.x.x`] = store;
+          this.store["".concat(major, ".x")] = store;
+          this.store["".concat(major, ".x.x")] = store;
         }
-        if (patch >= (this.store[`${major}.${minor}`] || 0)) {
-          this.maxPatches[`${major}.${minor}`] = patch;
-          this.store[`${major}.${minor}.x`] = store;
+        if (patch >= (this.store["".concat(major, ".").concat(minor)] || 0)) {
+          this.maxPatches["".concat(major, ".").concat(minor)] = patch;
+          this.store["".concat(major, ".").concat(minor, ".x")] = store;
         }
-        this.store[`${major}.${minor}.${patch}`] = store;
+        this.store["".concat(major, ".").concat(minor, ".").concat(patch)] = store;
         return this;
       };
       SemVerStore.prototype.get = function (version) {
@@ -3643,7 +2839,30 @@
     }, {
       "assert": 1
     }],
-    35: [function (require, module, exports) {
+    21: [function (require, module, exports) {
+      'use strict';
+
+      module.exports = {
+        name: '__fmw_internal_strategy_merged_tree_http_method__',
+        storage: function storage() {
+          const handlers = {};
+          return {
+            get: type => {
+              return handlers[type] || null;
+            },
+            set: (type, store) => {
+              handlers[type] = store;
+            }
+          };
+        },
+        deriveConstraint: req => {
+          /* istanbul ignore next */
+          return req.method;
+        },
+        mustMatchWhenDerived: true
+      };
+    }, {}],
+    22: [function (require, module, exports) {
       'use strict';
 
       // It must spot all the chars where decodeURIComponent(x) !== decodeURI(x)
@@ -3736,7 +2955,7 @@
         safeDecodeURIComponent
       };
     }, {}],
-    36: [function (require, module, exports) {
+    23: [function (require, module, exports) {
       /*
       object-assign
       (c) Sindre Sorhus
@@ -3819,7 +3038,7 @@
         return to;
       };
     }, {}],
-    37: [function (require, module, exports) {
+    24: [function (require, module, exports) {
       // shim for using process in browser
       var process = module.exports = {};
 
@@ -3996,7 +3215,7 @@
         return 0;
       };
     }, {}],
-    38: [function (require, module, exports) {
+    25: [function (require, module, exports) {
       'use strict';
 
       var parse = require('ret');
@@ -4042,9 +3261,9 @@
         return {}.toString.call(x) === '[object RegExp]';
       }
     }, {
-      "ret": 39
+      "ret": 26
     }],
-    39: [function (require, module, exports) {
+    26: [function (require, module, exports) {
       const util = require('./util');
       const types = require('./types');
       const sets = require('./sets');
@@ -4062,7 +3281,7 @@
           last = start.stack,
           groupStack = [];
         var repeatErr = i => {
-          util.error(regexpStr, `Nothing to repeat at column ${i - 1}`);
+          util.error(regexpStr, "Nothing to repeat at column ".concat(i - 1));
         };
 
         // Decode a few escaped characters.
@@ -4179,7 +3398,7 @@
                 } else if (c === '!') {
                   group.notFollowedBy = true;
                 } else if (c !== ':') {
-                  util.error(regexpStr, `Invalid group, character '${c}'` + ` after '?' at column ${i - 1}`);
+                  util.error(regexpStr, "Invalid group, character '".concat(c, "'") + " after '?' at column ".concat(i - 1));
                 }
                 group.remember = false;
               }
@@ -4198,7 +3417,7 @@
             // Pop group out of stack.
             case ')':
               if (groupStack.length === 0) {
-                util.error(regexpStr, `Unmatched ) at column ${i - 1}`);
+                util.error(regexpStr, "Unmatched ) at column ".concat(i - 1));
               }
               lastGroup = groupStack.pop();
 
@@ -4302,12 +3521,12 @@
       };
       module.exports.types = types;
     }, {
-      "./positions": 40,
-      "./sets": 41,
-      "./types": 42,
-      "./util": 43
+      "./positions": 27,
+      "./sets": 28,
+      "./types": 29,
+      "./util": 30
     }],
-    40: [function (require, module, exports) {
+    27: [function (require, module, exports) {
       const types = require('./types');
       exports.wordBoundary = () => ({
         type: types.POSITION,
@@ -4326,9 +3545,9 @@
         value: '$'
       });
     }, {
-      "./types": 42
+      "./types": 29
     }],
-    41: [function (require, module, exports) {
+    28: [function (require, module, exports) {
       const types = require('./types');
       const INTS = () => [{
         type: types.RANGE,
@@ -4451,9 +3670,9 @@
         not: true
       });
     }, {
-      "./types": 42
+      "./types": 29
     }],
-    42: [function (require, module, exports) {
+    29: [function (require, module, exports) {
       module.exports = {
         ROOT: 0,
         GROUP: 1,
@@ -4465,7 +3684,7 @@
         CHAR: 7
       };
     }, {}],
-    43: [function (require, module, exports) {
+    30: [function (require, module, exports) {
       const types = require('./types');
       const sets = require('./sets');
       const CTRL = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?';
@@ -4558,102 +3777,10 @@
         throw new SyntaxError('Invalid regular expression: /' + regexp + '/: ' + msg);
       };
     }, {
-      "./sets": 41,
-      "./types": 42
-    }],
-    44: [function (require, module, exports) {
-      (function (setImmediate, clearImmediate) {
-        (function () {
-          var nextTick = require('process/browser.js').nextTick;
-          var apply = Function.prototype.apply;
-          var slice = Array.prototype.slice;
-          var immediateIds = {};
-          var nextImmediateId = 0;
-
-          // DOM APIs, for completeness
-
-          exports.setTimeout = function () {
-            return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
-          };
-          exports.setInterval = function () {
-            return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
-          };
-          exports.clearTimeout = exports.clearInterval = function (timeout) {
-            timeout.close();
-          };
-          function Timeout(id, clearFn) {
-            this._id = id;
-            this._clearFn = clearFn;
-          }
-          Timeout.prototype.unref = Timeout.prototype.ref = function () {};
-          Timeout.prototype.close = function () {
-            this._clearFn.call(window, this._id);
-          };
-
-          // Does not start the time, just sets up the members needed.
-          exports.enroll = function (item, msecs) {
-            clearTimeout(item._idleTimeoutId);
-            item._idleTimeout = msecs;
-          };
-          exports.unenroll = function (item) {
-            clearTimeout(item._idleTimeoutId);
-            item._idleTimeout = -1;
-          };
-          exports._unrefActive = exports.active = function (item) {
-            clearTimeout(item._idleTimeoutId);
-            var msecs = item._idleTimeout;
-            if (msecs >= 0) {
-              item._idleTimeoutId = setTimeout(function onTimeout() {
-                if (item._onTimeout) item._onTimeout();
-              }, msecs);
-            }
-          };
-
-          // That's not how node.js implements it but the exposed api is the same.
-          exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function (fn) {
-            var id = nextImmediateId++;
-            var args = arguments.length < 2 ? false : slice.call(arguments, 1);
-            immediateIds[id] = true;
-            nextTick(function onNextTick() {
-              if (immediateIds[id]) {
-                // fn.call() is faster so we optimize for the common use-case
-                // @see http://jsperf.com/call-apply-segu
-                if (args) {
-                  fn.apply(null, args);
-                } else {
-                  fn.call(null);
-                }
-                // Prevent ids from leaking
-                exports.clearImmediate(id);
-              }
-            });
-            return id;
-          };
-          exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function (id) {
-            delete immediateIds[id];
-          };
-        }).call(this);
-      }).call(this, require("timers").setImmediate, require("timers").clearImmediate);
-    }, {
-      "process/browser.js": 37,
-      "timers": 44
-    }],
-    45: [function (require, module, exports) {
-      /**
-      * Simple browser shim loader - assign the npm module to a window global automatically
-      *
-      * @license MIT
-      * @author <steven@velozo.com>
-      */
-      var libNPMModuleWrapper = require('./Orator.js');
-      if (typeof window === 'object' && !window.hasOwnProperty('Orator')) {
-        window.Orator = libNPMModuleWrapper;
-      }
-      module.exports = libNPMModuleWrapper;
-    }, {
-      "./Orator.js": 52
+      "./sets": 28,
+      "./types": 29
     }],
-    46: [function (require, module, exports) {
+    31: [function (require, module, exports) {
       // Simple default configuration for application, when none is provided
 
       module.exports = {
@@ -4662,35 +3789,24 @@
         "ServicePort": 8080
       };
     }, {}],
-    47: [function (require, module, exports) {
+    32: [function (require, module, exports) {
       /**
-      * Default Service Server Function
-      *
-      * @license MIT
-      *
-      * @author Steven Velozo <steven@velozo.com>
+      * Default Service Server
       */
-
-      // Return the servers that are available without extensions loaded
-      getDefaultServiceServers = () => {
-        let tmpDefaultServiceServers = {};
-        tmpDefaultServiceServers.ipc = require('./Orator-ServiceServer-IPC.js');
-        tmpDefaultServiceServers.default = tmpDefaultServiceServers.ipc;
-        return tmpDefaultServiceServers;
-      };
-      module.exports = getDefaultServiceServers();
+      module.exports = require('./Orator-ServiceServer-IPC.js');
     }, {
-      "./Orator-ServiceServer-IPC.js": 51
+      "./Orator-ServiceServer-IPC.js": 35
     }],
-    48: [function (require, module, exports) {
-      class OratorServiceServerBase {
-        constructor(pOrator) {
-          this.orator = pOrator;
-          this.log = pOrator.log;
+    33: [function (require, module, exports) {
+      const libFableServiceProviderBase = require('fable-serviceproviderbase');
+      class OratorServiceServerBase extends libFableServiceProviderBase {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this.serviceType = 'OratorServiceServer';
           this.ServiceServerType = 'Base';
-          this.Name = this.orator.settings.Product;
+          this.Name = this.fable.settings.Product;
           this.URL = 'BASE_SERVICE_SERVER';
-          this.Port = this.orator.settings.ServicePort;
+          this.Port = this.options.ServicePort;
           this.Active = false;
         }
 
@@ -4743,100 +3859,139 @@
          *************************************************************************/
         use(fHandlerFunction) {
           if (typeof fHandlerFunction != 'function') {
-            this.log.error(`Orator USE global handler mapping failed -- parameter was expected to be a function with prototype function(Request, Response, Next) but type was ${typeof fHandlerFunction} instead of a string.`);
+            this.log.error("Orator USE global handler mapping failed -- parameter was expected to be a function with prototype function(Request, Response, Next) but type was ".concat(typeof fHandlerFunction, " instead of a string."));
             return false;
           }
           return true;
         }
-        doGet(pRoute, ...fRouteProcessingFunctions) {
+        doGet(pRoute) {
           return true;
         }
-        get(pRoute, ...fRouteProcessingFunctions) {
+        get(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator GET Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator GET Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
+          for (var _len = arguments.length, fRouteProcessingFunctions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            fRouteProcessingFunctions[_key - 1] = arguments[_key];
+          }
           return this.doGet(pRoute, ...fRouteProcessingFunctions);
         }
-        getWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        getWithBodyParser(pRoute) {
+          for (var _len2 = arguments.length, fRouteProcessingFunctions = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            fRouteProcessingFunctions[_key2 - 1] = arguments[_key2];
+          }
           return this.get(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
-        doPut(pRoute, ...fRouteProcessingFunctions) {
+        doPut(pRoute) {
           return true;
         }
-        put(pRoute, ...fRouteProcessingFunctions) {
+        put(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator PUT Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator PUT Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
+          for (var _len3 = arguments.length, fRouteProcessingFunctions = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+            fRouteProcessingFunctions[_key3 - 1] = arguments[_key3];
+          }
           return this.doPut(pRoute, ...fRouteProcessingFunctions);
         }
-        putWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        putWithBodyParser(pRoute) {
+          for (var _len4 = arguments.length, fRouteProcessingFunctions = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+            fRouteProcessingFunctions[_key4 - 1] = arguments[_key4];
+          }
           return this.put(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
-        doPost(pRoute, ...fRouteProcessingFunctions) {
+        doPost(pRoute) {
           return true;
         }
-        post(pRoute, ...fRouteProcessingFunctions) {
+        post(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator POST Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator POST Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
+          for (var _len5 = arguments.length, fRouteProcessingFunctions = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+            fRouteProcessingFunctions[_key5 - 1] = arguments[_key5];
+          }
           return this.doPost(pRoute, ...fRouteProcessingFunctions);
         }
-        postWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        postWithBodyParser(pRoute) {
+          for (var _len6 = arguments.length, fRouteProcessingFunctions = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+            fRouteProcessingFunctions[_key6 - 1] = arguments[_key6];
+          }
           return this.post(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
-        doDel(pRoute, ...fRouteProcessingFunctions) {
+        doDel(pRoute) {
           return true;
         }
-        del(pRoute, ...fRouteProcessingFunctions) {
+        del(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator DEL Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator DEL Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
+          for (var _len7 = arguments.length, fRouteProcessingFunctions = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
+            fRouteProcessingFunctions[_key7 - 1] = arguments[_key7];
+          }
           return this.doDel(pRoute, ...fRouteProcessingFunctions);
         }
-        delWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        delWithBodyParser(pRoute) {
+          for (var _len8 = arguments.length, fRouteProcessingFunctions = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
+            fRouteProcessingFunctions[_key8 - 1] = arguments[_key8];
+          }
           return this.del(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
-        doPatch(pRoute, ...fRouteProcessingFunctions) {
+        doPatch(pRoute) {
           return true;
         }
-        patch(pRoute, ...fRouteProcessingFunctions) {
+        patch(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator PATCH Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator PATCH Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
+          for (var _len9 = arguments.length, fRouteProcessingFunctions = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
+            fRouteProcessingFunctions[_key9 - 1] = arguments[_key9];
+          }
           return this.doPatch(pRoute, ...fRouteProcessingFunctions);
         }
-        patchWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        patchWithBodyParser(pRoute) {
+          for (var _len10 = arguments.length, fRouteProcessingFunctions = new Array(_len10 > 1 ? _len10 - 1 : 0), _key10 = 1; _key10 < _len10; _key10++) {
+            fRouteProcessingFunctions[_key10 - 1] = arguments[_key10];
+          }
           return this.patch(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
-        doOpts(pRoute, ...fRouteProcessingFunctions) {
+        doOpts(pRoute) {
           return true;
         }
-        opts(pRoute, ...fRouteProcessingFunctions) {
+        opts(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator OPTS Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator OPTS Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
+          for (var _len11 = arguments.length, fRouteProcessingFunctions = new Array(_len11 > 1 ? _len11 - 1 : 0), _key11 = 1; _key11 < _len11; _key11++) {
+            fRouteProcessingFunctions[_key11 - 1] = arguments[_key11];
+          }
           return this.doOpts(pRoute, ...fRouteProcessingFunctions);
         }
-        optsWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        optsWithBodyParser(pRoute) {
+          for (var _len12 = arguments.length, fRouteProcessingFunctions = new Array(_len12 > 1 ? _len12 - 1 : 0), _key12 = 1; _key12 < _len12; _key12++) {
+            fRouteProcessingFunctions[_key12 - 1] = arguments[_key12];
+          }
           return this.opts(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
-        doHead(pRoute, ...fRouteProcessingFunctions) {
+        doHead(pRoute) {
           return true;
         }
-        head(pRoute, ...fRouteProcessingFunctions) {
+        head(pRoute) {
           if (typeof pRoute != 'string') {
-            this.log.error(`Orator HEAD Route mapping failed -- route parameter was ${typeof pRoute} instead of a string.`);
+            this.log.error("Orator HEAD Route mapping failed -- route parameter was ".concat(typeof pRoute, " instead of a string."));
             return false;
           }
           return true;
         }
-        headWithBodyParser(pRoute, ...fRouteProcessingFunctions) {
+        headWithBodyParser(pRoute) {
+          for (var _len13 = arguments.length, fRouteProcessingFunctions = new Array(_len13 > 1 ? _len13 - 1 : 0), _key13 = 1; _key13 < _len13; _key13++) {
+            fRouteProcessingFunctions[_key13 - 1] = arguments[_key13];
+          }
           return this.head(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
         }
         /*************************************************************************
@@ -4846,47 +4001,28 @@
         // Programmatically invoke a route
         invoke(pMethod, pRoute, pData, fCallback) {
           // The base class version of this does nothing
-          this.log.debug(`Orator invoke called for route [${pRoute}] and landed on the base class; the service provider likely does not implement programmatic invoke capabilities.`, pData);
+          this.log.debug("Orator invoke called for route [".concat(pRoute, "] and landed on the base class; the service provider likely does not implement programmatic invoke capabilities."), pData);
           return false;
         }
       }
       module.exports = OratorServiceServerBase;
-    }, {}],
-    49: [function (require, module, exports) {
-      'use strict';
-
-      // This is taken directly from the find-my-way documentation for custom constraints and only mildly edited
-      const ipcResponseTypeStrategy = {
-        // strategy name for referencing in the route handler `constraints` options
-        name: 'ipc',
-        isAsync: true,
-        // storage factory for storing routes in the find-my-way route tree
-        storage: () => {
-          let handlers = {};
-          return {
-            get: type => {
-              return handlers[type] || null;
-            },
-            set: (type, store) => {
-              handlers[type] = store;
-            }
-          };
-        },
-        // function to get the value of the constraint from each incoming request
-        deriveConstraint: (pRequest, pContext, fDone) => {
-          // If we wanted to deny the IPC request based on a constraint, we would do:
-          // fDone(new Error(`The request was denied because ____ in the Request object wasn't right...`));
-          return fDone(null, 'IPC');
-        },
-        // optional flag marking if handlers without constraints can match requests that have a value for this constraint
-        mustMatchWhenDerived: true
-      };
-      module.exports = ipcResponseTypeStrategy;
-    }, {}],
-    50: [function (require, module, exports) {
+    }, {
+      "fable-serviceproviderbase": 6
+    }],
+    34: [function (require, module, exports) {
       class OratorServiceServerIPCSynthesizedResponse {
-        constructor(pLog, pRequestGUID) {
+        constructor(pHandler, pLog, pRequestGUID) {
           this.log = pLog;
+          if (pHandler.hasOwnProperty('params')) {
+            this.params = pHandler.params;
+          } else {
+            this.params = {};
+          }
+          if (pHandler.hasOwnProperty('searchParams')) {
+            this.searchParams = pHandler.searchParams;
+          } else {
+            this.searchParams = {};
+          }
           this.requestGUID = pRequestGUID;
           this.responseData = null;
           this.responseStatus = -1;
@@ -4901,7 +4037,7 @@
               this.responseData = this.responseData + pData;
               return true;
             } else {
-              this.log(`Request ${this.requestGUID} has tried to send() a string value after send()ing data type ${typeof this.responseData}.`, pData);
+              this.log("Request ".concat(this.requestGUID, " has tried to send() a string value after send()ing data type ").concat(typeof this.responseData, "."), pData);
               return false;
             }
           } else if (typeof pData == 'object') {
@@ -4913,7 +4049,7 @@
               this.responseData += this.responseData + JSON.stringify(pData);
               return true;
             } else {
-              this.log(`Request ${this.requestGUID} has tried to send() an object value to be auto stringified after send()ing data type ${typeof this.responseData}.`, pData);
+              this.log("Request ".concat(this.requestGUID, " has tried to send() an object value to be auto stringified after send()ing data type ").concat(typeof this.responseData, "."), pData);
               return false;
             }
           }
@@ -4921,68 +4057,74 @@
       }
       module.exports = OratorServiceServerIPCSynthesizedResponse;
     }, {}],
-    51: [function (require, module, exports) {
+    35: [function (require, module, exports) {
       const libOratorServiceServerBase = require('./Orator-ServiceServer-Base.js');
 
       // A synthesized response object, for simple IPC.
       const libOratorServiceServerIPCSynthesizedResponse = require('./Orator-ServiceServer-IPC-SynthesizedResponse.js');
       // A simple constrainer for the find-my-way router since we aren't using any kind of headers to pass version or host
-      const libOratorServiceServerIPCCustomConstrainer = require('./Orator-ServiceServer-IPC-RouterConstrainer.js');
+      //const libOratorServiceServerIPCCustomConstrainer = require('./Orator-ServiceServer-IPC-RouterConstrainer.js');
 
       // This library is the default router for our services
       const libFindMyWay = require('find-my-way');
-      //const libAsync = require('async');
-      const libAsyncWaterfall = require("async/waterfall");
-      const libAsyncEachOfSeries = require('async/eachOfSeries');
       class OratorServiceServerIPC extends libOratorServiceServerBase {
-        constructor(pOrator) {
-          super(pOrator);
-          this.routerOptions = this.orator.settings.hasOwnProperty('router_options') && typeof this.orator.settings.router_options == 'object' ? this.orator.settings.router_options : {};
-          this.router = libFindMyWay(this.routerOptions);
-          this.router.addConstraintStrategy(libOratorServiceServerIPCCustomConstrainer);
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this.router = libFindMyWay(this.options);
+          //this.router.addConstraintStrategy(libOratorServiceServerIPCCustomConstrainer);
+
           this.ServiceServerType = 'IPC';
           this.URL = 'IPC';
+          this.Port = 0;
           this.preBehaviorFunctions = [];
           this.behaviorMap = {};
           this.postBehaviorFunctions = [];
         }
         use(fHandlerFunction) {
-          if (!super.use(fHandlerFunction)) {
-            this.log.error(`IPC provider failed to map USE handler function!`);
-            return false;
-          }
-          this.preBehaviorFunctions.push(fHandlerFunction);
+          return this.addPreBehaviorFunction(fHandlerFunction);
         }
-        addPostBehaviorFunction(fHandlerFunction) {
+        addPreBehaviorFunction(fHandlerFunction) {
           if (!super.use(fHandlerFunction)) {
-            this.log.error(`IPC provider failed to map USE handler function!`);
+            this.log.error("IPC provider failed to map USE handler function!");
             return false;
           }
           this.preBehaviorFunctions.push(fHandlerFunction);
+          return true;
         }
         executePreBehaviorFunctions(pRequest, pResponse, fNext) {
-          libAsyncEachOfSeries(this.preBehaviorFunctions, (fBehaviorFunction, pFunctionIndex, fCallback) => {
-            return fBehaviorFunction(pRequest, pResponse, fCallback);
-          }, pError => {
+          let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+          for (let i = 0; i < this.preBehaviorFunctions.length; i++) {
+            let tmpPreBehaviorFunction = this.preBehaviorFunctions[i];
+            tmpAnticipate.anticipate(fStageComplete => {
+              return tmpPreBehaviorFunction(pRequest, pResponse, fStageComplete);
+            });
+          }
+          tmpAnticipate.wait(pError => {
             if (pError) {
-              this.log.error(`IPC Provider preBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);
+              this.log.error("IPC Provider preBehaviorFunction ".concat(pFunctionIndex, " failed with error: ").concat(pError), pError);
             }
             return fNext(pError);
           });
         }
         addPostBehaviorFunction(fHandlerFunction) {
           if (!super.use(fHandlerFunction)) {
-            this.log.error(`IPC provider failed to map USE handler function!`);
+            this.log.error("IPC provider failed to map USE handler function!");
             return false;
           }
-          this.preBehaviorFunctions.push(fHandlerFunction);
+          this.postBehaviorFunctions.push(fHandlerFunction);
+          return true;
         }
         executePostBehaviorFunctions(pRequest, pResponse, fNext) {
-          libAsyncEachOfSeries(this.postBehaviorFunctions, (fBehaviorFunction, pFunctionIndex, fCallback) => {
-            return fBehaviorFunction(pRequest, pResponse, fCallback);
-          }, pError => {
+          let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+          for (let i = 0; i < this.postBehaviorFunctions.length; i++) {
+            let tmpPostBehaviorFunction = this.postBehaviorFunctions[i];
+            tmpAnticipate.anticipate(fStageComplete => {
+              return tmpPostBehaviorFunction(pRequest, pResponse, fStageComplete);
+            });
+          }
+          tmpAnticipate.wait(pError => {
             if (pError) {
-              this.log.error(`IPC Provider postBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);
+              this.log.error("IPC Provider postBehaviorFunction ".concat(pFunctionIndex, " failed with error: ").concat(pError), pError);
             }
             return fNext(pError);
           });
@@ -5005,35 +4147,35 @@
         addRouteProcessor(pMethod, pRoute, pRouteFunctionArray) {
           // We have a constrainer on IPC so we can control channels eventually, if we like.
           // For now it just makes sure it was added with an IPC service server.
-          this.router.on(pMethod, pRoute, {
-            constraints: {
-              "ipc": "IPC"
+          this.router.on(pMethod, pRoute, this.buildFindMyWayHandler(pRouteFunctionArray));
+          return true;
+        }
+        buildFindMyWayHandler(pRouteFunctionArray) {
+          let tmpRouteFunctionArray = pRouteFunctionArray;
+          return (pRequest, pResponse, pData) => {
+            let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+            tmpAnticipate.anticipate(fNext => {
+              return this.executePreBehaviorFunctions(pRequest, pResponse, fNext);
+            });
+            for (let i = 0; i < tmpRouteFunctionArray.length; i++) {
+              let tmpRouteFunction = tmpRouteFunctionArray[i];
+              tmpAnticipate.anticipate(fNext => {
+                return tmpRouteFunction(pRequest, pResponse, fNext);
+              });
             }
-          }, (pRequest, pResponse, pParameters) => {
-            libAsyncWaterfall([fStageComplete => {
-              // Added to make this mimic what we saw with route parsing in the old restify
-              pRequest.params = pParameters;
-              return fStageComplete();
-            }, fStageComplete => {
-              return this.executePreBehaviorFunctions(pRequest, pResponse, fStageComplete);
-            }, fStageComplete => {
-              libAsyncEachOfSeries(pRouteFunctionArray, (fBehaviorFunction, pFunctionIndex, fCallback) => {
-                return fBehaviorFunction(pRequest, pResponse, fCallback);
-              }, pBehaviorFunctionError => {
+            tmpAnticipate.anticipate(fStageComplete => {
+              return this.executePostBehaviorFunctions(pRequest, pResponse, fStageComplete);
+            });
+            return new Promise((fResolve, fReject) => {
+              tmpAnticipate.wait(pBehaviorFunctionError => {
                 if (pBehaviorFunctionError) {
-                  this.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);
-                  return fNext(pError);
+                  this.log.error("IPC Provider behavior function ".concat(pFunctionIndex, " failed with error: ").concat(pBehaviorFunctionError), pBehaviorFunctionError);
+                  return fReject(pBehaviorFunctionError);
                 }
+                return fResolve();
               });
-            }, fStageComplete => {
-              return this.executePostBehaviorFunctions(pRequest, pResponse, fStageComplete);
-            }], pRequestError => {
-              if (pRequestError) {
-                this.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);
-              }
             });
-          });
-          return true;
+          };
         }
 
         // This is the virtualized "body parser"
@@ -5042,25 +4184,46 @@
             return fNext();
           };
         }
-        doGet(pRoute, ...fRouteProcessingFunctions) {
+        doGet(pRoute) {
+          for (var _len14 = arguments.length, fRouteProcessingFunctions = new Array(_len14 > 1 ? _len14 - 1 : 0), _key14 = 1; _key14 < _len14; _key14++) {
+            fRouteProcessingFunctions[_key14 - 1] = arguments[_key14];
+          }
           return this.addRouteProcessor('GET', pRoute, Array.from(fRouteProcessingFunctions));
         }
-        doPut(pRoute, ...fRouteProcessingFunctions) {
+        doPut(pRoute) {
+          for (var _len15 = arguments.length, fRouteProcessingFunctions = new Array(_len15 > 1 ? _len15 - 1 : 0), _key15 = 1; _key15 < _len15; _key15++) {
+            fRouteProcessingFunctions[_key15 - 1] = arguments[_key15];
+          }
           return this.addRouteProcessor('PUT', pRoute, Array.from(fRouteProcessingFunctions));
         }
-        doPost(pRoute, ...fRouteProcessingFunctions) {
+        doPost(pRoute) {
+          for (var _len16 = arguments.length, fRouteProcessingFunctions = new Array(_len16 > 1 ? _len16 - 1 : 0), _key16 = 1; _key16 < _len16; _key16++) {
+            fRouteProcessingFunctions[_key16 - 1] = arguments[_key16];
+          }
           return this.addRouteProcessor('POST', pRoute, Array.from(fRouteProcessingFunctions));
         }
-        doDel(pRoute, ...fRouteProcessingFunctions) {
-          return this.addRouteProcessor('DEL', pRoute, Array.from(fRouteProcessingFunctions));
+        doDel(pRoute) {
+          for (var _len17 = arguments.length, fRouteProcessingFunctions = new Array(_len17 > 1 ? _len17 - 1 : 0), _key17 = 1; _key17 < _len17; _key17++) {
+            fRouteProcessingFunctions[_key17 - 1] = arguments[_key17];
+          }
+          return this.addRouteProcessor('DELETE', pRoute, Array.from(fRouteProcessingFunctions));
         }
-        doPatch(pRoute, ...fRouteProcessingFunctions) {
+        doPatch(pRoute) {
+          for (var _len18 = arguments.length, fRouteProcessingFunctions = new Array(_len18 > 1 ? _len18 - 1 : 0), _key18 = 1; _key18 < _len18; _key18++) {
+            fRouteProcessingFunctions[_key18 - 1] = arguments[_key18];
+          }
           return this.addRouteProcessor('PATCH', pRoute, Array.from(fRouteProcessingFunctions));
         }
-        doOpts(pRoute, ...fRouteProcessingFunctions) {
-          return this.addRouteProcessor('OPTS', pRoute, Array.from(fRouteProcessingFunctions));
+        doOpts(pRoute) {
+          for (var _len19 = arguments.length, fRouteProcessingFunctions = new Array(_len19 > 1 ? _len19 - 1 : 0), _key19 = 1; _key19 < _len19; _key19++) {
+            fRouteProcessingFunctions[_key19 - 1] = arguments[_key19];
+          }
+          return this.addRouteProcessor('OPTIONS', pRoute, Array.from(fRouteProcessingFunctions));
         }
-        doHead(pRoute, ...fRouteProcessingFunctions) {
+        doHead(pRoute) {
+          for (var _len20 = arguments.length, fRouteProcessingFunctions = new Array(_len20 > 1 ? _len20 - 1 : 0), _key20 = 1; _key20 < _len20; _key20++) {
+            fRouteProcessingFunctions[_key20 - 1] = arguments[_key20];
+          }
           return this.addRouteProcessor('HEAD', pRoute, Array.from(fRouteProcessingFunctions));
         }
         /*************************************************************************
@@ -5070,43 +4233,55 @@
         // Programmatically invoke a route
         invoke(pMethod, pRoute, pData, fCallback) {
           // If the data is skipped and a callback is parameter 3, do the right thing
-          let tmpCallback = typeof fCallback == 'function' ? fCallback : typeof pData == 'function' ? pData :
-          // This is here in case the developer passed no callback and just wants to fire and forget the IPC call which might not be async safe
-          () => {};
+          let tmpCallback = typeof fCallback == 'function' ? fCallback : typeof pData == 'function' ? pData : false;
+          if (!tmpCallback) {
+            throw new Error("IPC Provider invoke() called without a callback function.");
+          }
 
           // Create a bare minimum request object for IPC to pass to our router
           let tmpRequest = {
             method: pMethod,
             url: pRoute,
-            guid: this.orator.fable.getUUID()
+            guid: this.fable.getUUID()
           };
 
+          // For now, dealing with no handler constraints.
+          let tmpHandler = this.router.find(tmpRequest.method, tmpRequest.url);
+
           // Create a container for the IPC response data to be aggregated to from send() methodds
-          let tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(this.log, tmpRequest.guid);
-          return this.router.lookup(tmpRequest, tmpSynthesizedResponseData, (pError, pResults) => {
+          let tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(tmpHandler, this.log, tmpRequest.guid);
+
+          // Map parsed params back to the request object
+          tmpRequest.params = tmpSynthesizedResponseData.params;
+          tmpRequest.searchParams = tmpSynthesizedResponseData.searchParams;
+
+          //params: handle._createParamsObject(params)//,
+          //searchParams: this.querystringParser(querystring)
+
+          tmpHandler.handler(tmpRequest, tmpSynthesizedResponseData, pData).then(pResults => {
+            return tmpCallback(null, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData, pResults);
+          }, pError => {
+            this.log.trace('IPC Response Received', {
+              Error: pError
+            });
             if (pError) {
-              this.log.error(`IPC Request Error Request GUID [${tmpRequest.guid}] handling route [${pRoute}]: ${pError}`, {
+              this.log.error("IPC Request Error Request GUID [".concat(tmpRequest.guid, "] handling route [").concat(pRoute, "]: ").concat(pError), {
                 Error: pError,
                 Route: pRoute,
                 Data: pData
               });
             }
-
-            // by default, send data back through
-            return tmpCallback(pError, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData, pResults);
+            return tmpCallback(pError, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData);
           });
         }
       }
       module.exports = OratorServiceServerIPC;
     }, {
-      "./Orator-ServiceServer-Base.js": 48,
-      "./Orator-ServiceServer-IPC-RouterConstrainer.js": 49,
-      "./Orator-ServiceServer-IPC-SynthesizedResponse.js": 50,
-      "async/eachOfSeries": 7,
-      "async/waterfall": 20,
-      "find-my-way": 29
+      "./Orator-ServiceServer-Base.js": 33,
+      "./Orator-ServiceServer-IPC-SynthesizedResponse.js": 34,
+      "find-my-way": 13
     }],
-    52: [function (require, module, exports) {
+    36: [function (require, module, exports) {
       /**
       * Orator Service Abstraction
       *
@@ -5116,16 +4291,13 @@
       * @module Orator Service
       */
 
+      const libFableServiceProviderBase = require('fable-serviceproviderbase');
+      const libDefaultOratorServiceServer = require('./Orator-Default-ServiceServer.js');
       const defaultOratorConfiguration = require('./Orator-Default-Configuration.js');
-      const defaultOratorServiceServers = require('./Orator-Default-ServiceServers-Node.js');
-      class Orator {
-        constructor(pFable, pServiceProvider) {
-          // We were passed a fully operational fable -- use this
-          this.fable = pFable;
-
-          // Carry core application requirements into the orator object for simplicity
-          this.settings = this.fable.settings;
-          this.log = this.fable.log;
+      class Orator extends libFableServiceProviderBase {
+        constructor(pFable, pOptions, pServiceHash) {
+          super(pFable, pOptions, pServiceHash);
+          this.serviceType = 'Orator';
 
           // Create the empty, important logic containers
           this.serviceServer = false;
@@ -5135,66 +4307,143 @@
           }
 
           // Now check to see that the ServicePort is set (this used to be APIServerPort)
-          if (!this.settings.hasOwnProperty('ServicePort')) {
-            if (this.settings.hasOwnProperty('APIServerPort')) {
+          if (!this.options.hasOwnProperty('ServicePort')) {
+            if (this.fable.settings.hasOwnProperty('APIServerPort')) {
               // Automatically migrate the legacy APIServerPort to ServicePort
-              this.settings.ServicePort = this.fable.settings.APIServerPort;
+              this.options.ServicePort = this.fable.settings.APIServerPort;
             } else {
               // Default to whatever the ... default is!
-              this.settings.ServicePort = defaultOratorConfiguration.ServicePort;
+              this.options.ServicePort = defaultOratorConfiguration.ServicePort;
             }
           }
 
           // Now check to see that the Product name is set
-          if (!this.settings.hasOwnProperty('Product')) {
-            this.settings.Product = defaultOratorConfiguration.Product;
+          if (!this.options.hasOwnProperty('Product')) {
+            this.options.Product = defaultOratorConfiguration.Product;
           }
         }
-        initializeServiceServer(fNext) {
-          var tmpNext = typeof fNext === 'function' ? fNext : () => {};
+        onBeforeInitialize() {
+          if (this.fable.settings.LogNoisiness > 3) {
+            this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " onBeforeInitialize:"));
+          }
+        }
+        onBeforeInitializeAsync(fNext) {
+          this.onBeforeInitialize();
+          // Check to see if there is a service server active; if not instantiate one (and use IPC if none is registered with Fable as the default provider)
           if (!this.serviceServer) {
             // If the developer hasn't set this to a service provider class of their own choosing, 
+            // TODO: Give the developer a chance to set a service provider instantiation address of their own choosing.
             // use the built-in network-less one.
-            if (!this.serviceServerProvider) {
-              this.serviceServerProvider = defaultOratorServiceServers.default;
+            if (!this.fable.OratorServiceServer) {
+              // If there isn't a default Service Server setup, create one.
+              let tmpServiceServerOptions = typeof this.options.ServiceServerOptions == 'undefined' ? {} : this.options.ServiceServerOptions;
+              if (!this.fable.serviceManager.servicesMap.hasOwnProperty('OratorServiceServer')) {
+                // Only register IPC if there isn't one yet.
+                this.fable.serviceManager.addServiceType('OratorServiceServer', libDefaultOratorServiceServer);
+              }
+              this.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', tmpServiceServerOptions, 'OratorServiceServer-AutoInit');
             }
-            this.serviceServer = new this.serviceServerProvider(this);
-
+            this.serviceServer = this.fable.OratorServiceServer;
             // For legacy reasons, we also will provide this under the "webServer" variable.
             this.webServer = this.serviceServer;
           } else {
-            this.log.warn(`Orator attempting to initialize a service server after initialization has already completed.`);
+            this.log.warn("Orator attempting to initialize a service server after initialization has already completed.");
+          }
+          fNext();
+        }
+        onInitialize() {
+          if (this.fable.settings.LogNoisiness > 3) {
+            this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " onInitialize:"));
+          }
+        }
+        onInitializeAsync(fNext) {
+          this.onInitialize();
+          return fNext();
+        }
+        onAfterInitialize() {
+          if (this.fable.settings.LogNoisiness > 3) {
+            this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " onAfterInitialize:"));
+          }
+        }
+        onAfterInitializeAsync(fNext) {
+          this.onAfterInitialize();
+          return fNext();
+        }
+        initialize(fCallback) {
+          // I hate this -- is there a reason to not require a callback?
+          let tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
+          if (!this.initializeTimestamp) {
+            let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+            if (this.fable.LogNoisiness > 3) {
+              this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " beginning initialization steps..."));
+            }
+            tmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onInitializeAsync.bind(this));
+            tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
+            tmpAnticipate.wait(pError => {
+              this.initializeTimestamp = this.fable.log.getTimeStamp();
+              if (this.fable.LogNoisiness > 2) {
+                this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " initialization steps complete."));
+              }
+              return tmpCallback(pError);
+            });
+          } else {
+            this.log.warn("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " async initialize called but initialization is already completed.  Aborting."));
+            // TODO: Should this be returning an error?
+            return tmpCallback();
           }
-          return tmpNext();
         }
-        _startServiceListener(fNext) {
-          return this.serviceServer.listen(this.settings.ServicePort, pError => {
-            this.log.info(`${this.serviceServer.Name} listening at ${this.serviceServer.URL} port ${this.serviceServer.Port}`);
+        onBeforeStartService(fNext) {
+          return fNext();
+        }
+        onStartService(fNext) {
+          this.onAfterInitialize();
+          return this.serviceServer.listen(this.options.ServicePort, pError => {
+            this.log.info("".concat(this.serviceServer.Name, " listening at ").concat(this.serviceServer.URL, " port ").concat(this.serviceServer.Port));
             return fNext(pError);
           });
         }
+        onAfterStartService(fNext) {
+          return fNext();
+        }
         startService(fNext) {
           var tmpNext = typeof fNext === 'function' ? fNext : () => {};
+          let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+          if (this.fable.LogNoisiness > 3) {
+            this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " beginning startService steps..."));
+          }
+
+          // Auto initialize if there is no serviceServer
           if (!this.serviceServer) {
-            this.initializeServiceServer();
+            tmpAnticipate.anticipate(this.initialize.bind(this));
           }
-          return this._startServiceListener(tmpNext);
+          tmpAnticipate.anticipate(this.onBeforeStartService.bind(this));
+          tmpAnticipate.anticipate(this.onStartService.bind(this));
+          tmpAnticipate.anticipate(this.onAfterStartService.bind(this));
+          tmpAnticipate.wait(pError => {
+            this.startServiceTimestamp = this.fable.log.getTimeStamp();
+            if (this.fable.LogNoisiness > 2) {
+              this.log.trace("Orator [".concat(this.UUID, "]::[").concat(this.Hash, "] ").concat(this.options.Product, " startService steps complete."));
+            }
+            return tmpNext(pError);
+          });
         }
-        stopService(fNext) {
-          var tmpNext = typeof fNext === 'function' ? fNext : () => {};
+        stopService(fCallback) {
+          var tmpCallback = typeof fCallback === 'function' ? fCallback : () => {};
           if (!this.serviceServer) {
-            let tmpMessage = `Orator attempting to stop a service server but the service server has not been intialized yet.`;
+            let tmpMessage = "Orator attempting to stop a service server but the service server has not been intialized yet.";
             this.log.warn(tmpMessage);
-            return tmpNext(tmpMessage);
+            return tmpCallback(tmpMessage);
           }
           if (!this.serviceServer.Active) {
-            let tmpMessage = `Orator attempting to stop a service server but the service server is not actively running.`;
+            let tmpMessage = "Orator attempting to stop a service server but the service server is not actively running.";
             this.log.warn(tmpMessage);
-            return tmpNext(tmpMessage);
+            return tmpCallback(tmpMessage);
           }
-          return this.serviceServer.close(tmpNext);
+          return this.serviceServer.close(tmpCallback);
         }
         invoke(pMethod, pRoute, pData, fCallback) {
+          //this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} invoking ${pMethod} ${pRoute}`);
           return this.serviceServer.invoke(pMethod, pRoute, pData, fCallback);
         }
 
@@ -5226,10 +4475,13 @@
 
       module.exports = Orator;
       module.exports.ServiceServerBase = require('./Orator-ServiceServer-Base.js');
+      module.exports.ServiceServerIPC = require('./Orator-ServiceServer-IPC.js');
     }, {
-      "./Orator-Default-Configuration.js": 46,
-      "./Orator-Default-ServiceServers-Node.js": 47,
-      "./Orator-ServiceServer-Base.js": 48
+      "./Orator-Default-Configuration.js": 31,
+      "./Orator-Default-ServiceServer.js": 32,
+      "./Orator-ServiceServer-Base.js": 33,
+      "./Orator-ServiceServer-IPC.js": 35,
+      "fable-serviceproviderbase": 6
     }]
-  }, {}, [45])(45);
+  }, {}, [36])(36);
 });