@feathersjs/client 4.5.8 → 4.5.12

package/dist/core.js

@@ -8,118 +8,40 @@
 	else
 		root["feathers"] = factory();
 })(this, function() {
-return /******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./src/core.js");
-/******/ })
-/************************************************************************/
-/******/ ({
+return /******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
 
 /***/ "../../node_modules/debug/src/browser.js":
-/*!**************************************************************************************!*\
-  !*** /Users/daffl/Development/feathersjs/feathers/node_modules/debug/src/browser.js ***!
-  \**************************************************************************************/
-/*! no static exports found */
+/*!***********************************************!*\
+  !*** ../../node_modules/debug/src/browser.js ***!
+  \***********************************************/
 /***/ (function(module, exports, __webpack_require__) {
 
-/* WEBPACK VAR INJECTION */(function(process) {function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
 /* eslint-env browser */
 
 /**
  * This is the web browser implementation of `debug()`.
  */
-exports.log = log;
 exports.formatArgs = formatArgs;
 exports.save = save;
 exports.load = load;
 exports.useColors = useColors;
 exports.storage = localstorage();
+
+exports.destroy = function () {
+  var warned = false;
+  return function () {
+    if (!warned) {
+      warned = true;
+      console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+    }
+  };
+}();
 /**
  * Colors.
  */
 
+
 exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
 /**
  * Currently only WebKit-based Web Inspectors, Firefox >= v31,
@@ -188,20 +110,16 @@ function formatArgs(args) {
   args.splice(lastC, 0, c);
 }
 /**
- * Invokes `console.log()` when available.
- * No-op when `console.log` is not a "function".
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
  *
  * @api public
  */
 
 
-function log() {
-  var _console;
-
-  // This hackery is required for IE8/9, where
-  // the `console.log` function doesn't have 'apply'
-  return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
-}
+exports.log = console.debug || console.log || function () {};
 /**
  * Save `namespaces`.
  *
@@ -280,16 +198,14 @@ formatters.j = function (v) {
     return '[UnexpectedJSONParseError]: ' + error.message;
   }
 };
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "../../node_modules/process/browser.js")))
 
 /***/ }),
 
 /***/ "../../node_modules/debug/src/common.js":
-/*!*************************************************************************************!*\
-  !*** /Users/daffl/Development/feathersjs/feathers/node_modules/debug/src/common.js ***!
-  \*************************************************************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*!**********************************************!*\
+  !*** ../../node_modules/debug/src/common.js ***!
+  \**********************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
@@ -297,7 +213,7 @@ function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread n
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
@@ -315,15 +231,11 @@ function setup(env) {
   createDebug.enable = enable;
   createDebug.enabled = enabled;
   createDebug.humanize = __webpack_require__(/*! ms */ "../../node_modules/ms/index.js");
+  createDebug.destroy = destroy;
   Object.keys(env).forEach(function (key) {
     createDebug[key] = env[key];
   });
   /**
-  * Active `debug` instances.
-  */
-
-  createDebug.instances = [];
-  /**
   * The currently active debug mode names, and names to skip.
   */
 
@@ -338,7 +250,7 @@ function setup(env) {
   createDebug.formatters = {};
   /**
   * Selects a color for a debug namespace
-  * @param {String} namespace The namespace string for the for the debug instance to be colored
+  * @param {String} namespace The namespace string for the debug instance to be colored
   * @return {Number|String} An ANSI color code for the given namespace
   * @api private
   */
@@ -365,6 +277,9 @@ function setup(env) {
 
   function createDebug(namespace) {
     var prevTime;
+    var enableOverride = null;
+    var namespacesCache;
+    var enabledCache;
 
     function debug() {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -396,7 +311,7 @@ function setup(env) {
       args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
         // If we encounter an escaped % then don't increase the array index
         if (match === '%%') {
-          return match;
+          return '%';
         }
 
         index++;
@@ -419,33 +334,38 @@ function setup(env) {
     }
 
     debug.namespace = namespace;
-    debug.enabled = createDebug.enabled(namespace);
     debug.useColors = createDebug.useColors();
-    debug.color = selectColor(namespace);
-    debug.destroy = destroy;
-    debug.extend = extend; // Debug.formatArgs = formatArgs;
-    // debug.rawLog = rawLog;
-    // env-specific initialization logic for debug instances
+    debug.color = createDebug.selectColor(namespace);
+    debug.extend = extend;
+    debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+    Object.defineProperty(debug, 'enabled', {
+      enumerable: true,
+      configurable: false,
+      get: function get() {
+        if (enableOverride !== null) {
+          return enableOverride;
+        }
+
+        if (namespacesCache !== createDebug.namespaces) {
+          namespacesCache = createDebug.namespaces;
+          enabledCache = createDebug.enabled(namespace);
+        }
+
+        return enabledCache;
+      },
+      set: function set(v) {
+        enableOverride = v;
+      }
+    }); // Env-specific initialization logic for debug instances
 
     if (typeof createDebug.init === 'function') {
       createDebug.init(debug);
     }
 
-    createDebug.instances.push(debug);
     return debug;
   }
 
-  function destroy() {
-    var index = createDebug.instances.indexOf(this);
-
-    if (index !== -1) {
-      createDebug.instances.splice(index, 1);
-      return true;
-    }
-
-    return false;
-  }
-
   function extend(namespace, delimiter) {
     var newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
     newDebug.log = this.log;
@@ -462,6 +382,7 @@ function setup(env) {
 
   function enable(namespaces) {
     createDebug.save(namespaces);
+    createDebug.namespaces = namespaces;
     createDebug.names = [];
     createDebug.skips = [];
     var i;
@@ -482,11 +403,6 @@ function setup(env) {
         createDebug.names.push(new RegExp('^' + namespaces + '$'));
       }
     }
-
-    for (i = 0; i < createDebug.instances.length; i++) {
-      var instance = createDebug.instances[i];
-      instance.enabled = createDebug.enabled(instance.namespace);
-    }
   }
   /**
   * Disable debug output.
@@ -562,6 +478,15 @@ function setup(env) {
 
     return val;
   }
+  /**
+  * XXX DO NOT USE. This is a temporary stub function.
+  * XXX It WILL be removed in the next major release.
+  */
+
+
+  function destroy() {
+    console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+  }
 
   createDebug.enable(createDebug.load());
   return createDebug;
@@ -571,2040 +496,1887 @@ module.exports = setup;
 
 /***/ }),
 
-/***/ "../../node_modules/events/events.js":
-/*!**********************************************************************************!*\
-  !*** /Users/daffl/Development/feathersjs/feathers/node_modules/events/events.js ***!
-  \**********************************************************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/***/ "./src/core.js":
+/*!*********************!*\
+  !*** ./src/core.js ***!
+  \*********************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+module.exports = __webpack_require__(/*! @feathersjs/feathers */ "../feathers/lib/index.js");
 
+/***/ }),
 
+/***/ "../commons/lib/hooks.js":
+/*!*******************************!*\
+  !*** ../commons/lib/hooks.js ***!
+  \*******************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-var R = typeof Reflect === 'object' ? Reflect : null
-var ReflectApply = R && typeof R.apply === 'function'
-  ? R.apply
-  : function ReflectApply(target, receiver, args) {
-    return Function.prototype.apply.call(target, receiver, args);
-  }
+"use strict";
 
-var ReflectOwnKeys
-if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys
-} else if (Object.getOwnPropertySymbols) {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
-      .concat(Object.getOwnPropertySymbols(target));
-  };
-} else {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target);
-  };
-}
 
-function ProcessEmitWarning(warning) {
-  if (console && console.warn) console.warn(warning);
-}
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-  return value !== value;
-}
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.enableHooks = exports.processHooks = exports.getHooks = exports.isHookObject = exports.convertHookData = exports.makeArguments = exports.defaultMakeArguments = exports.createHookObject = exports.ACTIVATE_HOOKS = void 0;
 
-function EventEmitter() {
-  EventEmitter.init.call(this);
-}
-module.exports = EventEmitter;
-module.exports.once = once;
+var utils_1 = __webpack_require__(/*! ./utils */ "../commons/lib/utils.js");
 
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+var _utils_1$_ = utils_1._,
+    each = _utils_1$_.each,
+    pick = _utils_1$_.pick;
+exports.ACTIVATE_HOOKS = (0, utils_1.createSymbol)('__feathersActivateHooks');
 
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._eventsCount = 0;
-EventEmitter.prototype._maxListeners = undefined;
+function createHookObject(method) {
+  var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var hook = {};
+  Object.defineProperty(hook, 'toJSON', {
+    value: function value() {
+      return pick(this, 'type', 'method', 'path', 'params', 'id', 'data', 'result', 'error');
+    }
+  });
+  return Object.assign(hook, data, {
+    method: method,
 
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
+    // A dynamic getter that returns the path of the service
+    get path() {
+      var app = data.app,
+          service = data.service;
 
-function checkListener(listener) {
-  if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-  }
-}
+      if (!service || !app || !app.services) {
+        return null;
+      }
 
-Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-  enumerable: true,
-  get: function() {
-    return defaultMaxListeners;
-  },
-  set: function(arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+      return Object.keys(app.services).find(function (path) {
+        return app.services[path] === service;
+      });
     }
-    defaultMaxListeners = arg;
-  }
-});
 
-EventEmitter.init = function() {
+  });
+}
 
-  if (this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
-    this._events = Object.create(null);
-    this._eventsCount = 0;
-  }
+exports.createHookObject = createHookObject; // Fallback used by `makeArguments` which usually won't be used
 
-  this._maxListeners = this._maxListeners || undefined;
-};
+function defaultMakeArguments(hook) {
+  var result = [];
 
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  if (typeof hook.id !== 'undefined') {
+    result.push(hook.id);
   }
-  this._maxListeners = n;
-  return this;
-};
 
-function _getMaxListeners(that) {
-  if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
+  if (hook.data) {
+    result.push(hook.data);
+  }
+
+  result.push(hook.params || {});
+  return result;
 }
 
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return _getMaxListeners(this);
-};
+exports.defaultMakeArguments = defaultMakeArguments; // Turns a hook object back into a list of arguments
+// to call a service method with
 
-EventEmitter.prototype.emit = function emit(type) {
-  var args = [];
-  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = (type === 'error');
+function makeArguments(hook) {
+  switch (hook.method) {
+    case 'find':
+      return [hook.params];
 
-  var events = this._events;
-  if (events !== undefined)
-    doError = (doError && events.error === undefined);
-  else if (!doError)
-    return false;
+    case 'get':
+    case 'remove':
+      return [hook.id, hook.params];
 
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    var er;
-    if (args.length > 0)
-      er = args[0];
-    if (er instanceof Error) {
-      // Note: The comments on the `throw` lines are intentional, they show
-      // up in Node's output if this results in an unhandled exception.
-      throw er; // Unhandled 'error' event
-    }
-    // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
-    err.context = er;
-    throw err; // Unhandled 'error' event
+    case 'update':
+    case 'patch':
+      return [hook.id, hook.data, hook.params];
+
+    case 'create':
+      return [hook.data, hook.params];
   }
 
-  var handler = events[type];
+  return defaultMakeArguments(hook);
+}
 
-  if (handler === undefined)
-    return false;
+exports.makeArguments = makeArguments; // Converts different hook registration formats into the
+// same internal format
 
-  if (typeof handler === 'function') {
-    ReflectApply(handler, this, args);
-  } else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      ReflectApply(listeners[i], this, args);
-  }
+function convertHookData(obj) {
+  var hook = {};
 
-  return true;
-};
+  if (Array.isArray(obj)) {
+    hook = {
+      all: obj
+    };
+  } else if (_typeof(obj) !== 'object') {
+    hook = {
+      all: [obj]
+    };
+  } else {
+    each(obj, function (value, key) {
+      hook[key] = !Array.isArray(value) ? [value] : value;
+    });
+  }
 
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
+  return hook;
+}
 
