siteversion 0.0.1-security → 0.0.2

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of siteversion might be problematic. Click here for more details.

Files changed (42) hide show
  1. package/index.js +56 -0
  2. package/package.json +14 -3
  3. package/proof/node_modules/dellingr/index.js +64 -0
  4. package/proof/node_modules/dellingr/package.json +41 -0
  5. package/proof/node_modules/dellingr/proof/package-lock.json +49 -0
  6. package/proof/node_modules/dellingr/proof/package.json +15 -0
  7. package/proof/node_modules/dotenv/CHANGELOG.md +347 -0
  8. package/proof/node_modules/dotenv/LICENSE +23 -0
  9. package/proof/node_modules/dotenv/README.md +406 -0
  10. package/proof/node_modules/dotenv/config.d.ts +1 -0
  11. package/proof/node_modules/dotenv/config.js +9 -0
  12. package/proof/node_modules/dotenv/lib/cli-options.js +11 -0
  13. package/proof/node_modules/dotenv/lib/env-options.js +20 -0
  14. package/proof/node_modules/dotenv/lib/main.d.ts +73 -0
  15. package/proof/node_modules/dotenv/lib/main.js +109 -0
  16. package/proof/node_modules/dotenv/package.json +86 -0
  17. package/proof/node_modules/node-fetch/LICENSE.md +22 -0
  18. package/proof/node_modules/node-fetch/README.md +590 -0
  19. package/proof/node_modules/node-fetch/browser.js +25 -0
  20. package/proof/node_modules/node-fetch/lib/index.es.js +1688 -0
  21. package/proof/node_modules/node-fetch/lib/index.js +1697 -0
  22. package/proof/node_modules/node-fetch/lib/index.mjs +1686 -0
  23. package/proof/node_modules/node-fetch/package.json +106 -0
  24. package/proof/node_modules/tr46/index.js +193 -0
  25. package/proof/node_modules/tr46/lib/.gitkeep +0 -0
  26. package/proof/node_modules/tr46/lib/mappingTable.json +1 -0
  27. package/proof/node_modules/tr46/package.json +62 -0
  28. package/proof/node_modules/webidl-conversions/LICENSE.md +12 -0
  29. package/proof/node_modules/webidl-conversions/README.md +53 -0
  30. package/proof/node_modules/webidl-conversions/lib/index.js +189 -0
  31. package/proof/node_modules/webidl-conversions/package.json +62 -0
  32. package/proof/node_modules/whatwg-url/LICENSE.txt +21 -0
  33. package/proof/node_modules/whatwg-url/README.md +67 -0
  34. package/proof/node_modules/whatwg-url/lib/URL-impl.js +200 -0
  35. package/proof/node_modules/whatwg-url/lib/URL.js +196 -0
  36. package/proof/node_modules/whatwg-url/lib/public-api.js +11 -0
  37. package/proof/node_modules/whatwg-url/lib/url-state-machine.js +1297 -0
  38. package/proof/node_modules/whatwg-url/lib/utils.js +20 -0
  39. package/proof/node_modules/whatwg-url/package.json +70 -0
  40. package/proof/package-lock.json +49 -0
  41. package/proof/package.json +15 -0
  42. package/README.md +0 -5
