text: var httpProxy = module.exports,
      extend    = require('util')._extend,
      parse_url = require('url').parse,
      EE3       = require('eventemitter3'),
      http      = require('http'),
      https     = require('https'),
      web       = require('./passes/web-incoming'),
      ws        = require('./passes/ws-incoming');
  
  httpProxy.Server = ProxyServer;
  
  /**
   * Returns a function that creates the loader for
   * either `ws` or `web`'s  passes.
   *
   * Examples:
   *
   *    httpProxy.createRightProxy('ws')
   *    // => [Function]
   *
   * @param {String} Type Either 'ws' or 'web'
   * 
   * @return {Function} Loader Function that when called returns an iterator for the right passes
   *
   * @api private
   */
  
  function createRightProxy(type, options) {
    return async function(req, res /*, [head], [opts] */) {
      var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
          args = [].slice.call(arguments),
          cntr = args.length - 1,
          head, cbl;
  
      /* optional args parse begin */
      if(typeof args[cntr] === 'function') {
        cbl = args[cntr];
  
        cntr--;
      }
  
      var requestOptions = options;
      if(
        !(args[cntr] instanceof Buffer) &&
        args[cntr] !== res
      ) {
        //Copy global options
        requestOptions = extend({}, options);
        //Overwrite with request options
        extend(requestOptions, args[cntr]);
  
        cntr--;
      }
  
      if(args[cntr] instanceof Buffer) {
        head = args[cntr];
      }
  
      /* optional args parse end */
  
      ['target', 'forward'].forEach(function(e) {
        if (typeof requestOptions[e] === 'string')
          requestOptions[e] = parse_url(requestOptions[e]);
      });
  
      if (!requestOptions.target && !requestOptions.forward) {
        return this.emit('error', new Error('Must provide a proper URL as target'));
      }
  
      for(var i=0; i < passes.length; i++) {
        /**
         * Call of passes functions
         * pass(req, res, options, head)
         *
         * In WebSockets case the `res` variable
         * refer to the connection socket
         * pass(req, socket, options, head)
         */
        const passResult = await passes[i](req, res, requestOptions, head, this, cbl);
        if(passResult) { // passes can return a truthy value to halt the loop
          break;
        }
      }
    };
  }
  httpProxy.createRightProxy = createRightProxy;
  
  function ProxyServer(options) {
    EE3.call(this);
  
    options = options || {};
    options.prependPath = options.prependPath === false ? false : true;
  
    this.web = this.proxyRequest           = createRightProxy('web', options);
    this.ws  = this.proxyWebsocketRequest  = createRightProxy('ws', options);
    this.options = options;
  
    this.webPasses = Object.keys(web).map(function(pass) {
      return web[pass];
    });
  
    this.wsPasses = Object.keys(ws).map(function(pass) {
      return ws[pass];
    });
  
    this.on('error', this.onError, this);
  
  }
  
  require('util').inherits(ProxyServer, EE3);
  
  ProxyServer.prototype.onError = function (err) {
    //
    // Remark: Replicate node core behavior using EE3
    // so we force people to handle their own errors
    //
    if(this.listeners('error').length === 1) {
      throw err;
    }
  };
  
  ProxyServer.prototype.listen = function(port, hostname) {
    var self    = this,
        closure = function(req, res) { self.web(req, res); };
  
    this._server  = this.options.ssl ?
      https.createServer(this.options.ssl, closure) :
      http.createServer(closure);
  
    if(this.options.ws) {
      this._server.on('upgrade', function(req, socket, head) { self.ws(req, socket, head); });
    }
  
    this._server.listen(port, hostname);
  
    return this;
  };
  
  ProxyServer.prototype.close = function(callback) {
    var self = this;
    if (this._server) {
      this._server.close(done);
    }
  
    // Wrap callback to nullify server after all open connections are closed.
    function done() {
      self._server = null;
      if (callback) {
        callback.apply(null, arguments);
      }
    };
  };
  
  ProxyServer.prototype.before = function(type, passName, callback) {
    if (type !== 'ws' && type !== 'web') {
      throw new Error('type must be `web` or `ws`');
    }
    var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
        i = false;
  
    passes.forEach(function(v, idx) {
      if(v.name === passName) i = idx;
    })
  
    if(i === false) throw new Error('No such pass');
  
    passes.splice(i, 0, callback);
  };
  ProxyServer.prototype.after = function(type, passName, callback) {
    if (type !== 'ws' && type !== 'web') {
      throw new Error('type must be `web` or `ws`');
    }
    var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
        i = false;
  
    passes.forEach(function(v, idx) {
      if(v.name === passName) i = idx;
    })
  
    if(i === false) throw new Error('No such pass');
  
    passes.splice(i++, 0, callback);
  };
  