-  checkListener(listener);
+exports.convertHookData = convertHookData; // Duck-checks a given object to be a hook object
+// A valid hook object has `type` and `method`
 
-  events = target._events;
-  if (events === undefined) {
-    events = target._events = Object.create(null);
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener !== undefined) {
-      target.emit('newListener', type,
-                  listener.listener ? listener.listener : listener);
+function isHookObject(hookObject) {
+  return _typeof(hookObject) === 'object' && typeof hookObject.method === 'string' && typeof hookObject.type === 'string';
+}
 
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
-    }
-    existing = events[type];
-  }
+exports.isHookObject = isHookObject; // Returns all service and application hooks combined
+// for a given method and type `appLast` sets if the hooks
+// from `app` should be added last (or first by default)
 
-  if (existing === undefined) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] =
-        prepend ? [listener, existing] : [existing, listener];
-      // If we've already got an array, just append.
-    } else if (prepend) {
-      existing.unshift(listener);
-    } else {
-      existing.push(listener);
-    }
+function getHooks(app, service, type, method) {
+  var appLast = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var appHooks = app.__hooks[type][method] || [];
+  var serviceHooks = service.__hooks[type][method] || [];
 
-    // Check for listener leak
-    m = _getMaxListeners(target);
-    if (m > 0 && existing.length > m && !existing.warned) {
-      existing.warned = true;
-      // No error code for this since it is a Warning
-      // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' +
-                          existing.length + ' ' + String(type) + ' listeners ' +
-                          'added. Use emitter.setMaxListeners() to ' +
-                          'increase limit');
-      w.name = 'MaxListenersExceededWarning';
-      w.emitter = target;
-      w.type = type;
-      w.count = existing.length;
-      ProcessEmitWarning(w);
-    }
+  if (appLast) {
+    // Run hooks in the order of service -> app -> finally
+    return serviceHooks.concat(appHooks);
   }
 
-  return target;
+  return appHooks.concat(serviceHooks);
 }
 
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+exports.getHooks = getHooks;
 
-EventEmitter.prototype.prependListener =
-    function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
-    };
+function processHooks(hooks, initialHookObject) {
+  var _this = this;
 
-function onceWrapper() {
-  if (!this.fired) {
-    this.target.removeListener(this.type, this.wrapFn);
-    this.fired = true;
-    if (arguments.length === 0)
-      return this.listener.call(this.target);
-    return this.listener.apply(this.target, arguments);
-  }
-}
+  var hookObject = initialHookObject;
 
-function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-  var wrapped = onceWrapper.bind(state);
-  wrapped.listener = listener;
-  state.wrapFn = wrapped;
-  return wrapped;
-}
+  var updateCurrentHook = function updateCurrentHook(current) {
+    // Either use the returned hook object or the current
+    // hook object from the chain if the hook returned undefined
+    if (current) {
+      if (!isHookObject(current)) {
+        throw new Error("".concat(hookObject.type, " hook for '").concat(hookObject.method, "' method returned invalid hook object"));
+      }
 
-EventEmitter.prototype.once = function once(type, listener) {
-  checkListener(listener);
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
-};
+      hookObject = current;
+    }
 
-EventEmitter.prototype.prependOnceListener =
-    function prependOnceListener(type, listener) {
-      checkListener(listener);
-      this.prependListener(type, _onceWrap(this, type, listener));
-      return this;
-    };
+    return hookObject;
+  }; // Go through all hooks and chain them into our promise
 
-// Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
-    function removeListener(type, listener) {
-      var list, events, position, i, originalListener;
 
-      checkListener(listener);
+  var promise = hooks.reduce(function (current, fn) {
+    // @ts-ignore
+    var hook = fn.bind(_this); // Use the returned hook object or the old one
 
-      events = this._events;
-      if (events === undefined)
-        return this;
+    return current.then(function (currentHook) {
+      return hook(currentHook);
+    }).then(updateCurrentHook);
+  }, Promise.resolve(hookObject));
+  return promise.then(function () {
+    return hookObject;
+  }).catch(function (error) {
+    // Add the hook information to any errors
+    error.hook = hookObject;
+    throw error;
+  });
+}
 
-      list = events[type];
-      if (list === undefined)
-        return this;
+exports.processHooks = processHooks; // Add `.hooks` functionality to an object
 
-      if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
-          this._events = Object.create(null);
-        else {
-          delete events[type];
-          if (events.removeListener)
-            this.emit('removeListener', type, list.listener || listener);
-        }
-      } else if (typeof list !== 'function') {
-        position = -1;
+function enableHooks(obj, methods, types) {
+  if (typeof obj.hooks === 'function') {
+    return obj;
+  }
 
-        for (i = list.length - 1; i >= 0; i--) {
-          if (list[i] === listener || list[i].listener === listener) {
-            originalListener = list[i].listener;
-            position = i;
-            break;
-          }
-        }
+  var hookData = {};
+  types.forEach(function (type) {
+    // Initialize properties where hook functions are stored
+    hookData[type] = {};
+  }); // Add non-enumerable `__hooks` property to the object
 
-        if (position < 0)
-          return this;
+  Object.defineProperty(obj, '__hooks', {
+    configurable: true,
+    value: hookData,
+    writable: true
+  });
+  return Object.assign(obj, {
+    hooks: function hooks(allHooks) {
+      var _this2 = this;
 
-        if (position === 0)
-          list.shift();
-        else {
-          spliceOne(list, position);
+      each(allHooks, function (current, type) {
+        // @ts-ignore
+        if (!_this2.__hooks[type]) {
+          throw new Error("'".concat(type, "' is not a valid hook type"));
         }
 
-        if (list.length === 1)
-          events[type] = list[0];
+        var hooks = convertHookData(current);
+        each(hooks, function (_value, method) {
+          if (method !== 'all' && methods.indexOf(method) === -1) {
+            throw new Error("'".concat(method, "' is not a valid hook method"));
+          }
+        });
+        methods.forEach(function (method) {
+          // @ts-ignore
+          var myHooks = _this2.__hooks[type][method] || (_this2.__hooks[type][method] = []);
 
-        if (events.removeListener !== undefined)
-          this.emit('removeListener', type, originalListener || listener);
-      }
+          if (hooks.all) {
+            myHooks.push.apply(myHooks, hooks.all);
+          }
 
+          if (hooks[method]) {
+            myHooks.push.apply(myHooks, hooks[method]);
+          }
+        });
+      });
       return this;
-    };
+    }
+  });
+}
 
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+exports.enableHooks = enableHooks;
 
-EventEmitter.prototype.removeAllListeners =
-    function removeAllListeners(type) {
-      var listeners, events, i;
+/***/ }),
 
-      events = this._events;
-      if (events === undefined)
-        return this;
+/***/ "../commons/lib/index.js":
+/*!*******************************!*\
+  !*** ../commons/lib/index.js ***!
+  \*******************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-      // not listening for removeListener, no need to emit
-      if (events.removeListener === undefined) {
-        if (arguments.length === 0) {
-          this._events = Object.create(null);
-          this._eventsCount = 0;
-        } else if (events[type] !== undefined) {
-          if (--this._eventsCount === 0)
-            this._events = Object.create(null);
-          else
-            delete events[type];
-        }
-        return this;
-      }
+"use strict";
 
-      // emit removeListener for all listeners on all events
-      if (arguments.length === 0) {
-        var keys = Object.keys(events);
-        var key;
-        for (i = 0; i < keys.length; ++i) {
-          key = keys[i];
-          if (key === 'removeListener') continue;
-          this.removeAllListeners(key);
-        }
-        this.removeAllListeners('removeListener');
-        this._events = Object.create(null);
-        this._eventsCount = 0;
-        return this;
-      }
 
-      listeners = events[type];
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, {
+    enumerable: true,
+    get: function get() {
+      return m[k];
+    }
+  });
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
 
-      if (typeof listeners === 'function') {
-        this.removeListener(type, listeners);
-      } else if (listeners !== undefined) {
-        // LIFO order
-        for (i = listeners.length - 1; i >= 0; i--) {
-          this.removeListener(type, listeners[i]);
-        }
-      }
+var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
 
-      return this;
-    };
+var __importStar = this && this.__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) {
+    if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  }
 
-function _listeners(target, type, unwrap) {
-  var events = target._events;
+  __setModuleDefault(result, mod);
 
-  if (events === undefined)
-    return [];
+  return result;
+};
 
-  var evlistener = events[type];
-  if (evlistener === undefined)
-    return [];
+var __exportStar = this && this.__exportStar || function (m, exports) {
+  for (var p in m) {
+    if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  }
+};
 
-  if (typeof evlistener === 'function')
-    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.hooks = void 0;
 
-  return unwrap ?
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-}
+var hookUtils = __importStar(__webpack_require__(/*! ./hooks */ "../commons/lib/hooks.js"));
 
-EventEmitter.prototype.listeners = function listeners(type) {
-  return _listeners(this, type, true);
-};
+__exportStar(__webpack_require__(/*! ./utils */ "../commons/lib/utils.js"), exports);
 
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
-  return _listeners(this, type, false);
-};
+exports.hooks = hookUtils;
 
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
-  }
-};
+/***/ }),
 
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
+/***/ "../commons/lib/utils.js":
+/*!*******************************!*\
+  !*** ../commons/lib/utils.js ***!
+  \*******************************/
+/***/ (function(__unused_webpack_module, exports) {
 
-  if (events !== undefined) {
-    var evlistener = events[type];
+"use strict";
 
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener !== undefined) {
-      return evlistener.length;
-    }
-  }
 
-  return 0;
-}
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-};
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
-function arrayClone(arr, n) {
-  var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
-    copy[i] = arr[i];
-  return copy;
-}
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++)
-    list[index] = list[index + 1];
-  list.pop();
-}
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
-  }
-  return ret;
-}
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-function once(emitter, name) {
-  return new Promise(function (resolve, reject) {
-    function eventListener() {
-      if (errorListener !== undefined) {
-        emitter.removeListener('error', errorListener);
-      }
-      resolve([].slice.call(arguments));
-    };
-    var errorListener;
-
-    // Adding an error listener is not optional because
-    // if an error is thrown on an event emitter we cannot
-    // guarantee that the actual event we are waiting will
-    // be fired. The result could be a silent way to create
-    // memory or file descriptor leaks, which is something
-    // we should avoid.
-    if (name !== 'error') {
-      errorListener = function errorListener(err) {
-        emitter.removeListener(name, eventListener);
-        reject(err);
-      };
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-      emitter.once('error', errorListener);
-    }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
-    emitter.once(name, eventListener);
-  });
-}
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.createSymbol = exports.makeUrl = exports.isPromise = exports._ = exports.stripSlashes = void 0; // Removes all leading and trailing slashes from a path
 
-/***/ }),
+function stripSlashes(name) {
+  return name.replace(/^(\/+)|(\/+)$/g, '');
+}
 
