superagent/lib/client.js

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

/**
 * Root reference for iframes.
 */
var root;

if (typeof window !== 'undefined') {
  // Browser window
  root = window;
} else if (typeof self === 'undefined') {
  // Other environments
  console.warn('Using browser-only version of superagent in non-browser environment');
  root = void 0;
} else {
  // Web Worker
  root = self;
}

var Emitter = require('component-emitter');

var safeStringify = require('fast-safe-stringify');

var qs = require('qs');

var RequestBase = require('./request-base');

var isObject = require('./is-object');

var ResponseBase = require('./response-base');

var Agent = require('./agent-base');
/**
 * Noop.
 */


function noop() {}
/**
 * Expose `request`.
 */


module.exports = function (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);
};

exports = module.exports;
var request = exports;
exports.Request = Request;
/**
 * Determine XHR.
 */

request.getXHR = function () {
  if (root.XMLHttpRequest && (!root.location || root.location.protocol !== 'file:' || !root.ActiveXObject)) {
    return new XMLHttpRequest();
  }

  try {
    return new ActiveXObject('Microsoft.XMLHTTP');
  } catch (_unused) {}

  try {
    return new ActiveXObject('Msxml2.XMLHTTP.6.0');
  } catch (_unused2) {}

  try {
    return new ActiveXObject('Msxml2.XMLHTTP.3.0');
  } catch (_unused3) {}

  try {
    return new ActiveXObject('Msxml2.XMLHTTP');
  } catch (_unused4) {}

  throw new Error('Browser-only version of superagent could not find XHR');
};
/**
 * Removes leading and trailing whitespace, added to support IE.
 *
 * @param {String} s
 * @return {String}
 * @api private
 */


var trim = ''.trim ? function (s) {
  return s.trim();
} : function (s) {
  return s.replace(/(^\s*|\s*$)/g, '');
};
/**
 * Serialize the given `obj`.
 *
 * @param {Object} obj
 * @return {String}
 * @api private
 */

function serialize(object) {
  if (!isObject(object)) return object;
  var pairs = [];

  for (var key in object) {
    if (Object.prototype.hasOwnProperty.call(object, key)) pushEncodedKeyValuePair(pairs, key, object[key]);
  }

  return pairs.join('&');
}
/**
 * Helps 'serialize' with serializing arrays.
 * Mutates the pairs array.
 *
 * @param {Array} pairs
 * @param {String} key
 * @param {Mixed} val
 */


function pushEncodedKeyValuePair(pairs, key, value) {
  if (value === undefined) return;

  if (value === null) {
    pairs.push(encodeURI(key));
    return;
  }

  if (Array.isArray(value)) {
    var _iterator = _createForOfIteratorHelper(value),
        _step;

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var v = _step.value;
        pushEncodedKeyValuePair(pairs, key, v);
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
  } else if (isObject(value)) {
    for (var subkey in value) {
      if (Object.prototype.hasOwnProperty.call(value, subkey)) pushEncodedKeyValuePair(pairs, "".concat(key, "[").concat(subkey, "]"), value[subkey]);
    }
  } else {
    pairs.push(encodeURI(key) + '=' + encodeURIComponent(value));
  }
}
/**
 * Expose serialization method.
 */


request.serializeObject = serialize;
/**
 * Parse the given x-www-form-urlencoded `str`.
 *
 * @param {String} str
 * @return {Object}
 * @api private
 */

function parseString(string_) {
  var object = {};
  var pairs = string_.split('&');
  var pair;
  var pos;

  for (var i = 0, length_ = pairs.length; i < length_; ++i) {
    pair = pairs[i];
    pos = pair.indexOf('=');

    if (pos === -1) {
      object[decodeURIComponent(pair)] = '';
    } else {
      object[decodeURIComponent(pair.slice(0, pos))] = decodeURIComponent(pair.slice(pos + 1));
    }
  }

  return object;
}
/**
 * Expose parser.
 */


request.parseString = parseString;
/**
 * Default MIME type map.
 *
 *     superagent.types.xml = 'application/xml';
 *
 */

request.types = {
  html: 'text/html',
  json: 'application/json',
  xml: 'text/xml',
  urlencoded: 'application/x-www-form-urlencoded',
  form: 'application/x-www-form-urlencoded',
  'form-data': 'application/x-www-form-urlencoded'
};
/**
 * Default serialization map.
 *
 *     superagent.serialize['application/xml'] = function(obj){
 *       return 'generated xml here';
 *     };
 *
 */

request.serialize = {
  'application/x-www-form-urlencoded': qs.stringify,
  'application/json': safeStringify
};
/**
 * Default parsers.
 *
 *     superagent.parse['application/xml'] = function(str){
 *       return { object parsed from str };
 *     };
 *
 */

request.parse = {
  'application/x-www-form-urlencoded': parseString,
  'application/json': JSON.parse
};
/**
 * Parse the given header `str` into
 * an object containing the mapped fields.
 *
 * @param {String} str
 * @return {Object}
 * @api private
 */

