function next(err) {     var layerError = err === 'route'       ? null       : err;      // remove added slash     if (slashAdded) {       req.url = req.url.substr(1);       slashAdded = false;     }      // restore altered req.url     if (removed.length !== 0) {       req.baseUrl = parentUrl;       req.url = protohost + removed + req.url.substr(protohost.length);       removed = '';     }      // no more matching layers     if (idx >= stack.length) {       setImmediate(done, layerError);       return;     }      // get pathname of request     var path = getPathname(req);      if (path == null) {       return done(layerError);     }      // find next matching layer     var layer;     var match;     var route;      while (match !== true && idx

function (n) {   debug('read', n);   var state = this._readableState;   var nOrig = n;    if (!util.isNumber(n) || n > 0)     state.emittedReadable = false;    // if we're doing read(0) to trigger a readable event, but we   // already have a bunch of data in the buffer, then just trigger   // the 'readable' event and move on.   if (n === 0 &&       state.needReadable &&       (state.length >= state.highWaterMark || state.ended)) {     debug('read: emitReadable', state.length, state.ended);     if (state.length === 0 && state.ended)       endReadable(this);     else       emitReadable(this);     return null;   }    n = howMuchToRead(n, state);    // if we've ended, and we're now clear, then finish it up.   if (n === 0 && state.ended) {     if (state.length === 0)       endReadable(this);     return null;   }    // All the actual chunk generation logic needs to be   // *below* the call to _read.  The reason is that in certain   // synthetic stream cases, such as passthrough streams, _read   // may be a completely synchronous operation which may change   // the state of the read buffer, providing enough data when   // before there was *not* enough.   //   // So, the steps are:   // 1. Figure out what the state of things will be after we do   // a read from the buffer.   //   // 2. If that resulting state will trigger a _read, then call _read.   // Note that this may be asynchronous, or synchronous.  Yes, it is   // deeply ugly to write APIs this way, but that still doesn't mean   // that the Readable class should behave improperly, as streams are   // designed to be sync/async agnostic.   // Take note if the _read call is sync or async (ie, if the read call   // has returned yet), so that we know whether or not it's safe to emit   // 'readable' etc.   //   // 3. Actually pull the requested chunks out of the buffer and return.    // if we need a readable event, then we need to do some reading.   var doRead = state.needReadable;   debug('need readable', doRead);    // if we currently have less than the highWaterMark, then also read some   if (state.length === 0 || state.length - n  0)     ret = fromList(n, state);   else     ret = null;    if (util.isNull(ret)) {     state.needReadable = true;     n = 0;   }    state.length -= n;    // If we have nothing in the buffer, then we want to know   // as soon as we *do* get something into the buffer.   if (state.length === 0 && !state.ended)     state.needReadable = true;    // If we tried to read() past the EOF, then emit end on the next tick.   if (nOrig !== n && state.ended && state.length === 0)     endReadable(this);    if (!util.isNull(ret))     this.emit('data', ret);    return ret; }

function render(view, options, callback) {   var app = this.req.app;   var done = callback;   var opts = options || {};   var req = this.req;   var self = this;    // support callback function as second arg   if (typeof options === 'function') {     done = options;     opts = {};   }    // merge res.locals   opts._locals = self.locals;    // default callback to respond   done = done || function (err, str) {     if (err) return req.next(err);     self.send(str);   };    // render   app.render(view, opts, done); }

function (view, options, fn) {         options = options || {};          var res = this,             req = this.req,             app = this.app,             accept = req.headers.accept || '';           var finalize = function (err, str) {             // keep existing callback if one was passed             if (typeof fn === 'function') {                 fn(err, str);             } else if (err) {                 req.next(err);             } else {                 res.send(str);             }         };          panels.finalize(req);          // support callback function as second arg         if (typeof options === 'function') {             fn = options;             options = {};         }          // merge res.locals         options._locals = res.locals;          var render_toolbar = function (str, callback) {             var standalone = settings.path === req.path;             var opts = {                 EDTsettings: settings,                 theme:       theme,                 req:         req,                 standalone:  standalone,                 extra_attrs: settings.extra_attrs,                 panels:      panels.render({                     locals: options,                     app:    app,                     res:    res,                     req:    req,                     view:   view                 }, settings, standalone)             };              jade.renderFile(template, opts, function (err, toolbar) {                 callback(err, err ? undefined : utils.inject_toolbar(str, toolbar));             });         };          var toolbar_callback = function (err, str) {             panels.post_render(req);              if (err) {                 console.log(err);                 req.next(err);              } else if (res.EDT_rendered) {                 // if callback method was used, more than one template may be rendered.                 // in this care, do not render another copy                 // TODO: see if we can catch this on the last render, and attach it in .send instead                 finalize(err, str);              } else {                 res.EDT_rendered = true;                 render_toolbar(str, finalize);             }         };          panels.pre_render(req);         if (req.path.indexOf(settings.path) === 0) {             // standalone mode             jade.renderFile(fullpage, function (err, str) {                 toolbar_callback(err, str);             });          } else {             // inject toolbar callback into render callback             res._EDT_orig_render.call(res, view, options, toolbar_callback);         }     }

function send(body) {   var chunk = body;   var encoding;   var len;   var req = this.req;   var type;    // settings   var app = this.app;    // allow status / body   if (arguments.length === 2) {     // res.send(body, status) backwards compat     if (typeof arguments[0] !== 'number' && typeof arguments[1] === 'number') {       deprecate('res.send(body, status): Use res.status(status).send(body) instead');       this.statusCode = arguments[1];     } else {       deprecate('res.send(status, body): Use res.status(status).send(body) instead');       this.statusCode = arguments[0];       chunk = arguments[1];     }   }    // disambiguate res.send(status) and res.send(status, num)   if (typeof chunk === 'number' && arguments.length === 1) {     // res.send(status) will set status message as text string     if (!this.get('Content-Type')) {       this.type('txt');     }      deprecate('res.send(status): Use res.sendStatus(status) instead');     this.statusCode = chunk;     chunk = statusCodes[chunk];   }    switch (typeof chunk) {     // string defaulting to html     case 'string':       if (!this.get('Content-Type')) {         this.type('html');       }       break;     case 'boolean':     case 'number':     case 'object':       if (chunk === null) {         chunk = '';       } else if (Buffer.isBuffer(chunk)) {         if (!this.get('Content-Type')) {           this.type('bin');         }       } else {         return this.json(chunk);       }       break;   }    // write strings in utf-8   if (typeof chunk === 'string') {     encoding = 'utf8';     type = this.get('Content-Type');      // reflect this in content-type     if (typeof type === 'string') {       this.set('Content-Type', setCharset(type, 'utf-8'));     }   }    // populate Content-Length   if (chunk !== undefined) {     if (!Buffer.isBuffer(chunk)) {       // convert chunk to Buffer; saves later double conversions       chunk = new Buffer(chunk, encoding);       encoding = undefined;     }      len = chunk.length;     this.set('Content-Length', len);   }    // populate ETag   var etag;   var generateETag = len !== undefined && app.get('etag fn');   if (typeof generateETag === 'function' && !this.get('ETag')) {     if ((etag = generateETag(chunk, encoding))) {       this.set('ETag', etag);     }   }    // freshness   if (req.fresh) this.statusCode = 304;    // strip irrelevant headers   if (204 == this.statusCode || 304 == this.statusCode) {     this.removeHeader('Content-Type');     this.removeHeader('Content-Length');     this.removeHeader('Transfer-Encoding');     chunk = '';   }    if (req.method === 'HEAD') {     // skip body for HEAD     this.end();   } else {     // respond     this.end(chunk, encoding);   }    return this; }

function () {         if (this.EDT_rendered !== true) {             request.add(this.req, arguments);         }         this._EDT_orig_send.apply(this, arguments);     }

function (req, res) {     res.locals.controller = x[0];     res.locals.action = act;     return t.apply(this, arguments);   }