-/***/ "../../node_modules/ms/index.js":
-/*!*****************************************************************************!*\
-  !*** /Users/daffl/Development/feathersjs/feathers/node_modules/ms/index.js ***!
-  \*****************************************************************************/
-/*! no static exports found */
-/***/ (function(module, exports) {
+exports.stripSlashes = stripSlashes; // A set of lodash-y utility functions that use ES6
 
-/**
- * Helpers.
- */
+exports._ = {
+  each: function each(obj, callback) {
+    if (obj && typeof obj.forEach === 'function') {
+      obj.forEach(callback);
+    } else if (exports._.isObject(obj)) {
+      Object.keys(obj).forEach(function (key) {
+        return callback(obj[key], key);
+      });
+    }
+  },
+  some: function some(value, callback) {
+    return Object.keys(value).map(function (key) {
+      return [value[key], key];
+    }).some(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          val = _ref2[0],
+          key = _ref2[1];
 
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var w = d * 7;
-var y = d * 365.25;
+      return callback(val, key);
+    });
+  },
+  every: function every(value, callback) {
+    return Object.keys(value).map(function (key) {
+      return [value[key], key];
+    }).every(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+          val = _ref4[0],
+          key = _ref4[1];
 
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- *  - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} [options]
- * @throws {Error} throw an error if val is not a non-empty string or a number
- * @return {String|Number}
- * @api public
- */
+      return callback(val, key);
+    });
+  },
+  keys: function keys(obj) {
+    return Object.keys(obj);
+  },
+  values: function values(obj) {
+    return exports._.keys(obj).map(function (key) {
+      return obj[key];
+    });
+  },
+  isMatch: function isMatch(obj, item) {
+    return exports._.keys(item).every(function (key) {
+      return obj[key] === item[key];
+    });
+  },
+  isEmpty: function isEmpty(obj) {
+    return exports._.keys(obj).length === 0;
+  },
+  isObject: function isObject(item) {
+    return _typeof(item) === 'object' && !Array.isArray(item) && item !== null;
+  },
+  isObjectOrArray: function isObjectOrArray(value) {
+    return _typeof(value) === 'object' && value !== null;
+  },
+  extend: function extend(first) {
+    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      rest[_key - 1] = arguments[_key];
+    }
 
-module.exports = function(val, options) {
-  options = options || {};
-  var type = typeof val;
-  if (type === 'string' && val.length > 0) {
-    return parse(val);
-  } else if (type === 'number' && isFinite(val)) {
-    return options.long ? fmtLong(val) : fmtShort(val);
-  }
-  throw new Error(
-    'val is not a non-empty string or a valid number. val=' +
-      JSON.stringify(val)
-  );
-};
+    return Object.assign.apply(Object, [first].concat(rest));
+  },
+  omit: function omit(obj) {
+    var result = exports._.extend({}, obj);
 
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
-
-function parse(str) {
-  str = String(str);
-  if (str.length > 100) {
-    return;
-  }
-  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-    str
-  );
-  if (!match) {
-    return;
-  }
-  var n = parseFloat(match[1]);
-  var type = (match[2] || 'ms').toLowerCase();
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'yrs':
-    case 'yr':
-    case 'y':
-      return n * y;
-    case 'weeks':
-    case 'week':
-    case 'w':
-      return n * w;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'hrs':
-    case 'hr':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'mins':
-    case 'min':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 'secs':
-    case 'sec':
-    case 's':
-      return n * s;
-    case 'milliseconds':
-    case 'millisecond':
-    case 'msecs':
-    case 'msec':
-    case 'ms':
-      return n;
-    default:
-      return undefined;
-  }
-}
-
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function fmtShort(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return Math.round(ms / d) + 'd';
-  }
-  if (msAbs >= h) {
-    return Math.round(ms / h) + 'h';
-  }
-  if (msAbs >= m) {
-    return Math.round(ms / m) + 'm';
-  }
-  if (msAbs >= s) {
-    return Math.round(ms / s) + 's';
-  }
-  return ms + 'ms';
-}
-
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
-
-function fmtLong(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return plural(ms, msAbs, d, 'day');
-  }
-  if (msAbs >= h) {
-    return plural(ms, msAbs, h, 'hour');
-  }
-  if (msAbs >= m) {
-    return plural(ms, msAbs, m, 'minute');
-  }
-  if (msAbs >= s) {
-    return plural(ms, msAbs, s, 'second');
-  }
-  return ms + ' ms';
-}
-
-/**
- * Pluralization helper.
- */
-
-function plural(ms, msAbs, n, name) {
-  var isPlural = msAbs >= n * 1.5;
-  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
-}
-
-
-/***/ }),
-
-/***/ "../../node_modules/process/browser.js":
-/*!************************************************************************************!*\
-  !*** /Users/daffl/Development/feathersjs/feathers/node_modules/process/browser.js ***!
-  \************************************************************************************/
-/*! no static exports found */
-/***/ (function(module, exports) {
+    for (var _len2 = arguments.length, keys = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      keys[_key2 - 1] = arguments[_key2];
+    }
 
-// shim for using process in browser
-var process = module.exports = {};
+    keys.forEach(function (key) {
+      return delete result[key];
+    });
+    return result;
+  },
+  pick: function pick(source) {
+    for (var _len3 = arguments.length, keys = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      keys[_key3 - 1] = arguments[_key3];
+    }
 
-// cached from whatever global is present so that test runners that stub it
-// don't break things.  But we need to wrap it in a try catch in case it is
-// wrapped in strict mode code which doesn't define any globals.  It's inside a
-// function because try/catches deoptimize in certain engines.
+    return keys.reduce(function (result, key) {
+      if (source[key] !== undefined) {
+        result[key] = source[key];
+      }
 
-var cachedSetTimeout;
-var cachedClearTimeout;
+      return result;
+    }, {});
+  },
+  // Recursively merge the source object into the target object
+  merge: function merge(target, source) {
+    if (exports._.isObject(target) && exports._.isObject(source)) {
+      Object.keys(source).forEach(function (key) {
+        if (exports._.isObject(source[key])) {
+          if (!target[key]) {
+            Object.assign(target, _defineProperty({}, key, {}));
+          }
 
-function defaultSetTimout() {
-    throw new Error('setTimeout has not been defined');
-}
-function defaultClearTimeout () {
-    throw new Error('clearTimeout has not been defined');
-}
-(function () {
-    try {
-        if (typeof setTimeout === 'function') {
-            cachedSetTimeout = setTimeout;
-        } else {
-            cachedSetTimeout = defaultSetTimout;
-        }
-    } catch (e) {
-        cachedSetTimeout = defaultSetTimout;
-    }
-    try {
-        if (typeof clearTimeout === 'function') {
-            cachedClearTimeout = clearTimeout;
+          exports._.merge(target[key], source[key]);
         } else {
-            cachedClearTimeout = defaultClearTimeout;
-        }
-    } catch (e) {
-        cachedClearTimeout = defaultClearTimeout;
-    }
-} ())
-function runTimeout(fun) {
-    if (cachedSetTimeout === setTimeout) {
-        //normal enviroments in sane situations
-        return setTimeout(fun, 0);
-    }
-    // if setTimeout wasn't available but was latter defined
-    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-        cachedSetTimeout = setTimeout;
-        return setTimeout(fun, 0);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedSetTimeout(fun, 0);
-    } catch(e){
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
-            return cachedSetTimeout.call(null, fun, 0);
-        } catch(e){
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
-            return cachedSetTimeout.call(this, fun, 0);
-        }
-    }
-
-
-}
-function runClearTimeout(marker) {
-    if (cachedClearTimeout === clearTimeout) {
-        //normal enviroments in sane situations
-        return clearTimeout(marker);
-    }
-    // if clearTimeout wasn't available but was latter defined
-    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-        cachedClearTimeout = clearTimeout;
-        return clearTimeout(marker);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedClearTimeout(marker);
-    } catch (e){
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
-            return cachedClearTimeout.call(null, marker);
-        } catch (e){
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
-            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
-            return cachedClearTimeout.call(this, marker);
+          Object.assign(target, _defineProperty({}, key, source[key]));
         }
+      });
     }
 
+    return target;
+  }
+}; // Duck-checks if an object looks like a promise
 
-
+function isPromise(result) {
+  return exports._.isObject(result) && typeof result.then === 'function';
 }
-var queue = [];
-var draining = false;
-var currentQueue;
-var queueIndex = -1;
 
-function cleanUpNextTick() {
-    if (!draining || !currentQueue) {
-        return;
-    }
-    draining = false;
-    if (currentQueue.length) {
-        queue = currentQueue.concat(queue);
-    } else {
-        queueIndex = -1;
-    }
-    if (queue.length) {
-        drainQueue();
-    }
-}
+exports.isPromise = isPromise;
 
-function drainQueue() {
-    if (draining) {
-        return;
-    }
-    var timeout = runTimeout(cleanUpNextTick);
-    draining = true;
-
-    var len = queue.length;
-    while(len) {
-        currentQueue = queue;
-        queue = [];
-        while (++queueIndex < len) {
-            if (currentQueue) {
-                currentQueue[queueIndex].run();
-            }
-        }
-        queueIndex = -1;
-        len = queue.length;
-    }
-    currentQueue = null;
-    draining = false;
-    runClearTimeout(timeout);
+function makeUrl(path) {
+  var app = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var get = typeof app.get === 'function' ? app.get.bind(app) : function () {};
+  var env = get('env') || "development";
+  var host = get('host') || process.env.HOST_NAME || 'localhost';
+  var protocol = env === 'development' || env === 'test' || env === undefined ? 'http' : 'https';
+  var PORT = get('port') || process.env.PORT || 3030;
+  var port = env === 'development' || env === 'test' || env === undefined ? ":".concat(PORT) : '';
+  path = path || '';
+  return "".concat(protocol, "://").concat(host).concat(port, "/").concat(exports.stripSlashes(path));
 }
 
-process.nextTick = function (fun) {
-    var args = new Array(arguments.length - 1);
-    if (arguments.length > 1) {
-        for (var i = 1; i < arguments.length; i++) {
-            args[i - 1] = arguments[i];
-        }
-    }
-    queue.push(new Item(fun, args));
-    if (queue.length === 1 && !draining) {
-        runTimeout(drainQueue);
-    }
-};
+exports.makeUrl = makeUrl;
 
-// v8 likes predictible objects
-function Item(fun, array) {
-    this.fun = fun;
-    this.array = array;
+function createSymbol(name) {
+  return typeof Symbol !== 'undefined' ? Symbol(name) : name;
 }
-Item.prototype.run = function () {
-    this.fun.apply(null, this.array);
-};
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-process.versions = {};
-
-function noop() {}
-
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-process.prependListener = noop;
-process.prependOnceListener = noop;
-
-process.listeners = function (name) { return [] }
-
-process.binding = function (name) {
-    throw new Error('process.binding is not supported');
-};
-
-process.cwd = function () { return '/' };
-process.chdir = function (dir) {
-    throw new Error('process.chdir is not supported');
-};
-process.umask = function() { return 0; };
 
+exports.createSymbol = createSymbol;
 
 /***/ }),
 
