.config/coc/extensions/node_modules/coc-go/node_modules/node-fetch/lib/index.mjs

   1 import Stream from 'stream';
   2 import http from 'http';
   3 import Url from 'url';
   4 import whatwgUrl from 'whatwg-url';
   5 import https from 'https';
   6 import zlib from 'zlib';
   7
   8 // Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
   9
  10 // fix for "Readable" isn't a named export issue
  11 const Readable = Stream.Readable;
  12
  13 const BUFFER = Symbol('buffer');
  14 const TYPE = Symbol('type');
  15
  16 class Blob {
  17         constructor() {
  18                 this[TYPE] = '';
  19
  20                 const blobParts = arguments[0];
  21                 const options = arguments[1];
  22
  23                 const buffers = [];
  24                 let size = 0;
  25
  26                 if (blobParts) {
  27                         const a = blobParts;
  28                         const length = Number(a.length);
  29                         for (let i = 0; i < length; i++) {
  30                                 const element = a[i];
  31                                 let buffer;
  32                                 if (element instanceof Buffer) {
  33                                         buffer = element;
  34                                 } else if (ArrayBuffer.isView(element)) {
  35                                         buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
  36                                 } else if (element instanceof ArrayBuffer) {
  37                                         buffer = Buffer.from(element);
  38                                 } else if (element instanceof Blob) {
  39                                         buffer = element[BUFFER];
  40                                 } else {
  41                                         buffer = Buffer.from(typeof element === 'string' ? element : String(element));
  42                                 }
  43                                 size += buffer.length;
  44                                 buffers.push(buffer);
  45                         }
  46                 }
  47
  48                 this[BUFFER] = Buffer.concat(buffers);
  49
  50                 let type = options && options.type !== undefined && String(options.type).toLowerCase();
  51                 if (type && !/[^\u0020-\u007E]/.test(type)) {
  52                         this[TYPE] = type;
  53                 }
  54         }
  55         get size() {
  56                 return this[BUFFER].length;
  57         }
  58         get type() {
  59                 return this[TYPE];
  60         }
  61         text() {
  62                 return Promise.resolve(this[BUFFER].toString());
  63         }
  64         arrayBuffer() {
  65                 const buf = this[BUFFER];
  66                 const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  67                 return Promise.resolve(ab);
  68         }
  69         stream() {
  70                 const readable = new Readable();
  71                 readable._read = function () {};
  72                 readable.push(this[BUFFER]);
  73                 readable.push(null);
  74                 return readable;
  75         }
  76         toString() {
  77                 return '[object Blob]';
  78         }
  79         slice() {
  80                 const size = this.size;
  81
  82                 const start = arguments[0];
  83                 const end = arguments[1];
  84                 let relativeStart, relativeEnd;
  85                 if (start === undefined) {
  86                         relativeStart = 0;
  87                 } else if (start < 0) {
  88                         relativeStart = Math.max(size + start, 0);
  89                 } else {
  90                         relativeStart = Math.min(start, size);
  91                 }
  92                 if (end === undefined) {
  93                         relativeEnd = size;
  94                 } else if (end < 0) {
  95                         relativeEnd = Math.max(size + end, 0);
  96                 } else {
  97                         relativeEnd = Math.min(end, size);
  98                 }
  99                 const span = Math.max(relativeEnd - relativeStart, 0);
 100
 101                 const buffer = this[BUFFER];
 102                 const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
 103                 const blob = new Blob([], { type: arguments[2] });
 104                 blob[BUFFER] = slicedBuffer;
 105                 return blob;
 106         }
 107 }
 108
 109 Object.defineProperties(Blob.prototype, {
 110         size: { enumerable: true },
 111         type: { enumerable: true },
 112         slice: { enumerable: true }
 113 });
 114
 115 Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
 116         value: 'Blob',
 117         writable: false,
 118         enumerable: false,
 119         configurable: true
 120 });
 121
 122 /**
 123  * fetch-error.js
 124  *
 125  * FetchError interface for operational errors
 126  */
 127
 128 /**
 129  * Create FetchError instance
 130  *
 131  * @param   String      message      Error message for human
 132  * @param   String      type         Error type for machine
 133  * @param   String      systemError  For Node.js system error
 134  * @return  FetchError
 135  */
 136 function FetchError(message, type, systemError) {
 137   Error.call(this, message);
 138
 139   this.message = message;
 140   this.type = type;
 141
 142   // when err.type is `system`, err.code contains system error code
 143   if (systemError) {
 144     this.code = this.errno = systemError.code;
 145   }
 146
 147   // hide custom error implementation details from end-users
 148   Error.captureStackTrace(this, this.constructor);
 149 }
 150
 151 FetchError.prototype = Object.create(Error.prototype);
 152 FetchError.prototype.constructor = FetchError;
 153 FetchError.prototype.name = 'FetchError';
 154
 155 let convert;
 156 try {
 157         convert = require('encoding').convert;
 158 } catch (e) {}
 159
 160 const INTERNALS = Symbol('Body internals');
 161
 162 // fix an issue where "PassThrough" isn't a named export for node <10
 163 const PassThrough = Stream.PassThrough;
 164
 165 /**
 166  * Body mixin
 167  *
 168  * Ref: https://fetch.spec.whatwg.org/#body
 169  *
 170  * @param   Stream  body  Readable stream
 171  * @param   Object  opts  Response options
 172  * @return  Void
 173  */
 174 function Body(body) {
 175         var _this = this;
 176
 177         var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
 178             _ref$size = _ref.size;
 179
 180         let size = _ref$size === undefined ? 0 : _ref$size;
 181         var _ref$timeout = _ref.timeout;
 182         let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
 183
 184         if (body == null) {
 185                 // body is undefined or null
 186                 body = null;
 187         } else if (isURLSearchParams(body)) {
 188                 // body is a URLSearchParams
 189                 body = Buffer.from(body.toString());
 190         } else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
 191                 // body is ArrayBuffer
 192                 body = Buffer.from(body);
 193         } else if (ArrayBuffer.isView(body)) {
 194                 // body is ArrayBufferView
 195                 body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
 196         } else if (body instanceof Stream) ; else {
 197                 // none of the above
 198                 // coerce to string then buffer
 199                 body = Buffer.from(String(body));
 200         }
 201         this[INTERNALS] = {
 202                 body,
 203                 disturbed: false,
 204                 error: null
 205         };
 206         this.size = size;
 207         this.timeout = timeout;
 208
 209         if (body instanceof Stream) {
 210                 body.on('error', function (err) {
 211                         const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
 212                         _this[INTERNALS].error = error;
 213                 });
 214         }
 215 }
 216
 217 Body.prototype = {
 218         get body() {
 219                 return this[INTERNALS].body;
 220         },
 221
 222         get bodyUsed() {
 223                 return this[INTERNALS].disturbed;
 224         },
 225
 226         /**
 227   * Decode response as ArrayBuffer
 228   *
 229   * @return  Promise
 230   */
 231         arrayBuffer() {
 232                 return consumeBody.call(this).then(function (buf) {
 233                         return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
 234                 });
 235         },
 236
 237         /**
 238   * Return raw response as Blob
 239   *
 240   * @return Promise
 241   */
 242         blob() {
 243                 let ct = this.headers && this.headers.get('content-type') || '';
 244                 return consumeBody.call(this).then(function (buf) {
 245                         return Object.assign(
 246                         // Prevent copying
 247                         new Blob([], {
 248                                 type: ct.toLowerCase()
 249                         }), {
 250                                 [BUFFER]: buf
 251                         });
 252                 });
 253         },
 254
 255         /**
 256   * Decode response as json
 257   *
 258   * @return  Promise
 259   */
 260         json() {
 261                 var _this2 = this;
 262
 263                 return consumeBody.call(this).then(function (buffer) {
 264                         try {
 265                                 return JSON.parse(buffer.toString());
 266                         } catch (err) {
 267                                 return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
 268                         }
 269                 });
 270         },
 271
 272         /**
 273   * Decode response as text
 274   *
 275   * @return  Promise
 276   */
 277         text() {
 278                 return consumeBody.call(this).then(function (buffer) {
 279                         return buffer.toString();
 280                 });
 281         },
 282
 283         /**
 284   * Decode response as buffer (non-spec api)
 285   *
 286   * @return  Promise
 287   */
 288         buffer() {
 289                 return consumeBody.call(this);
 290         },
 291
 292         /**
 293   * Decode response as text, while automatically detecting the encoding and
 294   * trying to decode to UTF-8 (non-spec api)
 295   *
 296   * @return  Promise
 297   */
 298         textConverted() {
 299                 var _this3 = this;
 300
 301                 return consumeBody.call(this).then(function (buffer) {
 302                         return convertBody(buffer, _this3.headers);
 303                 });
 304         }
 305 };
 306
 307 // In browsers, all properties are enumerable.
 308 Object.defineProperties(Body.prototype, {
 309         body: { enumerable: true },
 310         bodyUsed: { enumerable: true },
 311         arrayBuffer: { enumerable: true },
 312         blob: { enumerable: true },
 313         json: { enumerable: true },
 314         text: { enumerable: true }
 315 });
 316
 317 Body.mixIn = function (proto) {
 318         for (const name of Object.getOwnPropertyNames(Body.prototype)) {
 319                 // istanbul ignore else: future proof
 320                 if (!(name in proto)) {
 321                         const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
 322                         Object.defineProperty(proto, name, desc);
 323                 }
 324         }
 325 };
 326
 327 /**
 328  * Consume and convert an entire Body to a Buffer.
 329  *
 330  * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
 331  *
 332  * @return  Promise
 333  */
 334 function consumeBody() {
 335         var _this4 = this;
 336
 337         if (this[INTERNALS].disturbed) {
 338                 return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
 339         }
 340
 341         this[INTERNALS].disturbed = true;
 342
 343         if (this[INTERNALS].error) {
 344                 return Body.Promise.reject(this[INTERNALS].error);
 345         }
 346
 347         let body = this.body;
 348
 349         // body is null
 350         if (body === null) {
 351                 return Body.Promise.resolve(Buffer.alloc(0));
 352         }
 353
 354         // body is blob
 355         if (isBlob(body)) {
 356                 body = body.stream();
 357         }
 358
 359         // body is buffer
 360         if (Buffer.isBuffer(body)) {
 361                 return Body.Promise.resolve(body);
 362         }
 363
 364         // istanbul ignore if: should never happen
 365         if (!(body instanceof Stream)) {
 366                 return Body.Promise.resolve(Buffer.alloc(0));
 367         }
 368
 369         // body is stream
 370         // get ready to actually consume the body
 371         let accum = [];
 372         let accumBytes = 0;
 373         let abort = false;
 374
 375         return new Body.Promise(function (resolve, reject) {
 376                 let resTimeout;
 377
 378                 // allow timeout on slow response body
 379                 if (_this4.timeout) {
 380                         resTimeout = setTimeout(function () {
 381                                 abort = true;
 382                                 reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
 383                         }, _this4.timeout);
 384                 }
 385
 386                 // handle stream errors
 387                 body.on('error', function (err) {
 388                         if (err.name === 'AbortError') {
 389                                 // if the request was aborted, reject with this Error
 390                                 abort = true;
 391                                 reject(err);
 392                         } else {
 393                                 // other errors, such as incorrect content-encoding
 394                                 reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
 395                         }
 396                 });
 397
 398                 body.on('data', function (chunk) {
 399                         if (abort || chunk === null) {
 400                                 return;
 401                         }
 402
 403                         if (_this4.size && accumBytes + chunk.length > _this4.size) {
 404                                 abort = true;
 405                                 reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
 406                                 return;
 407                         }
 408
 409                         accumBytes += chunk.length;
 410                         accum.push(chunk);
 411                 });
 412
 413                 body.on('end', function () {
 414                         if (abort) {
 415                                 return;
 416                         }
 417
 418                         clearTimeout(resTimeout);
 419
 420                         try {
 421                                 resolve(Buffer.concat(accum, accumBytes));
 422                         } catch (err) {
 423                                 // handle streams that have accumulated too much data (issue #414)
 424                                 reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
 425                         }
 426                 });
 427         });
 428 }
 429
 430 /**
 431  * Detect buffer encoding and convert to target encoding
 432  * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
 433  *
 434  * @param   Buffer  buffer    Incoming buffer
 435  * @param   String  encoding  Target encoding
 436  * @return  String
 437  */
 438 function convertBody(buffer, headers) {
 439         if (typeof convert !== 'function') {
 440                 throw new Error('The package `encoding` must be installed to use the textConverted() function');
 441         }
 442
 443         const ct = headers.get('content-type');
 444         let charset = 'utf-8';
 445         let res, str;
 446
 447         // header
 448         if (ct) {
 449                 res = /charset=([^;]*)/i.exec(ct);
 450         }
 451
 452         // no charset in content type, peek at response body for at most 1024 bytes
 453         str = buffer.slice(0, 1024).toString();
 454
 455         // html5
 456         if (!res && str) {
 457                 res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
 458         }
 459
 460         // html4
 461         if (!res && str) {
 462                 res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
 463                 if (!res) {
 464                         res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
 465                         if (res) {
 466                                 res.pop(); // drop last quote
 467                         }
 468                 }
 469
 470                 if (res) {
 471                         res = /charset=(.*)/i.exec(res.pop());
 472                 }
 473         }
 474
 475         // xml
 476         if (!res && str) {
 477                 res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
 478         }
 479
 480         // found charset
 481         if (res) {
 482                 charset = res.pop();
 483
 484                 // prevent decode issues when sites use incorrect encoding
 485                 // ref: https://hsivonen.fi/encoding-menu/
 486                 if (charset === 'gb2312' || charset === 'gbk') {
 487                         charset = 'gb18030';
 488                 }
 489         }
 490
 491         // turn raw buffers into a single utf-8 buffer
 492         return convert(buffer, 'UTF-8', charset).toString();
 493 }
 494
 495 /**
 496  * Detect a URLSearchParams object
 497  * ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
 498  *
 499  * @param   Object  obj     Object to detect by type or brand
 500  * @return  String
 501  */
 502 function isURLSearchParams(obj) {
 503         // Duck-typing as a necessary condition.
 504         if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
 505                 return false;
 506         }
 507
 508         // Brand-checking and more duck-typing as optional condition.
 509         return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
 510 }
 511
 512 /**
 513  * Check if `obj` is a W3C `Blob` object (which `File` inherits from)
 514  * @param  {*} obj
 515  * @return {boolean}
 516  */
 517 function isBlob(obj) {
 518         return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
 519 }
 520
 521 /**
 522  * Clone body given Res/Req instance
 523  *
 524  * @param   Mixed  instance  Response or Request instance
 525  * @return  Mixed
 526  */
 527 function clone(instance) {
 528         let p1, p2;
 529         let body = instance.body;
 530
 531         // don't allow cloning a used body
 532         if (instance.bodyUsed) {
 533                 throw new Error('cannot clone body after it is used');
 534         }
 535
 536         // check that body is a stream and not form-data object
 537         // note: we can't clone the form-data object without having it as a dependency
 538         if (body instanceof Stream && typeof body.getBoundary !== 'function') {
 539                 // tee instance body
 540                 p1 = new PassThrough();
 541                 p2 = new PassThrough();
 542                 body.pipe(p1);
 543                 body.pipe(p2);
 544                 // set instance body to teed body and return the other teed body
 545                 instance[INTERNALS].body = p1;
 546                 body = p2;
 547         }
 548
 549         return body;
 550 }
 551
 552 /**
 553  * Performs the operation "extract a `Content-Type` value from |object|" as
 554  * specified in the specification:
 555  * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
 556  *
 557  * This function assumes that instance.body is present.
 558  *
 559  * @param   Mixed  instance  Any options.body input
 560  */
 561 function extractContentType(body) {
 562         if (body === null) {
 563                 // body is null
 564                 return null;
 565         } else if (typeof body === 'string') {
 566                 // body is string
 567                 return 'text/plain;charset=UTF-8';
 568         } else if (isURLSearchParams(body)) {
 569                 // body is a URLSearchParams
 570                 return 'application/x-www-form-urlencoded;charset=UTF-8';
 571         } else if (isBlob(body)) {
 572                 // body is blob
 573                 return body.type || null;
 574         } else if (Buffer.isBuffer(body)) {
 575                 // body is buffer
 576                 return null;
 577         } else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
 578                 // body is ArrayBuffer
 579                 return null;
 580         } else if (ArrayBuffer.isView(body)) {
 581                 // body is ArrayBufferView
 582                 return null;
 583         } else if (typeof body.getBoundary === 'function') {
 584                 // detect form data input from form-data module
 585                 return `multipart/form-data;boundary=${body.getBoundary()}`;
 586         } else if (body instanceof Stream) {
 587                 // body is stream
 588                 // can't really do much about this
 589                 return null;
 590         } else {
 591                 // Body constructor defaults other things to string
 592                 return 'text/plain;charset=UTF-8';
 593         }
 594 }
 595
 596 /**
 597  * The Fetch Standard treats this as if "total bytes" is a property on the body.
 598  * For us, we have to explicitly get it with a function.
 599  *
 600  * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
 601  *
 602  * @param   Body    instance   Instance of Body
 603  * @return  Number?            Number of bytes, or null if not possible
 604  */
 605 function getTotalBytes(instance) {
 606         const body = instance.body;
 607
 608
 609         if (body === null) {
 610                 // body is null
 611                 return 0;
 612         } else if (isBlob(body)) {
 613                 return body.size;
 614         } else if (Buffer.isBuffer(body)) {
 615                 // body is buffer
 616                 return body.length;
 617         } else if (body && typeof body.getLengthSync === 'function') {
 618                 // detect form data input from form-data module
 619                 if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
 620                 body.hasKnownLength && body.hasKnownLength()) {
 621                         // 2.x
 622                         return body.getLengthSync();
 623                 }
 624                 return null;
 625         } else {
 626                 // body is stream
 627                 return null;
 628         }
 629 }
 630
 631 /**
 632  * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
 633  *
 634  * @param   Body    instance   Instance of Body
 635  * @return  Void
 636  */
 637 function writeToStream(dest, instance) {
 638         const body = instance.body;
 639
 640
 641         if (body === null) {
 642                 // body is null
 643                 dest.end();
 644         } else if (isBlob(body)) {
 645                 body.stream().pipe(dest);
 646         } else if (Buffer.isBuffer(body)) {
 647                 // body is buffer
 648                 dest.write(body);
 649                 dest.end();
 650         } else {
 651                 // body is stream
 652                 body.pipe(dest);
 653         }
 654 }
 655
 656 // expose Promise
 657 Body.Promise = global.Promise;
 658
 659 /**
 660  * headers.js
 661  *
 662  * Headers class offers convenient helpers
 663  */
 664
 665 const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
 666 const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
 667
 668 function validateName(name) {
 669         name = `${name}`;
 670         if (invalidTokenRegex.test(name) || name === '') {
 671                 throw new TypeError(`${name} is not a legal HTTP header name`);
 672         }
 673 }
 674
 675 function validateValue(value) {
 676         value = `${value}`;
 677         if (invalidHeaderCharRegex.test(value)) {
 678                 throw new TypeError(`${value} is not a legal HTTP header value`);
 679         }
 680 }
 681
 682 /**
 683  * Find the key in the map object given a header name.
 684  *
 685  * Returns undefined if not found.
 686  *
 687  * @param   String  name  Header name
 688  * @return  String|Undefined
 689  */
 690 function find(map, name) {
 691         name = name.toLowerCase();
 692         for (const key in map) {
 693                 if (key.toLowerCase() === name) {
 694                         return key;
 695                 }
 696         }
 697         return undefined;
 698 }
 699
 700 const MAP = Symbol('map');
 701 class Headers {
 702         /**
 703   * Headers class
 704   *
 705   * @param   Object  headers  Response headers
 706   * @return  Void
 707   */
 708         constructor() {
 709                 let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
 710
 711                 this[MAP] = Object.create(null);
 712
 713                 if (init instanceof Headers) {
 714                         const rawHeaders = init.raw();
 715                         const headerNames = Object.keys(rawHeaders);
 716
 717                         for (const headerName of headerNames) {
 718                                 for (const value of rawHeaders[headerName]) {
 719                                         this.append(headerName, value);
 720                                 }
 721                         }
 722
 723                         return;
 724                 }
 725
 726                 // We don't worry about converting prop to ByteString here as append()
 727                 // will handle it.
 728                 if (init == null) ; else if (typeof init === 'object') {
 729                         const method = init[Symbol.iterator];
 730                         if (method != null) {
 731                                 if (typeof method !== 'function') {
 732                                         throw new TypeError('Header pairs must be iterable');
 733                                 }
 734
 735                                 // sequence<sequence<ByteString>>
 736                                 // Note: per spec we have to first exhaust the lists then process them
 737                                 const pairs = [];
 738                                 for (const pair of init) {
 739                                         if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
 740                                                 throw new TypeError('Each header pair must be iterable');
 741                                         }
 742                                         pairs.push(Array.from(pair));
 743                                 }
 744
 745                                 for (const pair of pairs) {
 746                                         if (pair.length !== 2) {
 747                                                 throw new TypeError('Each header pair must be a name/value tuple');
 748                                         }
 749                                         this.append(pair[0], pair[1]);
 750                                 }
 751                         } else {
 752                                 // record<ByteString, ByteString>
 753                                 for (const key of Object.keys(init)) {
 754                                         const value = init[key];
 755                                         this.append(key, value);
 756                                 }
 757                         }
 758                 } else {
 759                         throw new TypeError('Provided initializer must be an object');
 760                 }
 761         }
 762
 763         /**
 764   * Return combined header value given name
 765   *
 766   * @param   String  name  Header name
 767   * @return  Mixed
 768   */
 769         get(name) {
 770                 name = `${name}`;
 771                 validateName(name);
 772                 const key = find(this[MAP], name);
 773                 if (key === undefined) {
 774                         return null;
 775                 }
 776
 777                 return this[MAP][key].join(', ');
 778         }
 779
 780         /**
 781   * Iterate over all headers
 782   *
 783   * @param   Function  callback  Executed for each item with parameters (value, name, thisArg)
 784   * @param   Boolean   thisArg   `this` context for callback function
 785   * @return  Void
 786   */
 787         forEach(callback) {
 788                 let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
 789
 790                 let pairs = getHeaders(this);
 791                 let i = 0;
 792                 while (i < pairs.length) {
 793                         var _pairs$i = pairs[i];
 794                         const name = _pairs$i[0],
 795                               value = _pairs$i[1];
 796
 797                         callback.call(thisArg, value, name, this);
 798                         pairs = getHeaders(this);
 799                         i++;
 800                 }
 801         }
 802
 803         /**
 804   * Overwrite header values given name
 805   *
 806   * @param   String  name   Header name
 807   * @param   String  value  Header value
 808   * @return  Void
 809   */
 810         set(name, value) {
 811                 name = `${name}`;
 812                 value = `${value}`;
 813                 validateName(name);
 814                 validateValue(value);
 815                 const key = find(this[MAP], name);
 816                 this[MAP][key !== undefined ? key : name] = [value];
 817         }
 818
 819         /**
 820   * Append a value onto existing header
 821   *
 822   * @param   String  name   Header name
 823   * @param   String  value  Header value
 824   * @return  Void
 825   */
 826         append(name, value) {
 827                 name = `${name}`;
 828                 value = `${value}`;
 829                 validateName(name);
 830                 validateValue(value);
 831                 const key = find(this[MAP], name);
 832                 if (key !== undefined) {
 833                         this[MAP][key].push(value);
 834                 } else {
 835                         this[MAP][name] = [value];
 836                 }
 837         }
 838
 839         /**
 840   * Check for header name existence
 841   *
 842   * @param   String   name  Header name
 843   * @return  Boolean
 844   */
 845         has(name) {
 846                 name = `${name}`;
 847                 validateName(name);
 848                 return find(this[MAP], name) !== undefined;
 849         }
 850
 851         /**
 852   * Delete all header values given name
 853   *
 854   * @param   String  name  Header name
 855   * @return  Void
 856   */
 857         delete(name) {
 858                 name = `${name}`;
 859                 validateName(name);
 860                 const key = find(this[MAP], name);
 861                 if (key !== undefined) {
 862                         delete this[MAP][key];
 863                 }
 864         }
 865
 866         /**
 867   * Return raw headers (non-spec api)
 868   *
 869   * @return  Object
 870   */
 871         raw() {
 872                 return this[MAP];
 873         }
 874
 875         /**
 876   * Get an iterator on keys.
 877   *
 878   * @return  Iterator
 879   */
 880         keys() {
 881                 return createHeadersIterator(this, 'key');
 882         }
 883
 884         /**
 885   * Get an iterator on values.
 886   *
 887   * @return  Iterator
 888   */
 889         values() {
 890                 return createHeadersIterator(this, 'value');
 891         }
 892
 893         /**
 894   * Get an iterator on entries.
 895   *
 896   * This is the default iterator of the Headers object.
 897   *
 898   * @return  Iterator
 899   */
 900         [Symbol.iterator]() {
 901                 return createHeadersIterator(this, 'key+value');
 902         }
 903 }
 904 Headers.prototype.entries = Headers.prototype[Symbol.iterator];
 905
 906 Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
 907         value: 'Headers',
 908         writable: false,
 909         enumerable: false,
 910         configurable: true
 911 });
 912
 913 Object.defineProperties(Headers.prototype, {
 914         get: { enumerable: true },
 915         forEach: { enumerable: true },
 916         set: { enumerable: true },
 917         append: { enumerable: true },
 918         has: { enumerable: true },
 919         delete: { enumerable: true },
 920         keys: { enumerable: true },
 921         values: { enumerable: true },
 922         entries: { enumerable: true }
 923 });
 924
 925 function getHeaders(headers) {
 926         let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
 927
 928         const keys = Object.keys(headers[MAP]).sort();
 929         return keys.map(kind === 'key' ? function (k) {
 930                 return k.toLowerCase();
 931         } : kind === 'value' ? function (k) {
 932                 return headers[MAP][k].join(', ');
 933         } : function (k) {
 934                 return [k.toLowerCase(), headers[MAP][k].join(', ')];
 935         });
 936 }
 937
 938 const INTERNAL = Symbol('internal');
 939
 940 function createHeadersIterator(target, kind) {
 941         const iterator = Object.create(HeadersIteratorPrototype);
 942         iterator[INTERNAL] = {
 943                 target,
 944                 kind,
 945                 index: 0
 946         };
 947         return iterator;
 948 }
 949
 950 const HeadersIteratorPrototype = Object.setPrototypeOf({
 951         next() {
 952                 // istanbul ignore if
 953                 if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
 954                         throw new TypeError('Value of `this` is not a HeadersIterator');
 955                 }
 956
 957                 var _INTERNAL = this[INTERNAL];
 958                 const target = _INTERNAL.target,
 959                       kind = _INTERNAL.kind,
 960                       index = _INTERNAL.index;
 961
 962                 const values = getHeaders(target, kind);
 963                 const len = values.length;
 964                 if (index >= len) {
 965                         return {
 966                                 value: undefined,
 967                                 done: true
 968                         };
 969                 }
 970
 971                 this[INTERNAL].index = index + 1;
 972
 973                 return {
 974                         value: values[index],
 975                         done: false
 976                 };
 977         }
 978 }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
 979
 980 Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
 981         value: 'HeadersIterator',
 982         writable: false,
 983         enumerable: false,
 984         configurable: true
 985 });
 986
 987 /**
 988  * Export the Headers object in a form that Node.js can consume.
 989  *
 990  * @param   Headers  headers
 991  * @return  Object
 992  */
 993 function exportNodeCompatibleHeaders(headers) {
 994         const obj = Object.assign({ __proto__: null }, headers[MAP]);
 995
 996         // http.request() only supports string as Host header. This hack makes
 997         // specifying custom Host header possible.
 998         const hostHeaderKey = find(headers[MAP], 'Host');
 999         if (hostHeaderKey !== undefined) {
1000                 obj[hostHeaderKey] = obj[hostHeaderKey][0];
1001         }
1002
1003         return obj;
1004 }
1005
1006 /**
1007  * Create a Headers object from an object of headers, ignoring those that do
1008  * not conform to HTTP grammar productions.
1009  *
1010  * @param   Object  obj  Object of headers
1011  * @return  Headers
1012  */
1013 function createHeadersLenient(obj) {
1014         const headers = new Headers();
1015         for (const name of Object.keys(obj)) {
1016                 if (invalidTokenRegex.test(name)) {
1017                         continue;
1018                 }
1019                 if (Array.isArray(obj[name])) {
1020                         for (const val of obj[name]) {
1021                                 if (invalidHeaderCharRegex.test(val)) {
1022                                         continue;
1023                                 }
1024                                 if (headers[MAP][name] === undefined) {
1025                                         headers[MAP][name] = [val];
1026                                 } else {
1027                                         headers[MAP][name].push(val);
1028                                 }
1029                         }
1030                 } else if (!invalidHeaderCharRegex.test(obj[name])) {
1031                         headers[MAP][name] = [obj[name]];
1032                 }
1033         }
1034         return headers;
1035 }
1036
1037 const INTERNALS$1 = Symbol('Response internals');
1038
1039 // fix an issue where "STATUS_CODES" aren't a named export for node <10
1040 const STATUS_CODES = http.STATUS_CODES;
1041
1042 /**
1043  * Response class
1044  *
1045  * @param   Stream  body  Readable stream
1046  * @param   Object  opts  Response options
1047  * @return  Void
1048  */
1049 class Response {
1050         constructor() {
1051                 let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
1052                 let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1053
1054                 Body.call(this, body, opts);
1055
1056                 const status = opts.status || 200;
1057                 const headers = new Headers(opts.headers);
1058
1059                 if (body != null && !headers.has('Content-Type')) {
1060                         const contentType = extractContentType(body);
1061                         if (contentType) {
1062                                 headers.append('Content-Type', contentType);
1063                         }
1064                 }
1065
1066                 this[INTERNALS$1] = {
1067                         url: opts.url,
1068                         status,
1069                         statusText: opts.statusText || STATUS_CODES[status],
1070                         headers,
1071                         counter: opts.counter
1072                 };
1073         }
1074
1075         get url() {
1076                 return this[INTERNALS$1].url || '';
1077         }
1078
1079         get status() {
1080                 return this[INTERNALS$1].status;
1081         }
1082
1083         /**
1084   * Convenience property representing if the request ended normally
1085   */
1086         get ok() {
1087                 return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
1088         }
1089
1090         get redirected() {
1091                 return this[INTERNALS$1].counter > 0;
1092         }
1093
1094         get statusText() {
1095                 return this[INTERNALS$1].statusText;
1096         }
1097
1098         get headers() {
1099                 return this[INTERNALS$1].headers;
1100         }
1101
1102         /**
1103   * Clone this response
1104   *
1105   * @return  Response
1106   */
1107         clone() {
1108                 return new Response(clone(this), {
1109                         url: this.url,
1110                         status: this.status,
1111                         statusText: this.statusText,
1112                         headers: this.headers,
1113                         ok: this.ok,
1114                         redirected: this.redirected
1115                 });
1116         }
1117 }
1118
1119 Body.mixIn(Response.prototype);
1120
1121 Object.defineProperties(Response.prototype, {
1122         url: { enumerable: true },
1123         status: { enumerable: true },
1124         ok: { enumerable: true },
1125         redirected: { enumerable: true },
1126         statusText: { enumerable: true },
1127         headers: { enumerable: true },
1128         clone: { enumerable: true }
1129 });
1130
1131 Object.defineProperty(Response.prototype, Symbol.toStringTag, {
1132         value: 'Response',
1133         writable: false,
1134         enumerable: false,
1135         configurable: true
1136 });
1137
1138 const INTERNALS$2 = Symbol('Request internals');
1139 const URL = Url.URL || whatwgUrl.URL;
1140
1141 // fix an issue where "format", "parse" aren't a named export for node <10
1142 const parse_url = Url.parse;
1143 const format_url = Url.format;
1144
1145 /**
1146  * Wrapper around `new URL` to handle arbitrary URLs
1147  *
1148  * @param  {string} urlStr
1149  * @return {void}
1150  */
1151 function parseURL(urlStr) {
1152         /*
1153         Check whether the URL is absolute or not
1154                 Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
1155         Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
1156  */
1157         if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(urlStr)) {
1158                 urlStr = new URL(urlStr).toString();
1159         }
1160
1161         // Fallback to old implementation for arbitrary URLs
1162         return parse_url(urlStr);
1163 }
1164
1165 const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
1166
1167 /**
1168  * Check if a value is an instance of Request.
1169  *
1170  * @param   Mixed   input
1171  * @return  Boolean
1172  */
1173 function isRequest(input) {
1174         return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
1175 }
1176
1177 function isAbortSignal(signal) {
1178         const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
1179         return !!(proto && proto.constructor.name === 'AbortSignal');
1180 }
1181
1182 /**
1183  * Request class
1184  *
1185  * @param   Mixed   input  Url or Request instance
1186  * @param   Object  init   Custom options
1187  * @return  Void
1188  */
1189 class Request {
1190         constructor(input) {
1191                 let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1192
1193                 let parsedURL;
1194
1195                 // normalize input
1196                 if (!isRequest(input)) {
1197                         if (input && input.href) {
1198                                 // in order to support Node.js' Url objects; though WHATWG's URL objects
1199                                 // will fall into this branch also (since their `toString()` will return
1200                                 // `href` property anyway)
1201                                 parsedURL = parseURL(input.href);
1202                         } else {
1203                                 // coerce input to a string before attempting to parse
1204                                 parsedURL = parseURL(`${input}`);
1205                         }
1206                         input = {};
1207                 } else {
1208                         parsedURL = parseURL(input.url);
1209                 }
1210
1211                 let method = init.method || input.method || 'GET';
1212                 method = method.toUpperCase();
1213
1214                 if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
1215                         throw new TypeError('Request with GET/HEAD method cannot have body');
1216                 }
1217
1218                 let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
1219
1220                 Body.call(this, inputBody, {
1221                         timeout: init.timeout || input.timeout || 0,
1222                         size: init.size || input.size || 0
1223                 });
1224
1225                 const headers = new Headers(init.headers || input.headers || {});
1226
1227                 if (inputBody != null && !headers.has('Content-Type')) {
1228                         const contentType = extractContentType(inputBody);
1229                         if (contentType) {
1230                                 headers.append('Content-Type', contentType);
1231                         }
1232                 }
1233
1234                 let signal = isRequest(input) ? input.signal : null;
1235                 if ('signal' in init) signal = init.signal;
1236
1237                 if (signal != null && !isAbortSignal(signal)) {
1238                         throw new TypeError('Expected signal to be an instanceof AbortSignal');
1239                 }
1240
1241                 this[INTERNALS$2] = {
1242                         method,
1243                         redirect: init.redirect || input.redirect || 'follow',
1244                         headers,
1245                         parsedURL,
1246                         signal
1247                 };
1248
1249                 // node-fetch-only options
1250                 this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
1251                 this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
1252                 this.counter = init.counter || input.counter || 0;
1253                 this.agent = init.agent || input.agent;
1254         }
1255
1256         get method() {
1257                 return this[INTERNALS$2].method;
1258         }
1259
1260         get url() {
1261                 return format_url(this[INTERNALS$2].parsedURL);
1262         }
1263
1264         get headers() {
1265                 return this[INTERNALS$2].headers;
1266         }
1267
1268         get redirect() {
1269                 return this[INTERNALS$2].redirect;
1270         }
1271
1272         get signal() {
1273                 return this[INTERNALS$2].signal;
1274         }
1275
1276         /**
1277   * Clone this request
1278   *
1279   * @return  Request
1280   */
1281         clone() {
1282                 return new Request(this);
1283         }
1284 }
1285
1286 Body.mixIn(Request.prototype);
1287
1288 Object.defineProperty(Request.prototype, Symbol.toStringTag, {
1289         value: 'Request',
1290         writable: false,
1291         enumerable: false,
1292         configurable: true
1293 });
1294
1295 Object.defineProperties(Request.prototype, {
1296         method: { enumerable: true },
1297         url: { enumerable: true },
1298         headers: { enumerable: true },
1299         redirect: { enumerable: true },
1300         clone: { enumerable: true },
1301         signal: { enumerable: true }
1302 });
1303
1304 /**
1305  * Convert a Request to Node.js http request options.
1306  *
1307  * @param   Request  A Request instance
1308  * @return  Object   The options object to be passed to http.request
1309  */
1310 function getNodeRequestOptions(request) {
1311         const parsedURL = request[INTERNALS$2].parsedURL;
1312         const headers = new Headers(request[INTERNALS$2].headers);
1313
1314         // fetch step 1.3
1315         if (!headers.has('Accept')) {
1316                 headers.set('Accept', '*/*');
1317         }
1318
1319         // Basic fetch
1320         if (!parsedURL.protocol || !parsedURL.hostname) {
1321                 throw new TypeError('Only absolute URLs are supported');
1322         }
1323
1324         if (!/^https?:$/.test(parsedURL.protocol)) {
1325                 throw new TypeError('Only HTTP(S) protocols are supported');
1326         }
1327
1328         if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
1329                 throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
1330         }
1331
1332         // HTTP-network-or-cache fetch steps 2.4-2.7
1333         let contentLengthValue = null;
1334         if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
1335                 contentLengthValue = '0';
1336         }
1337         if (request.body != null) {
1338                 const totalBytes = getTotalBytes(request);
1339                 if (typeof totalBytes === 'number') {
1340                         contentLengthValue = String(totalBytes);
1341                 }
1342         }
1343         if (contentLengthValue) {
1344                 headers.set('Content-Length', contentLengthValue);
1345         }
1346
1347         // HTTP-network-or-cache fetch step 2.11
1348         if (!headers.has('User-Agent')) {
1349                 headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
1350         }
1351
1352         // HTTP-network-or-cache fetch step 2.15
1353         if (request.compress && !headers.has('Accept-Encoding')) {
1354                 headers.set('Accept-Encoding', 'gzip,deflate');
1355         }
1356
1357         let agent = request.agent;
1358         if (typeof agent === 'function') {
1359                 agent = agent(parsedURL);
1360         }
1361
1362         if (!headers.has('Connection') && !agent) {
1363                 headers.set('Connection', 'close');
1364         }
1365
1366         // HTTP-network fetch step 4.2
1367         // chunked encoding is handled by Node.js
1368
1369         return Object.assign({}, parsedURL, {
1370                 method: request.method,
1371                 headers: exportNodeCompatibleHeaders(headers),
1372                 agent
1373         });
1374 }
1375
1376 /**
1377  * abort-error.js
1378  *
1379  * AbortError interface for cancelled requests
1380  */
1381
1382 /**
1383  * Create AbortError instance
1384  *
1385  * @param   String      message      Error message for human
1386  * @return  AbortError
1387  */
1388 function AbortError(message) {
1389   Error.call(this, message);
1390
1391   this.type = 'aborted';
1392   this.message = message;
1393
1394   // hide custom error implementation details from end-users
1395   Error.captureStackTrace(this, this.constructor);
1396 }
1397
1398 AbortError.prototype = Object.create(Error.prototype);
1399 AbortError.prototype.constructor = AbortError;
1400 AbortError.prototype.name = 'AbortError';
1401
1402 // fix an issue where "PassThrough", "resolve" aren't a named export for node <10
1403 const PassThrough$1 = Stream.PassThrough;
1404 const resolve_url = Url.resolve;
1405
1406 /**
1407  * Fetch function
1408  *
1409  * @param   Mixed    url   Absolute url or Request instance
1410  * @param   Object   opts  Fetch options
1411  * @return  Promise
1412  */
1413 function fetch(url, opts) {
1414
1415         // allow custom promise
1416         if (!fetch.Promise) {
1417                 throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
1418         }
1419
1420         Body.Promise = fetch.Promise;
1421
1422         // wrap http.request into fetch
1423         return new fetch.Promise(function (resolve, reject) {
1424                 // build request object
1425                 const request = new Request(url, opts);
1426                 const options = getNodeRequestOptions(request);
1427
1428                 const send = (options.protocol === 'https:' ? https : http).request;
1429                 const signal = request.signal;
1430
1431                 let response = null;
1432
1433                 const abort = function abort() {
1434                         let error = new AbortError('The user aborted a request.');
1435                         reject(error);
1436                         if (request.body && request.body instanceof Stream.Readable) {
1437                                 request.body.destroy(error);
1438                         }
1439                         if (!response || !response.body) return;
1440                         response.body.emit('error', error);
1441                 };
1442
1443                 if (signal && signal.aborted) {
1444                         abort();
1445                         return;
1446                 }
1447
1448                 const abortAndFinalize = function abortAndFinalize() {
1449                         abort();
1450                         finalize();
1451                 };
1452
1453                 // send request
1454                 const req = send(options);
1455                 let reqTimeout;
1456
1457                 if (signal) {
1458                         signal.addEventListener('abort', abortAndFinalize);
1459                 }
1460
1461                 function finalize() {
1462                         req.abort();
1463                         if (signal) signal.removeEventListener('abort', abortAndFinalize);
1464                         clearTimeout(reqTimeout);
1465                 }
1466
1467                 if (request.timeout) {
1468                         req.once('socket', function (socket) {
1469                                 reqTimeout = setTimeout(function () {
1470                                         reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
1471                                         finalize();
1472                                 }, request.timeout);
1473                         });
1474                 }
1475
1476                 req.on('error', function (err) {
1477                         reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
1478                         finalize();
1479                 });
1480
1481                 req.on('response', function (res) {
1482                         clearTimeout(reqTimeout);
1483
1484                         const headers = createHeadersLenient(res.headers);
1485
1486                         // HTTP fetch step 5
1487                         if (fetch.isRedirect(res.statusCode)) {
1488                                 // HTTP fetch step 5.2
1489                                 const location = headers.get('Location');
1490
1491                                 // HTTP fetch step 5.3
1492                                 const locationURL = location === null ? null : resolve_url(request.url, location);
1493
1494                                 // HTTP fetch step 5.5
1495                                 switch (request.redirect) {
1496                                         case 'error':
1497                                                 reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
1498                                                 finalize();
1499                                                 return;
1500                                         case 'manual':
1501                                                 // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
1502                                                 if (locationURL !== null) {
1503                                                         // handle corrupted header
1504                                                         try {
1505                                                                 headers.set('Location', locationURL);
1506                                                         } catch (err) {
1507                                                                 // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
1508                                                                 reject(err);
1509                                                         }
1510                                                 }
1511                                                 break;
1512                                         case 'follow':
1513                                                 // HTTP-redirect fetch step 2
1514                                                 if (locationURL === null) {
1515                                                         break;
1516                                                 }
1517
1518                                                 // HTTP-redirect fetch step 5
1519                                                 if (request.counter >= request.follow) {
1520                                                         reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
1521                                                         finalize();
1522                                                         return;
1523                                                 }
1524
1525                                                 // HTTP-redirect fetch step 6 (counter increment)
1526                                                 // Create a new Request object.
1527                                                 const requestOpts = {
1528                                                         headers: new Headers(request.headers),
1529                                                         follow: request.follow,
1530                                                         counter: request.counter + 1,
1531                                                         agent: request.agent,
1532                                                         compress: request.compress,
1533                                                         method: request.method,
1534                                                         body: request.body,
1535                                                         signal: request.signal,
1536                                                         timeout: request.timeout,
1537                                                         size: request.size
1538                                                 };
1539
1540                                                 // HTTP-redirect fetch step 9
1541                                                 if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
1542                                                         reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
1543                                                         finalize();
1544                                                         return;
1545                                                 }
1546
1547                                                 // HTTP-redirect fetch step 11
1548                                                 if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
1549                                                         requestOpts.method = 'GET';
1550                                                         requestOpts.body = undefined;
1551                                                         requestOpts.headers.delete('content-length');
1552                                                 }
1553
1554                                                 // HTTP-redirect fetch step 15
1555                                                 resolve(fetch(new Request(locationURL, requestOpts)));
1556                                                 finalize();
1557                                                 return;
1558                                 }
1559                         }
1560
1561                         // prepare response
1562                         res.once('end', function () {
1563                                 if (signal) signal.removeEventListener('abort', abortAndFinalize);
1564                         });
1565                         let body = res.pipe(new PassThrough$1());
1566
1567                         const response_options = {
1568                                 url: request.url,
1569                                 status: res.statusCode,
1570                                 statusText: res.statusMessage,
1571                                 headers: headers,
1572                                 size: request.size,
1573                                 timeout: request.timeout,
1574                                 counter: request.counter
1575                         };
1576
1577                         // HTTP-network fetch step 12.1.1.3
1578                         const codings = headers.get('Content-Encoding');
1579
1580                         // HTTP-network fetch step 12.1.1.4: handle content codings
1581
1582                         // in following scenarios we ignore compression support
1583                         // 1. compression support is disabled
1584                         // 2. HEAD request
1585                         // 3. no Content-Encoding header
1586                         // 4. no content response (204)
1587                         // 5. content not modified response (304)
1588                         if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
1589                                 response = new Response(body, response_options);
1590                                 resolve(response);
1591                                 return;
1592                         }
1593
1594                         // For Node v6+
1595                         // Be less strict when decoding compressed responses, since sometimes
1596                         // servers send slightly invalid responses that are still accepted
1597                         // by common browsers.
1598                         // Always using Z_SYNC_FLUSH is what cURL does.
1599                         const zlibOptions = {
1600                                 flush: zlib.Z_SYNC_FLUSH,
1601                                 finishFlush: zlib.Z_SYNC_FLUSH
1602                         };
1603
1604                         // for gzip
1605                         if (codings == 'gzip' || codings == 'x-gzip') {
1606                                 body = body.pipe(zlib.createGunzip(zlibOptions));
1607                                 response = new Response(body, response_options);
1608                                 resolve(response);
1609                                 return;
1610                         }
1611
1612                         // for deflate
1613                         if (codings == 'deflate' || codings == 'x-deflate') {
1614                                 // handle the infamous raw deflate response from old servers
1615                                 // a hack for old IIS and Apache servers
1616                                 const raw = res.pipe(new PassThrough$1());
1617                                 raw.once('data', function (chunk) {
1618                                         // see http://stackoverflow.com/questions/37519828
1619                                         if ((chunk[0] & 0x0F) === 0x08) {
1620                                                 body = body.pipe(zlib.createInflate());
1621                                         } else {
1622                                                 body = body.pipe(zlib.createInflateRaw());
1623                                         }
1624                                         response = new Response(body, response_options);
1625                                         resolve(response);
1626                                 });
1627                                 return;
1628                         }
1629
1630                         // for br
1631                         if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
1632                                 body = body.pipe(zlib.createBrotliDecompress());
1633                                 response = new Response(body, response_options);
1634                                 resolve(response);
1635                                 return;
1636                         }
1637
1638                         // otherwise, use response as-is
1639                         response = new Response(body, response_options);
1640                         resolve(response);
1641                 });
1642
1643                 writeToStream(req, request);
1644         });
1645 }
1646 /**
1647  * Redirect code matching
1648  *
1649  * @param   Number   code  Status code
1650  * @return  Boolean
1651  */
1652 fetch.isRedirect = function (code) {
1653         return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
1654 };
1655
1656 // expose Promise
1657 fetch.Promise = global.Promise;
1658
1659 export default fetch;
1660 export { Headers, Request, Response, FetchError };