diff options
Diffstat (limited to 'together/node_modules/superagent/lib/node/index.js')
| -rw-r--r-- | together/node_modules/superagent/lib/node/index.js | 1409 |
1 files changed, 1409 insertions, 0 deletions
diff --git a/together/node_modules/superagent/lib/node/index.js b/together/node_modules/superagent/lib/node/index.js new file mode 100644 index 0000000..bb6da12 --- /dev/null +++ b/together/node_modules/superagent/lib/node/index.js @@ -0,0 +1,1409 @@ +"use strict"; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, 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; } + +/** + * Module dependencies. + */ +// eslint-disable-next-line node/no-deprecated-api +const _require = require('url'), + parse = _require.parse, + format = _require.format, + resolve = _require.resolve; + +const Stream = require('stream'); + +const https = require('https'); + +const http = require('http'); + +const fs = require('fs'); + +const zlib = require('zlib'); + +const util = require('util'); + +const qs = require('qs'); + +const mime = require('mime'); + +let methods = require('methods'); + +const FormData = require('form-data'); + +const formidable = require('formidable'); + +const debug = require('debug')('superagent'); + +const CookieJar = require('cookiejar'); + +const semverGte = require('semver/functions/gte'); + +const safeStringify = require('fast-safe-stringify'); + +const utils = require('../utils'); + +const RequestBase = require('../request-base'); + +const _require2 = require('./unzip'), + unzip = _require2.unzip; + +const Response = require('./response'); + +const mixin = utils.mixin, + hasOwn = utils.hasOwn; +let http2; +if (semverGte(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(request_) { + request_._header = {// coerces header names to lowercase + }; + request_.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._lookup = undefined; + this.once('end', this.clearTimeout.bind(this)); +} +/** + * Inherit from `Stream` (which inherits from `EventEmitter`). + * Mixin `RequestBase`. + */ + + +util.inherits(Request, Stream); +mixin(Request.prototype, RequestBase.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()"); + } + + let 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); + file.on('error', error => { + const formData = this._getFormData(); + + formData.emit('error', error); + }); + } else if (!o.filename && file.path) { + o.filename = file.path; + } + + this._getFormData().append(field, file, o); + } + + return this; +}; + +Request.prototype._getFormData = function () { + if (!this._formData) { + this._formData = new FormData(); + + this._formData.on('error', error => { + debug('FormData error', error); + + if (this.called) { + // The request has already finished and the callback was called. + // Silently ignore the error. + return; + } + + this.callback(error); + 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; +}; +/** + * Gets/sets the `lookup` function to use custom DNS resolver. + * + * @param {Function} lookup + * @return {Function} + * @api public + */ + + +Request.prototype.lookup = function (lookup) { + if (arguments.length === 0) return this._lookup; + this._lookup = lookup; + 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 (value) { + if (typeof value === 'string') { + this._query.push(value); + } else { + Object.assign(this.qs, value); + } + + 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) { + const request_ = this.request(); + + if (!this._streamRequest) { + this._streamRequest = true; + } + + return request_.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) { + this.req.once('response', res => { + // redirect + if (isRedirect(res.statusCode) && this._redirects++ !== this._maxRedirects) { + return this._redirect(res) === this ? this._pipeContinue(stream, options) : undefined; + } + + this.res = res; + + this._emitResponse(); + + if (this._aborted) return; + + if (this._shouldUnzip(res)) { + const unzipObject = zlib.createUnzip(); + unzipObject.on('error', error => { + if (error && error.code === 'Z_BUF_ERROR') { + // unexpected end of file is ignored by browsers and curl + stream.emit('end'); + return; + } + + stream.emit('error', error); + }); + res.pipe(unzipObject).pipe(stream, options); + } else { + res.pipe(stream, options); + } + + res.once('end', () => { + this.emit('end'); + }); + }); + return stream; +}; +/** + * Enable / disable buffering. + * + * @return {Boolean} [val] + * @return {Request} for chaining + * @api public + */ + + +Request.prototype.buffer = function (value) { + this._buffer = value !== false; + return this; +}; +/** + * Redirect to `url + * + * @param {IncomingMessage} res + * @return {Request} for chaining + * @api private + */ + + +Request.prototype._redirect = function (res) { + let 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(); + let headers = this.req.getHeaders ? this.req.getHeaders() : this.req._headers; + const 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' + }; + } + + const encoder = string => 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 () { + if (this.req) return this.req; + const options = {}; + + try { + const 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); + } + + let url = this.url; + const 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. + + let queryStringBackticks; + + if (url.includes('`')) { + const queryStartIndex = url.indexOf('?'); + + if (queryStartIndex !== -1) { + const 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) { + let i = 0; + url.query = url.query.replace(/%60/g, () => 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 + + const unixParts = url.path.match(/^([^/]+)(.+)$/); + options.socketPath = unixParts[1].replace(/%2F/g, '/'); + url.path = unixParts[2]; + } // Override IP address of a hostname + + + if (this._connectOverride) { + const _url = url, + hostname = _url.hostname; + const 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); + } + + let newHost; + let 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.lookup = this._lookup; + 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 + + + const module_ = this._enableHttp2 ? exports.protocols['http2:'].setProtocol(url.protocol) : exports.protocols[url.protocol]; // request + + this.req = module_.request(options); + const 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', () => { + this.emit('drain'); + }); + req.on('error', error => { + // 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 (this._aborted) return; // if not the same, we are in the **old** (cancelled) request, + // so need to continue (same as for above) + + if (this._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 (this.response) return; + this.callback(error); + }); // auth + + if (url.auth) { + const auth = url.auth.split(':'); + this.auth(auth[0], auth[1]); + } + + if (this.username && this.password) { + this.auth(this.username, this.password); + } + + for (const key in this.header) { + if (hasOwn(this.header, key)) req.setHeader(key, this.header[key]); + } // add cookies + + + if (this.cookies) { + if (hasOwn(this._header, 'cookie')) { + // merge + const temporaryJar = new CookieJar.CookieJar(); + temporaryJar.setCookies(this._header.cookie.split(';')); + temporaryJar.setCookies(this.cookies.split(';')); + req.setHeader('Cookie', temporaryJar.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 (error, res) { + if (this._shouldRetry(error, res)) { + return this._retry(); + } // Avoid the error which is emitted from 'socket hang up' to cause the fn undefined error on JS runtime. + + + const fn = this._callback || noop; + this.clearTimeout(); + if (this.called) return console.warn('superagent: double callback bug'); + this.called = true; + + if (!error) { + try { + if (!this._isResponseOK(res)) { + let message = 'Unsuccessful HTTP response'; + + if (res) { + message = http.STATUS_CODES[res.status] || message; + } + + error = new Error(message); + error.status = res ? res.status : undefined; + } + } catch (err) { + error = err; + error.status = error.status || (res ? res.status : undefined); + } + } // It's important that the callback is called outside try/catch + // to avoid double callback + + + if (!error) { + return fn(null, res); + } + + error.response = res; + if (this._maxRetries) error.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 (error && this.listeners('error').length > 0) { + this.emit('error', error); + } + + fn(error, 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 (object) { + return Buffer.isBuffer(object) || object instanceof Stream || object 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) { + const 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 () { + if (this._aborted) return this.callback(new Error('The request has been aborted even before .end() was called')); + let data = this._data; + const req = this.req; + const method = this.method; + + this._setTimeouts(); // body + + + if (method !== 'HEAD' && !req._headerSent) { + // serialize stuff + if (typeof data !== 'string') { + let contentType = req.getHeader('Content-Type'); // Parse out just the content type from the header (ignore the charset) + + if (contentType) contentType = contentType.split(';')[0]; + let 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', res => { + debug('%s %s -> %s', this.method, this.url, res.statusCode); + + if (this._responseTimeoutTimer) { + clearTimeout(this._responseTimeoutTimer); + } + + if (this.piped) { + return; + } + + const max = this._maxRedirects; + const mime = utils.type(res.headers['content-type'] || '') || 'text/plain'; + let type = mime.split('/')[0]; + if (type) type = type.toLowerCase().trim(); + const multipart = type === 'multipart'; + const redirect = isRedirect(res.statusCode); + const responseType = this._responseType; + this.res = res; // redirect + + if (redirect && this._redirects++ !== max) { + return this._redirect(res); + } + + if (this.method === 'HEAD') { + this.emit('end'); + this.callback(null, this._emitResponse()); + return; + } // zlib support + + + if (this._shouldUnzip(res)) { + unzip(req, res); + } + + let buffer = this._buffer; + + if (buffer === undefined && mime in exports.buffer) { + buffer = Boolean(exports.buffer[mime]); + } + + let parser = this._parser; + + if (undefined === buffer && 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) { + const form = formidable(); + parser = form.parse.bind(form); + buffer = true; + } else if (isBinary(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; + } + + this._resBuffered = buffer; + let parserHandlesEnd = false; + + if (buffer) { + // Protectiona against zip bombs and other nuisance + let responseBytesLeft = this._maxResponseSize || 200000000; + res.on('data', buf => { + responseBytesLeft -= buf.byteLength || buf.length > 0 ? buf.length : 0; + + if (responseBytesLeft < 0) { + // This will propagate through error event + const error = new Error('Maximum response size reached'); + error.code = 'ETOOLARGE'; // Parsers aren't required to observe error event, + // so would incorrectly report success + + parserHandlesEnd = false; // Will not emit error event + + res.destroy(error); // so we do callback now + + this.callback(error, null); + } + }); + } + + 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, (error, object, files) => { + if (this.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 (error && !this._aborted) { + return this.callback(error); + } + + if (parserHandlesEnd) { + this.emit('end'); + this.callback(null, this._emitResponse(object, files)); + } + }); + } catch (err) { + this.callback(err); + return; + } + } + + this.res = res; // unbuffered + + if (!buffer) { + debug('unbuffered %s %s', this.method, this.url); + this.callback(null, this._emitResponse()); + if (multipart) return; // allow multipart to handle end event + + res.once('end', () => { + debug('end %s %s', this.method, this.url); + this.emit('end'); + }); + return; + } // terminating events + + + res.once('error', error => { + parserHandlesEnd = false; + this.callback(error, null); + }); + if (!parserHandlesEnd) res.once('end', () => { + debug('end %s %s', this.method, this.url); // TODO: unless buffering emit earlier to stream + + this.emit('end'); + this.callback(null, this._emitResponse()); + }); + }); + this.emit('request', this); + + const getProgressMonitor = () => { + const lengthComputable = true; + const total = req.getHeader('Content-Length'); + let loaded = 0; + const progress = new Stream.Transform(); + + progress._transform = (chunk, encoding, callback) => { + loaded += chunk.length; + this.emit('progress', { + direction: 'upload', + lengthComputable, + loaded, + total + }); + callback(null, chunk); + }; + + return progress; + }; + + const bufferToChunks = buffer => { + const chunkSize = 16 * 1024; // default highWaterMark value + + const chunking = new Stream.Readable(); + const totalLength = buffer.length; + const remainder = totalLength % chunkSize; + const cutoff = totalLength - remainder; + + for (let i = 0; i < cutoff; i += chunkSize) { + const chunk = buffer.slice(i, i + chunkSize); + chunking.push(chunk); + } + + if (remainder > 0) { + const 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 + + + const formData = this._formData; + + if (formData) { + // set headers + const headers = formData.getHeaders(); + + for (const i in headers) { + if (hasOwn(headers, i)) { + debug('setting FormData header: "%s: %s"', i, headers[i]); + req.setHeader(i, headers[i]); + } + } // attempt to get "Content-Length" header + + + formData.getLength((error, length) => { + // TODO: Add chunked encoding when no length (if err) + if (error) debug('formData.getLength had error', error, length); + 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 = 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]; + methods.push('del'); +} + +var _iterator = _createForOfIteratorHelper(methods), + _step; + +try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + let method = _step.value; + const name = method; + method = method === 'del' ? 'delete' : method; + method = method.toUpperCase(); + + request[name] = (url, data, fn) => { + const request_ = request(method, url); + + if (typeof data === 'function') { + fn = data; + data = null; + } + + if (data) { + if (method === 'GET' || method === 'HEAD') { + request_.query(data); + } else { + request_.send(data); + } + } + + if (fn) request_.end(fn); + return request_; + }; + } + /** + * Check if `mime` is text and should be buffered. + * + * @param {String} mime + * @return {Boolean} + * @api public + */ + +} catch (err) { + _iterator.e(err); +} finally { + _iterator.f(); +} + +function isText(mime) { + const parts = mime.split('/'); + let type = parts[0]; + if (type) type = type.toLowerCase().trim(); + let subtype = parts[1]; + if (subtype) subtype = subtype.toLowerCase().trim(); + return type === 'text' || subtype === 'x-www-form-urlencoded'; +} // This is not a catchall, but a start. It might be useful +// in the long run to have file that includes all binary +// content types from https://www.iana.org/assignments/media-types/media-types.xhtml + + +function isBinary(mime) { + let _mime$split = mime.split('/'), + _mime$split2 = _slicedToArray(_mime$split, 2), + registry = _mime$split2[0], + name = _mime$split2[1]; + + if (registry) registry = registry.toLowerCase().trim(); + if (name) name = name.toLowerCase().trim(); + return ['audio', 'font', 'image', 'video'].includes(registry) || ['gz', 'gzip'].includes(name); +} +/** + * 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); +} +/** + * 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,"names":["require","parse","format","resolve","Stream","https","http","fs","zlib","util","qs","mime","methods","FormData","formidable","debug","CookieJar","semverGte","safeStringify","utils","RequestBase","unzip","Response","mixin","hasOwn","http2","process","version","request","method","url","exports","Request","end","arguments","length","module","agent","noop","define","protocols","serialize","stringify","buffer","_initHeaders","request_","_header","header","call","_enableHttp2","Boolean","env","HTTP2_TEST","_agent","_formData","writable","_redirects","redirects","cookies","_query","qsRaw","_redirectList","_streamRequest","_lookup","undefined","once","clearTimeout","bind","inherits","prototype","bool","Error","attach","field","file","options","_data","o","filename","createReadStream","on","error","formData","_getFormData","emit","path","append","called","callback","abort","lookup","type","set","includes","getType","accept","query","value","push","Object","assign","write","data","encoding","pipe","stream","piped","_pipeContinue","req","res","isRedirect","statusCode","_maxRedirects","_redirect","_emitResponse","_aborted","_shouldUnzip","unzipObject","createUnzip","code","_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","err","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","module_","setProtocol","setNoDelay","setHeader","response","username","password","temporaryJar","setCookies","cookie","getCookies","CookieAccessInfo","All","toValueString","_shouldRetry","_retry","fn","console","warn","_isResponseOK","message","STATUS_CODES","status","_maxRetries","listeners","_isHost","object","body","files","_end","_setTimeouts","_headerSent","contentType","getHeader","_serializer","isJSON","byteLength","_responseTimeoutTimer","max","toLowerCase","trim","multipart","redirect","responseType","_responseType","parser","_parser","image","form","isBinary","text","isText","_resBuffered","parserHandlesEnd","responseBytesLeft","_maxResponseSize","buf","destroy","timedout","getProgressMonitor","lengthComputable","total","loaded","progress","Transform","_transform","chunk","direction","bufferToChunks","chunkSize","chunking","Readable","totalLength","remainder","cutoff","remainderBuffer","getLength","connect","connectOverride","trustLocalhost","toggle","name","toUpperCase","send","parts","subtype","registry"],"sources":["../../src/node/index.js"],"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 semverGte = require('semver/functions/gte');\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\nconst { mixin, hasOwn } = utils;\n\nlet http2;\n\nif (semverGte(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(request_) {\n  request_._header = {\n    // coerces header names to lowercase\n  };\n  request_.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._lookup = undefined;\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\nmixin(Request.prototype, RequestBase.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      file.on('error', (error) => {\n        const formData = this._getFormData();\n        formData.emit('error', error);\n      });\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', (error) => {\n      debug('FormData error', error);\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(error);\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 * Gets/sets the `lookup` function to use custom DNS resolver.\n *\n * @param {Function} lookup\n * @return {Function}\n * @api public\n */\n\nRequest.prototype.lookup = function (lookup) {\n  if (arguments.length === 0) return this._lookup;\n  this._lookup = lookup;\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 (value) {\n  if (typeof value === 'string') {\n    this._query.push(value);\n  } else {\n    Object.assign(this.qs, value);\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 request_ = this.request();\n  if (!this._streamRequest) {\n    this._streamRequest = true;\n  }\n\n  return request_.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 unzipObject = zlib.createUnzip();\n      unzipObject.on('error', (error) => {\n        if (error && error.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', error);\n      });\n      res.pipe(unzipObject).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 (value) {\n  this._buffer = value !== 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.lookup = this._lookup;\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 module_ = this._enableHttp2\n    ? exports.protocols['http2:'].setProtocol(url.protocol)\n    : exports.protocols[url.protocol];\n\n  // request\n  this.req = module_.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', (error) => {\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(error);\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 (hasOwn(this.header, key)) req.setHeader(key, this.header[key]);\n  }\n\n  // add cookies\n  if (this.cookies) {\n    if (hasOwn(this._header, 'cookie')) {\n      // merge\n      const temporaryJar = new CookieJar.CookieJar();\n      temporaryJar.setCookies(this._header.cookie.split(';'));\n      temporaryJar.setCookies(this.cookies.split(';'));\n      req.setHeader(\n        'Cookie',\n        temporaryJar.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 (error, res) {\n  if (this._shouldRetry(error, 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 (!error) {\n    try {\n      if (!this._isResponseOK(res)) {\n        let message = 'Unsuccessful HTTP response';\n        if (res) {\n          message = http.STATUS_CODES[res.status] || message;\n        }\n\n        error = new Error(message);\n        error.status = res ? res.status : undefined;\n      }\n    } catch (err) {\n      error = err;\n      error.status = error.status || (res ? res.status : undefined);\n    }\n  }\n\n  // It's important that the callback is called outside try/catch\n  // to avoid double callback\n  if (!error) {\n    return fn(null, res);\n  }\n\n  error.response = res;\n  if (this._maxRetries) error.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 (error && this.listeners('error').length > 0) {\n    this.emit('error', error);\n  }\n\n  fn(error, 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 (object) {\n  return (\n    Buffer.isBuffer(object) ||\n    object instanceof Stream ||\n    object 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    let type = mime.split('/')[0];\n    if (type) type = type.toLowerCase().trim();\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 && 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    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 = formidable();\n        parser = form.parse.bind(form);\n        buffer = true;\n      } else if (isBinary(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        // 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 || 200_000_000;\n      res.on('data', (buf) => {\n        responseBytesLeft -= buf.byteLength || buf.length > 0 ? buf.length : 0;\n        if (responseBytesLeft < 0) {\n          // This will propagate through error event\n          const error = new Error('Maximum response size reached');\n          error.code = 'ETOOLARGE';\n          // Parsers aren't required to observe error event,\n          // so would incorrectly report success\n          parserHandlesEnd = false;\n          // Will not emit error event\n          res.destroy(error);\n          // so we do callback now\n          this.callback(error, null);\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, (error, object, 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 (error && !this._aborted) {\n            return this.callback(error);\n          }\n\n          if (parserHandlesEnd) {\n            this.emit('end');\n            this.callback(null, this._emitResponse(object, 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', (error) => {\n      parserHandlesEnd = false;\n      this.callback(error, 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, callback) => {\n      loaded += chunk.length;\n      this.emit('progress', {\n        direction: 'upload',\n        lengthComputable,\n        loaded,\n        total\n      });\n      callback(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 (hasOwn(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    formData.getLength((error, length) => {\n      // TODO: Add chunked encoding when no length (if err)\n      if (error) debug('formData.getLength had error', error, length);\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).pipe(getProgressMonitor()).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];\n  methods.push('del');\n}\n\nfor (let method of methods) {\n  const name = method;\n  method = method === 'del' ? 'delete' : method;\n\n  method = method.toUpperCase();\n  request[name] = (url, data, fn) => {\n    const request_ = 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        request_.query(data);\n      } else {\n        request_.send(data);\n      }\n    }\n\n    if (fn) request_.end(fn);\n    return request_;\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  let type = parts[0];\n  if (type) type = type.toLowerCase().trim();\n  let subtype = parts[1];\n  if (subtype) subtype = subtype.toLowerCase().trim();\n\n  return type === 'text' || subtype === 'x-www-form-urlencoded';\n}\n\n// This is not a catchall, but a start. It might be useful\n// in the long run to have file that includes all binary\n// content types from https://www.iana.org/assignments/media-types/media-types.xhtml\nfunction isBinary(mime) {\n  let [registry, name] = mime.split('/');\n  if (registry) registry = registry.toLowerCase().trim();\n  if (name) name = name.toLowerCase().trim();\n  return (\n    ['audio', 'font', 'image', 'video'].includes(registry) ||\n    ['gz', 'gzip'].includes(name)\n  );\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 * 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"],"mappings":"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"}
\ No newline at end of file |