-/***/ "../../node_modules/uberproto/lib/proto.js":
-/*!****************************************************************************************!*\
-  !*** /Users/daffl/Development/feathersjs/feathers/node_modules/uberproto/lib/proto.js ***!
-  \****************************************************************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/***/ "../feathers/lib/application.js":
+/*!**************************************!*\
+  !*** ../feathers/lib/application.js ***!
+  \**************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* global define */
-/**
- * Uberproto
- *
- * A base object for ECMAScript 5 style prototypal inheritance.
- *
- * @see https://github.com/rauschma/proto-js/
- * @see http://ejohn.org/blog/simple-javascript-inheritance/
- * @see http://uxebu.com/blog/2011/02/23/object-based-inheritance-for-ecmascript-5/
- */
-(function (root, factory) {
-  if (true) {
-    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
-				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
-				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  } else {}
-}(this, function () {
-  var HAS_SYMBOLS = typeof Object.getOwnPropertySymbols === 'function';
+var debug = __webpack_require__(/*! debug */ "../../node_modules/debug/src/browser.js")('feathers:application');
 
-  function makeSuper (_super, old, name, fn) {
-    var isFunction = typeof old === 'function';
-    var newMethod = function () {
-      var tmp = this._super;
+var _require = __webpack_require__(/*! @feathersjs/commons */ "../commons/lib/index.js"),
+    stripSlashes = _require.stripSlashes;
 
-      // Add a new ._super() method that is the same method
-      // but either pointing to the prototype method
-      // or to the overwritten method
-      this._super = isFunction ? old : _super[name];
+var Uberproto = __webpack_require__(/*! uberproto */ "../../node_modules/uberproto/lib/proto.js");
 
-      // The method only need to be bound temporarily, so we
-      // remove it when we're done executing
-      var ret = fn.apply(this, arguments);
+var events = __webpack_require__(/*! ./events */ "../feathers/lib/events.js");
 
-      this._super = tmp;
+var hooks = __webpack_require__(/*! ./hooks */ "../feathers/lib/hooks/index.js");
 
-      return ret;
-    };
+var version = __webpack_require__(/*! ./version */ "../feathers/lib/version.js");
 
-    if (isFunction) {
-      Object.keys(old).forEach(function (name) {
-        newMethod[name] = old[name];
-      });
+var Proto = Uberproto.extend({
+  create: null
+});
+var application = {
+  init: function init() {
+    Object.assign(this, {
+      version: version,
+      methods: ['find', 'get', 'create', 'update', 'patch', 'remove'],
+      mixins: [],
+      services: {},
+      providers: [],
+      _setup: false,
+      settings: {}
+    });
+    this.configure(hooks());
+    this.configure(events());
+  },
+  get: function get(name) {
+    return this.settings[name];
+  },
+  set: function set(name, value) {
+    this.settings[name] = value;
+    return this;
+  },
+  disable: function disable(name) {
+    this.settings[name] = false;
+    return this;
+  },
+  disabled: function disabled(name) {
+    return !this.settings[name];
+  },
+  enable: function enable(name) {
+    this.settings[name] = true;
+    return this;
+  },
+  enabled: function enabled(name) {
+    return !!this.settings[name];
+  },
+  configure: function configure(fn) {
+    fn.call(this, this);
+    return this;
+  },
+  service: function service(path, _service) {
+    if (typeof _service !== 'undefined') {
+      throw new Error('Registering a new service with `app.service(path, service)` is no longer supported. Use `app.use(path, service)` instead.');
+    }
 
-      if (HAS_SYMBOLS) {
-        Object.getOwnPropertySymbols(old).forEach(function (name) {
-          newMethod[name] = old[name];
-        });
-      }
+    var location = stripSlashes(path) || '/';
+    var current = this.services[location];
+
+    if (typeof current === 'undefined' && typeof this.defaultService === 'function') {
+      return this.use(location, this.defaultService(location)).service(location);
     }
 
-    return newMethod;
-  }
+    return current;
+  },
+  use: function use(path, service) {
+    var _this = this;
 
-  return {
-    /**
-     * Create a new object using Object.create. The arguments will be
-     * passed to the new instances init method or to a method name set in
-     * __init.
-     */
-    create: function () {
-      var instance = Object.create(this);
-      var init = typeof instance.__init === 'string' ? instance.__init : 'init';
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
-      if (typeof instance[init] === 'function') {
-        instance[init].apply(instance, arguments);
-      }
-      return instance;
-    },
-    /**
-     * Mixin a given set of properties
-     * @param prop The properties to mix in
-     * @param obj [optional]
-     * The object to add the mixin
-     */
-    mixin: function (prop, obj) {
-      var self = obj || this;
-      var fnTest = /\b_super\b/;
-      var _super = Object.getPrototypeOf(self) || self.prototype;
-      var descriptors = {};
-      var proto = prop;
-      var processProperty = function (name) {
-        var descriptor = Object.getOwnPropertyDescriptor(proto, name);
+    if (typeof path !== 'string') {
+      throw new Error("'".concat(path, "' is not a valid service path."));
+    }
 
-        if (!descriptors[name] && descriptor) {
-          descriptors[name] = descriptor;
-        }
-      };
+    var location = stripSlashes(path) || '/';
+    var isSubApp = typeof service.service === 'function' && service.services;
+    var isService = this.methods.concat('setup').some(function (name) {
+      return typeof service[name] === 'function';
+    });
 
-      // Collect all property descriptors
-      do {
-        Object.getOwnPropertyNames(proto).forEach(processProperty);
+    if (isSubApp) {
+      var subApp = service;
+      Object.keys(subApp.services).forEach(function (subPath) {
+        return _this.use("".concat(location, "/").concat(subPath), subApp.service(subPath));
+      });
+      return this;
+    }
 
-        if (HAS_SYMBOLS) {
-          Object.getOwnPropertySymbols(proto).forEach(processProperty);
-        }
-      } while ((proto = Object.getPrototypeOf(proto)) && Object.getPrototypeOf(proto));
+    if (!isService) {
+      throw new Error("Invalid service object passed for path `".concat(location, "`"));
+    } // If the service is already Uberproto'd use it directly
 
-      var processDescriptor = function (name) {
-        var descriptor = descriptors[name];
 
-        if (typeof descriptor.value === 'function' && fnTest.test(descriptor.value)) {
-          descriptor.value = makeSuper(_super, self[name], name, descriptor.value);
-        }
+    var protoService = Proto.isPrototypeOf(service) ? service : Proto.extend(service);
+    debug("Registering new service at `".concat(location, "`")); // Add all the mixins
 
-        Object.defineProperty(self, name, descriptor);
-      };
+    this.mixins.forEach(function (fn) {
+      return fn.call(_this, protoService, location, options);
+    });
 
-      Object.keys(descriptors).forEach(processDescriptor);
+    if (typeof protoService._setup === 'function') {
+      protoService._setup(this, location);
+    } // Run the provider functions to register the service
 
-      if (HAS_SYMBOLS) {
-        Object.getOwnPropertySymbols(descriptors).forEach(processDescriptor);
-      }
 
-      return self;
-    },
-    /**
-     * Extend the current or a given object with the given property and return the extended object.
-     * @param prop The properties to extend with
-     * @param obj [optional] The object to extend from
-     * @returns The extended object
-     */
-    extend: function (prop, obj) {
-      return this.mixin(prop, Object.create(obj || this));
-    },
-    /**
-     * Return a callback function with this set to the current or a given context object.
-     * @param name Name of the method to proxy
-     * @param args... [optional] Arguments to use for partial application
-     */
-    proxy: function (name) {
-      var fn = this[name];
-      var args = Array.prototype.slice.call(arguments, 1);
+    this.providers.forEach(function (provider) {
+      return provider.call(_this, protoService, location, options);
+    }); // If we ran setup already, set this service up explicitly
 
-      args.unshift(this);
-      return fn.bind.apply(fn, args);
+    if (this._isSetup && typeof protoService.setup === 'function') {
+      debug("Setting up service for `".concat(location, "`"));
+      protoService.setup(this, location);
     }
-  };
-}));
 
+    this.services[location] = protoService;
+    return this;
+  },
+  setup: function setup() {
+    var _this2 = this;
+
+    // Setup each service (pass the app so that they can look up other services etc.)
+    Object.keys(this.services).forEach(function (path) {
+      var service = _this2.services[path];
+      debug("Setting up service for `".concat(path, "`"));
+
+      if (typeof service.setup === 'function') {
+        service.setup(_this2, path);
+      }
+    });
+    this._isSetup = true;
+    return this;
+  }
+};
+module.exports = application;
 
 /***/ }),
 
