@corellium/corellium-cli 1.2.1 → 1.2.3

package/node_modules/superagent/lib/node/index.js

@@ -0,0 +1,1376 @@
+"use strict";
+
+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); }
+
+/**
+ * Module dependencies.
+ */
+// eslint-disable-next-line node/no-deprecated-api
+var _require = require('url'),
+    parse = _require.parse,
+    format = _require.format,
+    resolve = _require.resolve;
+
+var Stream = require('stream');
+
+var https = require('https');
+
+var http = require('http');
+
+var fs = require('fs');
+
+var zlib = require('zlib');
+
+var util = require('util');
+
+var qs = require('qs');
+
+var mime = require('mime');
+
+var methods = require('methods');
+
+var FormData = require('form-data');
+
+var formidable = require('formidable');
+
+var debug = require('debug')('superagent');
+
+var CookieJar = require('cookiejar');
+
+var semver = require('semver');
+
+var safeStringify = require('fast-safe-stringify');
+
+var utils = require('../utils');
+
+var RequestBase = require('../request-base');
+
+var _require2 = require('./unzip'),
+    unzip = _require2.unzip;
+
+var Response = require('./response');
+
+var http2;
+if (semver.gte(process.version, 'v10.10.0')) http2 = require('./http2wrapper');
+
+function request(method, url) {
+  // callback
+  if (typeof url === 'function') {
+    return new exports.Request('GET', method).end(url);
+  } // url first
+
+
+  if (arguments.length === 1) {
+    return new exports.Request('GET', method);
+  }
+
+  return new exports.Request(method, url);
+}
+
+module.exports = request;
+exports = module.exports;
+/**
+ * Expose `Request`.
+ */
+
+exports.Request = Request;
+/**
+ * Expose the agent function
+ */
+
+exports.agent = require('./agent');
+/**
+ * Noop.
+ */
+
+function noop() {}
+/**
+ * Expose `Response`.
+ */
+
+
+exports.Response = Response;
+/**
+ * Define "form" mime type.
+ */
+
+mime.define({
+  'application/x-www-form-urlencoded': ['form', 'urlencoded', 'form-data']
+}, true);
+/**
+ * Protocol map.
+ */
+
+exports.protocols = {
+  'http:': http,
+  'https:': https,
+  'http2:': http2
+};
+/**
+ * Default serialization map.
+ *
+ *     superagent.serialize['application/xml'] = function(obj){
+ *       return 'generated xml here';
+ *     };
+ *
+ */
+
+exports.serialize = {
+  'application/x-www-form-urlencoded': qs.stringify,
+  'application/json': safeStringify
+};
+/**
+ * Default parsers.
+ *
+ *     superagent.parse['application/xml'] = function(res, fn){
+ *       fn(null, res);
+ *     };
+ *
+ */
+
+exports.parse = require('./parsers');
+/**
+ * Default buffering map. Can be used to set certain
+ * response types to buffer/not buffer.
+ *
+ *     superagent.buffer['application/xml'] = true;
+ */
+
+exports.buffer = {};
+/**
+ * Initialize internal header tracking properties on a request instance.
+ *
+ * @param {Object} req the instance
+ * @api private
+ */
+
+function _initHeaders(req) {
+  req._header = {// coerces header names to lowercase
+  };
+  req.header = {// preserves header name case
+  };
+}
+/**
+ * Initialize a new `Request` with the given `method` and `url`.
+ *
+ * @param {String} method
+ * @param {String|Object} url
+ * @api public
+ */
+
+
+function Request(method, url) {
+  Stream.call(this);
+  if (typeof url !== 'string') url = format(url);
+  this._enableHttp2 = Boolean(process.env.HTTP2_TEST); // internal only
+
+  this._agent = false;
+  this._formData = null;
+  this.method = method;
+  this.url = url;
+
+  _initHeaders(this);
+
+  this.writable = true;
+  this._redirects = 0;
+  this.redirects(method === 'HEAD' ? 0 : 5);
+  this.cookies = '';
+  this.qs = {};
+  this._query = [];
+  this.qsRaw = this._query; // Unused, for backwards compatibility only
+
+  this._redirectList = [];
+  this._streamRequest = false;
+  this.once('end', this.clearTimeout.bind(this));
+}
+/**
+ * Inherit from `Stream` (which inherits from `EventEmitter`).
+ * Mixin `RequestBase`.
+ */
+
+
+util.inherits(Request, Stream); // eslint-disable-next-line new-cap
+
+RequestBase(Request.prototype);
+/**
+ * Enable or Disable http2.
+ *
+ * Enable http2.
+ *
+ * ``` js
+ * request.get('http://localhost/')
+ *   .http2()
+ *   .end(callback);
+ *
+ * request.get('http://localhost/')
+ *   .http2(true)
+ *   .end(callback);
+ * ```
+ *
+ * Disable http2.
+ *
+ * ``` js
+ * request = request.http2();
+ * request.get('http://localhost/')
+ *   .http2(false)
+ *   .end(callback);
+ * ```
+ *
+ * @param {Boolean} enable
+ * @return {Request} for chaining
+ * @api public
+ */
+
+Request.prototype.http2 = function (bool) {
+  if (exports.protocols['http2:'] === undefined) {
+    throw new Error('superagent: this version of Node.js does not support http2');
+  }
+
+  this._enableHttp2 = bool === undefined ? true : bool;
+  return this;
+};
+/**
+ * Queue the given `file` as an attachment to the specified `field`,
+ * with optional `options` (or filename).
+ *
+ * ``` js
+ * request.post('http://localhost/upload')
+ *   .attach('field', Buffer.from('<b>Hello world</b>'), 'hello.html')
+ *   .end(callback);
+ * ```
+ *
+ * A filename may also be used:
+ *
+ * ``` js
+ * request.post('http://localhost/upload')
+ *   .attach('files', 'image.jpg')
+ *   .end(callback);
+ * ```
+ *
+ * @param {String} field
+ * @param {String|fs.ReadStream|Buffer} file
+ * @param {String|Object} options
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.attach = function (field, file, options) {
+  if (file) {
+    if (this._data) {
+      throw new Error("superagent can't mix .send() and .attach()");
+    }
+
+    var o = options || {};
+
+    if (typeof options === 'string') {
+      o = {
+        filename: options
+      };
+    }
+
+    if (typeof file === 'string') {
+      if (!o.filename) o.filename = file;
+      debug('creating `fs.ReadStream` instance for file: %s', file);
+      file = fs.createReadStream(file);
+    } else if (!o.filename && file.path) {
+      o.filename = file.path;
+    }
+
+    this._getFormData().append(field, file, o);
+  }
+
+  return this;
+};
+
+Request.prototype._getFormData = function () {
+  var _this = this;
+
+  if (!this._formData) {
+    this._formData = new FormData();
+
+    this._formData.on('error', function (err) {
+      debug('FormData error', err);
+
+      if (_this.called) {
+        // The request has already finished and the callback was called.
+        // Silently ignore the error.
+        return;
+      }
+
+      _this.callback(err);
+
+      _this.abort();
+    });
+  }
+
+  return this._formData;
+};
+/**
+ * Gets/sets the `Agent` to use for this HTTP request. The default (if this
+ * function is not called) is to opt out of connection pooling (`agent: false`).
+ *
+ * @param {http.Agent} agent
+ * @return {http.Agent}
+ * @api public
+ */
+
+
+Request.prototype.agent = function (agent) {
+  if (arguments.length === 0) return this._agent;
+  this._agent = agent;
+  return this;
+};
+/**
+ * Set _Content-Type_ response header passed through `mime.getType()`.
+ *
+ * Examples:
+ *
+ *      request.post('/')
+ *        .type('xml')
+ *        .send(xmlstring)
+ *        .end(callback);
+ *
+ *      request.post('/')
+ *        .type('json')
+ *        .send(jsonstring)
+ *        .end(callback);
+ *
+ *      request.post('/')
+ *        .type('application/json')
+ *        .send(jsonstring)
+ *        .end(callback);
+ *
+ * @param {String} type
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.type = function (type) {
+  return this.set('Content-Type', type.includes('/') ? type : mime.getType(type));
+};
+/**
+ * Set _Accept_ response header passed through `mime.getType()`.
+ *
+ * Examples:
+ *
+ *      superagent.types.json = 'application/json';
+ *
+ *      request.get('/agent')
+ *        .accept('json')
+ *        .end(callback);
+ *
+ *      request.get('/agent')
+ *        .accept('application/json')
+ *        .end(callback);
+ *
+ * @param {String} accept
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.accept = function (type) {
+  return this.set('Accept', type.includes('/') ? type : mime.getType(type));
+};
+/**
+ * Add query-string `val`.
+ *
+ * Examples:
+ *
+ *   request.get('/shoes')
+ *     .query('size=10')
+ *     .query({ color: 'blue' })
+ *
+ * @param {Object|String} val
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.query = function (val) {
+  if (typeof val === 'string') {
+    this._query.push(val);
+  } else {
+    Object.assign(this.qs, val);
+  }
+
+  return this;
+};
+/**
+ * Write raw `data` / `encoding` to the socket.
+ *
+ * @param {Buffer|String} data
+ * @param {String} encoding
+ * @return {Boolean}
+ * @api public
+ */
+
+
+Request.prototype.write = function (data, encoding) {
+  var req = this.request();
+
+  if (!this._streamRequest) {
+    this._streamRequest = true;
+  }
+
+  return req.write(data, encoding);
+};
+/**
+ * Pipe the request body to `stream`.
+ *
+ * @param {Stream} stream
+ * @param {Object} options
+ * @return {Stream}
+ * @api public
+ */
+
+
+Request.prototype.pipe = function (stream, options) {
+  this.piped = true; // HACK...
+
+  this.buffer(false);
+  this.end();
+  return this._pipeContinue(stream, options);
+};
+
+Request.prototype._pipeContinue = function (stream, options) {
+  var _this2 = this;
+
+  this.req.once('response', function (res) {
+    // redirect
+    if (isRedirect(res.statusCode) && _this2._redirects++ !== _this2._maxRedirects) {
+      return _this2._redirect(res) === _this2 ? _this2._pipeContinue(stream, options) : undefined;
+    }
+
+    _this2.res = res;
+
+    _this2._emitResponse();
+
+    if (_this2._aborted) return;
+
+    if (_this2._shouldUnzip(res)) {
+      var unzipObj = zlib.createUnzip();
+      unzipObj.on('error', function (err) {
+        if (err && err.code === 'Z_BUF_ERROR') {
+          // unexpected end of file is ignored by browsers and curl
+          stream.emit('end');
+          return;
+        }
+
+        stream.emit('error', err);
+      });
+      res.pipe(unzipObj).pipe(stream, options);
+    } else {
+      res.pipe(stream, options);
+    }
+
+    res.once('end', function () {
+      _this2.emit('end');
+    });
+  });
+  return stream;
+};
+/**
+ * Enable / disable buffering.
+ *
+ * @return {Boolean} [val]
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.buffer = function (val) {
+  this._buffer = val !== false;
+  return this;
+};
+/**
+ * Redirect to `url
+ *
+ * @param {IncomingMessage} res
+ * @return {Request} for chaining
+ * @api private
+ */
+
+
+Request.prototype._redirect = function (res) {
+  var url = res.headers.location;
+
+  if (!url) {
+    return this.callback(new Error('No location header for redirect'), res);
+  }
+
+  debug('redirect %s -> %s', this.url, url); // location
+
+  url = resolve(this.url, url); // ensure the response is being consumed
+  // this is required for Node v0.10+
+
+  res.resume();
+  var headers = this.req.getHeaders ? this.req.getHeaders() : this.req._headers;
+  var changesOrigin = parse(url).host !== parse(this.url).host; // implementation of 302 following defacto standard
+
+  if (res.statusCode === 301 || res.statusCode === 302) {
+    // strip Content-* related fields
+    // in case of POST etc
+    headers = utils.cleanHeader(headers, changesOrigin); // force GET
+
+    this.method = this.method === 'HEAD' ? 'HEAD' : 'GET'; // clear data
+
+    this._data = null;
+  } // 303 is always GET
+
+
+  if (res.statusCode === 303) {
+    // strip Content-* related fields
+    // in case of POST etc
+    headers = utils.cleanHeader(headers, changesOrigin); // force method
+
+    this.method = 'GET'; // clear data
+
+    this._data = null;
+  } // 307 preserves method
+  // 308 preserves method
+
+
+  delete headers.host;
+  delete this.req;
+  delete this._formData; // remove all add header except User-Agent
+
+  _initHeaders(this); // redirect
+
+
+  this._endCalled = false;
+  this.url = url;
+  this.qs = {};
+  this._query.length = 0;
+  this.set(headers);
+  this.emit('redirect', res);
+
+  this._redirectList.push(this.url);
+
+  this.end(this._callback);
+  return this;
+};
+/**
+ * Set Authorization field value with `user` and `pass`.
+ *
+ * Examples:
+ *
+ *   .auth('tobi', 'learnboost')
+ *   .auth('tobi:learnboost')
+ *   .auth('tobi')
+ *   .auth(accessToken, { type: 'bearer' })
+ *
+ * @param {String} user
+ * @param {String} [pass]
+ * @param {Object} [options] options with authorization type 'basic' or 'bearer' ('basic' is default)
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.auth = function (user, pass, options) {
+  if (arguments.length === 1) pass = '';
+
+  if (_typeof(pass) === 'object' && pass !== null) {
+    // pass is optional and can be replaced with options
+    options = pass;
+    pass = '';
+  }
+
+  if (!options) {
+    options = {
+      type: 'basic'
+    };
+  }
+
+  var encoder = function encoder(string) {
+    return Buffer.from(string).toString('base64');
+  };
+
+  return this._auth(user, pass, options, encoder);
+};
+/**
+ * Set the certificate authority option for https request.
+ *
+ * @param {Buffer | Array} cert
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.ca = function (cert) {
+  this._ca = cert;
+  return this;
+};
+/**
+ * Set the client certificate key option for https request.
+ *
+ * @param {Buffer | String} cert
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.key = function (cert) {
+  this._key = cert;
+  return this;
+};
+/**
+ * Set the key, certificate, and CA certs of the client in PFX or PKCS12 format.
+ *
+ * @param {Buffer | String} cert
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.pfx = function (cert) {
+  if (_typeof(cert) === 'object' && !Buffer.isBuffer(cert)) {
+    this._pfx = cert.pfx;
+    this._passphrase = cert.passphrase;
+  } else {
+    this._pfx = cert;
+  }
+
+  return this;
+};
+/**
+ * Set the client certificate option for https request.
+ *
+ * @param {Buffer | String} cert
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.cert = function (cert) {
+  this._cert = cert;
+  return this;
+};
+/**
+ * Do not reject expired or invalid TLS certs.
+ * sets `rejectUnauthorized=true`. Be warned that this allows MITM attacks.
+ *
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype.disableTLSCerts = function () {
+  this._disableTLSCerts = true;
+  return this;
+};
+/**
+ * Return an http[s] request.
+ *
+ * @return {OutgoingMessage}
+ * @api private
+ */
+// eslint-disable-next-line complexity
+
+
+Request.prototype.request = function () {
+  var _this3 = this;
+
+  if (this.req) return this.req;
+  var options = {};
+
+  try {
+    var query = qs.stringify(this.qs, {
+      indices: false,
+      strictNullHandling: true
+    });
+
+    if (query) {
+      this.qs = {};
+
+      this._query.push(query);
+    }
+
+    this._finalizeQueryString();
+  } catch (err) {
+    return this.emit('error', err);
+  }
+
+  var url = this.url;
+  var retries = this._retries; // Capture backticks as-is from the final query string built above.
+  // Note: this'll only find backticks entered in req.query(String)
+  // calls, because qs.stringify unconditionally encodes backticks.
+
+  var queryStringBackticks;
+
+  if (url.includes('`')) {
+    var queryStartIndex = url.indexOf('?');
+
+    if (queryStartIndex !== -1) {
+      var queryString = url.slice(queryStartIndex + 1);
+      queryStringBackticks = queryString.match(/`|%60/g);
+    }
+  } // default to http://
+
+
+  if (url.indexOf('http') !== 0) url = "http://".concat(url);
+  url = parse(url); // See https://github.com/visionmedia/superagent/issues/1367
+
+  if (queryStringBackticks) {
+    var i = 0;
+    url.query = url.query.replace(/%60/g, function () {
+      return queryStringBackticks[i++];
+    });
+    url.search = "?".concat(url.query);
+    url.path = url.pathname + url.search;
+  } // support unix sockets
+
+
+  if (/^https?\+unix:/.test(url.protocol) === true) {
+    // get the protocol
+    url.protocol = "".concat(url.protocol.split('+')[0], ":"); // get the socket, path
+
+    var unixParts = url.path.match(/^([^/]+)(.+)$/);
+    options.socketPath = unixParts[1].replace(/%2F/g, '/');
+    url.path = unixParts[2];
+  } // Override IP address of a hostname
+
+
+  if (this._connectOverride) {
+    var _url = url,
+        hostname = _url.hostname;
+    var match = hostname in this._connectOverride ? this._connectOverride[hostname] : this._connectOverride['*'];
+
+    if (match) {
+      // backup the real host
+      if (!this._header.host) {
+        this.set('host', url.host);
+      }
+
+      var newHost;
+      var newPort;
+
+      if (_typeof(match) === 'object') {
+        newHost = match.host;
+        newPort = match.port;
+      } else {
+        newHost = match;
+        newPort = url.port;
+      } // wrap [ipv6]
+
+
+      url.host = /:/.test(newHost) ? "[".concat(newHost, "]") : newHost;
+
+      if (newPort) {
+        url.host += ":".concat(newPort);
+        url.port = newPort;
+      }
+
+      url.hostname = newHost;
+    }
+  } // options
+
+
+  options.method = this.method;
+  options.port = url.port;
+  options.path = url.path;
+  options.host = url.hostname;
+  options.ca = this._ca;
+  options.key = this._key;
+  options.pfx = this._pfx;
+  options.cert = this._cert;
+  options.passphrase = this._passphrase;
+  options.agent = this._agent;
+  options.rejectUnauthorized = typeof this._disableTLSCerts === 'boolean' ? !this._disableTLSCerts : process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0'; // Allows request.get('https://1.2.3.4/').set('Host', 'example.com')
+
+  if (this._header.host) {
+    options.servername = this._header.host.replace(/:\d+$/, '');
+  }
+
+  if (this._trustLocalhost && /^(?:localhost|127\.0\.0\.\d+|(0*:)+:0*1)$/.test(url.hostname)) {
+    options.rejectUnauthorized = false;
+  } // initiate request
+
+
+  var mod = this._enableHttp2 ? exports.protocols['http2:'].setProtocol(url.protocol) : exports.protocols[url.protocol]; // request
+
+  this.req = mod.request(options);
+  var req = this.req; // set tcp no delay
+
+  req.setNoDelay(true);
+
+  if (options.method !== 'HEAD') {
+    req.setHeader('Accept-Encoding', 'gzip, deflate');
+  }
+
+  this.protocol = url.protocol;
+  this.host = url.host; // expose events
+
+  req.once('drain', function () {
+    _this3.emit('drain');
+  });
+  req.on('error', function (err) {
+    // flag abortion here for out timeouts
+    // because node will emit a faux-error "socket hang up"
+    // when request is aborted before a connection is made
+    if (_this3._aborted) return; // if not the same, we are in the **old** (cancelled) request,
+    // so need to continue (same as for above)
+
+    if (_this3._retries !== retries) return; // if we've received a response then we don't want to let
+    // an error in the request blow up the response
+
+    if (_this3.response) return;
+
+    _this3.callback(err);
+  }); // auth
+
+  if (url.auth) {
+    var auth = url.auth.split(':');
+    this.auth(auth[0], auth[1]);
+  }
+
+  if (this.username && this.password) {
+    this.auth(this.username, this.password);
+  }
+
+  for (var key in this.header) {
+    if (Object.prototype.hasOwnProperty.call(this.header, key)) req.setHeader(key, this.header[key]);
+  } // add cookies
+
+
+  if (this.cookies) {
+    if (Object.prototype.hasOwnProperty.call(this._header, 'cookie')) {
+      // merge
+      var tmpJar = new CookieJar.CookieJar();
+      tmpJar.setCookies(this._header.cookie.split(';'));
+      tmpJar.setCookies(this.cookies.split(';'));
+      req.setHeader('Cookie', tmpJar.getCookies(CookieJar.CookieAccessInfo.All).toValueString());
+    } else {
+      req.setHeader('Cookie', this.cookies);
+    }
+  }
+
+  return req;
+};
+/**
+ * Invoke the callback with `err` and `res`
+ * and handle arity check.
+ *
+ * @param {Error} err
+ * @param {Response} res
+ * @api private
+ */
+
+
+Request.prototype.callback = function (err, res) {
+  if (this._shouldRetry(err, res)) {
+    return this._retry();
+  } // Avoid the error which is emitted from 'socket hang up' to cause the fn undefined error on JS runtime.
+
+
+  var fn = this._callback || noop;
+  this.clearTimeout();
+  if (this.called) return console.warn('superagent: double callback bug');
+  this.called = true;
+
+  if (!err) {
+    try {
+      if (!this._isResponseOK(res)) {
+        var msg = 'Unsuccessful HTTP response';
+
+        if (res) {
+          msg = http.STATUS_CODES[res.status] || msg;
+        }
+
+        err = new Error(msg);
+        err.status = res ? res.status : undefined;
+      }
+    } catch (err_) {
+      err = err_;
+    }
+  } // It's important that the callback is called outside try/catch
+  // to avoid double callback
+
+
+  if (!err) {
+    return fn(null, res);
+  }
+
+  err.response = res;
+  if (this._maxRetries) err.retries = this._retries - 1; // only emit error event if there is a listener
+  // otherwise we assume the callback to `.end()` will get the error
+
+  if (err && this.listeners('error').length > 0) {
+    this.emit('error', err);
+  }
+
+  fn(err, res);
+};
+/**
+ * Check if `obj` is a host object,
+ *
+ * @param {Object} obj host object
+ * @return {Boolean} is a host object
+ * @api private
+ */
+
+
+Request.prototype._isHost = function (obj) {
+  return Buffer.isBuffer(obj) || obj instanceof Stream || obj instanceof FormData;
+};
+/**
+ * Initiate request, invoking callback `fn(err, res)`
+ * with an instanceof `Response`.
+ *
+ * @param {Function} fn
+ * @return {Request} for chaining
+ * @api public
+ */
+
+
+Request.prototype._emitResponse = function (body, files) {
+  var response = new Response(this);
+  this.response = response;
+  response.redirects = this._redirectList;
+
+  if (undefined !== body) {
+    response.body = body;
+  }
+
+  response.files = files;
+
+  if (this._endCalled) {
+    response.pipe = function () {
+      throw new Error("end() has already been called, so it's too late to start piping");
+    };
+  }
+
+  this.emit('response', response);
+  return response;
+};
+
+Request.prototype.end = function (fn) {
+  this.request();
+  debug('%s %s', this.method, this.url);
+
+  if (this._endCalled) {
+    throw new Error('.end() was called twice. This is not supported in superagent');
+  }
+
+  this._endCalled = true; // store callback
+
+  this._callback = fn || noop;
+
+  this._end();
+};
+
+Request.prototype._end = function () {
+  var _this4 = this;
+
+  if (this._aborted) return this.callback(new Error('The request has been aborted even before .end() was called'));
+  var data = this._data;
+  var req = this.req;
+  var method = this.method;
+
+  this._setTimeouts(); // body
+
+
+  if (method !== 'HEAD' && !req._headerSent) {
+    // serialize stuff
+    if (typeof data !== 'string') {
+      var contentType = req.getHeader('Content-Type'); // Parse out just the content type from the header (ignore the charset)
+
+      if (contentType) contentType = contentType.split(';')[0];
+      var serialize = this._serializer || exports.serialize[contentType];
+
+      if (!serialize && isJSON(contentType)) {
+        serialize = exports.serialize['application/json'];
+      }
+
+      if (serialize) data = serialize(data);
+    } // content-length
+
+
+    if (data && !req.getHeader('Content-Length')) {
+      req.setHeader('Content-Length', Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data));
+    }
+  } // response
+  // eslint-disable-next-line complexity
+
+
+  req.once('response', function (res) {
+    debug('%s %s -> %s', _this4.method, _this4.url, res.statusCode);
+
+    if (_this4._responseTimeoutTimer) {
+      clearTimeout(_this4._responseTimeoutTimer);
+    }
+
+    if (_this4.piped) {
+      return;
+    }
+
+    var max = _this4._maxRedirects;
+    var mime = utils.type(res.headers['content-type'] || '') || 'text/plain';
+    var type = mime.split('/')[0];
+    var multipart = type === 'multipart';
+    var redirect = isRedirect(res.statusCode);
+    var responseType = _this4._responseType;
+    _this4.res = res; // redirect
+
+    if (redirect && _this4._redirects++ !== max) {
+      return _this4._redirect(res);
+    }
+
+    if (_this4.method === 'HEAD') {
+      _this4.emit('end');
+
+      _this4.callback(null, _this4._emitResponse());
+
+      return;
+    } // zlib support
+
+
+    if (_this4._shouldUnzip(res)) {
+      unzip(req, res);
+    }
+
+    var buffer = _this4._buffer;
+
+    if (buffer === undefined && mime in exports.buffer) {
+      buffer = Boolean(exports.buffer[mime]);
+    }
+
+    var parser = _this4._parser;
+
+    if (undefined === buffer) {
+      if (parser) {
+        console.warn("A custom superagent parser has been set, but buffering strategy for the parser hasn't been configured. Call `req.buffer(true or false)` or set `superagent.buffer[mime] = true or false`");
+        buffer = true;
+      }
+    }
+
+    if (!parser) {
+      if (responseType) {
+        parser = exports.parse.image; // It's actually a generic Buffer
+
+        buffer = true;
+      } else if (multipart) {
+        var form = new formidable.IncomingForm();
+        parser = form.parse.bind(form);
+        buffer = true;
+      } else if (isImageOrVideo(mime)) {
+        parser = exports.parse.image;
+        buffer = true; // For backwards-compatibility buffering default is ad-hoc MIME-dependent
+      } else if (exports.parse[mime]) {
+        parser = exports.parse[mime];
+      } else if (type === 'text') {
+        parser = exports.parse.text;
+        buffer = buffer !== false; // everyone wants their own white-labeled json
+      } else if (isJSON(mime)) {
+        parser = exports.parse['application/json'];
+        buffer = buffer !== false;
+      } else if (buffer) {
+        parser = exports.parse.text;
+      } else if (undefined === buffer) {
+        parser = exports.parse.image; // It's actually a generic Buffer
+
+        buffer = true;
+      }
+    } // by default only buffer text/*, json and messed up thing from hell
+
+
+    if (undefined === buffer && isText(mime) || isJSON(mime)) {
+      buffer = true;
+    }
+
+    _this4._resBuffered = buffer;
+    var parserHandlesEnd = false;
+
+    if (buffer) {
+      // Protectiona against zip bombs and other nuisance
+      var responseBytesLeft = _this4._maxResponseSize || 200000000;
+      res.on('data', function (buf) {
+        responseBytesLeft -= buf.byteLength || buf.length;
+
+        if (responseBytesLeft < 0) {
+          // This will propagate through error event
+          var err = new Error('Maximum response size reached');
+          err.code = 'ETOOLARGE'; // Parsers aren't required to observe error event,
+          // so would incorrectly report success
+
+          parserHandlesEnd = false; // Will emit error event
+
+          res.destroy(err);
+        }
+      });
+    }
+
+    if (parser) {
+      try {
+        // Unbuffered parsers are supposed to emit response early,
+        // which is weird BTW, because response.body won't be there.
+        parserHandlesEnd = buffer;
+        parser(res, function (err, obj, files) {
+          if (_this4.timedout) {
+            // Timeout has already handled all callbacks
+            return;
+          } // Intentional (non-timeout) abort is supposed to preserve partial response,
+          // even if it doesn't parse.
+
+
+          if (err && !_this4._aborted) {
+            return _this4.callback(err);
+          }
+
+          if (parserHandlesEnd) {
+            _this4.emit('end');
+
+            _this4.callback(null, _this4._emitResponse(obj, files));
+          }
+        });
+      } catch (err) {
+        _this4.callback(err);
+
+        return;
+      }
+    }
+
+    _this4.res = res; // unbuffered
+
+    if (!buffer) {
+      debug('unbuffered %s %s', _this4.method, _this4.url);
+
+      _this4.callback(null, _this4._emitResponse());
+
+      if (multipart) return; // allow multipart to handle end event
+
+      res.once('end', function () {
+        debug('end %s %s', _this4.method, _this4.url);
+
+        _this4.emit('end');
+      });
+      return;
+    } // terminating events
+
+
+    res.once('error', function (err) {
+      parserHandlesEnd = false;
+
+      _this4.callback(err, null);
+    });
+    if (!parserHandlesEnd) res.once('end', function () {
+      debug('end %s %s', _this4.method, _this4.url); // TODO: unless buffering emit earlier to stream
+
+      _this4.emit('end');
+
+      _this4.callback(null, _this4._emitResponse());
+    });
+  });
+  this.emit('request', this);
+
+  var getProgressMonitor = function getProgressMonitor() {
+    var lengthComputable = true;
+    var total = req.getHeader('Content-Length');
+    var loaded = 0;
+    var progress = new Stream.Transform();
+
+    progress._transform = function (chunk, encoding, cb) {
+      loaded += chunk.length;
+
+      _this4.emit('progress', {
+        direction: 'upload',
+        lengthComputable: lengthComputable,
+        loaded: loaded,
+        total: total
+      });
+
+      cb(null, chunk);
+    };
+
+    return progress;
+  };
+
+  var bufferToChunks = function bufferToChunks(buffer) {
+    var chunkSize = 16 * 1024; // default highWaterMark value
+
+    var chunking = new Stream.Readable();
+    var totalLength = buffer.length;
+    var remainder = totalLength % chunkSize;
+    var cutoff = totalLength - remainder;
+
+    for (var i = 0; i < cutoff; i += chunkSize) {
+      var chunk = buffer.slice(i, i + chunkSize);
+      chunking.push(chunk);
+    }
+
+    if (remainder > 0) {
+      var remainderBuffer = buffer.slice(-remainder);
+      chunking.push(remainderBuffer);
+    }
+
+    chunking.push(null); // no more data
+
+    return chunking;
+  }; // if a FormData instance got created, then we send that as the request body
+
+
+  var formData = this._formData;
+
+  if (formData) {
+    // set headers
+    var headers = formData.getHeaders();
+
+    for (var i in headers) {
+      if (Object.prototype.hasOwnProperty.call(headers, i)) {
+        debug('setting FormData header: "%s: %s"', i, headers[i]);
+        req.setHeader(i, headers[i]);
+      }
+    } // attempt to get "Content-Length" header
+    // eslint-disable-next-line handle-callback-err
+
+
+    formData.getLength(function (err, length) {
+      // TODO: Add chunked encoding when no length (if err)
+      debug('got FormData Content-Length: %s', length);
+
+      if (typeof length === 'number') {
+        req.setHeader('Content-Length', length);
+      }
+
+      formData.pipe(getProgressMonitor()).pipe(req);
+    });
+  } else if (Buffer.isBuffer(data)) {
+    bufferToChunks(data).pipe(getProgressMonitor()).pipe(req);
+  } else {
+    req.end(data);
+  }
+}; // Check whether response has a non-0-sized gzip-encoded body
+
+
+Request.prototype._shouldUnzip = function (res) {
+  if (res.statusCode === 204 || res.statusCode === 304) {
+    // These aren't supposed to have any body
+    return false;
+  } // header content is a string, and distinction between 0 and no information is crucial
+
+
+  if (res.headers['content-length'] === '0') {
+    // We know that the body is empty (unfortunately, this check does not cover chunked encoding)
+    return false;
+  } // console.log(res);
+
+
+  return /^\s*(?:deflate|gzip)\s*$/.test(res.headers['content-encoding']);
+};
+/**
+ * Overrides DNS for selected hostnames. Takes object mapping hostnames to IP addresses.
+ *
+ * When making a request to a URL with a hostname exactly matching a key in the object,
+ * use the given IP address to connect, instead of using DNS to resolve the hostname.
+ *
+ * A special host `*` matches every hostname (keep redirects in mind!)
+ *
+ *      request.connect({
+ *        'test.example.com': '127.0.0.1',
+ *        'ipv6.example.com': '::1',
+ *      })
+ */
+
+
+Request.prototype.connect = function (connectOverride) {
+  if (typeof connectOverride === 'string') {
+    this._connectOverride = {
+      '*': connectOverride
+    };
+  } else if (_typeof(connectOverride) === 'object') {
+    this._connectOverride = connectOverride;
+  } else {
+    this._connectOverride = undefined;
+  }
+
+  return this;
+};
+
+Request.prototype.trustLocalhost = function (toggle) {
+  this._trustLocalhost = toggle === undefined ? true : toggle;
+  return this;
+}; // generate HTTP verb methods
+
+
+if (!methods.includes('del')) {
+  // create a copy so we don't cause conflicts with
+  // other packages using the methods package and
+  // npm 3.x
+  methods = methods.slice(0);
+  methods.push('del');
+}
+
+methods.forEach(function (method) {
+  var name = method;
+  method = method === 'del' ? 'delete' : method;
+  method = method.toUpperCase();
+
+  request[name] = function (url, data, fn) {
+    var req = request(method, url);
+
+    if (typeof data === 'function') {
+      fn = data;
+      data = null;
+    }
+
+    if (data) {
+      if (method === 'GET' || method === 'HEAD') {
+        req.query(data);
+      } else {
+        req.send(data);
+      }
+    }
+
+    if (fn) req.end(fn);
+    return req;
+  };
+});
+/**
+ * Check if `mime` is text and should be buffered.
+ *
+ * @param {String} mime
+ * @return {Boolean}
+ * @api public
+ */
+
+function isText(mime) {
+  var parts = mime.split('/');
+  var type = parts[0];
+  var subtype = parts[1];
+  return type === 'text' || subtype === 'x-www-form-urlencoded';
+}
+
+function isImageOrVideo(mime) {
+  var type = mime.split('/')[0];
+  return type === 'image' || type === 'video';
+}
+/**
+ * Check if `mime` is json or has +json structured syntax suffix.
+ *
+ * @param {String} mime
+ * @return {Boolean}
+ * @api private
+ */
+
+
+function isJSON(mime) {
+  // should match /json or +json
+  // but not /json-seq
+  return /[/+]json($|[^-\w])/.test(mime);
+}
+/**
+ * Check if we should follow the redirect `code`.
+ *
+ * @param {Number} code
+ * @return {Boolean}
+ * @api private
+ */
+
+
+function isRedirect(code) {
+  return [301, 302, 303, 305, 307, 308].includes(code);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/node/index.js"],"names":["require","parse","format","resolve","Stream","https","http","fs","zlib","util","qs","mime","methods","FormData","formidable","debug","CookieJar","semver","safeStringify","utils","RequestBase","unzip","Response","http2","gte","process","version","request","method","url","exports","Request","end","arguments","length","module","agent","noop","define","protocols","serialize","stringify","buffer","_initHeaders","req","_header","header","call","_enableHttp2","Boolean","env","HTTP2_TEST","_agent","_formData","writable","_redirects","redirects","cookies","_query","qsRaw","_redirectList","_streamRequest","once","clearTimeout","bind","inherits","prototype","bool","undefined","Error","attach","field","file","options","_data","o","filename","createReadStream","path","_getFormData","append","on","err","called","callback","abort","type","set","includes","getType","accept","query","val","push","Object","assign","write","data","encoding","pipe","stream","piped","_pipeContinue","res","isRedirect","statusCode","_maxRedirects","_redirect","_emitResponse","_aborted","_shouldUnzip","unzipObj","createUnzip","code","emit","_buffer","headers","location","resume","getHeaders","_headers","changesOrigin","host","cleanHeader","_endCalled","_callback","auth","user","pass","encoder","string","Buffer","from","toString","_auth","ca","cert","_ca","key","_key","pfx","isBuffer","_pfx","_passphrase","passphrase","_cert","disableTLSCerts","_disableTLSCerts","indices","strictNullHandling","_finalizeQueryString","retries","_retries","queryStringBackticks","queryStartIndex","indexOf","queryString","slice","match","i","replace","search","pathname","test","protocol","split","unixParts","socketPath","_connectOverride","hostname","newHost","newPort","port","rejectUnauthorized","NODE_TLS_REJECT_UNAUTHORIZED","servername","_trustLocalhost","mod","setProtocol","setNoDelay","setHeader","response","username","password","hasOwnProperty","tmpJar","setCookies","cookie","getCookies","CookieAccessInfo","All","toValueString","_shouldRetry","_retry","fn","console","warn","_isResponseOK","msg","STATUS_CODES","status","err_","_maxRetries","listeners","_isHost","obj","body","files","_end","_setTimeouts","_headerSent","contentType","getHeader","_serializer","isJSON","byteLength","_responseTimeoutTimer","max","multipart","redirect","responseType","_responseType","parser","_parser","image","form","IncomingForm","isImageOrVideo","text","isText","_resBuffered","parserHandlesEnd","responseBytesLeft","_maxResponseSize","buf","destroy","timedout","getProgressMonitor","lengthComputable","total","loaded","progress","Transform","_transform","chunk","cb","direction","bufferToChunks","chunkSize","chunking","Readable","totalLength","remainder","cutoff","remainderBuffer","formData","getLength","connect","connectOverride","trustLocalhost","toggle","forEach","name","toUpperCase","send","parts","subtype"],"mappings":"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","sourcesContent":["/**\n * Module dependencies.\n */\n\n// eslint-disable-next-line node/no-deprecated-api\nconst { parse, format, resolve } = require('url');\nconst Stream = require('stream');\nconst https = require('https');\nconst http = require('http');\nconst fs = require('fs');\nconst zlib = require('zlib');\nconst util = require('util');\nconst qs = require('qs');\nconst mime = require('mime');\nlet methods = require('methods');\nconst FormData = require('form-data');\nconst formidable = require('formidable');\nconst debug = require('debug')('superagent');\nconst CookieJar = require('cookiejar');\nconst semver = require('semver');\nconst safeStringify = require('fast-safe-stringify');\n\nconst utils = require('../utils');\nconst RequestBase = require('../request-base');\nconst { unzip } = require('./unzip');\nconst Response = require('./response');\n\nlet http2;\n\nif (semver.gte(process.version, 'v10.10.0')) http2 = require('./http2wrapper');\n\nfunction request(method, url) {\n  // callback\n  if (typeof url === 'function') {\n    return new exports.Request('GET', method).end(url);\n  }\n\n  // url first\n  if (arguments.length === 1) {\n    return new exports.Request('GET', method);\n  }\n\n  return new exports.Request(method, url);\n}\n\nmodule.exports = request;\nexports = module.exports;\n\n/**\n * Expose `Request`.\n */\n\nexports.Request = Request;\n\n/**\n * Expose the agent function\n */\n\nexports.agent = require('./agent');\n\n/**\n * Noop.\n */\n\nfunction noop() {}\n\n/**\n * Expose `Response`.\n */\n\nexports.Response = Response;\n\n/**\n * Define \"form\" mime type.\n */\n\nmime.define(\n  {\n    'application/x-www-form-urlencoded': ['form', 'urlencoded', 'form-data']\n  },\n  true\n);\n\n/**\n * Protocol map.\n */\n\nexports.protocols = {\n  'http:': http,\n  'https:': https,\n  'http2:': http2\n};\n\n/**\n * Default serialization map.\n *\n *     superagent.serialize['application/xml'] = function(obj){\n *       return 'generated xml here';\n *     };\n *\n */\n\nexports.serialize = {\n  'application/x-www-form-urlencoded': qs.stringify,\n  'application/json': safeStringify\n};\n\n/**\n * Default parsers.\n *\n *     superagent.parse['application/xml'] = function(res, fn){\n *       fn(null, res);\n *     };\n *\n */\n\nexports.parse = require('./parsers');\n\n/**\n * Default buffering map. Can be used to set certain\n * response types to buffer/not buffer.\n *\n *     superagent.buffer['application/xml'] = true;\n */\nexports.buffer = {};\n\n/**\n * Initialize internal header tracking properties on a request instance.\n *\n * @param {Object} req the instance\n * @api private\n */\nfunction _initHeaders(req) {\n  req._header = {\n    // coerces header names to lowercase\n  };\n  req.header = {\n    // preserves header name case\n  };\n}\n\n/**\n * Initialize a new `Request` with the given `method` and `url`.\n *\n * @param {String} method\n * @param {String|Object} url\n * @api public\n */\n\nfunction Request(method, url) {\n  Stream.call(this);\n  if (typeof url !== 'string') url = format(url);\n  this._enableHttp2 = Boolean(process.env.HTTP2_TEST); // internal only\n  this._agent = false;\n  this._formData = null;\n  this.method = method;\n  this.url = url;\n  _initHeaders(this);\n  this.writable = true;\n  this._redirects = 0;\n  this.redirects(method === 'HEAD' ? 0 : 5);\n  this.cookies = '';\n  this.qs = {};\n  this._query = [];\n  this.qsRaw = this._query; // Unused, for backwards compatibility only\n  this._redirectList = [];\n  this._streamRequest = false;\n  this.once('end', this.clearTimeout.bind(this));\n}\n\n/**\n * Inherit from `Stream` (which inherits from `EventEmitter`).\n * Mixin `RequestBase`.\n */\nutil.inherits(Request, Stream);\n// eslint-disable-next-line new-cap\nRequestBase(Request.prototype);\n\n/**\n * Enable or Disable http2.\n *\n * Enable http2.\n *\n * ``` js\n * request.get('http://localhost/')\n *   .http2()\n *   .end(callback);\n *\n * request.get('http://localhost/')\n *   .http2(true)\n *   .end(callback);\n * ```\n *\n * Disable http2.\n *\n * ``` js\n * request = request.http2();\n * request.get('http://localhost/')\n *   .http2(false)\n *   .end(callback);\n * ```\n *\n * @param {Boolean} enable\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.http2 = function(bool) {\n  if (exports.protocols['http2:'] === undefined) {\n    throw new Error(\n      'superagent: this version of Node.js does not support http2'\n    );\n  }\n\n  this._enableHttp2 = bool === undefined ? true : bool;\n  return this;\n};\n\n/**\n * Queue the given `file` as an attachment to the specified `field`,\n * with optional `options` (or filename).\n *\n * ``` js\n * request.post('http://localhost/upload')\n *   .attach('field', Buffer.from('<b>Hello world</b>'), 'hello.html')\n *   .end(callback);\n * ```\n *\n * A filename may also be used:\n *\n * ``` js\n * request.post('http://localhost/upload')\n *   .attach('files', 'image.jpg')\n *   .end(callback);\n * ```\n *\n * @param {String} field\n * @param {String|fs.ReadStream|Buffer} file\n * @param {String|Object} options\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.attach = function(field, file, options) {\n  if (file) {\n    if (this._data) {\n      throw new Error(\"superagent can't mix .send() and .attach()\");\n    }\n\n    let o = options || {};\n    if (typeof options === 'string') {\n      o = { filename: options };\n    }\n\n    if (typeof file === 'string') {\n      if (!o.filename) o.filename = file;\n      debug('creating `fs.ReadStream` instance for file: %s', file);\n      file = fs.createReadStream(file);\n    } else if (!o.filename && file.path) {\n      o.filename = file.path;\n    }\n\n    this._getFormData().append(field, file, o);\n  }\n\n  return this;\n};\n\nRequest.prototype._getFormData = function() {\n  if (!this._formData) {\n    this._formData = new FormData();\n    this._formData.on('error', err => {\n      debug('FormData error', err);\n      if (this.called) {\n        // The request has already finished and the callback was called.\n        // Silently ignore the error.\n        return;\n      }\n\n      this.callback(err);\n      this.abort();\n    });\n  }\n\n  return this._formData;\n};\n\n/**\n * Gets/sets the `Agent` to use for this HTTP request. The default (if this\n * function is not called) is to opt out of connection pooling (`agent: false`).\n *\n * @param {http.Agent} agent\n * @return {http.Agent}\n * @api public\n */\n\nRequest.prototype.agent = function(agent) {\n  if (arguments.length === 0) return this._agent;\n  this._agent = agent;\n  return this;\n};\n\n/**\n * Set _Content-Type_ response header passed through `mime.getType()`.\n *\n * Examples:\n *\n *      request.post('/')\n *        .type('xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n *      request.post('/')\n *        .type('json')\n *        .send(jsonstring)\n *        .end(callback);\n *\n *      request.post('/')\n *        .type('application/json')\n *        .send(jsonstring)\n *        .end(callback);\n *\n * @param {String} type\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.type = function(type) {\n  return this.set(\n    'Content-Type',\n    type.includes('/') ? type : mime.getType(type)\n  );\n};\n\n/**\n * Set _Accept_ response header passed through `mime.getType()`.\n *\n * Examples:\n *\n *      superagent.types.json = 'application/json';\n *\n *      request.get('/agent')\n *        .accept('json')\n *        .end(callback);\n *\n *      request.get('/agent')\n *        .accept('application/json')\n *        .end(callback);\n *\n * @param {String} accept\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.accept = function(type) {\n  return this.set('Accept', type.includes('/') ? type : mime.getType(type));\n};\n\n/**\n * Add query-string `val`.\n *\n * Examples:\n *\n *   request.get('/shoes')\n *     .query('size=10')\n *     .query({ color: 'blue' })\n *\n * @param {Object|String} val\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.query = function(val) {\n  if (typeof val === 'string') {\n    this._query.push(val);\n  } else {\n    Object.assign(this.qs, val);\n  }\n\n  return this;\n};\n\n/**\n * Write raw `data` / `encoding` to the socket.\n *\n * @param {Buffer|String} data\n * @param {String} encoding\n * @return {Boolean}\n * @api public\n */\n\nRequest.prototype.write = function(data, encoding) {\n  const req = this.request();\n  if (!this._streamRequest) {\n    this._streamRequest = true;\n  }\n\n  return req.write(data, encoding);\n};\n\n/**\n * Pipe the request body to `stream`.\n *\n * @param {Stream} stream\n * @param {Object} options\n * @return {Stream}\n * @api public\n */\n\nRequest.prototype.pipe = function(stream, options) {\n  this.piped = true; // HACK...\n  this.buffer(false);\n  this.end();\n  return this._pipeContinue(stream, options);\n};\n\nRequest.prototype._pipeContinue = function(stream, options) {\n  this.req.once('response', res => {\n    // redirect\n    if (\n      isRedirect(res.statusCode) &&\n      this._redirects++ !== this._maxRedirects\n    ) {\n      return this._redirect(res) === this\n        ? this._pipeContinue(stream, options)\n        : undefined;\n    }\n\n    this.res = res;\n    this._emitResponse();\n    if (this._aborted) return;\n\n    if (this._shouldUnzip(res)) {\n      const unzipObj = zlib.createUnzip();\n      unzipObj.on('error', err => {\n        if (err && err.code === 'Z_BUF_ERROR') {\n          // unexpected end of file is ignored by browsers and curl\n          stream.emit('end');\n          return;\n        }\n\n        stream.emit('error', err);\n      });\n      res.pipe(unzipObj).pipe(stream, options);\n    } else {\n      res.pipe(stream, options);\n    }\n\n    res.once('end', () => {\n      this.emit('end');\n    });\n  });\n  return stream;\n};\n\n/**\n * Enable / disable buffering.\n *\n * @return {Boolean} [val]\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.buffer = function(val) {\n  this._buffer = val !== false;\n  return this;\n};\n\n/**\n * Redirect to `url\n *\n * @param {IncomingMessage} res\n * @return {Request} for chaining\n * @api private\n */\n\nRequest.prototype._redirect = function(res) {\n  let url = res.headers.location;\n  if (!url) {\n    return this.callback(new Error('No location header for redirect'), res);\n  }\n\n  debug('redirect %s -> %s', this.url, url);\n\n  // location\n  url = resolve(this.url, url);\n\n  // ensure the response is being consumed\n  // this is required for Node v0.10+\n  res.resume();\n\n  let headers = this.req.getHeaders ? this.req.getHeaders() : this.req._headers;\n\n  const changesOrigin = parse(url).host !== parse(this.url).host;\n\n  // implementation of 302 following defacto standard\n  if (res.statusCode === 301 || res.statusCode === 302) {\n    // strip Content-* related fields\n    // in case of POST etc\n    headers = utils.cleanHeader(headers, changesOrigin);\n\n    // force GET\n    this.method = this.method === 'HEAD' ? 'HEAD' : 'GET';\n\n    // clear data\n    this._data = null;\n  }\n\n  // 303 is always GET\n  if (res.statusCode === 303) {\n    // strip Content-* related fields\n    // in case of POST etc\n    headers = utils.cleanHeader(headers, changesOrigin);\n\n    // force method\n    this.method = 'GET';\n\n    // clear data\n    this._data = null;\n  }\n\n  // 307 preserves method\n  // 308 preserves method\n  delete headers.host;\n\n  delete this.req;\n  delete this._formData;\n\n  // remove all add header except User-Agent\n  _initHeaders(this);\n\n  // redirect\n  this._endCalled = false;\n  this.url = url;\n  this.qs = {};\n  this._query.length = 0;\n  this.set(headers);\n  this.emit('redirect', res);\n  this._redirectList.push(this.url);\n  this.end(this._callback);\n  return this;\n};\n\n/**\n * Set Authorization field value with `user` and `pass`.\n *\n * Examples:\n *\n *   .auth('tobi', 'learnboost')\n *   .auth('tobi:learnboost')\n *   .auth('tobi')\n *   .auth(accessToken, { type: 'bearer' })\n *\n * @param {String} user\n * @param {String} [pass]\n * @param {Object} [options] options with authorization type 'basic' or 'bearer' ('basic' is default)\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.auth = function(user, pass, options) {\n  if (arguments.length === 1) pass = '';\n  if (typeof pass === 'object' && pass !== null) {\n    // pass is optional and can be replaced with options\n    options = pass;\n    pass = '';\n  }\n\n  if (!options) {\n    options = { type: 'basic' };\n  }\n\n  const encoder = string => Buffer.from(string).toString('base64');\n\n  return this._auth(user, pass, options, encoder);\n};\n\n/**\n * Set the certificate authority option for https request.\n *\n * @param {Buffer | Array} cert\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.ca = function(cert) {\n  this._ca = cert;\n  return this;\n};\n\n/**\n * Set the client certificate key option for https request.\n *\n * @param {Buffer | String} cert\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.key = function(cert) {\n  this._key = cert;\n  return this;\n};\n\n/**\n * Set the key, certificate, and CA certs of the client in PFX or PKCS12 format.\n *\n * @param {Buffer | String} cert\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.pfx = function(cert) {\n  if (typeof cert === 'object' && !Buffer.isBuffer(cert)) {\n    this._pfx = cert.pfx;\n    this._passphrase = cert.passphrase;\n  } else {\n    this._pfx = cert;\n  }\n\n  return this;\n};\n\n/**\n * Set the client certificate option for https request.\n *\n * @param {Buffer | String} cert\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.cert = function(cert) {\n  this._cert = cert;\n  return this;\n};\n\n/**\n * Do not reject expired or invalid TLS certs.\n * sets `rejectUnauthorized=true`. Be warned that this allows MITM attacks.\n *\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.disableTLSCerts = function() {\n  this._disableTLSCerts = true;\n  return this;\n};\n\n/**\n * Return an http[s] request.\n *\n * @return {OutgoingMessage}\n * @api private\n */\n\n// eslint-disable-next-line complexity\nRequest.prototype.request = function() {\n  if (this.req) return this.req;\n\n  const options = {};\n\n  try {\n    const query = qs.stringify(this.qs, {\n      indices: false,\n      strictNullHandling: true\n    });\n    if (query) {\n      this.qs = {};\n      this._query.push(query);\n    }\n\n    this._finalizeQueryString();\n  } catch (err) {\n    return this.emit('error', err);\n  }\n\n  let { url } = this;\n  const retries = this._retries;\n\n  // Capture backticks as-is from the final query string built above.\n  // Note: this'll only find backticks entered in req.query(String)\n  // calls, because qs.stringify unconditionally encodes backticks.\n  let queryStringBackticks;\n  if (url.includes('`')) {\n    const queryStartIndex = url.indexOf('?');\n\n    if (queryStartIndex !== -1) {\n      const queryString = url.slice(queryStartIndex + 1);\n      queryStringBackticks = queryString.match(/`|%60/g);\n    }\n  }\n\n  // default to http://\n  if (url.indexOf('http') !== 0) url = `http://${url}`;\n  url = parse(url);\n\n  // See https://github.com/visionmedia/superagent/issues/1367\n  if (queryStringBackticks) {\n    let i = 0;\n    url.query = url.query.replace(/%60/g, () => queryStringBackticks[i++]);\n    url.search = `?${url.query}`;\n    url.path = url.pathname + url.search;\n  }\n\n  // support unix sockets\n  if (/^https?\\+unix:/.test(url.protocol) === true) {\n    // get the protocol\n    url.protocol = `${url.protocol.split('+')[0]}:`;\n\n    // get the socket, path\n    const unixParts = url.path.match(/^([^/]+)(.+)$/);\n    options.socketPath = unixParts[1].replace(/%2F/g, '/');\n    url.path = unixParts[2];\n  }\n\n  // Override IP address of a hostname\n  if (this._connectOverride) {\n    const { hostname } = url;\n    const match =\n      hostname in this._connectOverride\n        ? this._connectOverride[hostname]\n        : this._connectOverride['*'];\n    if (match) {\n      // backup the real host\n      if (!this._header.host) {\n        this.set('host', url.host);\n      }\n\n      let newHost;\n      let newPort;\n\n      if (typeof match === 'object') {\n        newHost = match.host;\n        newPort = match.port;\n      } else {\n        newHost = match;\n        newPort = url.port;\n      }\n\n      // wrap [ipv6]\n      url.host = /:/.test(newHost) ? `[${newHost}]` : newHost;\n      if (newPort) {\n        url.host += `:${newPort}`;\n        url.port = newPort;\n      }\n\n      url.hostname = newHost;\n    }\n  }\n\n  // options\n  options.method = this.method;\n  options.port = url.port;\n  options.path = url.path;\n  options.host = url.hostname;\n  options.ca = this._ca;\n  options.key = this._key;\n  options.pfx = this._pfx;\n  options.cert = this._cert;\n  options.passphrase = this._passphrase;\n  options.agent = this._agent;\n  options.rejectUnauthorized =\n    typeof this._disableTLSCerts === 'boolean'\n      ? !this._disableTLSCerts\n      : process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0';\n\n  // Allows request.get('https://1.2.3.4/').set('Host', 'example.com')\n  if (this._header.host) {\n    options.servername = this._header.host.replace(/:\\d+$/, '');\n  }\n\n  if (\n    this._trustLocalhost &&\n    /^(?:localhost|127\\.0\\.0\\.\\d+|(0*:)+:0*1)$/.test(url.hostname)\n  ) {\n    options.rejectUnauthorized = false;\n  }\n\n  // initiate request\n  const mod = this._enableHttp2\n    ? exports.protocols['http2:'].setProtocol(url.protocol)\n    : exports.protocols[url.protocol];\n\n  // request\n  this.req = mod.request(options);\n  const { req } = this;\n\n  // set tcp no delay\n  req.setNoDelay(true);\n\n  if (options.method !== 'HEAD') {\n    req.setHeader('Accept-Encoding', 'gzip, deflate');\n  }\n\n  this.protocol = url.protocol;\n  this.host = url.host;\n\n  // expose events\n  req.once('drain', () => {\n    this.emit('drain');\n  });\n\n  req.on('error', err => {\n    // flag abortion here for out timeouts\n    // because node will emit a faux-error \"socket hang up\"\n    // when request is aborted before a connection is made\n    if (this._aborted) return;\n    // if not the same, we are in the **old** (cancelled) request,\n    // so need to continue (same as for above)\n    if (this._retries !== retries) return;\n    // if we've received a response then we don't want to let\n    // an error in the request blow up the response\n    if (this.response) return;\n    this.callback(err);\n  });\n\n  // auth\n  if (url.auth) {\n    const auth = url.auth.split(':');\n    this.auth(auth[0], auth[1]);\n  }\n\n  if (this.username && this.password) {\n    this.auth(this.username, this.password);\n  }\n\n  for (const key in this.header) {\n    if (Object.prototype.hasOwnProperty.call(this.header, key))\n      req.setHeader(key, this.header[key]);\n  }\n\n  // add cookies\n  if (this.cookies) {\n    if (Object.prototype.hasOwnProperty.call(this._header, 'cookie')) {\n      // merge\n      const tmpJar = new CookieJar.CookieJar();\n      tmpJar.setCookies(this._header.cookie.split(';'));\n      tmpJar.setCookies(this.cookies.split(';'));\n      req.setHeader(\n        'Cookie',\n        tmpJar.getCookies(CookieJar.CookieAccessInfo.All).toValueString()\n      );\n    } else {\n      req.setHeader('Cookie', this.cookies);\n    }\n  }\n\n  return req;\n};\n\n/**\n * Invoke the callback with `err` and `res`\n * and handle arity check.\n *\n * @param {Error} err\n * @param {Response} res\n * @api private\n */\n\nRequest.prototype.callback = function(err, res) {\n  if (this._shouldRetry(err, res)) {\n    return this._retry();\n  }\n\n  // Avoid the error which is emitted from 'socket hang up' to cause the fn undefined error on JS runtime.\n  const fn = this._callback || noop;\n  this.clearTimeout();\n  if (this.called) return console.warn('superagent: double callback bug');\n  this.called = true;\n\n  if (!err) {\n    try {\n      if (!this._isResponseOK(res)) {\n        let msg = 'Unsuccessful HTTP response';\n        if (res) {\n          msg = http.STATUS_CODES[res.status] || msg;\n        }\n\n        err = new Error(msg);\n        err.status = res ? res.status : undefined;\n      }\n    } catch (err_) {\n      err = err_;\n    }\n  }\n\n  // It's important that the callback is called outside try/catch\n  // to avoid double callback\n  if (!err) {\n    return fn(null, res);\n  }\n\n  err.response = res;\n  if (this._maxRetries) err.retries = this._retries - 1;\n\n  // only emit error event if there is a listener\n  // otherwise we assume the callback to `.end()` will get the error\n  if (err && this.listeners('error').length > 0) {\n    this.emit('error', err);\n  }\n\n  fn(err, res);\n};\n\n/**\n * Check if `obj` is a host object,\n *\n * @param {Object} obj host object\n * @return {Boolean} is a host object\n * @api private\n */\nRequest.prototype._isHost = function(obj) {\n  return (\n    Buffer.isBuffer(obj) || obj instanceof Stream || obj instanceof FormData\n  );\n};\n\n/**\n * Initiate request, invoking callback `fn(err, res)`\n * with an instanceof `Response`.\n *\n * @param {Function} fn\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype._emitResponse = function(body, files) {\n  const response = new Response(this);\n  this.response = response;\n  response.redirects = this._redirectList;\n  if (undefined !== body) {\n    response.body = body;\n  }\n\n  response.files = files;\n  if (this._endCalled) {\n    response.pipe = function() {\n      throw new Error(\n        \"end() has already been called, so it's too late to start piping\"\n      );\n    };\n  }\n\n  this.emit('response', response);\n  return response;\n};\n\nRequest.prototype.end = function(fn) {\n  this.request();\n  debug('%s %s', this.method, this.url);\n\n  if (this._endCalled) {\n    throw new Error(\n      '.end() was called twice. This is not supported in superagent'\n    );\n  }\n\n  this._endCalled = true;\n\n  // store callback\n  this._callback = fn || noop;\n\n  this._end();\n};\n\nRequest.prototype._end = function() {\n  if (this._aborted)\n    return this.callback(\n      new Error('The request has been aborted even before .end() was called')\n    );\n\n  let data = this._data;\n  const { req } = this;\n  const { method } = this;\n\n  this._setTimeouts();\n\n  // body\n  if (method !== 'HEAD' && !req._headerSent) {\n    // serialize stuff\n    if (typeof data !== 'string') {\n      let contentType = req.getHeader('Content-Type');\n      // Parse out just the content type from the header (ignore the charset)\n      if (contentType) contentType = contentType.split(';')[0];\n      let serialize = this._serializer || exports.serialize[contentType];\n      if (!serialize && isJSON(contentType)) {\n        serialize = exports.serialize['application/json'];\n      }\n\n      if (serialize) data = serialize(data);\n    }\n\n    // content-length\n    if (data && !req.getHeader('Content-Length')) {\n      req.setHeader(\n        'Content-Length',\n        Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data)\n      );\n    }\n  }\n\n  // response\n  // eslint-disable-next-line complexity\n  req.once('response', res => {\n    debug('%s %s -> %s', this.method, this.url, res.statusCode);\n\n    if (this._responseTimeoutTimer) {\n      clearTimeout(this._responseTimeoutTimer);\n    }\n\n    if (this.piped) {\n      return;\n    }\n\n    const max = this._maxRedirects;\n    const mime = utils.type(res.headers['content-type'] || '') || 'text/plain';\n    const type = mime.split('/')[0];\n    const multipart = type === 'multipart';\n    const redirect = isRedirect(res.statusCode);\n    const responseType = this._responseType;\n\n    this.res = res;\n\n    // redirect\n    if (redirect && this._redirects++ !== max) {\n      return this._redirect(res);\n    }\n\n    if (this.method === 'HEAD') {\n      this.emit('end');\n      this.callback(null, this._emitResponse());\n      return;\n    }\n\n    // zlib support\n    if (this._shouldUnzip(res)) {\n      unzip(req, res);\n    }\n\n    let buffer = this._buffer;\n    if (buffer === undefined && mime in exports.buffer) {\n      buffer = Boolean(exports.buffer[mime]);\n    }\n\n    let parser = this._parser;\n    if (undefined === buffer) {\n      if (parser) {\n        console.warn(\n          \"A custom superagent parser has been set, but buffering strategy for the parser hasn't been configured. Call `req.buffer(true or false)` or set `superagent.buffer[mime] = true or false`\"\n        );\n        buffer = true;\n      }\n    }\n\n    if (!parser) {\n      if (responseType) {\n        parser = exports.parse.image; // It's actually a generic Buffer\n        buffer = true;\n      } else if (multipart) {\n        const form = new formidable.IncomingForm();\n        parser = form.parse.bind(form);\n        buffer = true;\n      } else if (isImageOrVideo(mime)) {\n        parser = exports.parse.image;\n        buffer = true; // For backwards-compatibility buffering default is ad-hoc MIME-dependent\n      } else if (exports.parse[mime]) {\n        parser = exports.parse[mime];\n      } else if (type === 'text') {\n        parser = exports.parse.text;\n        buffer = buffer !== false;\n\n        // everyone wants their own white-labeled json\n      } else if (isJSON(mime)) {\n        parser = exports.parse['application/json'];\n        buffer = buffer !== false;\n      } else if (buffer) {\n        parser = exports.parse.text;\n      } else if (undefined === buffer) {\n        parser = exports.parse.image; // It's actually a generic Buffer\n        buffer = true;\n      }\n    }\n\n    // by default only buffer text/*, json and messed up thing from hell\n    if ((undefined === buffer && isText(mime)) || isJSON(mime)) {\n      buffer = true;\n    }\n\n    this._resBuffered = buffer;\n    let parserHandlesEnd = false;\n    if (buffer) {\n      // Protectiona against zip bombs and other nuisance\n      let responseBytesLeft = this._maxResponseSize || 200000000;\n      res.on('data', buf => {\n        responseBytesLeft -= buf.byteLength || buf.length;\n        if (responseBytesLeft < 0) {\n          // This will propagate through error event\n          const err = new Error('Maximum response size reached');\n          err.code = 'ETOOLARGE';\n          // Parsers aren't required to observe error event,\n          // so would incorrectly report success\n          parserHandlesEnd = false;\n          // Will emit error event\n          res.destroy(err);\n        }\n      });\n    }\n\n    if (parser) {\n      try {\n        // Unbuffered parsers are supposed to emit response early,\n        // which is weird BTW, because response.body won't be there.\n        parserHandlesEnd = buffer;\n\n        parser(res, (err, obj, files) => {\n          if (this.timedout) {\n            // Timeout has already handled all callbacks\n            return;\n          }\n\n          // Intentional (non-timeout) abort is supposed to preserve partial response,\n          // even if it doesn't parse.\n          if (err && !this._aborted) {\n            return this.callback(err);\n          }\n\n          if (parserHandlesEnd) {\n            this.emit('end');\n            this.callback(null, this._emitResponse(obj, files));\n          }\n        });\n      } catch (err) {\n        this.callback(err);\n        return;\n      }\n    }\n\n    this.res = res;\n\n    // unbuffered\n    if (!buffer) {\n      debug('unbuffered %s %s', this.method, this.url);\n      this.callback(null, this._emitResponse());\n      if (multipart) return; // allow multipart to handle end event\n      res.once('end', () => {\n        debug('end %s %s', this.method, this.url);\n        this.emit('end');\n      });\n      return;\n    }\n\n    // terminating events\n    res.once('error', err => {\n      parserHandlesEnd = false;\n      this.callback(err, null);\n    });\n    if (!parserHandlesEnd)\n      res.once('end', () => {\n        debug('end %s %s', this.method, this.url);\n        // TODO: unless buffering emit earlier to stream\n        this.emit('end');\n        this.callback(null, this._emitResponse());\n      });\n  });\n\n  this.emit('request', this);\n\n  const getProgressMonitor = () => {\n    const lengthComputable = true;\n    const total = req.getHeader('Content-Length');\n    let loaded = 0;\n\n    const progress = new Stream.Transform();\n    progress._transform = (chunk, encoding, cb) => {\n      loaded += chunk.length;\n      this.emit('progress', {\n        direction: 'upload',\n        lengthComputable,\n        loaded,\n        total\n      });\n      cb(null, chunk);\n    };\n\n    return progress;\n  };\n\n  const bufferToChunks = buffer => {\n    const chunkSize = 16 * 1024; // default highWaterMark value\n    const chunking = new Stream.Readable();\n    const totalLength = buffer.length;\n    const remainder = totalLength % chunkSize;\n    const cutoff = totalLength - remainder;\n\n    for (let i = 0; i < cutoff; i += chunkSize) {\n      const chunk = buffer.slice(i, i + chunkSize);\n      chunking.push(chunk);\n    }\n\n    if (remainder > 0) {\n      const remainderBuffer = buffer.slice(-remainder);\n      chunking.push(remainderBuffer);\n    }\n\n    chunking.push(null); // no more data\n\n    return chunking;\n  };\n\n  // if a FormData instance got created, then we send that as the request body\n  const formData = this._formData;\n  if (formData) {\n    // set headers\n    const headers = formData.getHeaders();\n    for (const i in headers) {\n      if (Object.prototype.hasOwnProperty.call(headers, i)) {\n        debug('setting FormData header: \"%s: %s\"', i, headers[i]);\n        req.setHeader(i, headers[i]);\n      }\n    }\n\n    // attempt to get \"Content-Length\" header\n    // eslint-disable-next-line handle-callback-err\n    formData.getLength((err, length) => {\n      // TODO: Add chunked encoding when no length (if err)\n\n      debug('got FormData Content-Length: %s', length);\n      if (typeof length === 'number') {\n        req.setHeader('Content-Length', length);\n      }\n\n      formData.pipe(getProgressMonitor()).pipe(req);\n    });\n  } else if (Buffer.isBuffer(data)) {\n    bufferToChunks(data)\n      .pipe(getProgressMonitor())\n      .pipe(req);\n  } else {\n    req.end(data);\n  }\n};\n\n// Check whether response has a non-0-sized gzip-encoded body\nRequest.prototype._shouldUnzip = res => {\n  if (res.statusCode === 204 || res.statusCode === 304) {\n    // These aren't supposed to have any body\n    return false;\n  }\n\n  // header content is a string, and distinction between 0 and no information is crucial\n  if (res.headers['content-length'] === '0') {\n    // We know that the body is empty (unfortunately, this check does not cover chunked encoding)\n    return false;\n  }\n\n  // console.log(res);\n  return /^\\s*(?:deflate|gzip)\\s*$/.test(res.headers['content-encoding']);\n};\n\n/**\n * Overrides DNS for selected hostnames. Takes object mapping hostnames to IP addresses.\n *\n * When making a request to a URL with a hostname exactly matching a key in the object,\n * use the given IP address to connect, instead of using DNS to resolve the hostname.\n *\n * A special host `*` matches every hostname (keep redirects in mind!)\n *\n *      request.connect({\n *        'test.example.com': '127.0.0.1',\n *        'ipv6.example.com': '::1',\n *      })\n */\nRequest.prototype.connect = function(connectOverride) {\n  if (typeof connectOverride === 'string') {\n    this._connectOverride = { '*': connectOverride };\n  } else if (typeof connectOverride === 'object') {\n    this._connectOverride = connectOverride;\n  } else {\n    this._connectOverride = undefined;\n  }\n\n  return this;\n};\n\nRequest.prototype.trustLocalhost = function(toggle) {\n  this._trustLocalhost = toggle === undefined ? true : toggle;\n  return this;\n};\n\n// generate HTTP verb methods\nif (!methods.includes('del')) {\n  // create a copy so we don't cause conflicts with\n  // other packages using the methods package and\n  // npm 3.x\n  methods = methods.slice(0);\n  methods.push('del');\n}\n\nmethods.forEach(method => {\n  const name = method;\n  method = method === 'del' ? 'delete' : method;\n\n  method = method.toUpperCase();\n  request[name] = (url, data, fn) => {\n    const req = request(method, url);\n    if (typeof data === 'function') {\n      fn = data;\n      data = null;\n    }\n\n    if (data) {\n      if (method === 'GET' || method === 'HEAD') {\n        req.query(data);\n      } else {\n        req.send(data);\n      }\n    }\n\n    if (fn) req.end(fn);\n    return req;\n  };\n});\n\n/**\n * Check if `mime` is text and should be buffered.\n *\n * @param {String} mime\n * @return {Boolean}\n * @api public\n */\n\nfunction isText(mime) {\n  const parts = mime.split('/');\n  const type = parts[0];\n  const subtype = parts[1];\n\n  return type === 'text' || subtype === 'x-www-form-urlencoded';\n}\n\nfunction isImageOrVideo(mime) {\n  const type = mime.split('/')[0];\n\n  return type === 'image' || type === 'video';\n}\n\n/**\n * Check if `mime` is json or has +json structured syntax suffix.\n *\n * @param {String} mime\n * @return {Boolean}\n * @api private\n */\n\nfunction isJSON(mime) {\n  // should match /json or +json\n  // but not /json-seq\n  return /[/+]json($|[^-\\w])/.test(mime);\n}\n\n/**\n * Check if we should follow the redirect `code`.\n *\n * @param {Number} code\n * @return {Boolean}\n * @api private\n */\n\nfunction isRedirect(code) {\n  return [301, 302, 303, 305, 307, 308].includes(code);\n}\n"]}