text: /*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   */
  
  'use strict';
  
  /**
   * Module dependencies.
   * @private
   */
  
  import contentDisposition from 'content-disposition';
  import escapeHtml from 'escape-html';
  import http from 'http';
  import onFinished from 'on-finished';
  import path from 'path';
  import merge from 'utils-merge';
  import {sign} from 'cookie-signature';
  import {isAbsolute} from './utils';
  import {normalizeType} from './utils';
  import {normalizeTypes} from './utils';
  import {setCharset} from './utils';
  import cookie from 'cookie';
  import send from 'send';
  import vary from 'vary';
  
  const resolve = path.resolve;
  const mime = send.mime;
  const extname = path.extname;
  const statusCodes = http.STATUS_CODES;
  const charsetRegExp = /;\s*charset\s*=/;
  
  /**
   * Response class
   */
  class Response extends http.ServerResponse{
      constructor() {
          super({});
      }
  
      /**
       * Set status `code`.
       *
       * @param {Number} code
       * @return {ServerResponse}
       * @public
       */
      status(code) {
        this.statusCode = code;
        return this;
      }
  
      /**
       * Set Link header field with the given `links`.
       *
       * Examples:
       *
       *    res.links({
       *      next: 'http://api.example.com/users?page=2',
       *      last: 'http://api.example.com/users?page=5'
       *    });
       *
       * @param {Object} links
       * @return {ServerResponse}
       * @public
       */
      links(links){
        let link = this.get('Link') || '';
        if (link) {
            link += ', ';
        }
        let additional = Object.keys(links).map((rel)=> '<' + links[rel] + '>; rel="' + rel + '"').join(', ');
        return this.set('Link', link + additional);
      }
  
      /**
       * Send a response.
       *
       * Examples:
       *
       *     res.send(new Buffer('wahoo'));
       *     res.send({ some: 'json' });
       *     res.send('<p>some html</p>');
       *
       * @param {string|number|boolean|object|Buffer} body
       * @public
       */
      send(body) {
        let chunk = body;
        let encoding;
        let len;
        let type;
  
        // settings
        let req = this.req;
        let app = this.app;
  
        // disambiguate res.send(status) and res.send(status, num)
        if (typeof chunk === 'number') {
          // res.send(status) will set status message as text string
          if (!this.get('Content-Type')) {
            this.type('txt');
          }
  
          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 '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
        let etag;
        let 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;
      }
  
      /**
       * Send JSON response.
       *
       * Examples:
       *
       *     res.json(null);
       *     res.json({ user: 'tj' });
       *
       * @param {string|number|boolean|object} obj
       * @public
       */
      json(obj) {
        let val = obj;
  
        // settings
        let app = this.app;
        let replacer = app.get('json replacer');
        let spaces = app.get('json spaces');
        let body = JSON.stringify(val, replacer, spaces);
  
        // content-type
        if (!this.get('Content-Type')) {
          this.set('Content-Type', 'application/json');
        }
  
        return this.send(body);
      }
  
      /**
       * Send JSON response with JSONP callback support.
       *
       * Examples:
       *
       *     res.jsonp(null);
       *     res.jsonp({ user: 'tj' });
       *
       * @param {string|number|boolean|object} obj
       * @public
       */
      jsonp(obj) {
        let val = obj;
  
        // settings
        let app = this.app;
        let replacer = app.get('json replacer');
        let spaces = app.get('json spaces');
        let body = JSON.stringify(val, replacer, spaces);
        let callback = this.req.query[app.get('jsonp callback name')];
  
        // content-type
        if (!this.get('Content-Type')) {
          this.set('X-Content-Type-Options', 'nosniff');
          this.set('Content-Type', 'application/json');
        }
  
        // fixup callback
        if (Array.isArray(callback)) {
          callback = callback[0];
        }
  
        // jsonp
        if (typeof callback === 'string' && callback.length !== 0) {
          this.charset = 'utf-8';
          this.set('X-Content-Type-Options', 'nosniff');
          this.set('Content-Type', 'text/javascript');
  
          // restrict callback charset
          callback = callback.replace(/[^\[\]\w$.]/g, '');
  
          // replace chars not allowed in JavaScript that are in JSON
          body = body
            .replace(/\u2028/g, '\\u2028')
            .replace(/\u2029/g, '\\u2029');
  
          // the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse"
          // the typeof check is just to reduce client error noise
          body = '/**/ typeof ' + callback + ' === \'function\' && ' + callback + '(' + body + ');';
        }
  
        return this.send(body);
      }
  
      /**
       * Send given HTTP status code.
       *
       * Sets the response status to `statusCode` and the body of the
       * response to the standard description from node's http.STATUS_CODES
       * or the statusCode number if no description.
       *
       * Examples:
       *
       *     res.sendStatus(200);
       *
       * @param {number} statusCode
       * @public
       */
  
      sendStatus(statusCode) {
        let body = statusCodes[statusCode] || String(statusCode);
  
        this.statusCode = statusCode;
        this.type('txt');
  
        return this.send(body);
      }
  
      /**
       * Transfer the file at the given `path`.
       *
       * Automatically sets the _Content-Type_ response header field.
       * The callback `callback(err)` is invoked when the transfer is complete
       * or when an error occurs. Be sure to check `res.sentHeader`
       * if you wish to attempt responding, as the header and some data
       * may have already been transferred.
       *
       * Options:
       *
       *   - `maxAge`   defaulting to 0 (can be string converted by `ms`)
       *   - `root`     root directory for relative filenames
       *   - `headers`  object of headers to serve with file
       *   - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them
       *
       * Other options are passed along to `send`.
       *
       * Examples:
       *
       *  The following example illustrates how `res.sendFile()` may
       *  be used as an alternative for the `static()` middleware for
       *  dynamic situations. The code backing `res.sendFile()` is actually
       *  the same code, so HTTP cache support etc is identical.
       *
       *     app.get('/user/:uid/photos/:file', function(req, res){
       *       let uid = req.params.uid
       *         , file = req.params.file;
       *
       *       req.user.mayViewFilesFrom(uid, function(yes){
       *         if (yes) {
       *           res.sendFile('/uploads/' + uid + '/' + file);
       *         } else {
       *           res.send(403, 'Sorry! you cant see that.');
       *         }
       *       });
       *     });
       *
       * @public
       */
      sendFile(path, options, callback) {
        let done = callback;
        let req = this.req;
        let res = this;
        let next = req.next;
        let opts = options || {};
  
        if (!path) {
          throw new TypeError('path argument is required to res.sendFile');
        }
  
        // support function as second arg
        if (typeof options === 'function') {
          done = options;
          opts = {};
        }
  
        if (!opts.root && !isAbsolute(path)) {
          throw new TypeError('path must be absolute or specify root to res.sendFile');
        }
  
        // create file stream
        let pathname = encodeURI(path);
        let file = send(req, pathname, opts);
  
        // transfer
        sendfile(res, file, opts, function (err) {
          if (done) return done(err);
          if (err && err.code === 'EISDIR') return next();
  
          // next() all but write errors
          if (err && err.code !== 'ECONNABORTED' && err.syscall !== 'write') {
            next(err);
          }
        });
      }
  
      /**
       * Transfer the file at the given `path` as an attachment.
       *
       * Optionally providing an alternate attachment `filename`,
       * and optional callback `callback(err)`. The callback is invoked
       * when the data transfer is complete, or when an error has
       * ocurred. Be sure to check `res.headersSent` if you plan to respond.
       *
       * This method uses `res.sendfile()`.
       *
       * @public
       */
      download(path, filename, callback) {
        let done = callback;
        let name = filename;
  
        // support function as second arg
        if (typeof filename === 'function') {
          done = filename;
          name = null;
        }
  
        // set Content-Disposition when file is sent
        let headers = {
          'Content-Disposition': contentDisposition(name || path)
        };
  
        // Resolve the full path for sendFile
        let fullPath = resolve(path);
  
        return this.sendFile(fullPath, { headers: headers }, done);
      }
  
      /**
       * Set _Content-Type_ response header with `type` through `mime.lookup()`
       * when it does not contain "/", or set the Content-Type to `type` otherwise.
       *
       * Examples:
       *
       *     res.type('.html');
       *     res.type('html');
       *     res.type('json');
       *     res.type('application/json');
       *     res.type('png');
       *
       * @param {String} type
       * @return {ServerResponse} for chaining
       * @public
       */
  
      contentType(type) {
        let ct = type.indexOf('/') === -1
          ? mime.lookup(type)
          : type;
  
        return this.set('Content-Type', ct);
      }
  
      type(type){
          return this.contentType(type);
      }
  
      /**
       * Respond to the Acceptable formats using an `obj`
       * of mime-type callbacks.
       *
       * This method uses `req.accepted`, an array of
       * acceptable types ordered by their quality values.
       * When "Accept" is not present the _first_ callback
       * is invoked, otherwise the first match is used. When
       * no match is performed the server responds with
       * 406 "Not Acceptable".
       *
       * Content-Type is set for you, however if you choose
       * you may alter this within the callback using `res.type()`
       * or `res.set('Content-Type', ...)`.
       *
       *    res.format({
       *      'text/plain': function(){
       *        res.send('hey');
       *      },
       *
       *      'text/html': function(){
       *        res.send('<p>hey</p>');
       *      },
       *
       *      'appliation/json': function(){
       *        res.send({ message: 'hey' });
       *      }
       *    });
       *
       * In addition to canonicalized MIME types you may
       * also use extnames mapped to these types:
       *
       *    res.format({
       *      text: function(){
       *        res.send('hey');
       *      },
       *
       *      html: function(){
       *        res.send('<p>hey</p>');
       *      },
       *
       *      json: function(){
       *        res.send({ message: 'hey' });
       *      }
       *    });
       *
       * By default Express passes an `Error`
       * with a `.status` of 406 to `next(err)`
       * if a match is not made. If you provide
       * a `.default` callback it will be invoked
       * instead.
       *
       * @param {Object} obj
       * @return {ServerResponse} for chaining
       * @public
       */
      format(obj){
        let req = this.req;
        let next = req.next;
  
        let fn = obj.default;
        if (fn) delete obj.default;
        let keys = Object.keys(obj);
  
        let key = keys.length > 0
          ? req.accepts(keys)
          : false;
  
        this.vary("Accept");
  
        if (key) {
          this.set('Content-Type', normalizeType(key).value);
          obj[key](req, this, next);
        } else if (fn) {
          fn();
        } else {
          let err = new Error('Not Acceptable');
          err.status = err.statusCode = 406;
          err.types = normalizeTypes(keys).map(function(o){ return o.value });
          next(err);
        }
  
        return this;
      }
  
      /**
       * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
       *
       * @param {String} filename
       * @return {ServerResponse}
       * @public
       */
      attachment(filename) {
        if (filename) {
          this.type(extname(filename));
        }
  
        this.set('Content-Disposition', contentDisposition(filename));
  
        return this;
      }
  
      /**
       * Append additional header `field` with value `val`.
       *
       * Example:
       *
       *    res.append('Link', ['<http://localhost/>', '<http://localhost:3000/>']);
       *    res.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
       *    res.append('Warning', '199 Miscellaneous warning');
       *
       * @param {String} field
       * @param {String|Array} val
       * @return {ServerResponse} for chaining
       * @public
       */
      append(field, val) {
        let prev = this.get(field);
        let value = val;
  
        if (prev) {
          // concat the new and prev vals
          let _prev = Array.isArray(prev)?prev:[prev];
          let _val = Array.isArray(val)?val:[val];
  
          value = _prev.concat(_val);
        }
  
        return this.set(field, value);
      }
  
      /**
       * Set header `field` to `val`, or pass
       * an object of header fields.
       *
       * Examples:
       *
       *    res.set('Foo', ['bar', 'baz']);
       *    res.set('Accept', 'application/json');
       *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
       *
       * Aliased as `res.header()`.
       *
       * @param {String|Object} field
       * @param {String|Array} val
       * @return {ServerResponse} for chaining
       * @public
       */
      set(field, val) {
        if (arguments.length === 2) {
          let value = Array.isArray(val)
            ? val.map(String)
            : String(val);
  
          // add charset to content-type
          if (field.toLowerCase() === 'content-type' && !charsetRegExp.test(value)) {
            let charset = mime.charsets.lookup(value.split(';')[0]);
            if (charset) value += '; charset=' + charset.toLowerCase();
          }
  
          this.setHeader(field, value);
        } else {
          for (let key in field) {
            this.set(key, field[key]);
          }
        }
        return this;
      }
      header(field, val){
          return this.set(field, val);
      }
  
      /**
       * Get value for header `field`.
       *
       * @param {String} field
       * @return {String}
       * @public
       */
      get(field){
        return this.getHeader(field);
      }
  
      /**
       * Clear cookie `name`.
       *
       * @param {String} name
       * @param {Object} options
       * @return {ServerResponse} for chaining
       * @public
       */
      clearCookie(name, options) {
        let opts = merge({ expires: new Date(1), path: '/' }, options);
  
        return this.cookie(name, '', opts);
      }
  
      /**
       * Set cookie `name` to `value`, with the given `options`.
       *
       * Options:
       *
       *    - `maxAge`   max-age in milliseconds, converted to `expires`
       *    - `signed`   sign the cookie
       *    - `path`     defaults to "/"
       *
       * Examples:
       *
       *    // "Remember Me" for 15 minutes
       *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
       *
       *    // save as above
       *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
       *
       * @param {String} name
       * @param {String|Object} value
       * @param {Options} options
       * @return {ServerResponse} for chaining
       * @public
       */
      cookie(name, value, options) {
        let opts = merge({}, options);
        let secret = this.req.secret;
        let signed = opts.signed;
  
        if (signed && !secret) {
          throw new Error('cookieParser("secret") required for signed cookies');
        }
  
        let val = typeof value === 'object'
          ? 'j:' + JSON.stringify(value)
          : String(value);
  
        if (signed) {
          val = 's:' + sign(val, secret);
        }
  
        if ('maxAge' in opts) {
          opts.expires = new Date(Date.now() + opts.maxAge);
          opts.maxAge /= 1000;
        }
  
        if (opts.path == null) {
          opts.path = '/';
        }
  
        this.append('Set-Cookie', cookie.serialize(name, String(val), opts));
  
        return this;
      }
  
      /**
       * Set the location header to `url`.
       *
       * The given `url` can also be "back", which redirects
       * to the _Referrer_ or _Referer_ headers or "/".
       *
       * Examples:
       *
       *    res.location('/foo/bar').;
       *    res.location('http://example.com');
       *    res.location('../login');
       *
       * @param {String} url
       * @return {ServerResponse} for chaining
       * @public
       */
       location(url) {
        let loc = url;
  
        // "back" is an alias for the referrer
        if (url === 'back') {
          loc = this.req.get('Referrer') || '/';
        }
  
        // set location
        this.set('Location', loc);
        return this;
      }
  
      /**
       * Redirect to the given `url` with optional response `status`
       * defaulting to 302.
       *
       * The resulting `url` is determined by `res.location()`, so
       * it will play nicely with mounted apps, relative paths,
       * `"back"` etc.
       *
       * Examples:
       *
       *    res.redirect('/foo/bar');
       *    res.redirect('http://example.com');
       *    res.redirect(301, 'http://example.com');
       *    res.redirect('../login'); // /blog/post/1 -> /blog/login
       *
       * @public
       */
      redirect(url) {
        let address = url;
        let body;
        let status=302;
  
        // allow status / url
        if (arguments.length === 2) {
          if (typeof arguments[0] === 'number') {
            status = arguments[0];
            address = arguments[1];
          }
        }
  
        // Set location header
        this.location(address);
        address = this.get('Location');
  
        // Support text/{plain,html} by default
        this.format({
          text: function(){
            body = statusCodes[status] + '. Redirecting to ' + encodeURI(address);
          },
  
          html: function(){
            let u = escapeHtml(address);
            body = '<p>' + statusCodes[status] + '. Redirecting to <a href="' + u + '">' + u + '</a></p>';
          },
  
          default: function(){
            body = '';
          }
        });
  
        // Respond
        this.statusCode = status;
        this.set('Content-Length', Buffer.byteLength(body));
  
        if (this.req.method === 'HEAD') {
          this.end();
        } else {
          this.end(body);
        }
      }
  
      /**
       * Add `field` to Vary. If already present in the Vary set, then
       * this call is simply ignored.
       *
       * @param {Array|String} field
       * @return {ServerResponse} for chaining
       * @public
       */
      vary(field){
        vary(this, field);
  
        return this;
      }
  
      /**
       * Render `view` with the given `options` and optional callback `fn`.
       * When a callback function is given a response will _not_ be made
       * automatically, otherwise a response of _200_ and _text/html_ is given.
       *
       * Options:
       *
       *  - `cache`     boolean hinting to the engine it should cache
       *  - `filename`  filename of the view being rendered
       *
       * @public
       */
      render(view, options, callback) {
        let app = this.req.app;
        let done = callback;
        let opts = options || {};
        let req = this.req;
        let 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);
      };
  }
  
  
  // pipe the send file stream
  function sendfile(res, file, options, callback) {
    let done = false;
    let streaming;
  
    file.on('directory', ondirectory);
    file.on('end', onend);
    file.on('error', onerror);
    file.on('file', onfile);
    file.on('stream', onstream);
    onFinished(res, onfinish);
  
    if (options.headers) {
      // set headers on successful transfer
      file.on('headers', function headers(res) {
        let obj = options.headers;
        let keys = Object.keys(obj);
  
        for (let i = 0; i < keys.length; i++) {
          let k = keys[i];
          res.setHeader(k, obj[k]);
        }
      });
    }
  
    // pipe
    file.pipe(res);
  
    // request aborted
    function onaborted() {
      if (done) return;
      done = true;
  
      let err = new Error('Request aborted');
      err.code = 'ECONNABORTED';
      callback(err);
    }
  
    // directory
    function ondirectory() {
      if (done) return;
      done = true;
  
      let err = new Error('EISDIR, read');
      err.code = 'EISDIR';
      callback(err);
    }
  
    // errors
    function onerror(err) {
      if (done) return;
      done = true;
      callback(err);
    }
  
    // ended
    function onend() {
      if (done) return;
      done = true;
      callback();
    }
  
    // file
    function onfile() {
      streaming = false;
    }
  
    // finished
    function onfinish(err) {
      if (err && err.code === 'ECONNRESET') return onaborted();
      if (err) return onerror(err);
      if (done) return;
  
      setImmediate(function () {
        if (streaming !== false && !done) {
          onaborted();
          return;
        }
  
        if (done) return;
        done = true;
        callback();
      });
    }
  
    // streaming
    function onstream() {
      streaming = true;
    }
  }
  
  
  const res = new Response();
  export default res;
  