-/***/ "../commons/lib/hooks.js":
-/*!*******************************!*\
-  !*** ../commons/lib/hooks.js ***!
-  \*******************************/
-/*! no static exports found */
+/***/ "../feathers/lib/events.js":
+/*!*********************************!*\
+  !*** ../feathers/lib/events.js ***!
+  \*********************************/
 /***/ (function(module, exports, __webpack_require__) {
 
-"use strict";
+var _require = __webpack_require__(/*! events */ "../../node_modules/events/events.js"),
+    EventEmitter = _require.EventEmitter;
 
+var Proto = __webpack_require__(/*! uberproto */ "../../node_modules/uberproto/lib/proto.js"); // Returns a hook that emits service events. Should always be
+// used as the very last hook in the chain
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.enableHooks = exports.processHooks = exports.getHooks = exports.isHookObject = exports.convertHookData = exports.makeArguments = exports.defaultMakeArguments = exports.createHookObject = exports.ACTIVATE_HOOKS = void 0;
+var eventHook = exports.eventHook = function eventHook() {
+  return function (hook) {
+    var app = hook.app,
+        service = hook.service;
+    var eventName = hook.event === null ? hook.event : app.eventMappings[hook.method];
+    var isHookEvent = service._hookEvents && service._hookEvents.indexOf(eventName) !== -1; // If this event is not being sent yet and we are not in an error hook
 
-var utils_1 = __webpack_require__(/*! ./utils */ "../commons/lib/utils.js");
+    if (eventName && isHookEvent && hook.type !== 'error') {
+      var results = Array.isArray(hook.result) ? hook.result : [hook.result];
+      results.forEach(function (element) {
+        return service.emit(eventName, element, hook);
+      });
+    }
+  };
+}; // Mixin that turns a service into a Node event emitter
 
-var _utils_1$_ = utils_1._,
-    each = _utils_1$_.each,
-    pick = _utils_1$_.pick;
-exports.ACTIVATE_HOOKS = utils_1.createSymbol('__feathersActivateHooks');
 
-function createHookObject(method) {
-  var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var hook = {};
-  Object.defineProperty(hook, 'toJSON', {
-    value: function value() {
-      return pick(this, 'type', 'method', 'path', 'params', 'id', 'data', 'result', 'error');
-    }
-  });
-  return Object.assign(hook, data, {
-    method: method,
+var eventMixin = exports.eventMixin = function eventMixin(service) {
+  if (service._serviceEvents) {
+    return;
+  }
 
-    // A dynamic getter that returns the path of the service
-    get path() {
-      var app = data.app,
-          service = data.service;
+  var app = this; // Indicates if the service is already an event emitter
 
-      if (!service || !app || !app.services) {
-        return null;
-      }
+  var isEmitter = typeof service.on === 'function' && typeof service.emit === 'function'; // If not, mix it in (the service is always an Uberproto object that has a .mixin)
 
-      return Object.keys(app.services).find(function (path) {
-        return app.services[path] === service;
-      });
-    }
+  if (typeof service.mixin === 'function' && !isEmitter) {
+    service.mixin(EventEmitter.prototype);
+  } // Define non-enumerable properties of
 
-  });
-}
 
-exports.createHookObject = createHookObject; // Fallback used by `makeArguments` which usually won't be used
+  Object.defineProperties(service, {
+    // A list of all events that this service sends
+    _serviceEvents: {
+      value: Array.isArray(service.events) ? service.events.slice() : []
+    },
+    // A list of events that should be handled through the event hooks
+    _hookEvents: {
+      value: []
+    }
+  }); // `app.eventMappings` has the mapping from method name to event name
 
-function defaultMakeArguments(hook) {
-  var result = [];
+  Object.keys(app.eventMappings).forEach(function (method) {
+    var event = app.eventMappings[method];
+    var alreadyEmits = service._serviceEvents.indexOf(event) !== -1; // Add events for known methods to _serviceEvents and _hookEvents
+    // if the service indicated it does not send it itself yet
 
-  if (typeof hook.id !== 'undefined') {
-    result.push(hook.id);
-  }
+    if (typeof service[method] === 'function' && !alreadyEmits) {
+      service._serviceEvents.push(event);
 
-  if (hook.data) {
-    result.push(hook.data);
-  }
+      service._hookEvents.push(event);
+    }
+  });
+};
 
-  result.push(hook.params || {});
-  return result;
-}
+module.exports = function () {
+  return function (app) {
+    // Mappings from service method to event name
+    Object.assign(app, {
+      eventMappings: {
+        create: 'created',
+        update: 'updated',
+        remove: 'removed',
+        patch: 'patched'
+      }
+    }); // Register the event hook
+    // `finally` hooks always run last after `error` and `after` hooks
 
-exports.defaultMakeArguments = defaultMakeArguments; // Turns a hook object back into a list of arguments
-// to call a service method with
+    app.hooks({
+      finally: eventHook()
+    }); // Make the app an event emitter
 
-function makeArguments(hook) {
-  switch (hook.method) {
-    case 'find':
-      return [hook.params];
+    Proto.mixin(EventEmitter.prototype, app);
+    app.mixins.push(eventMixin);
+  };
+};
 
-    case 'get':
-    case 'remove':
-      return [hook.id, hook.params];
+/***/ }),
 
-    case 'update':
-    case 'patch':
-      return [hook.id, hook.data, hook.params];
+/***/ "../feathers/lib/hooks/base.js":
+/*!*************************************!*\
+  !*** ../feathers/lib/hooks/base.js ***!
+  \*************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    case 'create':
-      return [hook.data, hook.params];
-  }
+var _require = __webpack_require__(/*! @feathersjs/commons */ "../commons/lib/index.js"),
+    _ = _require._;
 
-  return defaultMakeArguments(hook);
-}
+var assignArguments = function assignArguments(context) {
+  var service = context.service,
+      method = context.method;
+  var parameters = service.methods[method];
+  context.arguments.forEach(function (value, index) {
+    context[parameters[index]] = value;
+  });
 
-exports.makeArguments = makeArguments; // Converts different hook registration formats into the
-// same internal format
+  if (!context.params) {
+    context.params = {};
+  }
 
-function convertHookData(obj) {
-  var hook = {};
+  return context;
+};
 
-  if (Array.isArray(obj)) {
-    hook = {
-      all: obj
-    };
-  } else if (_typeof(obj) !== 'object') {
-    hook = {
-      all: [obj]
-    };
-  } else {
-    each(obj, function (value, key) {
-      hook[key] = !Array.isArray(value) ? [value] : value;
-    });
-  }
+var validate = function validate(context) {
+  var service = context.service,
+      method = context.method,
+      path = context.path;
+  var parameters = service.methods[method];
 
-  return hook;
-}
+  if (parameters.includes('id') && context.id === undefined) {
+    throw new Error("An id must be provided to the '".concat(path, ".").concat(method, "' method"));
+  }
 
-exports.convertHookData = convertHookData; // Duck-checks a given object to be a hook object
-// A valid hook object has `type` and `method`
+  if (parameters.includes('data') && !_.isObjectOrArray(context.data)) {
+    throw new Error("A data object must be provided to the '".concat(path, ".").concat(method, "' method"));
+  }
 
-function isHookObject(hookObject) {
-  return _typeof(hookObject) === 'object' && typeof hookObject.method === 'string' && typeof hookObject.type === 'string';
-}
+  return context;
+};
 
-exports.isHookObject = isHookObject; // Returns all service and application hooks combined
-// for a given method and type `appLast` sets if the hooks
-// from `app` should be added last (or first by default)
+module.exports = [assignArguments, validate];
 
-function getHooks(app, service, type, method) {
-  var appLast = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-  var appHooks = app.__hooks[type][method] || [];
-  var serviceHooks = service.__hooks[type][method] || [];
+/***/ }),
 
-  if (appLast) {
-    // Run hooks in the order of service -> app -> finally
-    return serviceHooks.concat(appHooks);
-  }
+/***/ "../feathers/lib/hooks/index.js":
+/*!**************************************!*\
+  !*** ../feathers/lib/hooks/index.js ***!
+  \**************************************/
+/***/ (function(module, exports, __webpack_require__) {
 
-  return appHooks.concat(serviceHooks);
-}
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
-exports.getHooks = getHooks;
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-function processHooks(hooks, initialHookObject) {
-  var _this = this;
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-  var hookObject = initialHookObject;
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 
-  var updateCurrentHook = function updateCurrentHook(current) {
-    // Either use the returned hook object or the current
-    // hook object from the chain if the hook returned undefined
-    if (current) {
-      if (!isHookObject(current)) {
-        throw new Error("".concat(hookObject.type, " hook for '").concat(hookObject.method, "' method returned invalid hook object"));
-      }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-      hookObject = current;
-    }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-    return hookObject;
-  }; // Go through all hooks and chain them into our promise
+var _require = __webpack_require__(/*! @feathersjs/commons */ "../commons/lib/index.js"),
+    hooks = _require.hooks,
+    isPromise = _require.isPromise;
 
+var baseHooks = __webpack_require__(/*! ./base */ "../feathers/lib/hooks/base.js");
 
-  var promise = hooks.reduce(function (current, fn) {
-    // @ts-ignore
-    var hook = fn.bind(_this); // Use the returned hook object or the old one
+var createHookObject = hooks.createHookObject,
+    getHooks = hooks.getHooks,
+    processHooks = hooks.processHooks,
+    enableHooks = hooks.enableHooks,
+    ACTIVATE_HOOKS = hooks.ACTIVATE_HOOKS;
 
-    return current.then(function (currentHook) {
-      return hook(currentHook);
-    }).then(updateCurrentHook);
-  }, Promise.resolve(hookObject));
-  return promise.then(function () {
-    return hookObject;
-  }).catch(function (error) {
-    // Add the hook information to any errors
-    error.hook = hookObject;
-    throw error;
-  });
-}
+var withHooks = function withHooks(_ref) {
+  var app = _ref.app,
+      service = _ref.service,
+      method = _ref.method,
+      original = _ref.original;
+  return function () {
+    var _hooks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-exports.processHooks = processHooks; // Add `.hooks` functionality to an object
+    var hooks = app.hookTypes.reduce(function (result, type) {
+      var value = _hooks[type] || [];
+      result[type] = Array.isArray(value) ? value : [value];
+      return result;
+    }, {});
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
 
-function enableHooks(obj, methods, types) {
-  if (typeof obj.hooks === 'function') {
-    return obj;
-  }
+      var returnHook = args[args.length - 1] === true ? args.pop() : false; // Create the hook object that gets passed through
 
-  var hookData = {};
-  types.forEach(function (type) {
-    // Initialize properties where hook functions are stored
-    hookData[type] = {};
-  }); // Add non-enumerable `__hooks` property to the object
+      var hookObject = createHookObject(method, {
+        type: 'before',
+        // initial hook object type
+        arguments: args,
+        service: service,
+        app: app
+      });
+      return Promise.resolve(hookObject) // Run `before` hooks
+      .then(function (hookObject) {
+        return processHooks.call(service, baseHooks.concat(hooks.before), hookObject);
+      }) // Run the original method
+      .then(function (hookObject) {
+        // If `hookObject.result` is set, skip the original method
+        if (typeof hookObject.result !== 'undefined') {
+          return hookObject;
+        } // Otherwise, call it with arguments created from the hook object
 
-  Object.defineProperty(obj, '__hooks', {
-    configurable: true,
-    value: hookData,
-    writable: true
-  });
-  return Object.assign(obj, {
-    hooks: function hooks(allHooks) {
-      var _this2 = this;
 
-      each(allHooks, function (current, type) {
-        // @ts-ignore
-        if (!_this2.__hooks[type]) {
-          throw new Error("'".concat(type, "' is not a valid hook type"));
-        }
+        var promise = new Promise(function (resolve) {
+          var func = original || service[method];
+          var args = service.methods[method].map(function (value) {
+            return hookObject[value];
+          });
+          var result = func.apply(service, args);
 
-        var hooks = convertHookData(current);
-        each(hooks, function (_value, method) {
-          if (method !== 'all' && methods.indexOf(method) === -1) {
-            throw new Error("'".concat(method, "' is not a valid hook method"));
-          }
-        });
-        methods.forEach(function (method) {
-          // @ts-ignore
-          var myHooks = _this2.__hooks[type][method] || (_this2.__hooks[type][method] = []);
-
-          if (hooks.all) {
-            myHooks.push.apply(myHooks, hooks.all);
+          if (!isPromise(result)) {
+            throw new Error("Service method '".concat(hookObject.method, "' for '").concat(hookObject.path, "' service must return a promise"));
           }
 
-          if (hooks[method]) {
-            myHooks.push.apply(myHooks, hooks[method]);
-          }
+          resolve(result);
+        });
+        return promise.then(function (result) {
+          hookObject.result = result;
+          return hookObject;
+        }).catch(function (error) {
+          error.hook = hookObject;
+          throw error;
+        });
+      }) // Run `after` hooks
+      .then(function (hookObject) {
+        var afterHookObject = Object.assign({}, hookObject, {
+          type: 'after'
+        });
+        return processHooks.call(service, hooks.after, afterHookObject);
+      }) // Run `errors` hooks
+      .catch(function (error) {
+        var errorHookObject = Object.assign({}, error.hook, {
+          type: 'error',
+          original: error.hook,
+          error: error,
+          result: undefined
+        });
+        return processHooks.call(service, hooks.error, errorHookObject).catch(function (error) {
+          var errorHookObject = Object.assign({}, error.hook, {
+            error: error,
+            result: undefined
+          });
+          return errorHookObject;
+        });
+      }) // Run `finally` hooks
+      .then(function (hookObject) {
+        return processHooks.call(service, hooks.finally, hookObject).catch(function (error) {
+          var errorHookObject = Object.assign({}, error.hook, {
+            error: error,
+            result: undefined
+          });
+          return errorHookObject;
         });
+      }) // Resolve with a result or reject with an error
+      .then(function (hookObject) {
+        if (typeof hookObject.error !== 'undefined' && typeof hookObject.result === 'undefined') {
+          return Promise.reject(returnHook ? hookObject : hookObject.error);
+        } else {
+          return returnHook ? hookObject : hookObject.result;
+        }
       });
-      return this;
-    }
-  });
-}
-
-exports.enableHooks = enableHooks;
-
-/***/ }),
+    };
+  };
+}; // A service mixin that adds `service.hooks()` method and functionality
 
-/***/ "../commons/lib/index.js":
-/*!*******************************!*\
-  !*** ../commons/lib/index.js ***!
-  \*******************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
 
-"use strict";
+var hookMixin = exports.hookMixin = function hookMixin(service) {
+  if (typeof service.hooks === 'function') {
+    return;
+  }
 
+  service.methods = Object.getOwnPropertyNames(service).filter(function (key) {
+    return typeof service[key] === 'function' && service[key][ACTIVATE_HOOKS];
+  }).reduce(function (result, methodName) {
+    result[methodName] = service[methodName][ACTIVATE_HOOKS];
+    return result;
+  }, service.methods || {});
+  Object.assign(service.methods, {
+    find: ['params'],
+    get: ['id', 'params'],
+    create: ['data', 'params'],
+    update: ['id', 'data', 'params'],
+    patch: ['id', 'data', 'params'],
+    remove: ['id', 'params']
+  });
+  var app = this;
+  var methodNames = Object.keys(service.methods); // Assemble the mixin object that contains all "hooked" service methods
 
-var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  Object.defineProperty(o, k2, {
-    enumerable: true,
-    get: function get() {
-      return m[k];
+  var mixin = methodNames.reduce(function (mixin, method) {
+    if (typeof service[method] !== 'function') {
+      return mixin;
     }
-  });
-} : function (o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  o[k2] = m[k];
-});
 
-var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
-  Object.defineProperty(o, "default", {
-    enumerable: true,
-    value: v
-  });
-} : function (o, v) {
-  o["default"] = v;
-});
+    mixin[method] = function () {
+      var service = this;
+      var args = Array.from(arguments);
 
-var __importStar = this && this.__importStar || function (mod) {
-  if (mod && mod.__esModule) return mod;
-  var result = {};
-  if (mod != null) for (var k in mod) {
-    if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-  }
+      var original = service._super.bind(service);
 
-  __setModuleDefault(result, mod);
+      return withHooks({
+        app: app,
+        service: service,
+        method: method,
+        original: original
+      })({
+        before: getHooks(app, service, 'before', method),
+        after: getHooks(app, service, 'after', method, true),
+        error: getHooks(app, service, 'error', method, true),
+        finally: getHooks(app, service, 'finally', method, true)
+      }).apply(void 0, _toConsumableArray(args));
+    };
 
-  return result;
-};
+    return mixin;
+  }, {}); // Add .hooks method and properties to the service
 
-var __exportStar = this && this.__exportStar || function (m, exports) {
-  for (var p in m) {
-    if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-  }
+  enableHooks(service, methodNames, app.hookTypes);
+  service.mixin(mixin);
 };
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.hooks = void 0;
+module.exports = function () {
+  return function (app) {
+    // We store a reference of all supported hook types on the app
+    // in case someone needs it
+    Object.assign(app, {
+      hookTypes: ['before', 'after', 'error', 'finally']
+    }); // Add functionality for hooks to be registered as app.hooks
 
-var hookUtils = __importStar(__webpack_require__(/*! ./hooks */ "../commons/lib/hooks.js"));
+    enableHooks(app, app.methods, app.hookTypes);
+    app.mixins.push(hookMixin);
+  };
+};
 