@@ -0,0 +1,1686 @@
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
+ const URL$1 = Url.URL || whatwgUrl.URL;
1403
+
1404
+ // fix an issue where "PassThrough", "resolve" aren't a named export for node <10
1405
+ const PassThrough$1 = Stream.PassThrough;
1406
+
1407
+ const isDomainOrSubdomain = function isDomainOrSubdomain(destination, original) {
1408
+ const orig = new URL$1(original).hostname;
1409
+ const dest = new URL$1(destination).hostname;
1410
+
1411
+ return orig === dest || orig[orig.length - dest.length - 1] === '.' && orig.endsWith(dest);
1412
+ };
1413
+
1414
+ /**
1415
+ * Fetch function
1416
+ *
1417
+ * @param Mixed url Absolute url or Request instance
1418
+ * @param Object opts Fetch options
1419
+ * @return Promise
1420
+ */
1421
+ function fetch(url, opts) {
1422
+
1423
+ // allow custom promise
1424
+ if (!fetch.Promise) {
1425
+ throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
1426
+ }
1427
+
1428
+ Body.Promise = fetch.Promise;
1429
+
1430
+ // wrap http.request into fetch
1431
+ return new fetch.Promise(function (resolve, reject) {
1432
+ // build request object
1433
+ const request = new Request(url, opts);
1434
+ const options = getNodeRequestOptions(request);
1435
+
1436
+ const send = (options.protocol === 'https:' ? https : http).request;
1437
+ const signal = request.signal;
1438
+
1439
+ let response = null;
1440
+
1441
+ const abort = function abort() {
1442
+ let error = new AbortError('The user aborted a request.');
1443
+ reject(error);
1444
+ if (request.body && request.body instanceof Stream.Readable) {
1445
+ request.body.destroy(error);
1446
+ }
1447
+ if (!response || !response.body) return;
1448
+ response.body.emit('error', error);
1449
+ };
1450
+
1451
+ if (signal && signal.aborted) {
1452
+ abort();
1453
+ return;
1454
+ }
1455
+
1456
+ const abortAndFinalize = function abortAndFinalize() {
1457
+ abort();
1458
+ finalize();
1459
+ };
1460
+
1461
+ // send request
1462
+ const req = send(options);
1463
+ let reqTimeout;
1464
+
1465
+ if (signal) {
1466
+ signal.addEventListener('abort', abortAndFinalize);
1467
+ }
1468
+
1469
+ function finalize() {
1470
+ req.abort();
1471
+ if (signal) signal.removeEventListener('abort', abortAndFinalize);
1472
+ clearTimeout(reqTimeout);
1473
+ }
1474
+
1475
+ if (request.timeout) {
1476
+ req.once('socket', function (socket) {
1477
+ reqTimeout = setTimeout(function () {
1478
+ reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
1479
+ finalize();
1480
+ }, request.timeout);
1481
+ });
1482
+ }
1483
+
1484
+ req.on('error', function (err) {
1485
+ reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
1486
+ finalize();
1487
+ });
1488
+
1489
+ req.on('response', function (res) {
1490
+ clearTimeout(reqTimeout);
1491
+
1492
+ const headers = createHeadersLenient(res.headers);
1493
+
1494
+ // HTTP fetch step 5
1495
+ if (fetch.isRedirect(res.statusCode)) {
1496
+ // HTTP fetch step 5.2
1497
+ const location = headers.get('Location');
1498
+
1499
+ // HTTP fetch step 5.3
1500
+ let locationURL = null;
1501
+ try {
1502
+ locationURL = location === null ? null : new URL$1(location, request.url).toString();
1503
+ } catch (err) {
1504
+ // error here can only be invalid URL in Location: header
1505
+ // do not throw when options.redirect == manual
1506
+ // let the user extract the errorneous redirect URL
1507
+ if (request.redirect !== 'manual') {
1508
+ reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect'));
1509
+ finalize();
1510
+ return;
1511
+ }
1512
+ }
1513
+
1514
+ // HTTP fetch step 5.5
1515
+ switch (request.redirect) {
1516
+ case 'error':
1517
+ reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
1518
+ finalize();
1519
+ return;
1520
+ case 'manual':
1521
+ // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
1522
+ if (locationURL !== null) {
1523
+ // handle corrupted header
1524
+ try {
1525
+ headers.set('Location', locationURL);
1526
+ } catch (err) {
1527
+ // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
1528
+ reject(err);
1529
+ }
1530
+ }
1531
+ break;
1532
+ case 'follow':
1533
+ // HTTP-redirect fetch step 2
1534
+ if (locationURL === null) {
1535
+ break;
1536
+ }
1537
+
1538
+ // HTTP-redirect fetch step 5
1539
+ if (request.counter >= request.follow) {
1540
+ reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
1541
+ finalize();
1542
+ return;
1543
+ }
1544
+
1545
+ // HTTP-redirect fetch step 6 (counter increment)
1546
+ // Create a new Request object.
1547
+ const requestOpts = {
1548
+ headers: new Headers(request.headers),
1549
+ follow: request.follow,
1550
+ counter: request.counter + 1,
1551
+ agent: request.agent,
1552
+ compress: request.compress,
1553
+ method: request.method,
1554
+ body: request.body,
1555
+ signal: request.signal,
1556
+ timeout: request.timeout,
1557
+ size: request.size
1558
+ };
1559
+
1560
+ if (!isDomainOrSubdomain(request.url, locationURL)) {
1561
+ for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
1562
+ requestOpts.headers.delete(name);
1563
+ }
1564
+ }
1565
+
1566
+ // HTTP-redirect fetch step 9
1567
+ if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
1568
+ reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
1569
+ finalize();
1570
+ return;
1571
+ }
1572
+
1573
+ // HTTP-redirect fetch step 11
1574
+ if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
1575
+ requestOpts.method = 'GET';
1576
+ requestOpts.body = undefined;
1577
+ requestOpts.headers.delete('content-length');
1578
+ }
1579
+
1580
+ // HTTP-redirect fetch step 15
1581
+ resolve(fetch(new Request(locationURL, requestOpts)));
1582
+ finalize();
1583
+ return;
1584
+ }
1585
+ }
1586
+
1587
+ // prepare response
1588
+ res.once('end', function () {
1589
+ if (signal) signal.removeEventListener('abort', abortAndFinalize);
1590
+ });
1591
+ let body = res.pipe(new PassThrough$1());
1592
+
1593
+ const response_options = {
1594
+ url: request.url,
1595
+ status: res.statusCode,
1596
+ statusText: res.statusMessage,
1597
+ headers: headers,
1598
+ size: request.size,
1599
+ timeout: request.timeout,
1600
+ counter: request.counter
1601
+ };
1602
+
1603
+ // HTTP-network fetch step 12.1.1.3
1604
+ const codings = headers.get('Content-Encoding');
1605
+
1606
+ // HTTP-network fetch step 12.1.1.4: handle content codings
1607
+
1608
+ // in following scenarios we ignore compression support
1609
+ // 1. compression support is disabled
1610
+ // 2. HEAD request
1611
+ // 3. no Content-Encoding header
1612
+ // 4. no content response (204)
1613
+ // 5. content not modified response (304)
1614
+ if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
1615
+ response = new Response(body, response_options);
1616
+ resolve(response);
1617
+ return;
1618
+ }
1619
+
1620
+ // For Node v6+
1621
+ // Be less strict when decoding compressed responses, since sometimes
1622
+ // servers send slightly invalid responses that are still accepted
1623
+ // by common browsers.
1624
+ // Always using Z_SYNC_FLUSH is what cURL does.
1625
+ const zlibOptions = {
1626
+ flush: zlib.Z_SYNC_FLUSH,
1627
+ finishFlush: zlib.Z_SYNC_FLUSH
1628
+ };
1629
+
1630
+ // for gzip
1631
+ if (codings == 'gzip' || codings == 'x-gzip') {
1632
+ body = body.pipe(zlib.createGunzip(zlibOptions));
1633
+ response = new Response(body, response_options);
1634
+ resolve(response);
1635
+ return;
1636
+ }
1637
+
1638
+ // for deflate
1639
+ if (codings == 'deflate' || codings == 'x-deflate') {
1640
+ // handle the infamous raw deflate response from old servers
1641
+ // a hack for old IIS and Apache servers
1642
+ const raw = res.pipe(new PassThrough$1());
1643
+ raw.once('data', function (chunk) {
1644
+ // see http://stackoverflow.com/questions/37519828
1645
+ if ((chunk[0] & 0x0F) === 0x08) {
1646
+ body = body.pipe(zlib.createInflate());
1647
+ } else {
1648
+ body = body.pipe(zlib.createInflateRaw());
1649
+ }
1650
+ response = new Response(body, response_options);
1651
+ resolve(response);
1652
+ });
1653
+ return;
1654
+ }
1655
+
1656
+ // for br
1657
+ if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
1658
+ body = body.pipe(zlib.createBrotliDecompress());
1659
+ response = new Response(body, response_options);
1660
+ resolve(response);
1661
+ return;
1662
+ }
1663
+
1664
+ // otherwise, use response as-is
1665
+ response = new Response(body, response_options);
1666
+ resolve(response);
1667
+ });
1668
+
1669
+ writeToStream(req, request);
1670
+ });
1671
+ }
1672
+ /**
1673
+ * Redirect code matching
1674
+ *
1675
+ * @param Number code Status code
1676
+ * @return Boolean
1677
+ */
1678
+ fetch.isRedirect = function (code) {
1679
+ return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
1680
+ };
1681
+
1682
+ // expose Promise
1683
+ fetch.Promise = global.Promise;
1684
+
1685
+ export default fetch;
1686
+ export { Headers, Request, Response, FetchError };