function parseHeader(string_) {
  var lines = string_.split(/\r?\n/);
  var fields = {};
  var index;
  var line;
  var field;
  var value;

  for (var i = 0, length_ = lines.length; i < length_; ++i) {
    line = lines[i];
    index = line.indexOf(':');

    if (index === -1) {
      // could be empty line, just skip it
      continue;
    }

    field = line.slice(0, index).toLowerCase();
    value = trim(line.slice(index + 1));
    fields[field] = value;
  }

  return fields;
}
/**
 * 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])/i.test(mime);
}
/**
 * Initialize a new `Response` with the given `xhr`.
 *
 *  - set flags (.ok, .error, etc)
 *  - parse header
 *
 * Examples:
 *
 *  Aliasing `superagent` as `request` is nice:
 *
 *      request = superagent;
 *
 *  We can use the promise-like API, or pass callbacks:
 *
 *      request.get('/').end(function(res){});
 *      request.get('/', function(res){});
 *
 *  Sending data can be chained:
 *
 *      request
 *        .post('/user')
 *        .send({ name: 'tj' })
 *        .end(function(res){});
 *
 *  Or passed to `.send()`:
 *
 *      request
 *        .post('/user')
 *        .send({ name: 'tj' }, function(res){});
 *
 *  Or passed to `.post()`:
 *
 *      request
 *        .post('/user', { name: 'tj' })
 *        .end(function(res){});
 *
 * Or further reduced to a single call for simple cases:
 *
 *      request
 *        .post('/user', { name: 'tj' }, function(res){});
 *
 * @param {XMLHTTPRequest} xhr
 * @param {Object} options
 * @api private
 */


function Response(request_) {
  this.req = request_;
  this.xhr = this.req.xhr; // responseText is accessible only if responseType is '' or 'text' and on older browsers

  this.text = this.req.method !== 'HEAD' && (this.xhr.responseType === '' || this.xhr.responseType === 'text') || typeof this.xhr.responseType === 'undefined' ? this.xhr.responseText : null;
  this.statusText = this.req.xhr.statusText;
  var status = this.xhr.status; // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request

  if (status === 1223) {
    status = 204;
  }

  this._setStatusProperties(status);

  this.headers = parseHeader(this.xhr.getAllResponseHeaders());
  this.header = this.headers; // getAllResponseHeaders sometimes falsely returns "" for CORS requests, but
  // getResponseHeader still works. so we get content-type even if getting
  // other headers fails.

  this.header['content-type'] = this.xhr.getResponseHeader('content-type');

  this._setHeaderProperties(this.header);

  if (this.text === null && request_._responseType) {
    this.body = this.xhr.response;
  } else {
    this.body = this.req.method === 'HEAD' ? null : this._parseBody(this.text ? this.text : this.xhr.response);
  }
} // eslint-disable-next-line new-cap


ResponseBase(Response.prototype);
/**
 * Parse the given body `str`.
 *
 * Used for auto-parsing of bodies. Parsers
 * are defined on the `superagent.parse` object.
 *
 * @param {String} str
 * @return {Mixed}
 * @api private
 */

Response.prototype._parseBody = function (string_) {
  var parse = request.parse[this.type];

  if (this.req._parser) {
    return this.req._parser(this, string_);
  }

  if (!parse && isJSON(this.type)) {
    parse = request.parse['application/json'];
  }

  return parse && string_ && (string_.length > 0 || string_ instanceof Object) ? parse(string_) : null;
};
/**
 * Return an `Error` representative of this response.
 *
 * @return {Error}
 * @api public
 */


Response.prototype.toError = function () {
  var req = this.req;
  var method = req.method;
  var url = req.url;
  var message = "cannot ".concat(method, " ").concat(url, " (").concat(this.status, ")");
  var error = new Error(message);
  error.status = this.status;
  error.method = method;
  error.url = url;
  return error;
};
/**
 * Expose `Response`.
 */


request.Response = Response;
/**
 * Initialize a new `Request` with the given `method` and `url`.
 *
 * @param {String} method
 * @param {String} url
 * @api public
 */

function Request(method, url) {
  var self = this;
  this._query = this._query || [];
  this.method = method;
  this.url = url;
  this.header = {}; // preserves header name case

  this._header = {}; // coerces header names to lowercase

  this.on('end', function () {
    var error = null;
    var res = null;

    try {
      res = new Response(self);
    } catch (error_) {
      error = new Error('Parser is unable to parse the response');
      error.parse = true;
      error.original = error_; // issue #675: return the raw response if the response parsing fails

      if (self.xhr) {
        // ie9 doesn't have 'response' property
        error.rawResponse = typeof self.xhr.responseType === 'undefined' ? self.xhr.responseText : self.xhr.response; // issue #876: return the http status code if the response parsing fails

        error.status = self.xhr.status ? self.xhr.status : null;
        error.statusCode = error.status; // backwards-compat only
      } else {
        error.rawResponse = null;
        error.status = null;
      }

      return self.callback(error);
    }

    self.emit('response', res);
    var new_error;

    try {
      if (!self._isResponseOK(res)) {
        new_error = new Error(res.statusText || res.text || 'Unsuccessful HTTP response');
      }
    } catch (err) {
      new_error = err; // ok() callback can throw
    } // #1000 don't catch errors from the callback to avoid double calling it


    if (new_error) {
      new_error.original = error;
      new_error.response = res;
      new_error.status = res.status;
      self.callback(new_error, res);
    } else {
      self.callback(null, res);
    }
  });
}
/**
 * Mixin `Emitter` and `RequestBase`.
 */
// eslint-disable-next-line new-cap


Emitter(Request.prototype); // eslint-disable-next-line new-cap

RequestBase(Request.prototype);
/**
 * Set Content-Type to `type`, mapping values from `request.types`.
 *
 * Examples:
 *
 *      superagent.types.xml = 'application/xml';
 *
 *      request.post('/')
 *        .type('xml')
 *        .send(xmlstring)
 *        .end(callback);
 *
 *      request.post('/')
 *        .type('application/xml')
 *        .send(xmlstring)
 *        .end(callback);
 *
 * @param {String} type
 * @return {Request} for chaining
 * @api public
 */