-__exportStar(__webpack_require__(/*! ./utils */ "../commons/lib/utils.js"), exports);
+module.exports.withHooks = withHooks;
+module.exports.ACTIVATE_HOOKS = ACTIVATE_HOOKS;
 
-exports.hooks = hookUtils;
+module.exports.activateHooks = function activateHooks(args) {
+  return function (fn) {
+    Object.defineProperty(fn, ACTIVATE_HOOKS, {
+      value: args
+    });
+    return fn;
+  };
+};
 
 /***/ }),
 
-/***/ "../commons/lib/utils.js":
-/*!*******************************!*\
-  !*** ../commons/lib/utils.js ***!
-  \*******************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/***/ "../feathers/lib/index.js":
+/*!********************************!*\
+  !*** ../feathers/lib/index.js ***!
+  \********************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/* WEBPACK VAR INJECTION */(function(process) {
+var Proto = __webpack_require__(/*! uberproto */ "../../node_modules/uberproto/lib/proto.js");
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var Application = __webpack_require__(/*! ./application */ "../feathers/lib/application.js");
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+var version = __webpack_require__(/*! ./version */ "../feathers/lib/version.js");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+var _require = __webpack_require__(/*! ./hooks */ "../feathers/lib/hooks/index.js"),
+    ACTIVATE_HOOKS = _require.ACTIVATE_HOOKS,
+    activateHooks = _require.activateHooks; // A base object Prototype that does not inherit from a
+// potentially polluted Object prototype
 
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+var baseObject = Object.create(null);
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function createApplication() {
+  var app = Object.create(baseObject); // Mix in the base application
 
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+  Proto.mixin(Application, app);
+  app.init();
+  return app;
+}
 
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+createApplication.version = version;
+createApplication.ACTIVATE_HOOKS = ACTIVATE_HOOKS;
+createApplication.activateHooks = activateHooks;
+module.exports = createApplication; // For better ES module (TypeScript) compatibility
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createSymbol = exports.makeUrl = exports.isPromise = exports._ = exports.stripSlashes = void 0; // Removes all leading and trailing slashes from a path
+module.exports["default"] = createApplication;
 
-function stripSlashes(name) {
-  return name.replace(/^(\/+)|(\/+)$/g, '');
-}
+/***/ }),
 
-exports.stripSlashes = stripSlashes; // A set of lodash-y utility functions that use ES6
+/***/ "../feathers/lib/version.js":
+/*!**********************************!*\
+  !*** ../feathers/lib/version.js ***!
+  \**********************************/
+/***/ (function(module) {
 
-exports._ = {
-  each: function each(obj, callback) {
-    if (obj && typeof obj.forEach === 'function') {
-      obj.forEach(callback);
-    } else if (exports._.isObject(obj)) {
-      Object.keys(obj).forEach(function (key) {
-        return callback(obj[key], key);
-      });
-    }
-  },
-  some: function some(value, callback) {
-    return Object.keys(value).map(function (key) {
-      return [value[key], key];
-    }).some(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-          val = _ref2[0],
-          key = _ref2[1];
+module.exports = '4.5.12';
 
-      return callback(val, key);
-    });
-  },
-  every: function every(value, callback) {
-    return Object.keys(value).map(function (key) {
-      return [value[key], key];
-    }).every(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-          val = _ref4[0],
-          key = _ref4[1];
+/***/ }),
 
-      return callback(val, key);
-    });
-  },
-  keys: function keys(obj) {
-    return Object.keys(obj);
-  },
-  values: function values(obj) {
-    return exports._.keys(obj).map(function (key) {
-      return obj[key];
-    });
-  },
-  isMatch: function isMatch(obj, item) {
-    return exports._.keys(item).every(function (key) {
-      return obj[key] === item[key];
-    });
-  },
-  isEmpty: function isEmpty(obj) {
-    return exports._.keys(obj).length === 0;
-  },
-  isObject: function isObject(item) {
-    return _typeof(item) === 'object' && !Array.isArray(item) && item !== null;
-  },
-  isObjectOrArray: function isObjectOrArray(value) {
-    return _typeof(value) === 'object' && value !== null;
-  },
-  extend: function extend(first) {
-    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      rest[_key - 1] = arguments[_key];
-    }
-
-    return Object.assign.apply(Object, [first].concat(rest));
-  },
-  omit: function omit(obj) {
-    var result = exports._.extend({}, obj);
-
-    for (var _len2 = arguments.length, keys = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      keys[_key2 - 1] = arguments[_key2];
-    }
-
-    keys.forEach(function (key) {
-      return delete result[key];
-    });
-    return result;
-  },
-  pick: function pick(source) {
-    for (var _len3 = arguments.length, keys = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-      keys[_key3 - 1] = arguments[_key3];
-    }
+/***/ "../../node_modules/events/events.js":
+/*!*******************************************!*\
+  !*** ../../node_modules/events/events.js ***!
+  \*******************************************/
+/***/ (function(module) {
 
-    return keys.reduce(function (result, key) {
-      if (source[key] !== undefined) {
-        result[key] = source[key];
-      }
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-      return result;
-    }, {});
-  },
-  // Recursively merge the source object into the target object
-  merge: function merge(target, source) {
-    if (exports._.isObject(target) && exports._.isObject(source)) {
-      Object.keys(source).forEach(function (key) {
-        if (exports._.isObject(source[key])) {
-          if (!target[key]) {
-            Object.assign(target, _defineProperty({}, key, {}));
-          }
 
-          exports._.merge(target[key], source[key]);
-        } else {
-          Object.assign(target, _defineProperty({}, key, source[key]));
-        }
-      });
-    }
 
-    return target;
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
   }
-}; // Duck-checks if an object looks like a promise
 
-function isPromise(result) {
-  return exports._.isObject(result) && typeof result.then === 'function';
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target)
+      .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target);
+  };
 }
 
-exports.isPromise = isPromise;
-
-function makeUrl(path) {
-  var app = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var get = typeof app.get === 'function' ? app.get.bind(app) : function () {};
-  var env = get('env') || "development";
-  var host = get('host') || process.env.HOST_NAME || 'localhost';
-  var protocol = env === 'development' || env === 'test' || env === undefined ? 'http' : 'https';
-  var PORT = get('port') || process.env.PORT || 3030;
-  var port = env === 'development' || env === 'test' || env === undefined ? ":".concat(PORT) : '';
-  path = path || '';
-  return "".concat(protocol, "://").concat(host).concat(port, "/").concat(exports.stripSlashes(path));
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
 }
 
-exports.makeUrl = makeUrl;
-
-function createSymbol(name) {
-  return typeof Symbol !== 'undefined' ? Symbol(name) : name;
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
 }
 
-exports.createSymbol = createSymbol;
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../node_modules/process/browser.js */ "../../node_modules/process/browser.js")))
-
-/***/ }),
-
-/***/ "../feathers/lib/application.js":
-/*!**************************************!*\
-  !*** ../feathers/lib/application.js ***!
-  \**************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-var debug = __webpack_require__(/*! debug */ "../../node_modules/debug/src/browser.js")('feathers:application');
-
-var _require = __webpack_require__(/*! @feathersjs/commons */ "../commons/lib/index.js"),
-    stripSlashes = _require.stripSlashes;
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+module.exports.once = once;
 
-var Uberproto = __webpack_require__(/*! uberproto */ "../../node_modules/uberproto/lib/proto.js");
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
 
-var events = __webpack_require__(/*! ./events */ "../feathers/lib/events.js");
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
 
-var hooks = __webpack_require__(/*! ./hooks */ "../feathers/lib/hooks/index.js");
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
 
-var version = __webpack_require__(/*! ./version */ "../feathers/lib/version.js");
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
 
-var Proto = Uberproto.extend({
-  create: null
-});
-var application = {
-  init: function init() {
-    Object.assign(this, {
-      version: version,
-      methods: ['find', 'get', 'create', 'update', 'patch', 'remove'],
-      mixins: [],
-      services: {},
-      providers: [],
-      _setup: false,
-      settings: {}
-    });
-    this.configure(hooks());
-    this.configure(events());
-  },
-  get: function get(name) {
-    return this.settings[name];
-  },
-  set: function set(name, value) {
-    this.settings[name] = value;
-    return this;
-  },
-  disable: function disable(name) {
-    this.settings[name] = false;
-    return this;
-  },
-  disabled: function disabled(name) {
-    return !this.settings[name];
-  },
-  enable: function enable(name) {
-    this.settings[name] = true;
-    return this;
-  },
-  enabled: function enabled(name) {
-    return !!this.settings[name];
-  },
-  configure: function configure(fn) {
-    fn.call(this, this);
-    return this;
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
   },
-  service: function service(path, _service) {
-    if (typeof _service !== 'undefined') {
-      throw new Error('Registering a new service with `app.service(path, service)` is no longer supported. Use `app.use(path, service)` instead.');
+  set: function(arg) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
     }
+    defaultMaxListeners = arg;
+  }
+});
 
