@lopatnov/express-reverse-proxy 1.2.0 → 2.0.0

package/node_modules/@pm2/io/node_modules/eventemitter2/lib/eventemitter2.js

@@ -1,1629 +0,0 @@
-/*!
- * EventEmitter2
- * https://github.com/hij1nx/EventEmitter2
- *
- * Copyright (c) 2013 hij1nx
- * Licensed under the MIT license.
- */
-;!function(undefined) {
-  var hasOwnProperty= Object.hasOwnProperty;
-  var isArray = Array.isArray ? Array.isArray : function _isArray(obj) {
-    return Object.prototype.toString.call(obj) === "[object Array]";
-  };
-  var defaultMaxListeners = 10;
-  var nextTickSupported= typeof process=='object' && typeof process.nextTick=='function';
-  var symbolsSupported= typeof Symbol==='function';
-  var reflectSupported= typeof Reflect === 'object';
-  var setImmediateSupported= typeof setImmediate === 'function';
-  var _setImmediate= setImmediateSupported ? setImmediate : setTimeout;
-  var ownKeys= symbolsSupported? (reflectSupported && typeof Reflect.ownKeys==='function'? Reflect.ownKeys : function(obj){
-    var arr= Object.getOwnPropertyNames(obj);
-    arr.push.apply(arr, Object.getOwnPropertySymbols(obj));
-    return arr;
-  }) : Object.keys;
-
-  function init() {
-    this._events = {};
-    if (this._conf) {
-      configure.call(this, this._conf);
-    }
-  }
-
-  function configure(conf) {
-    if (conf) {
-      this._conf = conf;
-
-      conf.delimiter && (this.delimiter = conf.delimiter);
-
-      if(conf.maxListeners!==undefined){
-          this._maxListeners= conf.maxListeners;
-      }
-
-      conf.wildcard && (this.wildcard = conf.wildcard);
-      conf.newListener && (this._newListener = conf.newListener);
-      conf.removeListener && (this._removeListener = conf.removeListener);
-      conf.verboseMemoryLeak && (this.verboseMemoryLeak = conf.verboseMemoryLeak);
-      conf.ignoreErrors && (this.ignoreErrors = conf.ignoreErrors);
-
-      if (this.wildcard) {
-        this.listenerTree = {};
-      }
-    }
-  }
-
-  function logPossibleMemoryLeak(count, eventName) {
-    var errorMsg = '(node) warning: possible EventEmitter memory ' +
-        'leak detected. ' + count + ' listeners added. ' +
-        'Use emitter.setMaxListeners() to increase limit.';
-
-    if(this.verboseMemoryLeak){
-      errorMsg += ' Event name: ' + eventName + '.';
-    }
-
-    if(typeof process !== 'undefined' && process.emitWarning){
-      var e = new Error(errorMsg);
-      e.name = 'MaxListenersExceededWarning';
-      e.emitter = this;
-      e.count = count;
-      process.emitWarning(e);
-    } else {
-      console.error(errorMsg);
-
-      if (console.trace){
-        console.trace();
-      }
-    }
-  }
-
-  var toArray = function (a, b, c) {
-    var n = arguments.length;
-    switch (n) {
-      case 0:
-        return [];
-      case 1:
-        return [a];
-      case 2:
-        return [a, b];
-      case 3:
-        return [a, b, c];
-      default:
-        var arr = new Array(n);
-        while (n--) {
-          arr[n] = arguments[n];
-        }
-        return arr;
-    }
-  };
-
-  function toObject(keys, values) {
-    var obj = {};
-    var key;
-    var len = keys.length;
-    var valuesCount = values ? value.length : 0;
-    for (var i = 0; i < len; i++) {
-      key = keys[i];
-      obj[key] = i < valuesCount ? values[i] : undefined;
-    }
-    return obj;
-  }
-
-  function TargetObserver(emitter, target, options) {
-    this._emitter = emitter;
-    this._target = target;
-    this._listeners = {};
-    this._listenersCount = 0;
-
-    var on, off;
-
-    if (options.on || options.off) {
-      on = options.on;
-      off = options.off;
-    }
-
-    if (target.addEventListener) {
-      on = target.addEventListener;
-      off = target.removeEventListener;
-    } else if (target.addListener) {
-      on = target.addListener;
-      off = target.removeListener;
-    } else if (target.on) {
-      on = target.on;
-      off = target.off;
-    }
-
-    if (!on && !off) {
-      throw Error('target does not implement any known event API');
-    }
-
-    if (typeof on !== 'function') {
-      throw TypeError('on method must be a function');
-    }
-
-    if (typeof off !== 'function') {
-      throw TypeError('off method must be a function');
-    }
-
-    this._on = on;
-    this._off = off;
-
-    var _observers= emitter._observers;
-    if(_observers){
-      _observers.push(this);
-    }else{
-      emitter._observers= [this];
-    }
-  }
-
-  Object.assign(TargetObserver.prototype, {
-    subscribe: function(event, localEvent, reducer){
-      var observer= this;
-      var target= this._target;
-      var emitter= this._emitter;
-      var listeners= this._listeners;
-      var handler= function(){
-        var args= toArray.apply(null, arguments);
-        var eventObj= {
-          data: args,
-          name: localEvent,
-          original: event
-        };
-        if(reducer){
-          var result= reducer.call(target, eventObj);
-          if(result!==false){
-            emitter.emit.apply(emitter, [eventObj.name].concat(args))
-          }
-          return;
-        }
-        emitter.emit.apply(emitter, [localEvent].concat(args));
-      };
-
-
-      if(listeners[event]){
-        throw Error('Event \'' + event + '\' is already listening');
-      }
-
-      this._listenersCount++;
-
-      if(emitter._newListener && emitter._removeListener && !observer._onNewListener){
-
-        this._onNewListener = function (_event) {
-          if (_event === localEvent && listeners[event] === null) {
-            listeners[event] = handler;
-            observer._on.call(target, event, handler);
-          }
-        };
-
-        emitter.on('newListener', this._onNewListener);
-
-        this._onRemoveListener= function(_event){
-          if(_event === localEvent && !emitter.hasListeners(_event) && listeners[event]){
-            listeners[event]= null;
-            observer._off.call(target, event, handler);
-          }
-        };
-
-        listeners[event]= null;
-
-        emitter.on('removeListener', this._onRemoveListener);
-      }else{
-        listeners[event]= handler;
-        observer._on.call(target, event, handler);
-      }
-    },
-
-    unsubscribe: function(event){
-      var observer= this;
-      var listeners= this._listeners;
-      var emitter= this._emitter;
-      var handler;
-      var events;
-      var off= this._off;
-      var target= this._target;
-      var i;
-
-      if(event && typeof event!=='string'){
-        throw TypeError('event must be a string');
-      }
-
-      function clearRefs(){
-        if(observer._onNewListener){
-          emitter.off('newListener', observer._onNewListener);
-          emitter.off('removeListener', observer._onRemoveListener);
-          observer._onNewListener= null;
-          observer._onRemoveListener= null;
-        }
-        var index= findTargetIndex.call(emitter, observer);
-        emitter._observers.splice(index, 1);
-      }
-
-      if(event){
-        handler= listeners[event];
-        if(!handler) return;
-        off.call(target, event, handler);
-        delete listeners[event];
-        if(!--this._listenersCount){
-          clearRefs();
-        }
-      }else{
-        events= ownKeys(listeners);
-        i= events.length;
-        while(i-->0){
-          event= events[i];
-          off.call(target, event, listeners[event]);
-        }
-        this._listeners= {};
-        this._listenersCount= 0;
-        clearRefs();
-      }
-    }
-  });
-
-  function resolveOptions(options, schema, reducers, allowUnknown) {
-    var computedOptions = Object.assign({}, schema);
-
-    if (!options) return computedOptions;
-
-    if (typeof options !== 'object') {
-      throw TypeError('options must be an object')
-    }
-
-    var keys = Object.keys(options);
-    var length = keys.length;
-    var option, value;
-    var reducer;
-
-    function reject(reason) {
-      throw Error('Invalid "' + option + '" option value' + (reason ? '. Reason: ' + reason : ''))
-    }
-
-    for (var i = 0; i < length; i++) {
-      option = keys[i];
-      if (!allowUnknown && !hasOwnProperty.call(schema, option)) {
-        throw Error('Unknown "' + option + '" option');
-      }
-      value = options[option];
-      if (value !== undefined) {
-        reducer = reducers[option];
-        computedOptions[option] = reducer ? reducer(value, reject) : value;
-      }
-    }
-    return computedOptions;
-  }
-
-  function constructorReducer(value, reject) {
-    if (typeof value !== 'function' || !value.hasOwnProperty('prototype')) {
-      reject('value must be a constructor');
-    }
-    return value;
-  }
-
-  function makeTypeReducer(types) {
-    var message= 'value must be type of ' + types.join('|');
-    var len= types.length;
-    var firstType= types[0];
-    var secondType= types[1];
-
-    if (len === 1) {
-      return function (v, reject) {
-        if (typeof v === firstType) {
-          return v;
-        }
-        reject(message);
-      }
-    }
-
-    if (len === 2) {
-      return function (v, reject) {
-        var kind= typeof v;
-        if (kind === firstType || kind === secondType) return v;
-        reject(message);
-      }
-    }
-
-    return function (v, reject) {
-      var kind = typeof v;
-      var i = len;
-      while (i-- > 0) {
-        if (kind === types[i]) return v;
-      }
-      reject(message);
-    }
-  }
-
-  var functionReducer= makeTypeReducer(['function']);
-
-  var objectFunctionReducer= makeTypeReducer(['object', 'function']);
-
-  function makeCancelablePromise(Promise, executor, options) {
-    var isCancelable;
-    var callbacks;
-    var timer= 0;
-    var subscriptionClosed;
-
-    var promise = new Promise(function (resolve, reject, onCancel) {
-      options= resolveOptions(options, {
-        timeout: 0,
-        overload: false
-      }, {
-        timeout: function(value, reject){
-          value*= 1;
-          if (typeof value !== 'number' || value < 0 || !Number.isFinite(value)) {
-            reject('timeout must be a positive number');
-          }
-          return value;
-        }
-      });
-
-      isCancelable = !options.overload && typeof Promise.prototype.cancel === 'function' && typeof onCancel === 'function';
-
-      function cleanup() {
-        if (callbacks) {
-          callbacks = null;
-        }
-        if (timer) {
-          clearTimeout(timer);
-          timer = 0;
-        }
-      }
-
-      var _resolve= function(value){
-        cleanup();
-        resolve(value);
-      };
-
-      var _reject= function(err){
-        cleanup();
-        reject(err);
-      };
-
-      if (isCancelable) {
-        executor(_resolve, _reject, onCancel);
-      } else {
-        callbacks = [function(reason){
-          _reject(reason || Error('canceled'));
-        }];
-        executor(_resolve, _reject, function (cb) {
-          if (subscriptionClosed) {
-            throw Error('Unable to subscribe on cancel event asynchronously')
-          }
-          if (typeof cb !== 'function') {
-            throw TypeError('onCancel callback must be a function');
-          }
-          callbacks.push(cb);
-        });
-        subscriptionClosed= true;
-      }
-
-      if (options.timeout > 0) {
-        timer= setTimeout(function(){
-          var reason= Error('timeout');
-          reason.code = 'ETIMEDOUT'
-          timer= 0;
-          promise.cancel(reason);
-          reject(reason);
-        }, options.timeout);
-      }
-    });
-
-    if (!isCancelable) {
-      promise.cancel = function (reason) {
-        if (!callbacks) {
-          return;
-        }
-        var length = callbacks.length;
-        for (var i = 1; i < length; i++) {
-          callbacks[i](reason);
-        }
-        // internal callback to reject the promise
-        callbacks[0](reason);
-        callbacks = null;
-      };
-    }
-
-    return promise;
-  }
-
-  function findTargetIndex(observer) {
-    var observers = this._observers;
-    if(!observers){
-      return -1;
-    }
-    var len = observers.length;
-    for (var i = 0; i < len; i++) {
-      if (observers[i]._target === observer) return i;
-    }
-    return -1;
-  }
-
-  // Attention, function return type now is array, always !
-  // It has zero elements if no any matches found and one or more
-  // elements (leafs) if there are matches
-  //
-  function searchListenerTree(handlers, type, tree, i, typeLength) {
-    if (!tree) {
-      return null;
-    }
-
-    if (i === 0) {
-      var kind = typeof type;
-      if (kind === 'string') {
-        var ns, n, l = 0, j = 0, delimiter = this.delimiter, dl = delimiter.length;
-        if ((n = type.indexOf(delimiter)) !== -1) {
-          ns = new Array(5);
-          do {
-            ns[l++] = type.slice(j, n);
-            j = n + dl;
-          } while ((n = type.indexOf(delimiter, j)) !== -1);
-
-          ns[l++] = type.slice(j);
-          type = ns;
-          typeLength = l;
-        } else {
-          type = [type];
-          typeLength = 1;
-        }
-      } else if (kind === 'object') {
-        typeLength = type.length;
-      } else {
-        type = [type];
-        typeLength = 1;
-      }
-    }
-
-    var listeners= null, branch, xTree, xxTree, isolatedBranch, endReached, currentType = type[i],
-        nextType = type[i + 1], branches, _listeners;
-
-    if (i === typeLength) {
-      //
-      // If at the end of the event(s) list and the tree has listeners
-      // invoke those listeners.
-      //
-
-      if(tree._listeners) {
-        if (typeof tree._listeners === 'function') {
-          handlers && handlers.push(tree._listeners);
-          listeners = [tree];
-        } else {
-          handlers && handlers.push.apply(handlers, tree._listeners);
-          listeners = [tree];
-        }
-      }
-    } else {
-
-      if (currentType === '*') {
-        //
-        // If the event emitted is '*' at this part
-        // or there is a concrete match at this patch
-        //
-        branches = ownKeys(tree);
-        n = branches.length;
-        while (n-- > 0) {
-          branch = branches[n];
-          if (branch !== '_listeners') {
-            _listeners = searchListenerTree(handlers, type, tree[branch], i + 1, typeLength);
-            if (_listeners) {
-              if (listeners) {
-                listeners.push.apply(listeners, _listeners);
-              } else {
-                listeners = _listeners;
-              }
-            }
-          }
-        }
-        return listeners;
-      } else if (currentType === '**') {
-        endReached = (i + 1 === typeLength || (i + 2 === typeLength && nextType === '*'));
-        if (endReached && tree._listeners) {
-          // The next element has a _listeners, add it to the handlers.
-          listeners = searchListenerTree(handlers, type, tree, typeLength, typeLength);
-        }
-
-        branches = ownKeys(tree);
-        n = branches.length;
-        while (n-- > 0) {
-          branch = branches[n];
-          if (branch !== '_listeners') {
-            if (branch === '*' || branch === '**') {
-              if (tree[branch]._listeners && !endReached) {
-                _listeners = searchListenerTree(handlers, type, tree[branch], typeLength, typeLength);
-                if (_listeners) {
-                  if (listeners) {
-                    listeners.push.apply(listeners, _listeners);
-                  } else {
-                    listeners = _listeners;
-                  }
-                }
-              }
-              _listeners = searchListenerTree(handlers, type, tree[branch], i, typeLength);
-            } else if (branch === nextType) {
-              _listeners = searchListenerTree(handlers, type, tree[branch], i + 2, typeLength);
-            } else {
-              // No match on this one, shift into the tree but not in the type array.
-              _listeners = searchListenerTree(handlers, type, tree[branch], i, typeLength);
-            }
-            if (_listeners) {
-              if (listeners) {
-                listeners.push.apply(listeners, _listeners);
-              } else {
-                listeners = _listeners;
-              }
-            }
-          }
-        }
-        return listeners;
-      } else if (tree[currentType]) {
-        listeners = searchListenerTree(handlers, type, tree[currentType], i + 1, typeLength);
-      }
-    }
-
-      xTree = tree['*'];
-    if (xTree) {
-      //
-      // If the listener tree will allow any match for this part,
-      // then recursively explore all branches of the tree
-      //
-      searchListenerTree(handlers, type, xTree, i + 1, typeLength);
-    }
-
-    xxTree = tree['**'];
-    if (xxTree) {
-      if (i < typeLength) {
-        if (xxTree._listeners) {
-          // If we have a listener on a '**', it will catch all, so add its handler.
-          searchListenerTree(handlers, type, xxTree, typeLength, typeLength);
-        }
-
-        // Build arrays of matching next branches and others.
-        branches= ownKeys(xxTree);
-        n= branches.length;
-        while(n-->0){
-          branch= branches[n];
-          if (branch !== '_listeners') {
-            if (branch === nextType) {
-              // We know the next element will match, so jump twice.
-              searchListenerTree(handlers, type, xxTree[branch], i + 2, typeLength);
-            } else if (branch === currentType) {
-              // Current node matches, move into the tree.
-              searchListenerTree(handlers, type, xxTree[branch], i + 1, typeLength);
-            } else {
-              isolatedBranch = {};
-              isolatedBranch[branch] = xxTree[branch];
-              searchListenerTree(handlers, type, {'**': isolatedBranch}, i + 1, typeLength);
-            }
-          }
-        }
-      } else if (xxTree._listeners) {
-        // We have reached the end and still on a '**'
-        searchListenerTree(handlers, type, xxTree, typeLength, typeLength);
-      } else if (xxTree['*'] && xxTree['*']._listeners) {
-        searchListenerTree(handlers, type, xxTree['*'], typeLength, typeLength);
-      }
-    }
-
-    return listeners;
-  }
-
-  function growListenerTree(type, listener, prepend) {
-    var len = 0, j = 0, i, delimiter = this.delimiter, dl= delimiter.length, ns;
-
-    if(typeof type==='string') {
-      if ((i = type.indexOf(delimiter)) !== -1) {
-        ns = new Array(5);
-        do {
-          ns[len++] = type.slice(j, i);
-          j = i + dl;
-        } while ((i = type.indexOf(delimiter, j)) !== -1);
-
-        ns[len++] = type.slice(j);
-      }else{
-        ns= [type];
-        len= 1;
-      }
-    }else{
-      ns= type;
-      len= type.length;
-    }
-
-    //
-    // Looks for two consecutive '**', if so, don't add the event at all.
-    //
-    if (len > 1) {
-      for (i = 0; i + 1 < len; i++) {
-        if (ns[i] === '**' && ns[i + 1] === '**') {
-          return;
-        }
-      }
-    }
-
-
-
-    var tree = this.listenerTree, name;
-
-    for (i = 0; i < len; i++) {
-      name = ns[i];
-
-      tree = tree[name] || (tree[name] = {});
-
-      if (i === len - 1) {
-        if (!tree._listeners) {
-          tree._listeners = listener;
-        } else {
-          if (typeof tree._listeners === 'function') {
-            tree._listeners = [tree._listeners];
-          }
-
-          if (prepend) {
-            tree._listeners.unshift(listener);
-          } else {
-            tree._listeners.push(listener);
-          }
-
-          if (
-              !tree._listeners.warned &&
-              this._maxListeners > 0 &&
-              tree._listeners.length > this._maxListeners
-          ) {
-            tree._listeners.warned = true;
-            logPossibleMemoryLeak.call(this, tree._listeners.length, name);
-          }
-        }
-        return true;
-      }
-    }
-
-    return true;
-  }
-
-  function collectTreeEvents(tree, events, root, asArray){
-     var branches= ownKeys(tree);
-     var i= branches.length;
-     var branch, branchName, path;
-     var hasListeners= tree['_listeners'];
-     var isArrayPath;
-
-     while(i-->0){
-         branchName= branches[i];
-
-         branch= tree[branchName];
-
-         if(branchName==='_listeners'){
-             path= root;
-         }else {
-             path = root ? root.concat(branchName) : [branchName];
-         }
-
-         isArrayPath= asArray || typeof branchName==='symbol';
-
-         hasListeners && events.push(isArrayPath? path : path.join(this.delimiter));
-
-         if(typeof branch==='object'){
-             collectTreeEvents.call(this, branch, events, path, isArrayPath);
-         }
-     }
-
-     return events;
-  }
-
-  function recursivelyGarbageCollect(root) {
-    var keys = ownKeys(root);
-    var i= keys.length;
-    var obj, key, flag;
-    while(i-->0){
-      key = keys[i];
-      obj = root[key];
-
-      if(obj){
-          flag= true;
-          if(key !== '_listeners' && !recursivelyGarbageCollect(obj)){
-             delete root[key];
-          }
-      }
-    }
-
-    return flag;
-  }
-
-  function Listener(emitter, event, listener){
-    this.emitter= emitter;
-    this.event= event;
-    this.listener= listener;
-  }
-
-  Listener.prototype.off= function(){
-    this.emitter.off(this.event, this.listener);
-    return this;
-  };
-
-  function setupListener(event, listener, options){
-      if (options === true) {
-        promisify = true;
-      } else if (options === false) {
-        async = true;
-      } else {
-        if (!options || typeof options !== 'object') {
-          throw TypeError('options should be an object or true');
-        }
-        var async = options.async;
-        var promisify = options.promisify;
-        var nextTick = options.nextTick;
-        var objectify = options.objectify;
-      }
-
-      if (async || nextTick || promisify) {
-        var _listener = listener;
-        var _origin = listener._origin || listener;
-
-        if (nextTick && !nextTickSupported) {
-          throw Error('process.nextTick is not supported');
-        }
-
-        if (promisify === undefined) {
-          promisify = listener.constructor.name === 'AsyncFunction';
-        }
-
-        listener = function () {
-          var args = arguments;
-          var context = this;
-          var event = this.event;
-
-          return promisify ? (nextTick ? Promise.resolve() : new Promise(function (resolve) {
-            _setImmediate(resolve);
-          }).then(function () {
-            context.event = event;
-            return _listener.apply(context, args)
-          })) : (nextTick ? process.nextTick : _setImmediate)(function () {
-            context.event = event;
-            _listener.apply(context, args)
-          });
-        };
-
-        listener._async = true;
-        listener._origin = _origin;
-      }
-
-    return [listener, objectify? new Listener(this, event, listener): this];
-  }
-
-  function EventEmitter(conf) {
-    this._events = {};
-    this._newListener = false;
-    this._removeListener = false;
-    this.verboseMemoryLeak = false;
-    configure.call(this, conf);
-  }
-
-  EventEmitter.EventEmitter2 = EventEmitter; // backwards compatibility for exporting EventEmitter property
-
-  EventEmitter.prototype.listenTo= function(target, events, options){
-    if(typeof target!=='object'){
-      throw TypeError('target musts be an object');
-    }
-
-    var emitter= this;
-
-    options = resolveOptions(options, {
-      on: undefined,
-      off: undefined,
-      reducers: undefined
-    }, {
-      on: functionReducer,
-      off: functionReducer,
-      reducers: objectFunctionReducer
-    });
-
-    function listen(events){
-      if(typeof events!=='object'){
-        throw TypeError('events must be an object');
-      }
-
-      var reducers= options.reducers;
-      var index= findTargetIndex.call(emitter, target);
-      var observer;
-
-      if(index===-1){
-        observer= new TargetObserver(emitter, target, options);
-      }else{
-        observer= emitter._observers[index];
-      }
-
-      var keys= ownKeys(events);
-      var len= keys.length;
-      var event;
-      var isSingleReducer= typeof reducers==='function';
-
-      for(var i=0; i<len; i++){
-        event= keys[i];
-        observer.subscribe(
-            event,
-            events[event] || event,
-            isSingleReducer ? reducers : reducers && reducers[event]
-        );
-      }
-    }
-
-    isArray(events)?
-        listen(toObject(events)) :
-        (typeof events==='string'? listen(toObject(events.split(/\s+/))): listen(events));
-
-    return this;
-  };
-
-  EventEmitter.prototype.stopListeningTo = function (target, event) {
-    var observers = this._observers;
-
-    if(!observers){
-      return false;
-    }
-
-    var i = observers.length;
-    var observer;
-    var matched= false;
-
-    if(target && typeof target!=='object'){
-      throw TypeError('target should be an object');
-    }
-
-    while (i-- > 0) {
-      observer = observers[i];
-      if (!target || observer._target === target) {
-        observer.unsubscribe(event);
-        matched= true;
-      }
-    }
-
-    return matched;
-  };
-
-  // 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.
-  //
-  // Obviously not all Emitters should be limited to 10. This function allows
-  // that to be increased. Set to zero for unlimited.
-
-  EventEmitter.prototype.delimiter = '.';
-
-  EventEmitter.prototype.setMaxListeners = function(n) {
-    if (n !== undefined) {
-      this._maxListeners = n;
-      if (!this._conf) this._conf = {};
-      this._conf.maxListeners = n;
-    }
-  };
-
-  EventEmitter.prototype.getMaxListeners = function() {
-    return this._maxListeners;
-  };
-
-  EventEmitter.prototype.event = '';
-
-  EventEmitter.prototype.once = function(event, fn, options) {
-    return this._once(event, fn, false, options);
-  };
-
-  EventEmitter.prototype.prependOnceListener = function(event, fn, options) {
-    return this._once(event, fn, true, options);
-  };
-
-  EventEmitter.prototype._once = function(event, fn, prepend, options) {
-    return this._many(event, 1, fn, prepend, options);
-  };
-
-  EventEmitter.prototype.many = function(event, ttl, fn, options) {
-    return this._many(event, ttl, fn, false, options);
-  };
-
-  EventEmitter.prototype.prependMany = function(event, ttl, fn, options) {
-    return this._many(event, ttl, fn, true, options);
-  };
-
-  EventEmitter.prototype._many = function(event, ttl, fn, prepend, options) {
-    var self = this;
-
-    if (typeof fn !== 'function') {
-      throw new Error('many only accepts instances of Function');
-    }
-
-    function listener() {
-      if (--ttl === 0) {
-        self.off(event, listener);
-      }
-      return fn.apply(this, arguments);
-    }
-
-    listener._origin = fn;
-
-    return this._on(event, listener, prepend, options);
-  };
-
-  EventEmitter.prototype.emit = function() {
-    if (!this._events && !this._all) {
-      return false;
-    }
-
-    this._events || init.call(this);
-
-    var type = arguments[0], ns, wildcard= this.wildcard;
-    var args,l,i,j, containsSymbol;
-
-    if (type === 'newListener' && !this._newListener) {
-      if (!this._events.newListener) {
-        return false;
-      }
-    }
-
-    if (wildcard) {
-      ns= type;
-      if(type!=='newListener' && type!=='removeListener'){
-        if (typeof type === 'object') {
-          l = type.length;
-          if (symbolsSupported) {
-            for (i = 0; i < l; i++) {
-              if (typeof type[i] === 'symbol') {
-                containsSymbol = true;
-                break;
-              }
-            }
-          }
-          if (!containsSymbol) {
-            type = type.join(this.delimiter);
-          }
-        }
-      }
-    }
-
-    var al = arguments.length;
-    var handler;
-
-    if (this._all && this._all.length) {
-      handler = this._all.slice();
-
-      for (i = 0, l = handler.length; i < l; i++) {
-        this.event = type;
-        switch (al) {
-        case 1:
-          handler[i].call(this, type);
-          break;
-        case 2:
-          handler[i].call(this, type, arguments[1]);
-          break;
-        case 3:
-          handler[i].call(this, type, arguments[1], arguments[2]);
-          break;
-        default:
-          handler[i].apply(this, arguments);
-        }
-      }
-    }
-
-    if (wildcard) {
-      handler = [];
-      searchListenerTree.call(this, handler, ns, this.listenerTree, 0, l);
-    } else {
-      handler = this._events[type];
-      if (typeof handler === 'function') {
-        this.event = type;
-        switch (al) {
-        case 1:
-          handler.call(this);
-          break;
-        case 2:
-          handler.call(this, arguments[1]);
-          break;
-        case 3:
-          handler.call(this, arguments[1], arguments[2]);
-          break;
-        default:
-          args = new Array(al - 1);
-          for (j = 1; j < al; j++) args[j - 1] = arguments[j];
-          handler.apply(this, args);
-        }
-        return true;
-      } else if (handler) {
-        // need to make copy of handlers because list can change in the middle
-        // of emit call
-        handler = handler.slice();
-      }
-    }
-
-    if (handler && handler.length) {
-      if (al > 3) {
-        args = new Array(al - 1);
-        for (j = 1; j < al; j++) args[j - 1] = arguments[j];
-      }
-      for (i = 0, l = handler.length; i < l; i++) {
-        this.event = type;
-        switch (al) {
-        case 1:
-          handler[i].call(this);
-          break;
-        case 2:
-          handler[i].call(this, arguments[1]);
-          break;
-        case 3:
-          handler[i].call(this, arguments[1], arguments[2]);
-          break;
-        default:
-          handler[i].apply(this, args);
-        }
-      }
-      return true;
-    } else if (!this.ignoreErrors && !this._all && type === 'error') {
-      if (arguments[1] instanceof Error) {
-        throw arguments[1]; // Unhandled 'error' event
-      } else {
-        throw new Error("Uncaught, unspecified 'error' event.");
-      }
-    }
-
-    return !!this._all;
-  };
-
-  EventEmitter.prototype.emitAsync = function() {
-    if (!this._events && !this._all) {
-      return false;
-    }
-
-    this._events || init.call(this);
-
-    var type = arguments[0], wildcard= this.wildcard, ns, containsSymbol;
-    var args,l,i,j;
-
-    if (type === 'newListener' && !this._newListener) {
-        if (!this._events.newListener) { return Promise.resolve([false]); }
-    }
-
-    if (wildcard) {
-      ns= type;
-      if(type!=='newListener' && type!=='removeListener'){
-        if (typeof type === 'object') {
-          l = type.length;
-          if (symbolsSupported) {
-            for (i = 0; i < l; i++) {
-              if (typeof type[i] === 'symbol') {
-                containsSymbol = true;
-                break;
-              }
-            }
-          }
-          if (!containsSymbol) {
-            type = type.join(this.delimiter);
-          }
-        }
-      }
-    }
-
-    var promises= [];
-
-    var al = arguments.length;
-    var handler;
-
-    if (this._all) {
-      for (i = 0, l = this._all.length; i < l; i++) {
-        this.event = type;
-        switch (al) {
-        case 1:
-          promises.push(this._all[i].call(this, type));
-          break;
-        case 2:
-          promises.push(this._all[i].call(this, type, arguments[1]));
-          break;
-        case 3:
-          promises.push(this._all[i].call(this, type, arguments[1], arguments[2]));
-          break;
-        default:
-          promises.push(this._all[i].apply(this, arguments));
-        }
-      }
-    }
-
-    if (wildcard) {
-      handler = [];
-      searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
-    } else {
-      handler = this._events[type];
-    }
-
-    if (typeof handler === 'function') {
-      this.event = type;
-      switch (al) {
-      case 1:
-        promises.push(handler.call(this));
-        break;
-      case 2:
-        promises.push(handler.call(this, arguments[1]));
-        break;
-      case 3:
-        promises.push(handler.call(this, arguments[1], arguments[2]));
-        break;
-      default:
-        args = new Array(al - 1);
-        for (j = 1; j < al; j++) args[j - 1] = arguments[j];
-        promises.push(handler.apply(this, args));
-      }
-    } else if (handler && handler.length) {
-      handler = handler.slice();
-      if (al > 3) {
-        args = new Array(al - 1);
-        for (j = 1; j < al; j++) args[j - 1] = arguments[j];
-      }
-      for (i = 0, l = handler.length; i < l; i++) {
-        this.event = type;
-        switch (al) {
-        case 1:
-          promises.push(handler[i].call(this));
-          break;
-        case 2:
-          promises.push(handler[i].call(this, arguments[1]));
-          break;
-        case 3:
-          promises.push(handler[i].call(this, arguments[1], arguments[2]));
-          break;
-        default:
-          promises.push(handler[i].apply(this, args));
-        }
-      }
-    } else if (!this.ignoreErrors && !this._all && type === 'error') {
-      if (arguments[1] instanceof Error) {
-        return Promise.reject(arguments[1]); // Unhandled 'error' event
-      } else {
-        return Promise.reject("Uncaught, unspecified 'error' event.");
-      }
-    }
-
-    return Promise.all(promises);
-  };
-
-  EventEmitter.prototype.on = function(type, listener, options) {
-    return this._on(type, listener, false, options);
-  };
-
-  EventEmitter.prototype.prependListener = function(type, listener, options) {
-    return this._on(type, listener, true, options);
-  };
-
-  EventEmitter.prototype.onAny = function(fn) {
-    return this._onAny(fn, false);
-  };
-
-  EventEmitter.prototype.prependAny = function(fn) {
-    return this._onAny(fn, true);
-  };
-
-  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-  EventEmitter.prototype._onAny = function(fn, prepend){
-    if (typeof fn !== 'function') {
-      throw new Error('onAny only accepts instances of Function');
-    }
-
-    if (!this._all) {
-      this._all = [];
-    }
-
-    // Add the function to the event listener collection.
-    if(prepend){
-      this._all.unshift(fn);
-    }else{
-      this._all.push(fn);
-    }
-
-    return this;
-  };
-
-  EventEmitter.prototype._on = function(type, listener, prepend, options) {
-    if (typeof type === 'function') {
-      this._onAny(type, listener);
-      return this;
-    }
-
-    if (typeof listener !== 'function') {
-      throw new Error('on only accepts instances of Function');
-    }
-    this._events || init.call(this);
-
-    var returnValue= this, temp;
-
-    if (options !== undefined) {
-      temp = setupListener.call(this, type, listener, options);
-      listener = temp[0];
-      returnValue = temp[1];
-    }
-
-    // To avoid recursion in the case that type == "newListeners"! Before
-    // adding it to the listeners, first emit "newListeners".
-    if (this._newListener) {
-      this.emit('newListener', type, listener);
-    }
-
-    if (this.wildcard) {
-      growListenerTree.call(this, type, listener, prepend);
-      return returnValue;
-    }
-
-    if (!this._events[type]) {
-      // Optimize the case of one listener. Don't need the extra array object.
-      this._events[type] = listener;
-    } else {
-      if (typeof this._events[type] === 'function') {
-        // Change to array.
-        this._events[type] = [this._events[type]];
-      }
-
-      // If we've already got an array, just add
-      if(prepend){
-        this._events[type].unshift(listener);
-      }else{
-        this._events[type].push(listener);
-      }
-
-      // Check for listener leak
-      if (
-        !this._events[type].warned &&
-        this._maxListeners > 0 &&
-        this._events[type].length > this._maxListeners
-      ) {
-        this._events[type].warned = true;
-        logPossibleMemoryLeak.call(this, this._events[type].length, type);
-      }
-    }
-
-    return returnValue;
-  };
-
-  EventEmitter.prototype.off = function(type, listener) {
-    if (typeof listener !== 'function') {
-      throw new Error('removeListener only takes instances of Function');
-    }
-
-    var handlers,leafs=[];
-
-    if(this.wildcard) {
-      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
-      leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
-      if(!leafs) return this;
-    } else {
-      // does not use listeners(), so no side effect of creating _events[type]
-      if (!this._events[type]) return this;
-      handlers = this._events[type];
-      leafs.push({_listeners:handlers});
-    }
-
-    for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {
-      var leaf = leafs[iLeaf];
-      handlers = leaf._listeners;
-      if (isArray(handlers)) {
-
-        var position = -1;
-
-        for (var i = 0, length = handlers.length; i < length; i++) {
-          if (handlers[i] === listener ||
-            (handlers[i].listener && handlers[i].listener === listener) ||
-            (handlers[i]._origin && handlers[i]._origin === listener)) {
-            position = i;
-            break;
-          }
-        }
-
-        if (position < 0) {
-          continue;
-        }
-
-        if(this.wildcard) {
-          leaf._listeners.splice(position, 1);
-        }
-        else {
-          this._events[type].splice(position, 1);
-        }
-
-        if (handlers.length === 0) {
-          if(this.wildcard) {
-            delete leaf._listeners;
-          }
-          else {
-            delete this._events[type];
-          }
-        }
-        if (this._removeListener)
-          this.emit("removeListener", type, listener);
-
-        return this;
-      }
-      else if (handlers === listener ||
-        (handlers.listener && handlers.listener === listener) ||
-        (handlers._origin && handlers._origin === listener)) {
-        if(this.wildcard) {
-          delete leaf._listeners;
-        }
-        else {
-          delete this._events[type];
-        }
-        if (this._removeListener)
-          this.emit("removeListener", type, listener);
-      }
-    }
-
-    this.listenerTree && recursivelyGarbageCollect(this.listenerTree);
-
-    return this;
-  };
-
-  EventEmitter.prototype.offAny = function(fn) {
-    var i = 0, l = 0, fns;
-    if (fn && this._all && this._all.length > 0) {
-      fns = this._all;
-      for(i = 0, l = fns.length; i < l; i++) {
-        if(fn === fns[i]) {
-          fns.splice(i, 1);
-          if (this._removeListener)
-            this.emit("removeListenerAny", fn);
-          return this;
-        }
-      }
-    } else {
-      fns = this._all;
-      if (this._removeListener) {
-        for(i = 0, l = fns.length; i < l; i++)
-          this.emit("removeListenerAny", fns[i]);
-      }
-      this._all = [];
-    }
-    return this;
-  };
-
-  EventEmitter.prototype.removeListener = EventEmitter.prototype.off;
-
-  EventEmitter.prototype.removeAllListeners = function (type) {
-    if (type === undefined) {
-      !this._events || init.call(this);
-      return this;
-    }
-
-    if (this.wildcard) {
-      var leafs = searchListenerTree.call(this, null, type, this.listenerTree, 0), leaf, i;
-      if (!leafs) return this;
-      for (i = 0; i < leafs.length; i++) {
-        leaf = leafs[i];
-        leaf._listeners = null;
-      }
-      this.listenerTree && recursivelyGarbageCollect(this.listenerTree);
-    } else if (this._events) {
-      this._events[type] = null;
-    }
-    return this;
-  };
-
-  EventEmitter.prototype.listeners = function (type) {
-    var _events = this._events;
-    var keys, listeners, allListeners;
-    var i;
-    var listenerTree;
-
-    if (type === undefined) {
-      if (this.wildcard) {
-        throw Error('event name required for wildcard emitter');
-      }
-
-      if (!_events) {
-        return [];
-      }
-
-      keys = ownKeys(_events);
-      i = keys.length;
-      allListeners = [];
-      while (i-- > 0) {
-        listeners = _events[keys[i]];
-        if (typeof listeners === 'function') {
-          allListeners.push(listeners);
-        } else {
-          allListeners.push.apply(allListeners, listeners);
-        }
-      }
-      return allListeners;
-    } else {
-      if (this.wildcard) {
-        listenerTree= this.listenerTree;
-        if(!listenerTree) return [];
-        var handlers = [];
-        var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
-        searchListenerTree.call(this, handlers, ns, listenerTree, 0);
-        return handlers;
-      }
-
-      if (!_events) {
-        return [];
-      }
-
-      listeners = _events[type];
-
-      if (!listeners) {
-        return [];
-      }
-      return typeof listeners === 'function' ? [listeners] : listeners;
-    }
-  };
-
-  EventEmitter.prototype.eventNames = function(nsAsArray){
-    var _events= this._events;
-    return this.wildcard? collectTreeEvents.call(this, this.listenerTree, [], null, nsAsArray) : (_events? ownKeys(_events) : []);
-  };
-
-  EventEmitter.prototype.listenerCount = function(type) {
-    return this.listeners(type).length;
-  };
-
-  EventEmitter.prototype.hasListeners = function (type) {
-    if (this.wildcard) {
-      var handlers = [];
-      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
-      searchListenerTree.call(this, handlers, ns, this.listenerTree, 0);
-      return handlers.length > 0;
-    }
-
-    var _events = this._events;
-    var _all = this._all;
-
-    return !!(_all && _all.length || _events && (type === undefined ? ownKeys(_events).length : _events[type]));
-  };
-
-  EventEmitter.prototype.listenersAny = function() {
-
-    if(this._all) {
-      return this._all;
-    }
-    else {
-      return [];
-    }
-
-  };
-
-  EventEmitter.prototype.waitFor = function (event, options) {
-    var self = this;
-    var type = typeof options;
-    if (type === 'number') {
-      options = {timeout: options};
-    } else if (type === 'function') {
-      options = {filter: options};
-    }
-
-    options= resolveOptions(options, {
-      timeout: 0,
-      filter: undefined,
-      handleError: false,
-      Promise: Promise,
-      overload: false
-    }, {
-      filter: functionReducer,
-      Promise: constructorReducer
-    });
-
-    return makeCancelablePromise(options.Promise, function (resolve, reject, onCancel) {
-      function listener() {
-        var filter= options.filter;
-        if (filter && !filter.apply(self, arguments)) {
-          return;
-        }
-        self.off(event, listener);
-        if (options.handleError) {
-          var err = arguments[0];
-          err ? reject(err) : resolve(toArray.apply(null, arguments).slice(1));
-        } else {
-          resolve(toArray.apply(null, arguments));
-        }
-      }
-
-      onCancel(function(){
-        self.off(event, listener);
-      });
-
-      self._on(event, listener, false);
-    }, {
-      timeout: options.timeout,
-      overload: options.overload
-    })
-  };
-
-  function once(emitter, name, options) {
-    options= resolveOptions(options, {
-      Promise: Promise,
-      timeout: 0,
-      overload: false
-    }, {
-      Promise: constructorReducer
-    });
-
-    var _Promise= options.Promise;
-
-    return makeCancelablePromise(_Promise, function(resolve, reject, onCancel){
-      var handler;
-      if (typeof emitter.addEventListener === 'function') {
-        handler=  function () {
-          resolve(toArray.apply(null, arguments));
-        };
-
-        onCancel(function(){
-          emitter.removeEventListener(name, handler);
-        });
-
-        emitter.addEventListener(
-            name,
-            handler,
-            {once: true}
-        );
-        return;
-      }
-
-      var eventListener = function(){
-        errorListener && emitter.removeListener('error', errorListener);
-        resolve(toArray.apply(null, arguments));
-      };
-
-      var errorListener;
-
-      if (name !== 'error') {
-        errorListener = function (err){
-          emitter.removeListener(name, eventListener);
-          reject(err);
-        };
-
-        emitter.once('error', errorListener);
-      }
-
-      onCancel(function(){
-        errorListener && emitter.removeListener('error', errorListener);
-        emitter.removeListener(name, eventListener);
-      });
-
-      emitter.once(name, eventListener);
-    }, {
-      timeout: options.timeout,
-      overload: options.overload
-    });
-  }
-
-  var prototype= EventEmitter.prototype;
-
-  Object.defineProperties(EventEmitter, {
-    defaultMaxListeners: {
-      get: function () {
-        return prototype._maxListeners;
-      },
-      set: function (n) {
-        if (typeof n !== 'number' || n < 0 || Number.isNaN(n)) {
-          throw TypeError('n must be a non-negative number')
-        }
-        prototype._maxListeners = n;
-      },
-      enumerable: true
-    },
-    once: {
-      value: once,
-      writable: true,
-      configurable: true
-    }
-  });
-
-  Object.defineProperties(prototype, {
-      _maxListeners: {
-          value: defaultMaxListeners,
-          writable: true,
-          configurable: true
-      },
-      _observers: {value: null, writable: true, configurable: true}
-  });
-
-  if (typeof define === 'function' && define.amd) {
-     // AMD. Register as an anonymous module.
-    define(function() {
-      return EventEmitter;
-    });
-  } else if (typeof exports === 'object') {
-    // CommonJS
-    module.exports = EventEmitter;
-  }
-  else {
-    // global for any kind of environment.
-    var _global= new Function('','return this')();
-    _global.EventEmitter2 = EventEmitter;
-  }
-}();