Request.prototype.type = function (type) {
  this.set('Content-Type', request.types[type] || type);
  return this;
};
/**
 * Set Accept to `type`, mapping values from `request.types`.
 *
 * 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) {
  this.set('Accept', request.types[type] || type);
  return this;
};
/**
 * Set Authorization field value with `user` and `pass`.
 *
 * @param {String} user
 * @param {String} [pass] optional in case of using 'bearer' as type
 * @param {Object} options with 'type' property 'auto', 'basic' or 'bearer' (default 'basic')
 * @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: typeof btoa === 'function' ? 'basic' : 'auto'
    };
  }

  var encoder = function encoder(string) {
    if (typeof btoa === 'function') {
      return btoa(string);
    }

    throw new Error('Cannot use basic auth, btoa is not a function');
  };

  return this._auth(user, pass, options, encoder);
};
/**
 * 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 (value) {
  if (typeof value !== 'string') value = serialize(value);
  if (value) this._query.push(value);
  return this;
};
/**
 * Queue the given `file` as an attachment to the specified `field`,
 * with optional `options` (or filename).
 *
 * ``` js
 * request.post('/upload')
 *   .attach('content', new Blob(['<a id="a"><b id="b">hey!</b></a>'], { type: "text/html"}))
 *   .end(callback);
 * ```
 *
 * @param {String} field
 * @param {Blob|File} 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()");
    }

    this._getFormData().append(field, file, options || file.name);
  }

  return this;
};

Request.prototype._getFormData = function () {
  if (!this._formData) {
    this._formData = new root.FormData();
  }

  return this._formData;
};
/**
 * Invoke the callback with `err` and `res`
 * and handle arity check.
 *
 * @param {Error} err
 * @param {Response} res
 * @api private
 */


Request.prototype.callback = function (error, res) {
  if (this._shouldRetry(error, res)) {
    return this._retry();
  }

  var fn = this._callback;
  this.clearTimeout();

  if (error) {
    if (this._maxRetries) error.retries = this._retries - 1;
    this.emit('error', error);
  }

  fn(error, res);
};
/**
 * Invoke callback with x-domain error.
 *
 * @api private
 */


Request.prototype.crossDomainError = function () {
  var error = new Error('Request has been terminated\nPossible causes: the network is offline, Origin is not allowed by Access-Control-Allow-Origin, the page is being unloaded, etc.');
  error.crossDomain = true;
  error.status = this.status;
  error.method = this.method;
  error.url = this.url;
  this.callback(error);
}; // This only warns, because the request is still likely to work


Request.prototype.agent = function () {
  console.warn('This is not supported in browser version of superagent');
  return this;
};

Request.prototype.ca = Request.prototype.agent;
Request.prototype.buffer = Request.prototype.ca; // This throws, because it can't send/receive data as expected

Request.prototype.write = function () {
  throw new Error('Streaming is not supported in browser version of superagent');
};

Request.prototype.pipe = Request.prototype.write;
/**
 * Check if `obj` is a host object,
 * we don't want to serialize these :)
 *
 * @param {Object} obj host object
 * @return {Boolean} is a host object
 * @api private
 */

Request.prototype._isHost = function (object) {
  // Native objects stringify to [object File], [object Blob], [object FormData], etc.
  return object && _typeof(object) === 'object' && !Array.isArray(object) && Object.prototype.toString.call(object) !== '[object Object]';
};
/**
 * Initiate request, invoking callback `fn(res)`
 * with an instanceof `Response`.
 *
 * @param {Function} fn
 * @return {Request} for chaining
 * @api public
 */


Request.prototype.end = function (fn) {
  if (this._endCalled) {
    console.warn('Warning: .end() was called twice. This is not supported in superagent');
  }

  this._endCalled = true; // store callback

  this._callback = fn || noop; // querystring

  this._finalizeQueryString();

  this._end();
};

Request.prototype._setUploadTimeout = function () {
  var self = this; // upload timeout it's wokrs only if deadline timeout is off

  if (this._uploadTimeout && !this._uploadTimeoutTimer) {
    this._uploadTimeoutTimer = setTimeout(function () {
      self._timeoutError('Upload timeout of ', self._uploadTimeout, 'ETIMEDOUT');
    }, this._uploadTimeout);
  }
}; // eslint-disable-next-line complexity