-    var location = stripSlashes(path) || '/';
-    var current = this.services[location];
+EventEmitter.init = function() {
 
-    if (typeof current === 'undefined' && typeof this.defaultService === 'function') {
-      return this.use(location, this.defaultService(location)).service(location);
-    }
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
 
-    return current;
-  },
-  use: function use(path, service) {
-    var _this = this;
+  this._maxListeners = this._maxListeners || undefined;
+};
 
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  }
+  this._maxListeners = n;
+  return this;
+};
 
-    if (typeof path !== 'string') {
-      throw new Error("'".concat(path, "' is not a valid service path."));
-    }
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
 
-    var location = stripSlashes(path) || '/';
-    var isSubApp = typeof service.service === 'function' && service.services;
-    var isService = this.methods.concat('setup').some(function (name) {
-      return typeof service[name] === 'function';
-    });
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
 
-    if (isSubApp) {
-      var subApp = service;
-      Object.keys(subApp.services).forEach(function (subPath) {
-        return _this.use("".concat(location, "/").concat(subPath), subApp.service(subPath));
-      });
-      return this;
+EventEmitter.prototype.emit = function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+  var doError = (type === 'error');
+
+  var events = this._events;
+  if (events !== undefined)
+    doError = (doError && events.error === undefined);
+  else if (!doError)
+    return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    var er;
+    if (args.length > 0)
+      er = args[0];
+    if (er instanceof Error) {
+      // Note: The comments on the `throw` lines are intentional, they show
+      // up in Node's output if this results in an unhandled exception.
+      throw er; // Unhandled 'error' event
     }
+    // At least give some kind of context to the user
+    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+    err.context = er;
+    throw err; // Unhandled 'error' event
+  }
 
-    if (!isService) {
-      throw new Error("Invalid service object passed for path `".concat(location, "`"));
-    } // If the service is already Uberproto'd use it directly
+  var handler = events[type];
 
+  if (handler === undefined)
+    return false;
 
-    var protoService = Proto.isPrototypeOf(service) ? service : Proto.extend(service);
-    debug("Registering new service at `".concat(location, "`")); // Add all the mixins
+  if (typeof handler === 'function') {
+    ReflectApply(handler, this, args);
+  } else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      ReflectApply(listeners[i], this, args);
+  }
 
-    this.mixins.forEach(function (fn) {
-      return fn.call(_this, protoService, location, options);
-    });
+  return true;
+};
 
-    if (typeof protoService._setup === 'function') {
-      protoService._setup(this, location);
-    } // Run the provider functions to register the service
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
 
+  checkListener(listener);
 
-    this.providers.forEach(function (provider) {
-      return provider.call(_this, protoService, location, options);
-    }); // If we ran setup already, set this service up explicitly
+  events = target._events;
+  if (events === undefined) {
+    events = target._events = Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener !== undefined) {
+      target.emit('newListener', type,
+                  listener.listener ? listener.listener : listener);
 
-    if (this._isSetup && typeof protoService.setup === 'function') {
-      debug("Setting up service for `".concat(location, "`"));
-      protoService.setup(this, location);
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
     }
+    existing = events[type];
+  }
 
-    this.services[location] = protoService;
-    return this;
-  },
-  setup: function setup() {
-    var _this2 = this;
-
-    // Setup each service (pass the app so that they can look up other services etc.)
-    Object.keys(this.services).forEach(function (path) {
-      var service = _this2.services[path];
-      debug("Setting up service for `".concat(path, "`"));
+  if (existing === undefined) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] =
+        prepend ? [listener, existing] : [existing, listener];
+      // If we've already got an array, just append.
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
 
-      if (typeof service.setup === 'function') {
-        service.setup(_this2, path);
-      }
-    });
-    this._isSetup = true;
-    return this;
+    // Check for listener leak
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      var w = new Error('Possible EventEmitter memory leak detected. ' +
+                          existing.length + ' ' + String(type) + ' listeners ' +
+                          'added. Use emitter.setMaxListeners() to ' +
+                          'increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
   }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
 };
-module.exports = application;
 
-/***/ }),
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-/***/ "../feathers/lib/events.js":
-/*!*********************************!*\
-  !*** ../feathers/lib/events.js ***!
-  \*********************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
 
-var _require = __webpack_require__(/*! events */ "../../node_modules/events/events.js"),
-    EventEmitter = _require.EventEmitter;
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0)
+      return this.listener.call(this.target);
+    return this.listener.apply(this.target, arguments);
+  }
+}
 
-var Proto = __webpack_require__(/*! uberproto */ "../../node_modules/uberproto/lib/proto.js"); // Returns a hook that emits service events. Should always be
-// used as the very last hook in the chain
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
 
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
 
-var eventHook = exports.eventHook = function eventHook() {
-  return function (hook) {
-    var app = hook.app,
-        service = hook.service;
-    var eventName = hook.event === null ? hook.event : app.eventMappings[hook.method];
-    var isHookEvent = service._hookEvents && service._hookEvents.indexOf(eventName) !== -1; // If this event is not being sent yet and we are not in an error hook
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
 
-    if (eventName && isHookEvent && hook.type !== 'error') {
-      var results = Array.isArray(hook.result) ? hook.result : [hook.result];
-      results.forEach(function (element) {
-        return service.emit(eventName, element, hook);
-      });
-    }
-  };
-}; // Mixin that turns a service into a Node event emitter
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
 
+      checkListener(listener);
 
-var eventMixin = exports.eventMixin = function eventMixin(service) {
-  if (service._serviceEvents) {
-    return;
-  }
+      events = this._events;
+      if (events === undefined)
+        return this;
 
-  var app = this; // Indicates if the service is already an event emitter
+      list = events[type];
+      if (list === undefined)
+        return this;
 
-  var isEmitter = typeof service.on === 'function' && typeof service.emit === 'function'; // If not, mix it in (the service is always an Uberproto object that has a .mixin)
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
 
-  if (typeof service.mixin === 'function' && !isEmitter) {
-    service.mixin(EventEmitter.prototype);
-  } // Define non-enumerable properties of
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
 
+        if (position < 0)
+          return this;
 
-  Object.defineProperties(service, {
-    // A list of all events that this service sends
-    _serviceEvents: {
-      value: Array.isArray(service.events) ? service.events.slice() : []
-    },
-    // A list of events that should be handled through the event hooks
-    _hookEvents: {
-      value: []
-    }
-  }); // `app.eventMappings` has the mapping from method name to event name
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
 
-  Object.keys(app.eventMappings).forEach(function (method) {
-    var event = app.eventMappings[method];
-    var alreadyEmits = service._serviceEvents.indexOf(event) !== -1; // Add events for known methods to _serviceEvents and _hookEvents
-    // if the service indicated it does not send it itself yet
+        if (list.length === 1)
+          events[type] = list[0];
 
-    if (typeof service[method] === 'function' && !alreadyEmits) {
-      service._serviceEvents.push(event);
+        if (events.removeListener !== undefined)
+          this.emit('removeListener', type, originalListener || listener);
+      }
 
-      service._hookEvents.push(event);
-    }
-  });
-};
+      return this;
+    };
 
-module.exports = function () {
-  return function (app) {
-    // Mappings from service method to event name
-    Object.assign(app, {
-      eventMappings: {
-        create: 'created',
-        update: 'updated',
-        remove: 'removed',
-        patch: 'patched'
-      }
-    }); // Register the event hook
-    // `finally` hooks always run last after `error` and `after` hooks
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-    app.hooks({
-      finally: eventHook()
-    }); // Make the app an event emitter
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events, i;
 
-    Proto.mixin(EventEmitter.prototype, app);
-    app.mixins.push(eventMixin);
-  };
-};
+      events = this._events;
+      if (events === undefined)
+        return this;
 
-/***/ }),
+      // not listening for removeListener, no need to emit
+      if (events.removeListener === undefined) {
+        if (arguments.length === 0) {
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== undefined) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
 
-/***/ "../feathers/lib/hooks/base.js":
-/*!*************************************!*\
-  !*** ../feathers/lib/hooks/base.js ***!
-  \*************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
 
-var _require = __webpack_require__(/*! @feathersjs/commons */ "../commons/lib/index.js"),
-    _ = _require._;
+      listeners = events[type];
 
-var assignArguments = function assignArguments(context) {
-  var service = context.service,
-      method = context.method;
-  var parameters = service.methods[method];
-  context.arguments.forEach(function (value, index) {
-    context[parameters[index]] = value;
-  });
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners !== undefined) {
+        // LIFO order
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
 
-  if (!context.params) {
-    context.params = {};
-  }
+      return this;
+    };
 
-  return context;
-};
+function _listeners(target, type, unwrap) {
+  var events = target._events;
 
-var validate = function validate(context) {
-  var service = context.service,
-      method = context.method,
-      path = context.path;
-  var parameters = service.methods[method];
+  if (events === undefined)
+    return [];
 
-  if (parameters.includes('id') && context.id === undefined) {
-    throw new Error("An id must be provided to the '".concat(path, ".").concat(method, "' method"));
-  }
+  var evlistener = events[type];
+  if (evlistener === undefined)
+    return [];
 
-  if (parameters.includes('data') && !_.isObjectOrArray(context.data)) {
-    throw new Error("A data object must be provided to the '".concat(path, ".").concat(method, "' method"));
-  }
+  if (typeof evlistener === 'function')
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
 
-  return context;
+  return unwrap ?
+    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
 };
 
-module.exports = [assignArguments, validate];
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
 
-/***/ }),
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
 
-/***/ "../feathers/lib/hooks/index.js":
-/*!**************************************!*\
-  !*** ../feathers/lib/hooks/index.js ***!
-  \**************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+  if (events !== undefined) {
+    var evlistener = events[type];
 
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener !== undefined) {
+      return evlistener.length;
+    }
+  }
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+  return 0;
+}
 
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
 
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+    list[index] = list[index + 1];
+  list.pop();
+}
 
-var _require = __webpack_require__(/*! @feathersjs/commons */ "../commons/lib/index.js"),
-    hooks = _require.hooks,
-    isPromise = _require.isPromise;
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
 
-var baseHooks = __webpack_require__(/*! ./base */ "../feathers/lib/hooks/base.js");
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
 
-var createHookObject = hooks.createHookObject,
-    getHooks = hooks.getHooks,
-    processHooks = hooks.processHooks,
-    enableHooks = hooks.enableHooks,
-    ACTIVATE_HOOKS = hooks.ACTIVATE_HOOKS;
+    function resolver() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve([].slice.call(arguments));
+    };
 
-var withHooks = function withHooks(_ref) {
-  var app = _ref.app,
-      service = _ref.service,
-      method = _ref.method,
-      original = _ref.original;
-  return function () {
-    var _hooks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
 
-    var hooks = app.hookTypes.reduce(function (result, type) {
-      var value = _hooks[type] || [];
-      result[type] = Array.isArray(value) ? value : [value];
-      return result;
-    }, {});
-    return function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
       }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
 
-      var returnHook = args[args.length - 1] === true ? args.pop() : false; // Create the hook object that gets passed through
 
-      var hookObject = createHookObject(method, {
-        type: 'before',
-        // initial hook object type
-        arguments: args,
-        service: service,
-        app: app
-      });
-      return Promise.resolve(hookObject) // Run `before` hooks
-      .then(function (hookObject) {
-        return processHooks.call(service, baseHooks.concat(hooks.before), hookObject);
-      }) // Run the original method
-      .then(function (hookObject) {
-        // If `hookObject.result` is set, skip the original method
-        if (typeof hookObject.result !== 'undefined') {
-          return hookObject;
-        } // Otherwise, call it with arguments created from the hook object
+/***/ }),
 
+/***/ "../../node_modules/ms/index.js":
+/*!**************************************!*\
+  !*** ../../node_modules/ms/index.js ***!
+  \**************************************/
+/***/ (function(module) {
 
-        var promise = new Promise(function (resolve) {
-          var func = original || service[method];
-          var args = service.methods[method].map(function (value) {
-            return hookObject[value];
-          });
-          var result = func.apply(service, args);
+/**
+ * Helpers.
+ */
 
-          if (!isPromise(result)) {
-            throw new Error("Service method '".concat(hookObject.method, "' for '").concat(hookObject.path, "' service must return a promise"));
-          }
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
 
-          resolve(result);
-        });
-        return promise.then(function (result) {
-          hookObject.result = result;
-          return hookObject;
-        }).catch(function (error) {
-          error.hook = hookObject;
-          throw error;
-        });
-      }) // Run `after` hooks
-      .then(function (hookObject) {
-        var afterHookObject = Object.assign({}, hookObject, {
-          type: 'after'
-        });
-        return processHooks.call(service, hooks.after, afterHookObject);
-      }) // Run `errors` hooks
-      .catch(function (error) {
-        var errorHookObject = Object.assign({}, error.hook, {
-          type: 'error',
-          original: error.hook,
-          error: error,
-          result: undefined
-        });
-        return processHooks.call(service, hooks.error, errorHookObject).catch(function (error) {
-          var errorHookObject = Object.assign({}, error.hook, {
-            error: error,
-            result: undefined
-          });
-          return errorHookObject;
-        });
-      }) // Run `finally` hooks
-      .then(function (hookObject) {
-        return processHooks.call(service, hooks.finally, hookObject).catch(function (error) {
-          var errorHookObject = Object.assign({}, error.hook, {
-            error: error,
-            result: undefined
-          });
-          return errorHookObject;
-        });
-      }) // Resolve with a result or reject with an error
-      .then(function (hookObject) {
-        if (typeof hookObject.error !== 'undefined' && typeof hookObject.result === 'undefined') {
-          return Promise.reject(returnHook ? hookObject : hookObject.error);
-        } else {
-          return returnHook ? hookObject : hookObject.result;
-        }
-      });
-    };
-  };
-}; // A service mixin that adds `service.hooks()` method and functionality
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
 
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
 
-var hookMixin = exports.hookMixin = function hookMixin(service) {
-  if (typeof service.hooks === 'function') {
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
     return;
   }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
 
-  service.methods = Object.getOwnPropertyNames(service).filter(function (key) {
-    return typeof service[key] === 'function' && service[key][ACTIVATE_HOOKS];
-  }).reduce(function (result, methodName) {
-    result[methodName] = service[methodName][ACTIVATE_HOOKS];
-    return result;
-  }, service.methods || {});
-  Object.assign(service.methods, {
-    find: ['params'],
-    get: ['id', 'params'],
-    create: ['data', 'params'],
-    update: ['id', 'data', 'params'],
-    patch: ['id', 'data', 'params'],
-    remove: ['id', 'params']
-  });
-  var app = this;
-  var methodNames = Object.keys(service.methods); // Assemble the mixin object that contains all "hooked" service methods
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
 
-  var mixin = methodNames.reduce(function (mixin, method) {
-    if (typeof service[method] !== 'function') {
-      return mixin;
-    }
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
 
-    mixin[method] = function () {
-      var service = this;
-      var args = Array.from(arguments);
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
 
-      var original = service._super.bind(service);
+/**
+ * Pluralization helper.
+ */
 
-      return withHooks({
-        app: app,
-        service: service,
-        method: method,
-        original: original
-      })({
-        before: getHooks(app, service, 'before', method),
-        after: getHooks(app, service, 'after', method, true),
-        error: getHooks(app, service, 'error', method, true),
-        finally: getHooks(app, service, 'finally', method, true)
-      }).apply(void 0, _toConsumableArray(args));
-    };
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
 
-    return mixin;
-  }, {}); // Add .hooks method and properties to the service
 
-  enableHooks(service, methodNames, app.hookTypes);
-  service.mixin(mixin);
-};
+/***/ }),
 
-module.exports = function () {
-  return function (app) {
-    // We store a reference of all supported hook types on the app
-    // in case someone needs it
-    Object.assign(app, {
-      hookTypes: ['before', 'after', 'error', 'finally']
-    }); // Add functionality for hooks to be registered as app.hooks
+/***/ "../../node_modules/uberproto/lib/proto.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/uberproto/lib/proto.js ***!
+  \*************************************************/
+/***/ (function(module, exports) {
 
-    enableHooks(app, app.methods, app.hookTypes);
-    app.mixins.push(hookMixin);
-  };
-};
+var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* global define */
+/**
+ * Uberproto
+ *
+ * A base object for ECMAScript 5 style prototypal inheritance.
+ *
+ * @see https://github.com/rauschma/proto-js/
+ * @see http://ejohn.org/blog/simple-javascript-inheritance/
+ * @see http://uxebu.com/blog/2011/02/23/object-based-inheritance-for-ecmascript-5/
+ */
+(function (root, factory) {
+  if (true) {
+    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  } else {}
+}(this, function () {
+  var HAS_SYMBOLS = typeof Object.getOwnPropertySymbols === 'function';
 
-module.exports.withHooks = withHooks;
-module.exports.ACTIVATE_HOOKS = ACTIVATE_HOOKS;
+  function makeSuper (_super, old, name, fn) {
+    var isFunction = typeof old === 'function';
+    var newMethod = function () {
+      var tmp = this._super;
 
-module.exports.activateHooks = function activateHooks(args) {
-  return function (fn) {
-    Object.defineProperty(fn, ACTIVATE_HOOKS, {
-      value: args
-    });
-    return fn;
-  };
-};
+      // Add a new ._super() method that is the same method
+      // but either pointing to the prototype method
+      // or to the overwritten method
+      this._super = isFunction ? old : _super[name];
 
-/***/ }),
+      // The method only need to be bound temporarily, so we
+      // remove it when we're done executing
+      var ret = fn.apply(this, arguments);
 
-/***/ "../feathers/lib/index.js":
-/*!********************************!*\
-  !*** ../feathers/lib/index.js ***!
-  \********************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+      this._super = tmp;
 
-var Proto = __webpack_require__(/*! uberproto */ "../../node_modules/uberproto/lib/proto.js");
+      return ret;
+    };
 
-var Application = __webpack_require__(/*! ./application */ "../feathers/lib/application.js");
+    if (isFunction) {
+      Object.keys(old).forEach(function (name) {
+        newMethod[name] = old[name];
+      });
 
-var version = __webpack_require__(/*! ./version */ "../feathers/lib/version.js");
+      if (HAS_SYMBOLS) {
+        Object.getOwnPropertySymbols(old).forEach(function (name) {
+          newMethod[name] = old[name];
+        });
+      }
+    }
 
-var _require = __webpack_require__(/*! ./hooks */ "../feathers/lib/hooks/index.js"),
-    ACTIVATE_HOOKS = _require.ACTIVATE_HOOKS,
-    activateHooks = _require.activateHooks; // A base object Prototype that does not inherit from a
-// potentially polluted Object prototype
+    return newMethod;
+  }
 
+  return {
+    /**
+     * Create a new object using Object.create. The arguments will be
+     * passed to the new instances init method or to a method name set in
+     * __init.
+     */
+    create: function () {
+      var instance = Object.create(this);
+      var init = typeof instance.__init === 'string' ? instance.__init : 'init';
 
-var baseObject = Object.create(null);
+      if (typeof instance[init] === 'function') {
+        instance[init].apply(instance, arguments);
+      }
+      return instance;
+    },
+    /**
+     * Mixin a given set of properties
+     * @param prop The properties to mix in
+     * @param obj [optional]
+     * The object to add the mixin
+     */
+    mixin: function (prop, obj) {
+      var self = obj || this;
+      var fnTest = /\b_super\b/;
+      var _super = Object.getPrototypeOf(self) || self.prototype;
+      var descriptors = {};
+      var proto = prop;
+      var processProperty = function (name) {
+        var descriptor = Object.getOwnPropertyDescriptor(proto, name);
 
-function createApplication() {
-  var app = Object.create(baseObject); // Mix in the base application
+        if (!descriptors[name] && descriptor) {
+          descriptors[name] = descriptor;
+        }
+      };
 
-  Proto.mixin(Application, app);
-  app.init();
-  return app;
-}
+      // Collect all property descriptors
+      do {
+        Object.getOwnPropertyNames(proto).forEach(processProperty);
 
-createApplication.version = version;
-createApplication.ACTIVATE_HOOKS = ACTIVATE_HOOKS;
-createApplication.activateHooks = activateHooks;
-module.exports = createApplication; // For better ES module (TypeScript) compatibility
+        if (HAS_SYMBOLS) {
+          Object.getOwnPropertySymbols(proto).forEach(processProperty);
+        }
+      } while ((proto = Object.getPrototypeOf(proto)) && Object.getPrototypeOf(proto));
 
-module.exports.default = createApplication;
+      var processDescriptor = function (name) {
+        var descriptor = descriptors[name];
 
-/***/ }),
+        if (typeof descriptor.value === 'function' && fnTest.test(descriptor.value)) {
+          descriptor.value = makeSuper(_super, self[name], name, descriptor.value);
+        }
 
-/***/ "../feathers/lib/version.js":
-/*!**********************************!*\
-  !*** ../feathers/lib/version.js ***!
-  \**********************************/
-/*! no static exports found */
-/***/ (function(module, exports) {
+        Object.defineProperty(self, name, descriptor);
+      };
 
-module.exports = '4.5.8';
+      Object.keys(descriptors).forEach(processDescriptor);
 
-/***/ }),
+      if (HAS_SYMBOLS) {
+        Object.getOwnPropertySymbols(descriptors).forEach(processDescriptor);
+      }
 
-/***/ "./src/core.js":
-/*!*********************!*\
-  !*** ./src/core.js ***!
-  \*********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+      return self;
+    },
+    /**
+     * Extend the current or a given object with the given property and return the extended object.
+     * @param prop The properties to extend with
+     * @param obj [optional] The object to extend from
+     * @returns The extended object
+     */
+    extend: function (prop, obj) {
+      return this.mixin(prop, Object.create(obj || this));
+    },
+    /**
+     * Return a callback function with this set to the current or a given context object.
+     * @param name Name of the method to proxy
+     * @param args... [optional] Arguments to use for partial application
+     */
+    proxy: function (name) {
+      var fn = this[name];
+      var args = Array.prototype.slice.call(arguments, 1);
+
+      args.unshift(this);
+      return fn.bind.apply(fn, args);
+    }
+  };
+}));
 
-module.exports = __webpack_require__(/*! @feathersjs/feathers */ "../feathers/lib/index.js");
 
 /***/ })
 
-/******/ });
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module used 'module' so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./src/core.js");
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
 });
 //# sourceMappingURL=core.js.map