Request.prototype._end = function () {
  if (this._aborted) return this.callback(new Error('The request has been aborted even before .end() was called'));
  var self = this;
  this.xhr = request.getXHR();
  var xhr = this.xhr;
  var data = this._formData || this._data;

  this._setTimeouts(); // state change


  xhr.addEventListener('readystatechange', function () {
    var readyState = xhr.readyState;

    if (readyState >= 2 && self._responseTimeoutTimer) {
      clearTimeout(self._responseTimeoutTimer);
    }

    if (readyState !== 4) {
      return;
    } // In IE9, reads to any property (e.g. status) off of an aborted XHR will
    // result in the error "Could not complete the operation due to error c00c023f"


    var status;

    try {
      status = xhr.status;
    } catch (_unused5) {
      status = 0;
    }

    if (!status) {
      if (self.timedout || self._aborted) return;
      return self.crossDomainError();
    }

    self.emit('end');
  }); // progress

  var handleProgress = function handleProgress(direction, e) {
    if (e.total > 0) {
      e.percent = e.loaded / e.total * 100;

      if (e.percent === 100) {
        clearTimeout(self._uploadTimeoutTimer);
      }
    }

    e.direction = direction;
    self.emit('progress', e);
  };

  if (this.hasListeners('progress')) {
    try {
      xhr.addEventListener('progress', handleProgress.bind(null, 'download'));

      if (xhr.upload) {
        xhr.upload.addEventListener('progress', handleProgress.bind(null, 'upload'));
      }
    } catch (_unused6) {// Accessing xhr.upload fails in IE from a web worker, so just pretend it doesn't exist.
      // Reported here:
      // https://connect.microsoft.com/IE/feedback/details/837245/xmlhttprequest-upload-throws-invalid-argument-when-used-from-web-worker-context
    }
  }

  if (xhr.upload) {
    this._setUploadTimeout();
  } // initiate request


  try {
    if (this.username && this.password) {
      xhr.open(this.method, this.url, true, this.username, this.password);
    } else {
      xhr.open(this.method, this.url, true);
    }
  } catch (err) {
    // see #1149
    return this.callback(err);
  } // CORS


  if (this._withCredentials) xhr.withCredentials = true; // body

  if (!this._formData && this.method !== 'GET' && this.method !== 'HEAD' && typeof data !== 'string' && !this._isHost(data)) {
    // serialize stuff
    var contentType = this._header['content-type'];

    var _serialize = this._serializer || request.serialize[contentType ? contentType.split(';')[0] : ''];

    if (!_serialize && isJSON(contentType)) {
      _serialize = request.serialize['application/json'];
    }

    if (_serialize) data = _serialize(data);
  } // set header fields


  for (var field in this.header) {
    if (this.header[field] === null) continue;
    if (Object.prototype.hasOwnProperty.call(this.header, field)) xhr.setRequestHeader(field, this.header[field]);
  }

  if (this._responseType) {
    xhr.responseType = this._responseType;
  } // send stuff


  this.emit('request', this); // IE11 xhr.send(undefined) sends 'undefined' string as POST payload (instead of nothing)
  // We need null here if data is undefined

  xhr.send(typeof data === 'undefined' ? null : data);
};

request.agent = function () {
  return new Agent();
};

var _loop = function _loop() {
  var method = _arr[_i];

  Agent.prototype[method.toLowerCase()] = function (url, fn) {
    var request_ = new request.Request(method, url);

    this._setDefaults(request_);

    if (fn) {
      request_.end(fn);
    }

    return request_;
  };
};

for (var _i = 0, _arr = ['GET', 'POST', 'OPTIONS', 'PATCH', 'PUT', 'DELETE']; _i < _arr.length; _i++) {
  _loop();
}

Agent.prototype.del = Agent.prototype.delete;
/**
 * GET `url` with optional callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed|Function} [data] or fn
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */

request.get = function (url, data, fn) {
  var request_ = request('GET', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.query(data);
  if (fn) request_.end(fn);
  return request_;
};
/**
 * HEAD `url` with optional callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed|Function} [data] or fn
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */


request.head = function (url, data, fn) {
  var request_ = request('HEAD', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.query(data);
  if (fn) request_.end(fn);
  return request_;
};
/**
 * OPTIONS query to `url` with optional callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed|Function} [data] or fn
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */


request.options = function (url, data, fn) {
  var request_ = request('OPTIONS', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.send(data);
  if (fn) request_.end(fn);
  return request_;
};
/**
 * DELETE `url` with optional `data` and callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed} [data]
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */


function del(url, data, fn) {
  var request_ = request('DELETE', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.send(data);
  if (fn) request_.end(fn);
  return request_;
}

request.del = del;
request.delete = del;
/**
 * PATCH `url` with optional `data` and callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed} [data]
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */

request.patch = function (url, data, fn) {
  var request_ = request('PATCH', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.send(data);
  if (fn) request_.end(fn);
  return request_;
};
/**
 * POST `url` with optional `data` and callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed} [data]
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */


request.post = function (url, data, fn) {
  var request_ = request('POST', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.send(data);
  if (fn) request_.end(fn);
  return request_;
};
/**
 * PUT `url` with optional `data` and callback `fn(res)`.
 *
 * @param {String} url
 * @param {Mixed|Function} [data] or fn
 * @param {Function} [fn]
 * @return {Request}
 * @api public
 */


request.put = function (url, data, fn) {
  var request_ = request('PUT', url);

  if (typeof data === 'function') {
    fn = data;
    data = null;
  }

  if (data) request_.send(data);
  if (fn) request_.end(fn);
  return request_;
};
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/client.js"],"names":["root","window","self","console","warn","Emitter","require","safeStringify","qs","RequestBase","isObject","ResponseBase","Agent","noop","module","exports","method","url","Request","end","arguments","length","request","getXHR","XMLHttpRequest","location","protocol","ActiveXObject","Error","trim","s","replace","serialize","object","pairs","key","Object","prototype","hasOwnProperty","call","pushEncodedKeyValuePair","join","value","undefined","push","encodeURI","Array","isArray","v","subkey","encodeURIComponent","serializeObject","parseString","string_","split","pair","pos","i","length_","indexOf","decodeURIComponent","slice","types","html","json","xml","urlencoded","form","stringify","parse","JSON","parseHeader","lines","fields","index","line","field","toLowerCase","isJSON","mime","test","Response","request_","req","xhr","text","responseType","responseText","statusText","status","_setStatusProperties","headers","getAllResponseHeaders","header","getResponseHeader","_setHeaderProperties","_responseType","body","response","_parseBody","type","_parser","toError","message","error","_query","_header","on","res","error_","original","rawResponse","statusCode","callback","emit","new_error","_isResponseOK","err","set","accept","auth","user","pass","options","btoa","encoder","string","_auth","query","attach","file","_data","_getFormData","append","name","_formData","FormData","_shouldRetry","_retry","fn","_callback","clearTimeout","_maxRetries","retries","_retries","crossDomainError","crossDomain","agent","ca","buffer","write","pipe","_isHost","toString","_endCalled","_finalizeQueryString","_end","_setUploadTimeout","_uploadTimeout","_uploadTimeoutTimer","setTimeout","_timeoutError","_aborted","data","_setTimeouts","addEventListener","readyState","_responseTimeoutTimer","timedout","handleProgress","direction","e","total","percent","loaded","hasListeners","bind","upload","username","password","open","_withCredentials","withCredentials","contentType","_serializer","setRequestHeader","send","_setDefaults","del","delete","get","head","patch","post","put"],"mappings":"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","sourcesContent":["/**\n * Root reference for iframes.\n */\n\nlet root;\nif (typeof window !== 'undefined') {\n  // Browser window\n  root = window;\n} else if (typeof self === 'undefined') {\n  // Other environments\n  console.warn(\n    'Using browser-only version of superagent in non-browser environment'\n  );\n  root = this;\n} else {\n  // Web Worker\n  root = self;\n}\n\nconst Emitter = require('component-emitter');\nconst safeStringify = require('fast-safe-stringify');\nconst qs = require('qs');\nconst RequestBase = require('./request-base');\nconst isObject = require('./is-object');\nconst ResponseBase = require('./response-base');\nconst Agent = require('./agent-base');\n\n/**\n * Noop.\n */\n\nfunction noop() {}\n\n/**\n * Expose `request`.\n */\n\nmodule.exports = function (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\nexports = module.exports;\n\nconst request = exports;\n\nexports.Request = Request;\n\n/**\n * Determine XHR.\n */\n\nrequest.getXHR = () => {\n  if (\n    root.XMLHttpRequest &&\n    (!root.location ||\n      root.location.protocol !== 'file:' ||\n      !root.ActiveXObject)\n  ) {\n    return new XMLHttpRequest();\n  }\n\n  try {\n    return new ActiveXObject('Microsoft.XMLHTTP');\n  } catch {}\n\n  try {\n    return new ActiveXObject('Msxml2.XMLHTTP.6.0');\n  } catch {}\n\n  try {\n    return new ActiveXObject('Msxml2.XMLHTTP.3.0');\n  } catch {}\n\n  try {\n    return new ActiveXObject('Msxml2.XMLHTTP');\n  } catch {}\n\n  throw new Error('Browser-only version of superagent could not find XHR');\n};\n\n/**\n * Removes leading and trailing whitespace, added to support IE.\n *\n * @param {String} s\n * @return {String}\n * @api private\n */\n\nconst trim = ''.trim ? (s) => s.trim() : (s) => s.replace(/(^\\s*|\\s*$)/g, '');\n\n/**\n * Serialize the given `obj`.\n *\n * @param {Object} obj\n * @return {String}\n * @api private\n */\n\nfunction serialize(object) {\n  if (!isObject(object)) return object;\n  const pairs = [];\n  for (const key in object) {\n    if (Object.prototype.hasOwnProperty.call(object, key))\n      pushEncodedKeyValuePair(pairs, key, object[key]);\n  }\n\n  return pairs.join('&');\n}\n\n/**\n * Helps 'serialize' with serializing arrays.\n * Mutates the pairs array.\n *\n * @param {Array} pairs\n * @param {String} key\n * @param {Mixed} val\n */\n\nfunction pushEncodedKeyValuePair(pairs, key, value) {\n  if (value === undefined) return;\n  if (value === null) {\n    pairs.push(encodeURI(key));\n    return;\n  }\n\n  if (Array.isArray(value)) {\n    for (const v of value) {\n      pushEncodedKeyValuePair(pairs, key, v);\n    }\n  } else if (isObject(value)) {\n    for (const subkey in value) {\n      if (Object.prototype.hasOwnProperty.call(value, subkey))\n        pushEncodedKeyValuePair(pairs, `${key}[${subkey}]`, value[subkey]);\n    }\n  } else {\n    pairs.push(encodeURI(key) + '=' + encodeURIComponent(value));\n  }\n}\n\n/**\n * Expose serialization method.\n */\n\nrequest.serializeObject = serialize;\n\n/**\n * Parse the given x-www-form-urlencoded `str`.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nfunction parseString(string_) {\n  const object = {};\n  const pairs = string_.split('&');\n  let pair;\n  let pos;\n\n  for (let i = 0, length_ = pairs.length; i < length_; ++i) {\n    pair = pairs[i];\n    pos = pair.indexOf('=');\n    if (pos === -1) {\n      object[decodeURIComponent(pair)] = '';\n    } else {\n      object[decodeURIComponent(pair.slice(0, pos))] = decodeURIComponent(\n        pair.slice(pos + 1)\n      );\n    }\n  }\n\n  return object;\n}\n\n/**\n * Expose parser.\n */\n\nrequest.parseString = parseString;\n\n/**\n * Default MIME type map.\n *\n *     superagent.types.xml = 'application/xml';\n *\n */\n\nrequest.types = {\n  html: 'text/html',\n  json: 'application/json',\n  xml: 'text/xml',\n  urlencoded: 'application/x-www-form-urlencoded',\n  form: 'application/x-www-form-urlencoded',\n  'form-data': 'application/x-www-form-urlencoded'\n};\n\n/**\n * Default serialization map.\n *\n *     superagent.serialize['application/xml'] = function(obj){\n *       return 'generated xml here';\n *     };\n *\n */\n\nrequest.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(str){\n *       return { object parsed from str };\n *     };\n *\n */\n\nrequest.parse = {\n  'application/x-www-form-urlencoded': parseString,\n  'application/json': JSON.parse\n};\n\n/**\n * Parse the given header `str` into\n * an object containing the mapped fields.\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nfunction parseHeader(string_) {\n  const lines = string_.split(/\\r?\\n/);\n  const fields = {};\n  let index;\n  let line;\n  let field;\n  let value;\n\n  for (let i = 0, length_ = lines.length; i < length_; ++i) {\n    line = lines[i];\n    index = line.indexOf(':');\n    if (index === -1) {\n      // could be empty line, just skip it\n      continue;\n    }\n\n    field = line.slice(0, index).toLowerCase();\n    value = trim(line.slice(index + 1));\n    fields[field] = value;\n  }\n\n  return fields;\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])/i.test(mime);\n}\n\n/**\n * Initialize a new `Response` with the given `xhr`.\n *\n *  - set flags (.ok, .error, etc)\n *  - parse header\n *\n * Examples:\n *\n *  Aliasing `superagent` as `request` is nice:\n *\n *      request = superagent;\n *\n *  We can use the promise-like API, or pass callbacks:\n *\n *      request.get('/').end(function(res){});\n *      request.get('/', function(res){});\n *\n *  Sending data can be chained:\n *\n *      request\n *        .post('/user')\n *        .send({ name: 'tj' })\n *        .end(function(res){});\n *\n *  Or passed to `.send()`:\n *\n *      request\n *        .post('/user')\n *        .send({ name: 'tj' }, function(res){});\n *\n *  Or passed to `.post()`:\n *\n *      request\n *        .post('/user', { name: 'tj' })\n *        .end(function(res){});\n *\n * Or further reduced to a single call for simple cases:\n *\n *      request\n *        .post('/user', { name: 'tj' }, function(res){});\n *\n * @param {XMLHTTPRequest} xhr\n * @param {Object} options\n * @api private\n */\n\nfunction Response(request_) {\n  this.req = request_;\n  this.xhr = this.req.xhr;\n  // responseText is accessible only if responseType is '' or 'text' and on older browsers\n  this.text =\n    (this.req.method !== 'HEAD' &&\n      (this.xhr.responseType === '' || this.xhr.responseType === 'text')) ||\n    typeof this.xhr.responseType === 'undefined'\n      ? this.xhr.responseText\n      : null;\n  this.statusText = this.req.xhr.statusText;\n  let { status } = this.xhr;\n  // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request\n  if (status === 1223) {\n    status = 204;\n  }\n\n  this._setStatusProperties(status);\n  this.headers = parseHeader(this.xhr.getAllResponseHeaders());\n  this.header = this.headers;\n  // getAllResponseHeaders sometimes falsely returns \"\" for CORS requests, but\n  // getResponseHeader still works. so we get content-type even if getting\n  // other headers fails.\n  this.header['content-type'] = this.xhr.getResponseHeader('content-type');\n  this._setHeaderProperties(this.header);\n\n  if (this.text === null && request_._responseType) {\n    this.body = this.xhr.response;\n  } else {\n    this.body =\n      this.req.method === 'HEAD'\n        ? null\n        : this._parseBody(this.text ? this.text : this.xhr.response);\n  }\n}\n\n// eslint-disable-next-line new-cap\nResponseBase(Response.prototype);\n\n/**\n * Parse the given body `str`.\n *\n * Used for auto-parsing of bodies. Parsers\n * are defined on the `superagent.parse` object.\n *\n * @param {String} str\n * @return {Mixed}\n * @api private\n */\n\nResponse.prototype._parseBody = function (string_) {\n  let parse = request.parse[this.type];\n  if (this.req._parser) {\n    return this.req._parser(this, string_);\n  }\n\n  if (!parse && isJSON(this.type)) {\n    parse = request.parse['application/json'];\n  }\n\n  return parse && string_ && (string_.length > 0 || string_ instanceof Object)\n    ? parse(string_)\n    : null;\n};\n\n/**\n * Return an `Error` representative of this response.\n *\n * @return {Error}\n * @api public\n */\n\nResponse.prototype.toError = function () {\n  const { req } = this;\n  const { method } = req;\n  const { url } = req;\n\n  const message = `cannot ${method} ${url} (${this.status})`;\n  const error = new Error(message);\n  error.status = this.status;\n  error.method = method;\n  error.url = url;\n\n  return error;\n};\n\n/**\n * Expose `Response`.\n */\n\nrequest.Response = Response;\n\n/**\n * Initialize a new `Request` with the given `method` and `url`.\n *\n * @param {String} method\n * @param {String} url\n * @api public\n */\n\nfunction Request(method, url) {\n  const self = this;\n  this._query = this._query || [];\n  this.method = method;\n  this.url = url;\n  this.header = {}; // preserves header name case\n  this._header = {}; // coerces header names to lowercase\n  this.on('end', () => {\n    let error = null;\n    let res = null;\n\n    try {\n      res = new Response(self);\n    } catch (error_) {\n      error = new Error('Parser is unable to parse the response');\n      error.parse = true;\n      error.original = error_;\n      // issue #675: return the raw response if the response parsing fails\n      if (self.xhr) {\n        // ie9 doesn't have 'response' property\n        error.rawResponse =\n          typeof self.xhr.responseType === 'undefined'\n            ? self.xhr.responseText\n            : self.xhr.response;\n        // issue #876: return the http status code if the response parsing fails\n        error.status = self.xhr.status ? self.xhr.status : null;\n        error.statusCode = error.status; // backwards-compat only\n      } else {\n        error.rawResponse = null;\n        error.status = null;\n      }\n\n      return self.callback(error);\n    }\n\n    self.emit('response', res);\n\n    let new_error;\n    try {\n      if (!self._isResponseOK(res)) {\n        new_error = new Error(\n          res.statusText || res.text || 'Unsuccessful HTTP response'\n        );\n      }\n    } catch (err) {\n      new_error = err; // ok() callback can throw\n    }\n\n    // #1000 don't catch errors from the callback to avoid double calling it\n    if (new_error) {\n      new_error.original = error;\n      new_error.response = res;\n      new_error.status = res.status;\n      self.callback(new_error, res);\n    } else {\n      self.callback(null, res);\n    }\n  });\n}\n\n/**\n * Mixin `Emitter` and `RequestBase`.\n */\n\n// eslint-disable-next-line new-cap\nEmitter(Request.prototype);\n// eslint-disable-next-line new-cap\nRequestBase(Request.prototype);\n\n/**\n * Set Content-Type to `type`, mapping values from `request.types`.\n *\n * Examples:\n *\n *      superagent.types.xml = 'application/xml';\n *\n *      request.post('/')\n *        .type('xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n *      request.post('/')\n *        .type('application/xml')\n *        .send(xmlstring)\n *        .end(callback);\n *\n * @param {String} type\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.type = function (type) {\n  this.set('Content-Type', request.types[type] || type);\n  return this;\n};\n\n/**\n * Set Accept to `type`, mapping values from `request.types`.\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  this.set('Accept', request.types[type] || type);\n  return this;\n};\n\n/**\n * Set Authorization field value with `user` and `pass`.\n *\n * @param {String} user\n * @param {String} [pass] optional in case of using 'bearer' as type\n * @param {Object} options with 'type' property 'auto', 'basic' or 'bearer' (default 'basic')\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 = {\n      type: typeof btoa === 'function' ? 'basic' : 'auto'\n    };\n  }\n\n  const encoder = (string) => {\n    if (typeof btoa === 'function') {\n      return btoa(string);\n    }\n\n    throw new Error('Cannot use basic auth, btoa is not a function');\n  };\n\n  return this._auth(user, pass, options, encoder);\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 (value) {\n  if (typeof value !== 'string') value = serialize(value);\n  if (value) this._query.push(value);\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('/upload')\n *   .attach('content', new Blob(['<a id=\"a\"><b id=\"b\">hey!</b></a>'], { type: \"text/html\"}))\n *   .end(callback);\n * ```\n *\n * @param {String} field\n * @param {Blob|File} 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    this._getFormData().append(field, file, options || file.name);\n  }\n\n  return this;\n};\n\nRequest.prototype._getFormData = function () {\n  if (!this._formData) {\n    this._formData = new root.FormData();\n  }\n\n  return this._formData;\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 (error, res) {\n  if (this._shouldRetry(error, res)) {\n    return this._retry();\n  }\n\n  const fn = this._callback;\n  this.clearTimeout();\n\n  if (error) {\n    if (this._maxRetries) error.retries = this._retries - 1;\n    this.emit('error', error);\n  }\n\n  fn(error, res);\n};\n\n/**\n * Invoke callback with x-domain error.\n *\n * @api private\n */\n\nRequest.prototype.crossDomainError = function () {\n  const error = new Error(\n    'Request has been terminated\\nPossible causes: the network is offline, Origin is not allowed by Access-Control-Allow-Origin, the page is being unloaded, etc.'\n  );\n  error.crossDomain = true;\n\n  error.status = this.status;\n  error.method = this.method;\n  error.url = this.url;\n\n  this.callback(error);\n};\n\n// This only warns, because the request is still likely to work\nRequest.prototype.agent = function () {\n  console.warn('This is not supported in browser version of superagent');\n  return this;\n};\n\nRequest.prototype.ca = Request.prototype.agent;\nRequest.prototype.buffer = Request.prototype.ca;\n\n// This throws, because it can't send/receive data as expected\nRequest.prototype.write = () => {\n  throw new Error(\n    'Streaming is not supported in browser version of superagent'\n  );\n};\n\nRequest.prototype.pipe = Request.prototype.write;\n\n/**\n * Check if `obj` is a host object,\n * we don't want to serialize these :)\n *\n * @param {Object} obj host object\n * @return {Boolean} is a host object\n * @api private\n */\nRequest.prototype._isHost = function (object) {\n  // Native objects stringify to [object File], [object Blob], [object FormData], etc.\n  return (\n    object &&\n    typeof object === 'object' &&\n    !Array.isArray(object) &&\n    Object.prototype.toString.call(object) !== '[object Object]'\n  );\n};\n\n/**\n * Initiate request, invoking callback `fn(res)`\n * with an instanceof `Response`.\n *\n * @param {Function} fn\n * @return {Request} for chaining\n * @api public\n */\n\nRequest.prototype.end = function (fn) {\n  if (this._endCalled) {\n    console.warn(\n      'Warning: .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  // querystring\n  this._finalizeQueryString();\n\n  this._end();\n};\n\nRequest.prototype._setUploadTimeout = function () {\n  const self = this;\n\n  // upload timeout it's wokrs only if deadline timeout is off\n  if (this._uploadTimeout && !this._uploadTimeoutTimer) {\n    this._uploadTimeoutTimer = setTimeout(() => {\n      self._timeoutError(\n        'Upload timeout of ',\n        self._uploadTimeout,\n        'ETIMEDOUT'\n      );\n    }, this._uploadTimeout);\n  }\n};\n\n// eslint-disable-next-line complexity\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  const self = this;\n  this.xhr = request.getXHR();\n  const { xhr } = this;\n  let data = this._formData || this._data;\n\n  this._setTimeouts();\n\n  // state change\n  xhr.addEventListener('readystatechange', () => {\n    const { readyState } = xhr;\n    if (readyState >= 2 && self._responseTimeoutTimer) {\n      clearTimeout(self._responseTimeoutTimer);\n    }\n\n    if (readyState !== 4) {\n      return;\n    }\n\n    // In IE9, reads to any property (e.g. status) off of an aborted XHR will\n    // result in the error \"Could not complete the operation due to error c00c023f\"\n    let status;\n    try {\n      status = xhr.status;\n    } catch {\n      status = 0;\n    }\n\n    if (!status) {\n      if (self.timedout || self._aborted) return;\n      return self.crossDomainError();\n    }\n\n    self.emit('end');\n  });\n\n  // progress\n  const handleProgress = (direction, e) => {\n    if (e.total > 0) {\n      e.percent = (e.loaded / e.total) * 100;\n\n      if (e.percent === 100) {\n        clearTimeout(self._uploadTimeoutTimer);\n      }\n    }\n\n    e.direction = direction;\n    self.emit('progress', e);\n  };\n\n  if (this.hasListeners('progress')) {\n    try {\n      xhr.addEventListener('progress', handleProgress.bind(null, 'download'));\n      if (xhr.upload) {\n        xhr.upload.addEventListener(\n          'progress',\n          handleProgress.bind(null, 'upload')\n        );\n      }\n    } catch {\n      // Accessing xhr.upload fails in IE from a web worker, so just pretend it doesn't exist.\n      // Reported here:\n      // https://connect.microsoft.com/IE/feedback/details/837245/xmlhttprequest-upload-throws-invalid-argument-when-used-from-web-worker-context\n    }\n  }\n\n  if (xhr.upload) {\n    this._setUploadTimeout();\n  }\n\n  // initiate request\n  try {\n    if (this.username && this.password) {\n      xhr.open(this.method, this.url, true, this.username, this.password);\n    } else {\n      xhr.open(this.method, this.url, true);\n    }\n  } catch (err) {\n    // see #1149\n    return this.callback(err);\n  }\n\n  // CORS\n  if (this._withCredentials) xhr.withCredentials = true;\n\n  // body\n  if (\n    !this._formData &&\n    this.method !== 'GET' &&\n    this.method !== 'HEAD' &&\n    typeof data !== 'string' &&\n    !this._isHost(data)\n  ) {\n    // serialize stuff\n    const contentType = this._header['content-type'];\n    let serialize =\n      this._serializer ||\n      request.serialize[contentType ? contentType.split(';')[0] : ''];\n    if (!serialize && isJSON(contentType)) {\n      serialize = request.serialize['application/json'];\n    }\n\n    if (serialize) data = serialize(data);\n  }\n\n  // set header fields\n  for (const field in this.header) {\n    if (this.header[field] === null) continue;\n\n    if (Object.prototype.hasOwnProperty.call(this.header, field))\n      xhr.setRequestHeader(field, this.header[field]);\n  }\n\n  if (this._responseType) {\n    xhr.responseType = this._responseType;\n  }\n\n  // send stuff\n  this.emit('request', this);\n\n  // IE11 xhr.send(undefined) sends 'undefined' string as POST payload (instead of nothing)\n  // We need null here if data is undefined\n  xhr.send(typeof data === 'undefined' ? null : data);\n};\n\nrequest.agent = () => new Agent();\n\nfor (const method of ['GET', 'POST', 'OPTIONS', 'PATCH', 'PUT', 'DELETE']) {\n  Agent.prototype[method.toLowerCase()] = function (url, fn) {\n    const request_ = new request.Request(method, url);\n    this._setDefaults(request_);\n    if (fn) {\n      request_.end(fn);\n    }\n\n    return request_;\n  };\n}\n\nAgent.prototype.del = Agent.prototype.delete;\n\n/**\n * GET `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.get = (url, data, fn) => {\n  const request_ = request('GET', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.query(data);\n  if (fn) request_.end(fn);\n  return request_;\n};\n\n/**\n * HEAD `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.head = (url, data, fn) => {\n  const request_ = request('HEAD', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.query(data);\n  if (fn) request_.end(fn);\n  return request_;\n};\n\n/**\n * OPTIONS query to `url` with optional callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.options = (url, data, fn) => {\n  const request_ = request('OPTIONS', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.send(data);\n  if (fn) request_.end(fn);\n  return request_;\n};\n\n/**\n * DELETE `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nfunction del(url, data, fn) {\n  const request_ = request('DELETE', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.send(data);\n  if (fn) request_.end(fn);\n  return request_;\n}\n\nrequest.del = del;\nrequest.delete = del;\n\n/**\n * PATCH `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.patch = (url, data, fn) => {\n  const request_ = request('PATCH', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.send(data);\n  if (fn) request_.end(fn);\n  return request_;\n};\n\n/**\n * POST `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed} [data]\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.post = (url, data, fn) => {\n  const request_ = request('POST', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.send(data);\n  if (fn) request_.end(fn);\n  return request_;\n};\n\n/**\n * PUT `url` with optional `data` and callback `fn(res)`.\n *\n * @param {String} url\n * @param {Mixed|Function} [data] or fn\n * @param {Function} [fn]\n * @return {Request}\n * @api public\n */\n\nrequest.put = (url, data, fn) => {\n  const request_ = request('PUT', url);\n  if (typeof data === 'function') {\n    fn = data;\n    data = null;\n  }\n\n  if (data) request_.send(data);\n  if (fn) request_.end(fn);\n  return request_;\n};\n"]}