source: node_modules/node-fetch-commonjs/index.js

/* eslint-disable */
exports = module.exports = fetch;
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var http = require('http');
var https = require('https');
var zlib = require('zlib');
var Stream = require('stream');
var buffer = require('buffer');
var util = require('util');
var url = require('url');
var net = require('net');
var fs = require('fs');
var path = require('path');
var DOMException = require('node-domexception');

/**
 * Returns a `Buffer` instance from the given data URI `uri`.
 *
 * @param {String} uri Data URI to turn into a Buffer instance
 * @returns {Buffer} Buffer instance from Data URI
 * @api public
 */
function dataUriToBuffer(uri) {
    if (!/^data:/i.test(uri)) {
        throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
    }
    // strip newlines
    uri = uri.replace(/\r?\n/g, '');
    // split the URI up into the "metadata" and the "data" portions
    const firstComma = uri.indexOf(',');
    if (firstComma === -1 || firstComma <= 4) {
        throw new TypeError('malformed data: URI');
    }
    // remove the "data:" scheme and parse the metadata
    const meta = uri.substring(5, firstComma).split(';');
    let charset = '';
    let base64 = false;
    const type = meta[0] || 'text/plain';
    let typeFull = type;
    for (let i = 1; i < meta.length; i++) {
        if (meta[i] === 'base64') {
            base64 = true;
        }
        else if (meta[i]) {
            typeFull += `;${meta[i]}`;
            if (meta[i].indexOf('charset=') === 0) {
                charset = meta[i].substring(8);
            }
        }
    }
    // defaults to US-ASCII only if type is not provided
    if (!meta[0] && !charset.length) {
        typeFull += ';charset=US-ASCII';
        charset = 'US-ASCII';
    }
    // get the encoded data portion and decode URI-encoded chars
    const encoding = base64 ? 'base64' : 'ascii';
    const data = unescape(uri.substring(firstComma + 1));
    const buffer = Buffer.from(data, encoding);
    // set `.type` and `.typeFull` properties to MIME type
    buffer.type = type;
    buffer.typeFull = typeFull;
    // set the `.charset` property
    buffer.charset = charset;
    return buffer;
}

/* c8 ignore start */
// 64 KiB (same size chrome slice theirs blob into Uint8array's)
const POOL_SIZE$1 = 65536;

if (!globalThis.ReadableStream) {
  // `node:stream/web` got introduced in v16.5.0 as experimental
  // and it's preferred over the polyfilled version. So we also
  // suppress the warning that gets emitted by NodeJS for using it.
  try {
    const process = require('node:process');
    const { emitWarning } = process;
    try {
      process.emitWarning = () => {};
      Object.assign(globalThis, require('node:stream/web'));
      process.emitWarning = emitWarning;
    } catch (error) {
      process.emitWarning = emitWarning;
      throw error
    }
  } catch (error) {
    // fallback to polyfill implementation
    Object.assign(globalThis, require('web-streams-polyfill/dist/ponyfill.es2018.js'));
  }
}

try {
  // Don't use node: prefix for this, require+node: is not supported until node v14.14
  // Only `import()` can use prefix in 12.20 and later
  const { Blob } = require('buffer');
  if (Blob && !Blob.prototype.stream) {
    Blob.prototype.stream = function name (params) {
      let position = 0;
      const blob = this;

      return new ReadableStream({
        type: 'bytes',
        async pull (ctrl) {
          const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE$1));
          const buffer = await chunk.arrayBuffer();
          position += buffer.byteLength;
          ctrl.enqueue(new Uint8Array(buffer));

          if (position === blob.size) {
            ctrl.close();
          }
        }
      })
    };
  }
} catch (error) {}
/* c8 ignore end */

/*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */


// 64 KiB (same size chrome slice theirs blob into Uint8array's)
const POOL_SIZE = 65536;

/** @param {(Blob | Uint8Array)[]} parts */
async function * toIterator (parts, clone = true) {
  for (const part of parts) {
    if ('stream' in part) {
      yield * (/** @type {AsyncIterableIterator<Uint8Array>} */ (part.stream()));
    } else if (ArrayBuffer.isView(part)) {
      if (clone) {
        let position = part.byteOffset;
        const end = part.byteOffset + part.byteLength;
        while (position !== end) {
          const size = Math.min(end - position, POOL_SIZE);
          const chunk = part.buffer.slice(position, position + size);
          position += chunk.byteLength;
          yield new Uint8Array(chunk);
        }
      } else {
        yield part;
      }
    /* c8 ignore next 10 */
    } else {
      // For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
      let position = 0, b = (/** @type {Blob} */ (part));
      while (position !== b.size) {
        const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
        const buffer = await chunk.arrayBuffer();
        position += buffer.byteLength;
        yield new Uint8Array(buffer);
      }
    }
  }
}

const _Blob = class Blob {
  /** @type {Array.<(Blob|Uint8Array)>} */
  #parts = []
  #type = ''
  #size = 0
  #endings = 'transparent'

  /**
   * The Blob() constructor returns a new Blob object. The content
   * of the blob consists of the concatenation of the values given
   * in the parameter array.
   *
   * @param {*} blobParts
   * @param {{ type?: string, endings?: string }} [options]
   */
  constructor (blobParts = [], options = {}) {
    if (typeof blobParts !== 'object' || blobParts === null) {
      throw new TypeError('Failed to construct \'Blob\': The provided value cannot be converted to a sequence.')
    }

    if (typeof blobParts[Symbol.iterator] !== 'function') {
      throw new TypeError('Failed to construct \'Blob\': The object must have a callable @@iterator property.')
    }

    if (typeof options !== 'object' && typeof options !== 'function') {
      throw new TypeError('Failed to construct \'Blob\': parameter 2 cannot convert to dictionary.')
    }

    if (options === null) options = {};

    const encoder = new TextEncoder();
    for (const element of blobParts) {
      let part;
      if (ArrayBuffer.isView(element)) {
        part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
      } else if (element instanceof ArrayBuffer) {
        part = new Uint8Array(element.slice(0));
      } else if (element instanceof Blob) {
        part = element;
      } else {
        part = encoder.encode(`${element}`);
      }

      this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
      this.#parts.push(part);
    }

    this.#endings = `${options.endings === undefined ? 'transparent' : options.endings}`;
    const type = options.type === undefined ? '' : String(options.type);
    this.#type = /^[\x20-\x7E]*$/.test(type) ? type : '';
  }

  /**
   * The Blob interface's size property returns the
   * size of the Blob in bytes.
   */
  get size () {
    return this.#size
  }

  /**
   * The type property of a Blob object returns the MIME type of the file.
   */
  get type () {
    return this.#type
  }

  /**
   * The text() method in the Blob interface returns a Promise
   * that resolves with a string containing the contents of
   * the blob, interpreted as UTF-8.
   *
   * @return {Promise<string>}
   */
  async text () {
    // More optimized than using this.arrayBuffer()
    // that requires twice as much ram
    const decoder = new TextDecoder();
    let str = '';
    for await (const part of toIterator(this.#parts, false)) {
      str += decoder.decode(part, { stream: true });
    }
    // Remaining
    str += decoder.decode();
    return str
  }

  /**
   * The arrayBuffer() method in the Blob interface returns a
   * Promise that resolves with the contents of the blob as
   * binary data contained in an ArrayBuffer.
   *
   * @return {Promise<ArrayBuffer>}
   */
  async arrayBuffer () {
    // Easier way... Just a unnecessary overhead
    // const view = new Uint8Array(this.size);
    // await this.stream().getReader({mode: 'byob'}).read(view);
    // return view.buffer;

    const data = new Uint8Array(this.size);
    let offset = 0;
    for await (const chunk of toIterator(this.#parts, false)) {
      data.set(chunk, offset);
      offset += chunk.length;
    }

    return data.buffer
  }

  stream () {
    const it = toIterator(this.#parts, true);

    return new globalThis.ReadableStream({
      // @ts-ignore
      type: 'bytes',
      async pull (ctrl) {
        const chunk = await it.next();
        chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
      },

      async cancel () {
        await it.return();
      }
    })
  }

  /**
   * The Blob interface's slice() method creates and returns a
   * new Blob object which contains data from a subset of the
   * blob on which it's called.
   *
   * @param {number} [start]
   * @param {number} [end]
   * @param {string} [type]
   */
  slice (start = 0, end = this.size, type = '') {
    const { size } = this;

    let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
    let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);

    const span = Math.max(relativeEnd - relativeStart, 0);
    const parts = this.#parts;
    const blobParts = [];
    let added = 0;

    for (const part of parts) {
      // don't add the overflow to new blobParts
      if (added >= span) {
        break
      }

      const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
      if (relativeStart && size <= relativeStart) {
        // Skip the beginning and change the relative
        // start & end position as we skip the unwanted parts
        relativeStart -= size;
        relativeEnd -= size;
      } else {
        let chunk;
        if (ArrayBuffer.isView(part)) {
          chunk = part.subarray(relativeStart, Math.min(size, relativeEnd));
          added += chunk.byteLength;
        } else {
          chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
          added += chunk.size;
        }
        relativeEnd -= size;
        blobParts.push(chunk);
        relativeStart = 0; // All next sequential parts should start at 0
      }
    }

    const blob = new Blob([], { type: String(type).toLowerCase() });
    blob.#size = span;
    blob.#parts = blobParts;

    return blob
  }

  get [Symbol.toStringTag] () {
    return 'Blob'
  }

  static [Symbol.hasInstance] (object) {
    return (
      object &&
      typeof object === 'object' &&
      typeof object.constructor === 'function' &&
      (
        typeof object.stream === 'function' ||
        typeof object.arrayBuffer === 'function'
      ) &&
      /^(Blob|File)$/.test(object[Symbol.toStringTag])
    )
  }
};

Object.defineProperties(_Blob.prototype, {
  size: { enumerable: true },
  type: { enumerable: true },
  slice: { enumerable: true }
});

/** @type {typeof globalThis.Blob} */
const Blob = _Blob;

const _File = class File extends Blob {
  #lastModified = 0
  #name = ''

  /**
   * @param {*[]} fileBits
   * @param {string} fileName
   * @param {{lastModified?: number, type?: string}} options
   */// @ts-ignore
  constructor (fileBits, fileName, options = {}) {
    if (arguments.length < 2) {
      throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`)
    }
    super(fileBits, options);

    if (options === null) options = {};

    // Simulate WebIDL type casting for NaN value in lastModified option.
    const lastModified = options.lastModified === undefined ? Date.now() : Number(options.lastModified);
    if (!Number.isNaN(lastModified)) {
      this.#lastModified = lastModified;
    }

    this.#name = String(fileName);
  }

  get name () {
    return this.#name
  }

  get lastModified () {
    return this.#lastModified
  }

  get [Symbol.toStringTag] () {
    return 'File'
  }

  static [Symbol.hasInstance] (object) {
    return !!object && object instanceof Blob &&
      /^(File)$/.test(object[Symbol.toStringTag])
  }
};

/** @type {typeof globalThis.File} */// @ts-ignore
const File = _File;

/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */


var {toStringTag:t,iterator:i,hasInstance:h}=Symbol,
r=Math.random,
m='append,set,get,getAll,delete,keys,values,entries,forEach,constructor'.split(','),
f=(a,b,c)=>(a+='',/^(Blob|File)$/.test(b && b[t])?[(c=c!==void 0?c+'':b[t]=='File'?b.name:'blob',a),b.name!==c||b[t]=='blob'?new File([b],c,b):b]:[a,b+'']),
e=(c,f)=>(f?c:c.replace(/\r?\n|\r/g,'\r\n')).replace(/\n/g,'%0A').replace(/\r/g,'%0D').replace(/"/g,'%22'),
x=(n, a, e)=>{if(a.length<e){throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e} arguments required, but only ${a.length} present.`)}};

/** @type {typeof globalThis.FormData} */
const FormData = class FormData {
#d=[];
constructor(...a){if(a.length)throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`)}
get [t]() {return 'FormData'}
[i](){return this.entries()}
static [h](o) {return o&&typeof o==='object'&&o[t]==='FormData'&&!m.some(m=>typeof o[m]!='function')}
append(...a){x('append',arguments,2);this.#d.push(f(...a));}
delete(a){x('delete',arguments,1);a+='';this.#d=this.#d.filter(([b])=>b!==a);}
get(a){x('get',arguments,1);a+='';for(var b=this.#d,l=b.length,c=0;c<l;c++)if(b[c][0]===a)return b[c][1];return null}
getAll(a,b){x('getAll',arguments,1);b=[];a+='';this.#d.forEach(c=>c[0]===a&&b.push(c[1]));return b}
has(a){x('has',arguments,1);a+='';return this.#d.some(b=>b[0]===a)}
forEach(a,b){x('forEach',arguments,1);for(var [c,d]of this)a.call(b,d,c,this);}
set(...a){x('set',arguments,2);var b=[],c=!0;a=f(...a);this.#d.forEach(d=>{d[0]===a[0]?c&&(c=!b.push(a)):b.push(d);});c&&b.push(a);this.#d=b;}
*entries(){yield*this.#d;}
*keys(){for(var[a]of this)yield a;}
*values(){for(var[,a]of this)yield a;}};

/** @param {FormData} F */
function formDataToBlob (F,B=Blob){
var b=`${r()}${r()}`.replace(/\./g, '').slice(-28).padStart(32, '-'),c=[],p=`--${b}\r\nContent-Disposition: form-data; name="`;
F.forEach((v,n)=>typeof v=='string'
?c.push(p+e(n)+`"\r\n\r\n${v.replace(/\r(?!\n)|(?<!\r)\n/g, '\r\n')}\r\n`)
:c.push(p+e(n)+`"; filename="${e(v.name, 1)}"\r\nContent-Type: ${v.type||"application/octet-stream"}\r\n\r\n`, v, '\r\n'));
c.push(`--${b}--`);
return new B(c,{type:"multipart/form-data; boundary="+b})}

class FetchBaseError extends Error {
        constructor(message, type) {
                super(message);
                // Hide custom error implementation details from end-users
                Error.captureStackTrace(this, this.constructor);

                this.type = type;
        }

        get name() {
                return this.constructor.name;
        }

        get [Symbol.toStringTag]() {
                return this.constructor.name;
        }
}

/**
 * @typedef {{ address?: string, code: string, dest?: string, errno: number, info?: object, message: string, path?: string, port?: number, syscall: string}} SystemError
*/

/**
 * FetchError interface for operational errors
 */
class FetchError extends FetchBaseError {
        /**
         * @param  {string} message -      Error message for human
         * @param  {string} [type] -        Error type for machine
         * @param  {SystemError} [systemError] - For Node.js system error
         */
        constructor(message, type, systemError) {
                super(message, type);
                // When err.type is `system`, err.erroredSysCall contains system error and err.code contains system error code
                if (systemError) {
                        // eslint-disable-next-line no-multi-assign
                        this.code = this.errno = systemError.code;
                        this.erroredSysCall = systemError.syscall;
                }
        }
}

/**
 * Is.js
 *
 * Object type checks.
 */

const NAME = Symbol.toStringTag;

/**
 * Check if `obj` is a URLSearchParams object
 * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
 * @param {*} object - Object to check for
 * @return {boolean}
 */
const isURLSearchParameters = object => {
        return (
                typeof object === 'object' &&
                typeof object.append === 'function' &&
                typeof object.delete === 'function' &&
                typeof object.get === 'function' &&
                typeof object.getAll === 'function' &&
                typeof object.has === 'function' &&
                typeof object.set === 'function' &&
                typeof object.sort === 'function' &&
                object[NAME] === 'URLSearchParams'
        );
};

/**
 * Check if `object` is a W3C `Blob` object (which `File` inherits from)
 * @param {*} object - Object to check for
 * @return {boolean}
 */
const isBlob = object => {
        return (
                object &&
                typeof object === 'object' &&
                typeof object.arrayBuffer === 'function' &&
                typeof object.type === 'string' &&
                typeof object.stream === 'function' &&
                typeof object.constructor === 'function' &&
                /^(Blob|File)$/.test(object[NAME])
        );
};

/**
 * Check if `obj` is an instance of AbortSignal.
 * @param {*} object - Object to check for
 * @return {boolean}
 */
const isAbortSignal = object => {
        return (
                typeof object === 'object' && (
                        object[NAME] === 'AbortSignal' ||
                        object[NAME] === 'EventTarget'
                )
        );
};

/**
 * isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
 * the parent domain.
 *
 * Both domains must already be in canonical form.
 * @param {string|URL} original
 * @param {string|URL} destination
 */
const isDomainOrSubdomain = (destination, original) => {
        const orig = new URL(original).hostname;
        const dest = new URL(destination).hostname;

        return orig === dest || orig.endsWith(`.${dest}`);
};

/**
 * isSameProtocol reports whether the two provided URLs use the same protocol.
 *
 * Both domains must already be in canonical form.
 * @param {string|URL} original
 * @param {string|URL} destination
 */
const isSameProtocol = (destination, original) => {
        const orig = new URL(original).protocol;
        const dest = new URL(destination).protocol;

        return orig === dest;
};

const pipeline = util.promisify(Stream.pipeline);
const INTERNALS$2 = Symbol('Body internals');

/**
 * Body mixin
 *
 * Ref: https://fetch.spec.whatwg.org/#body
 *
 * @param   Stream  body  Readable stream
 * @param   Object  opts  Response options
 * @return  Void
 */
class Body {
        constructor(body, {
                size = 0
        } = {}) {
                let boundary = null;

                if (body === null) {
                        // Body is undefined or null
                        body = null;
                } else if (isURLSearchParameters(body)) {
                        // Body is a URLSearchParams
                        body = buffer.Buffer.from(body.toString());
                } else if (isBlob(body)) ; else if (buffer.Buffer.isBuffer(body)) ; else if (util.types.isAnyArrayBuffer(body)) {
                        // Body is ArrayBuffer
                        body = buffer.Buffer.from(body);
                } else if (ArrayBuffer.isView(body)) {
                        // Body is ArrayBufferView
                        body = buffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
                } else if (body instanceof Stream) ; else if (body instanceof FormData) {
                        // Body is FormData
                        body = formDataToBlob(body);
                        boundary = body.type.split('=')[1];
                } else {
                        // None of the above
                        // coerce to string then buffer
                        body = buffer.Buffer.from(String(body));
                }

                let stream = body;

                if (buffer.Buffer.isBuffer(body)) {
                        stream = Stream.Readable.from(body);
                } else if (isBlob(body)) {
                        stream = Stream.Readable.from(body.stream());
                }

                this[INTERNALS$2] = {
                        body,
                        stream,
                        boundary,
                        disturbed: false,
                        error: null
                };
                this.size = size;

                if (body instanceof Stream) {
                        body.on('error', error_ => {
                                const error = error_ instanceof FetchBaseError ?
                                        error_ :
                                        new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, 'system', error_);
                                this[INTERNALS$2].error = error;
                        });
                }
        }

        get body() {
                return this[INTERNALS$2].stream;
        }

        get bodyUsed() {
                return this[INTERNALS$2].disturbed;
        }

        /**
         * Decode response as ArrayBuffer
         *
         * @return  Promise
         */
        async arrayBuffer() {
                const {buffer, byteOffset, byteLength} = await consumeBody(this);
                return buffer.slice(byteOffset, byteOffset + byteLength);
        }

        async formData() {
                const ct = this.headers.get('content-type');

                if (ct.startsWith('application/x-www-form-urlencoded')) {
                        const formData = new FormData();
                        const parameters = new URLSearchParams(await this.text());

                        for (const [name, value] of parameters) {
                                formData.append(name, value);
                        }

                        return formData;
                }

                const {toFormData} = await Promise.resolve().then(function () { return require('./multipart-parser-25a14693.js'); });
                return toFormData(this.body, ct);
        }

        /**
         * Return raw response as Blob
         *
         * @return Promise
         */
        async blob() {
                const ct = (this.headers && this.headers.get('content-type')) || (this[INTERNALS$2].body && this[INTERNALS$2].body.type) || '';
                const buf = await this.arrayBuffer();

                return new Blob([buf], {
                        type: ct
                });
        }

        /**
         * Decode response as json
         *
         * @return  Promise
         */
        async json() {
                const text = await this.text();
                return JSON.parse(text);
        }

        /**
         * Decode response as text
         *
         * @return  Promise
         */
        async text() {
                const buffer = await consumeBody(this);
                return new TextDecoder().decode(buffer);
        }

        /**
         * Decode response as buffer (non-spec api)
         *
         * @return  Promise
         */
        buffer() {
                return consumeBody(this);
        }
}

Body.prototype.buffer = util.deprecate(Body.prototype.buffer, 'Please use \'response.arrayBuffer()\' instead of \'response.buffer()\'', 'node-fetch#buffer');

// In browsers, all properties are enumerable.
Object.defineProperties(Body.prototype, {
        body: {enumerable: true},
        bodyUsed: {enumerable: true},
        arrayBuffer: {enumerable: true},
        blob: {enumerable: true},
        json: {enumerable: true},
        text: {enumerable: true},
        data: {get: util.deprecate(() => {},
                'data doesn\'t exist, use json(), text(), arrayBuffer(), or body instead',
                'https://github.com/node-fetch/node-fetch/issues/1000 (response)')}
});

/**
 * Consume and convert an entire Body to a Buffer.
 *
 * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
 *
 * @return Promise
 */
async function consumeBody(data) {
        if (data[INTERNALS$2].disturbed) {
                throw new TypeError(`body used already for: ${data.url}`);
        }

        data[INTERNALS$2].disturbed = true;

        if (data[INTERNALS$2].error) {
                throw data[INTERNALS$2].error;
        }

        const {body} = data;

        // Body is null
        if (body === null) {
                return buffer.Buffer.alloc(0);
        }

        /* c8 ignore next 3 */
        if (!(body instanceof Stream)) {
                return buffer.Buffer.alloc(0);
        }

        // Body is stream
        // get ready to actually consume the body
        const accum = [];
        let accumBytes = 0;

        try {
                for await (const chunk of body) {
                        if (data.size > 0 && accumBytes + chunk.length > data.size) {
                                const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, 'max-size');
                                body.destroy(error);
                                throw error;
                        }

                        accumBytes += chunk.length;
                        accum.push(chunk);
                }
        } catch (error) {
                const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, 'system', error);
                throw error_;
        }

        if (body.readableEnded === true || body._readableState.ended === true) {
                try {
                        if (accum.every(c => typeof c === 'string')) {
                                return buffer.Buffer.from(accum.join(''));
                        }

                        return buffer.Buffer.concat(accum, accumBytes);
                } catch (error) {
                        throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, 'system', error);
                }
        } else {
                throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
        }
}

/**
 * Clone body given Res/Req instance
 *
 * @param   Mixed   instance       Response or Request instance
 * @param   String  highWaterMark  highWaterMark for both PassThrough body streams
 * @return  Mixed
 */
const clone = (instance, highWaterMark) => {
        let p1;
        let p2;
        let {body} = instance[INTERNALS$2];

        // Don't allow cloning a used body
        if (instance.bodyUsed) {
                throw new Error('cannot clone body after it is used');
        }

        // Check that body is a stream and not form-data object
        // note: we can't clone the form-data object without having it as a dependency
        if ((body instanceof Stream) && (typeof body.getBoundary !== 'function')) {
                // Tee instance body
                p1 = new Stream.PassThrough({highWaterMark});
                p2 = new Stream.PassThrough({highWaterMark});
                body.pipe(p1);
                body.pipe(p2);
                // Set instance body to teed body and return the other teed body
                instance[INTERNALS$2].stream = p1;
                body = p2;
        }

        return body;
};

const getNonSpecFormDataBoundary = util.deprecate(
        body => body.getBoundary(),
        'form-data doesn\'t follow the spec and requires special treatment. Use alternative package',
        'https://github.com/node-fetch/node-fetch/issues/1167'
);

/**
 * Performs the operation "extract a `Content-Type` value from |object|" as
 * specified in the specification:
 * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
 *
 * This function assumes that instance.body is present.
 *
 * @param {any} body Any options.body input
 * @returns {string | null}
 */
const extractContentType = (body, request) => {
        // Body is null or undefined
        if (body === null) {
                return null;
        }

        // Body is string
        if (typeof body === 'string') {
                return 'text/plain;charset=UTF-8';
        }

        // Body is a URLSearchParams
        if (isURLSearchParameters(body)) {
                return 'application/x-www-form-urlencoded;charset=UTF-8';
        }

        // Body is blob
        if (isBlob(body)) {
                return body.type || null;
        }

        // Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
        if (buffer.Buffer.isBuffer(body) || util.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
                return null;
        }

        if (body instanceof FormData) {
                return `multipart/form-data; boundary=${request[INTERNALS$2].boundary}`;
        }

        // Detect form data input from form-data module
        if (body && typeof body.getBoundary === 'function') {
                return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
        }

        // Body is stream - can't really do much about this
        if (body instanceof Stream) {
                return null;
        }

        // Body constructor defaults other things to string
        return 'text/plain;charset=UTF-8';
};

/**
 * The Fetch Standard treats this as if "total bytes" is a property on the body.
 * For us, we have to explicitly get it with a function.
 *
 * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
 *
 * @param {any} obj.body Body object from the Body instance.
 * @returns {number | null}
 */
const getTotalBytes = request => {
        const {body} = request[INTERNALS$2];

        // Body is null or undefined
        if (body === null) {
                return 0;
        }

        // Body is Blob
        if (isBlob(body)) {
                return body.size;
        }

        // Body is Buffer
        if (buffer.Buffer.isBuffer(body)) {
                return body.length;
        }

        // Detect form data input from form-data module
        if (body && typeof body.getLengthSync === 'function') {
                return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
        }

        // Body is stream
        return null;
};

/**
 * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
 *
 * @param {Stream.Writable} dest The stream to write to.
 * @param obj.body Body object from the Body instance.
 * @returns {Promise<void>}
 */
const writeToStream = async (dest, {body}) => {
        if (body === null) {
                // Body is null
                dest.end();
        } else {
                // Body is stream
                await pipeline(body, dest);
        }
};

/**
 * Headers.js
 *
 * Headers class offers convenient helpers
 */


/* c8 ignore next 9 */
const validateHeaderName = typeof http.validateHeaderName === 'function' ?
        http.validateHeaderName :
        name => {
                if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
                        const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
                        Object.defineProperty(error, 'code', {value: 'ERR_INVALID_HTTP_TOKEN'});
                        throw error;
                }
        };

/* c8 ignore next 9 */
const validateHeaderValue = typeof http.validateHeaderValue === 'function' ?
        http.validateHeaderValue :
        (name, value) => {
                if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
                        const error = new TypeError(`Invalid character in header content ["${name}"]`);
                        Object.defineProperty(error, 'code', {value: 'ERR_INVALID_CHAR'});
                        throw error;
                }
        };

/**
 * @typedef {Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>} HeadersInit
 */

/**
 * This Fetch API interface allows you to perform various actions on HTTP request and response headers.
 * These actions include retrieving, setting, adding to, and removing.
 * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.
 * You can add to this using methods like append() (see Examples.)
 * In all methods of this interface, header names are matched by case-insensitive byte sequence.
 *
 */
class Headers extends URLSearchParams {
        /**
         * Headers class
         *
         * @constructor
         * @param {HeadersInit} [init] - Response headers
         */
        constructor(init) {
                // Validate and normalize init object in [name, value(s)][]
                /** @type {string[][]} */
                let result = [];
                if (init instanceof Headers) {
                        const raw = init.raw();
                        for (const [name, values] of Object.entries(raw)) {
                                result.push(...values.map(value => [name, value]));
                        }
                } else if (init == null) ; else if (typeof init === 'object' && !util.types.isBoxedPrimitive(init)) {
                        const method = init[Symbol.iterator];
                        // eslint-disable-next-line no-eq-null, eqeqeq
                        if (method == null) {
                                // Record<ByteString, ByteString>
                                result.push(...Object.entries(init));
                        } else {
                                if (typeof method !== 'function') {
                                        throw new TypeError('Header pairs must be iterable');
                                }

                                // Sequence<sequence<ByteString>>
                                // Note: per spec we have to first exhaust the lists then process them
                                result = [...init]
                                        .map(pair => {
                                                if (
                                                        typeof pair !== 'object' || util.types.isBoxedPrimitive(pair)
                                                ) {
                                                        throw new TypeError('Each header pair must be an iterable object');
                                                }

                                                return [...pair];
                                        }).map(pair => {
                                                if (pair.length !== 2) {
                                                        throw new TypeError('Each header pair must be a name/value tuple');
                                                }

                                                return [...pair];
                                        });
                        }
                } else {
                        throw new TypeError('Failed to construct \'Headers\': The provided value is not of type \'(sequence<sequence<ByteString>> or record<ByteString, ByteString>)');
                }

                // Validate and lowercase
                result =
                        result.length > 0 ?
                                result.map(([name, value]) => {
                                        validateHeaderName(name);
                                        validateHeaderValue(name, String(value));
                                        return [String(name).toLowerCase(), String(value)];
                                }) :
                                undefined;

                super(result);

                // Returning a Proxy that will lowercase key names, validate parameters and sort keys
                // eslint-disable-next-line no-constructor-return
                return new Proxy(this, {
                        get(target, p, receiver) {
                                switch (p) {
                                        case 'append':
                                        case 'set':
                                                return (name, value) => {
                                                        validateHeaderName(name);
                                                        validateHeaderValue(name, String(value));
                                                        return URLSearchParams.prototype[p].call(
                                                                target,
                                                                String(name).toLowerCase(),
                                                                String(value)
                                                        );
                                                };

                                        case 'delete':
                                        case 'has':
                                        case 'getAll':
                                                return name => {
                                                        validateHeaderName(name);
                                                        return URLSearchParams.prototype[p].call(
                                                                target,
                                                                String(name).toLowerCase()
                                                        );
                                                };

                                        case 'keys':
                                                return () => {
                                                        target.sort();
                                                        return new Set(URLSearchParams.prototype.keys.call(target)).keys();
                                                };

                                        default:
                                                return Reflect.get(target, p, receiver);
                                }
                        }
                });
                /* c8 ignore next */
        }

        get [Symbol.toStringTag]() {
                return this.constructor.name;
        }

        toString() {
                return Object.prototype.toString.call(this);
        }

        get(name) {
                const values = this.getAll(name);
                if (values.length === 0) {
                        return null;
                }

                let value = values.join(', ');
                if (/^content-encoding$/i.test(name)) {
                        value = value.toLowerCase();
                }

                return value;
        }

        forEach(callback, thisArg = undefined) {
                for (const name of this.keys()) {
                        Reflect.apply(callback, thisArg, [this.get(name), name, this]);
                }
        }

        * values() {
                for (const name of this.keys()) {
                        yield this.get(name);
                }
        }

        /**
         * @type {() => IterableIterator<[string, string]>}
         */
        * entries() {
                for (const name of this.keys()) {
                        yield [name, this.get(name)];
                }
        }

        [Symbol.iterator]() {
                return this.entries();
        }

        /**
         * Node-fetch non-spec method
         * returning all headers and their values as array
         * @returns {Record<string, string[]>}
         */
        raw() {
                return [...this.keys()].reduce((result, key) => {
                        result[key] = this.getAll(key);
                        return result;
                }, {});
        }

        /**
         * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
         */
        [Symbol.for('nodejs.util.inspect.custom')]() {
                return [...this.keys()].reduce((result, key) => {
                        const values = this.getAll(key);
                        // Http.request() only supports string as Host header.
                        // This hack makes specifying custom Host header possible.
                        if (key === 'host') {
                                result[key] = values[0];
                        } else {
                                result[key] = values.length > 1 ? values : values[0];
                        }

                        return result;
                }, {});
        }
}

/**
 * Re-shaping object for Web IDL tests
 * Only need to do it for overridden methods
 */
Object.defineProperties(
        Headers.prototype,
        ['get', 'entries', 'forEach', 'values'].reduce((result, property) => {
                result[property] = {enumerable: true};
                return result;
        }, {})
);

/**
 * Create a Headers object from an http.IncomingMessage.rawHeaders, ignoring those that do
 * not conform to HTTP grammar productions.
 * @param {import('http').IncomingMessage['rawHeaders']} headers
 */
function fromRawHeaders(headers = []) {
        return new Headers(
                headers
                        // Split into pairs
                        .reduce((result, value, index, array) => {
                                if (index % 2 === 0) {
                                        result.push(array.slice(index, index + 2));
                                }

                                return result;
                        }, [])
                        .filter(([name, value]) => {
                                try {
                                        validateHeaderName(name);
                                        validateHeaderValue(name, String(value));
                                        return true;
                                } catch {
                                        return false;
                                }
                        })

        );
}

const redirectStatus = new Set([301, 302, 303, 307, 308]);

/**
 * Redirect code matching
 *
 * @param {number} code - Status code
 * @return {boolean}
 */
const isRedirect = code => {
        return redirectStatus.has(code);
};

/**
 * Response.js
 *
 * Response class provides content decoding
 */


const INTERNALS$1 = Symbol('Response internals');

/**
 * Response class
 *
 * Ref: https://fetch.spec.whatwg.org/#response-class
 *
 * @param   Stream  body  Readable stream
 * @param   Object  opts  Response options
 * @return  Void
 */
class Response extends Body {
        constructor(body = null, options = {}) {
                super(body, options);

                // eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
                const status = options.status != null ? options.status : 200;

                const headers = new Headers(options.headers);

                if (body !== null && !headers.has('Content-Type')) {
                        const contentType = extractContentType(body, this);
                        if (contentType) {
                                headers.append('Content-Type', contentType);
                        }
                }

                this[INTERNALS$1] = {
                        type: 'default',
                        url: options.url,
                        status,
                        statusText: options.statusText || '',
                        headers,
                        counter: options.counter,
                        highWaterMark: options.highWaterMark
                };
        }

        get type() {
                return this[INTERNALS$1].type;
        }

        get url() {
                return this[INTERNALS$1].url || '';
        }

        get status() {
                return this[INTERNALS$1].status;
        }

        /**
         * Convenience property representing if the request ended normally
         */
        get ok() {
                return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
        }

        get redirected() {
                return this[INTERNALS$1].counter > 0;
        }

        get statusText() {
                return this[INTERNALS$1].statusText;
        }

        get headers() {
                return this[INTERNALS$1].headers;
        }

        get highWaterMark() {
                return this[INTERNALS$1].highWaterMark;
        }

        /**
         * Clone this response
         *
         * @return  Response
         */
        clone() {
                return new Response(clone(this, this.highWaterMark), {
                        type: this.type,
                        url: this.url,
                        status: this.status,
                        statusText: this.statusText,
                        headers: this.headers,
                        ok: this.ok,
                        redirected: this.redirected,
                        size: this.size,
                        highWaterMark: this.highWaterMark
                });
        }

        /**
         * @param {string} url    The URL that the new response is to originate from.
         * @param {number} status An optional status code for the response (e.g., 302.)
         * @returns {Response}    A Response object.
         */
        static redirect(url, status = 302) {
                if (!isRedirect(status)) {
                        throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
                }

                return new Response(null, {
                        headers: {
                                location: new URL(url).toString()
                        },
                        status
                });
        }

        static error() {
                const response = new Response(null, {status: 0, statusText: ''});
                response[INTERNALS$1].type = 'error';
                return response;
        }

        static json(data = undefined, init = {}) {
                const body = JSON.stringify(data);

                if (body === undefined) {
                        throw new TypeError('data is not JSON serializable');
                }

                const headers = new Headers(init && init.headers);

                if (!headers.has('content-type')) {
                        headers.set('content-type', 'application/json');
                }

                return new Response(body, {
                        ...init,
                        headers
                });
        }

        get [Symbol.toStringTag]() {
                return 'Response';
        }
}

Object.defineProperties(Response.prototype, {
        type: {enumerable: true},
        url: {enumerable: true},
        status: {enumerable: true},
        ok: {enumerable: true},
        redirected: {enumerable: true},
        statusText: {enumerable: true},
        headers: {enumerable: true},
        clone: {enumerable: true}
});

const getSearch = parsedURL => {
        if (parsedURL.search) {
                return parsedURL.search;
        }

        const lastOffset = parsedURL.href.length - 1;
        const hash = parsedURL.hash || (parsedURL.href[lastOffset] === '#' ? '#' : '');
        return parsedURL.href[lastOffset - hash.length] === '?' ? '?' : '';
};

/**
 * @external URL
 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/URL|URL}
 */

/**
 * @module utils/referrer
 * @private
 */

/**
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#strip-url|Referrer Policy §8.4. Strip url for use as a referrer}
 * @param {string} URL
 * @param {boolean} [originOnly=false]
 */
function stripURLForUseAsAReferrer(url, originOnly = false) {
        // 1. If url is null, return no referrer.
        if (url == null) { // eslint-disable-line no-eq-null, eqeqeq
                return 'no-referrer';
        }

        url = new URL(url);

        // 2. If url's scheme is a local scheme, then return no referrer.
        if (/^(about|blob|data):$/.test(url.protocol)) {
                return 'no-referrer';
        }

        // 3. Set url's username to the empty string.
        url.username = '';

        // 4. Set url's password to null.
        // Note: `null` appears to be a mistake as this actually results in the password being `"null"`.
        url.password = '';

        // 5. Set url's fragment to null.
        // Note: `null` appears to be a mistake as this actually results in the fragment being `"#null"`.
        url.hash = '';

        // 6. If the origin-only flag is true, then:
        if (originOnly) {
                // 6.1. Set url's path to null.
                // Note: `null` appears to be a mistake as this actually results in the path being `"/null"`.
                url.pathname = '';

                // 6.2. Set url's query to null.
                // Note: `null` appears to be a mistake as this actually results in the query being `"?null"`.
                url.search = '';
        }

        // 7. Return url.
        return url;
}

/**
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#enumdef-referrerpolicy|enum ReferrerPolicy}
 */
const ReferrerPolicy = new Set([
        '',
        'no-referrer',
        'no-referrer-when-downgrade',
        'same-origin',
        'origin',
        'strict-origin',
        'origin-when-cross-origin',
        'strict-origin-when-cross-origin',
        'unsafe-url'
]);

/**
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#default-referrer-policy|default referrer policy}
 */
const DEFAULT_REFERRER_POLICY = 'strict-origin-when-cross-origin';

/**
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#referrer-policies|Referrer Policy §3. Referrer Policies}
 * @param {string} referrerPolicy
 * @returns {string} referrerPolicy
 */
function validateReferrerPolicy(referrerPolicy) {
        if (!ReferrerPolicy.has(referrerPolicy)) {
                throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
        }

        return referrerPolicy;
}

/**
 * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy|Referrer Policy §3.2. Is origin potentially trustworthy?}
 * @param {external:URL} url
 * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
 */
function isOriginPotentiallyTrustworthy(url) {
        // 1. If origin is an opaque origin, return "Not Trustworthy".
        // Not applicable

        // 2. Assert: origin is a tuple origin.
        // Not for implementations

        // 3. If origin's scheme is either "https" or "wss", return "Potentially Trustworthy".
        if (/^(http|ws)s:$/.test(url.protocol)) {
                return true;
        }

        // 4. If origin's host component matches one of the CIDR notations 127.0.0.0/8 or ::1/128 [RFC4632], return "Potentially Trustworthy".
        const hostIp = url.host.replace(/(^\[)|(]$)/g, '');
        const hostIPVersion = net.isIP(hostIp);

        if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
                return true;
        }

        if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
                return true;
        }

        // 5. If origin's host component is "localhost" or falls within ".localhost", and the user agent conforms to the name resolution rules in [let-localhost-be-localhost], return "Potentially Trustworthy".
        // We are returning FALSE here because we cannot ensure conformance to
        // let-localhost-be-loalhost (https://tools.ietf.org/html/draft-west-let-localhost-be-localhost)
        if (url.host === 'localhost' || url.host.endsWith('.localhost')) {
                return false;
        }

        // 6. If origin's scheme component is file, return "Potentially Trustworthy".
        if (url.protocol === 'file:') {
                return true;
        }

        // 7. If origin's scheme component is one which the user agent considers to be authenticated, return "Potentially Trustworthy".
        // Not supported

        // 8. If origin has been configured as a trustworthy origin, return "Potentially Trustworthy".
        // Not supported

        // 9. Return "Not Trustworthy".
        return false;
}

/**
 * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-url-trustworthy|Referrer Policy §3.3. Is url potentially trustworthy?}
 * @param {external:URL} url
 * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
 */
function isUrlPotentiallyTrustworthy(url) {
        // 1. If url is "about:blank" or "about:srcdoc", return "Potentially Trustworthy".
        if (/^about:(blank|srcdoc)$/.test(url)) {
                return true;
        }

        // 2. If url's scheme is "data", return "Potentially Trustworthy".
        if (url.protocol === 'data:') {
                return true;
        }

        // Note: The origin of blob: and filesystem: URLs is the origin of the context in which they were
        // created. Therefore, blobs created in a trustworthy origin will themselves be potentially
        // trustworthy.
        if (/^(blob|filesystem):$/.test(url.protocol)) {
                return true;
        }

        // 3. Return the result of executing §3.2 Is origin potentially trustworthy? on url's origin.
        return isOriginPotentiallyTrustworthy(url);
}

/**
 * Modifies the referrerURL to enforce any extra security policy considerations.
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
 * @callback module:utils/referrer~referrerURLCallback
 * @param {external:URL} referrerURL
 * @returns {external:URL} modified referrerURL
 */

/**
 * Modifies the referrerOrigin to enforce any extra security policy considerations.
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
 * @callback module:utils/referrer~referrerOriginCallback
 * @param {external:URL} referrerOrigin
 * @returns {external:URL} modified referrerOrigin
 */

/**
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}
 * @param {Request} request
 * @param {object} o
 * @param {module:utils/referrer~referrerURLCallback} o.referrerURLCallback
 * @param {module:utils/referrer~referrerOriginCallback} o.referrerOriginCallback
 * @returns {external:URL} Request's referrer
 */
function determineRequestsReferrer(request, {referrerURLCallback, referrerOriginCallback} = {}) {
        // There are 2 notes in the specification about invalid pre-conditions.  We return null, here, for
        // these cases:
        // > Note: If request's referrer is "no-referrer", Fetch will not call into this algorithm.
        // > Note: If request's referrer policy is the empty string, Fetch will not call into this
        // > algorithm.
        if (request.referrer === 'no-referrer' || request.referrerPolicy === '') {
                return null;
        }

        // 1. Let policy be request's associated referrer policy.
        const policy = request.referrerPolicy;

        // 2. Let environment be request's client.
        // not applicable to node.js

        // 3. Switch on request's referrer:
        if (request.referrer === 'about:client') {
                return 'no-referrer';
        }

        // "a URL": Let referrerSource be request's referrer.
        const referrerSource = request.referrer;

        // 4. Let request's referrerURL be the result of stripping referrerSource for use as a referrer.
        let referrerURL = stripURLForUseAsAReferrer(referrerSource);

        // 5. Let referrerOrigin be the result of stripping referrerSource for use as a referrer, with the
        //    origin-only flag set to true.
        let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);

        // 6. If the result of serializing referrerURL is a string whose length is greater than 4096, set
        //    referrerURL to referrerOrigin.
        if (referrerURL.toString().length > 4096) {
                referrerURL = referrerOrigin;
        }

        // 7. The user agent MAY alter referrerURL or referrerOrigin at this point to enforce arbitrary
        //    policy considerations in the interests of minimizing data leakage. For example, the user
        //    agent could strip the URL down to an origin, modify its host, replace it with an empty
        //    string, etc.
        if (referrerURLCallback) {
                referrerURL = referrerURLCallback(referrerURL);
        }

        if (referrerOriginCallback) {
                referrerOrigin = referrerOriginCallback(referrerOrigin);
        }

        // 8.Execute the statements corresponding to the value of policy:
        const currentURL = new URL(request.url);

        switch (policy) {
                case 'no-referrer':
                        return 'no-referrer';

                case 'origin':
                        return referrerOrigin;

                case 'unsafe-url':
                        return referrerURL;

                case 'strict-origin':
                        // 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
                        //    potentially trustworthy URL, then return no referrer.
                        if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
                                return 'no-referrer';
                        }

                        // 2. Return referrerOrigin.
                        return referrerOrigin.toString();

                case 'strict-origin-when-cross-origin':
                        // 1. If the origin of referrerURL and the origin of request's current URL are the same, then
                        //    return referrerURL.
                        if (referrerURL.origin === currentURL.origin) {
                                return referrerURL;
                        }

                        // 2. If referrerURL is a potentially trustworthy URL and request's current URL is not a
                        //    potentially trustworthy URL, then return no referrer.
                        if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
                                return 'no-referrer';
                        }

                        // 3. Return referrerOrigin.
                        return referrerOrigin;

                case 'same-origin':
                        // 1. If the origin of referrerURL and the origin of request's current URL are the same, then
                        //    return referrerURL.
                        if (referrerURL.origin === currentURL.origin) {
                                return referrerURL;
                        }

                        // 2. Return no referrer.
                        return 'no-referrer';

                case 'origin-when-cross-origin':
                        // 1. If the origin of referrerURL and the origin of request's current URL are the same, then
                        //    return referrerURL.
                        if (referrerURL.origin === currentURL.origin) {
                                return referrerURL;
                        }

                        // Return referrerOrigin.
                        return referrerOrigin;

                case 'no-referrer-when-downgrade':
                        // 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
                        //    potentially trustworthy URL, then return no referrer.
                        if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
                                return 'no-referrer';
                        }

                        // 2. Return referrerURL.
                        return referrerURL;

                default:
                        throw new TypeError(`Invalid referrerPolicy: ${policy}`);
        }
}

/**
 * @see {@link https://w3c.github.io/webappsec-referrer-policy/#parse-referrer-policy-from-header|Referrer Policy §8.1. Parse a referrer policy from a Referrer-Policy header}
 * @param {Headers} headers Response headers
 * @returns {string} policy
 */
function parseReferrerPolicyFromHeader(headers) {
        // 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy`
        //    and response’s header list.
        const policyTokens = (headers.get('referrer-policy') || '').split(/[,\s]+/);

        // 2. Let policy be the empty string.
        let policy = '';

        // 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty
        //    string, then set policy to token.
        // Note: This algorithm loops over multiple policy values to allow deployment of new policy
        // values with fallbacks for older user agents, as described in § 11.1 Unknown Policy Values.
        for (const token of policyTokens) {
                if (token && ReferrerPolicy.has(token)) {
                        policy = token;
                }
        }

        // 4. Return policy.
        return policy;
}

/**
 * Request.js
 *
 * Request class contains server only options
 *
 * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
 */


const INTERNALS = Symbol('Request internals');

/**
 * Check if `obj` is an instance of Request.
 *
 * @param  {*} object
 * @return {boolean}
 */
const isRequest = object => {
        return (
                typeof object === 'object' &&
                typeof object[INTERNALS] === 'object'
        );
};

const doBadDataWarn = util.deprecate(() => {},
        '.data is not a valid RequestInit property, use .body instead',
        'https://github.com/node-fetch/node-fetch/issues/1000 (request)');

/**
 * Request class
 *
 * Ref: https://fetch.spec.whatwg.org/#request-class
 *
 * @param   Mixed   input  Url or Request instance
 * @param   Object  init   Custom options
 * @return  Void
 */
class Request extends Body {
        constructor(input, init = {}) {
                let parsedURL;

                // Normalize input and force URL to be encoded as UTF-8 (https://github.com/node-fetch/node-fetch/issues/245)
                if (isRequest(input)) {
                        parsedURL = new URL(input.url);
                } else {
                        parsedURL = new URL(input);
                        input = {};
                }

                if (parsedURL.username !== '' || parsedURL.password !== '') {
                        throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
                }

                let method = init.method || input.method || 'GET';
                if (/^(delete|get|head|options|post|put)$/i.test(method)) {
                        method = method.toUpperCase();
                }

                if (!isRequest(init) && 'data' in init) {
                        doBadDataWarn();
                }

                // eslint-disable-next-line no-eq-null, eqeqeq
                if ((init.body != null || (isRequest(input) && input.body !== null)) &&
                        (method === 'GET' || method === 'HEAD')) {
                        throw new TypeError('Request with GET/HEAD method cannot have body');
                }

                const inputBody = init.body ?
                        init.body :
                        (isRequest(input) && input.body !== null ?
                                clone(input) :
                                null);

                super(inputBody, {
                        size: init.size || input.size || 0
                });

                const headers = new Headers(init.headers || input.headers || {});

                if (inputBody !== null && !headers.has('Content-Type')) {
                        const contentType = extractContentType(inputBody, this);
                        if (contentType) {
                                headers.set('Content-Type', contentType);
                        }
                }

                let signal = isRequest(input) ?
                        input.signal :
                        null;
                if ('signal' in init) {
                        signal = init.signal;
                }

                // eslint-disable-next-line no-eq-null, eqeqeq
                if (signal != null && !isAbortSignal(signal)) {
                        throw new TypeError('Expected signal to be an instanceof AbortSignal or EventTarget');
                }

                // §5.4, Request constructor steps, step 15.1
                // eslint-disable-next-line no-eq-null, eqeqeq
                let referrer = init.referrer == null ? input.referrer : init.referrer;
                if (referrer === '') {
                        // §5.4, Request constructor steps, step 15.2
                        referrer = 'no-referrer';
                } else if (referrer) {
                        // §5.4, Request constructor steps, step 15.3.1, 15.3.2
                        const parsedReferrer = new URL(referrer);
                        // §5.4, Request constructor steps, step 15.3.3, 15.3.4
                        referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? 'client' : parsedReferrer;
                } else {
                        referrer = undefined;
                }

                this[INTERNALS] = {
                        method,
                        redirect: init.redirect || input.redirect || 'follow',
                        headers,
                        parsedURL,
                        signal,
                        referrer
                };

                // Node-fetch-only options
                this.follow = init.follow === undefined ? (input.follow === undefined ? 20 : input.follow) : init.follow;
                this.compress = init.compress === undefined ? (input.compress === undefined ? true : input.compress) : init.compress;
                this.counter = init.counter || input.counter || 0;
                this.agent = init.agent || input.agent;
                this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
                this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;

                // §5.4, Request constructor steps, step 16.
                // Default is empty string per https://fetch.spec.whatwg.org/#concept-request-referrer-policy
                this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || '';
        }

        /** @returns {string} */
        get method() {
                return this[INTERNALS].method;
        }

        /** @returns {string} */
        get url() {
                return url.format(this[INTERNALS].parsedURL);
        }

        /** @returns {Headers} */
        get headers() {
                return this[INTERNALS].headers;
        }

        get redirect() {
                return this[INTERNALS].redirect;
        }

        /** @returns {AbortSignal} */
        get signal() {
                return this[INTERNALS].signal;
        }

        // https://fetch.spec.whatwg.org/#dom-request-referrer
        get referrer() {
                if (this[INTERNALS].referrer === 'no-referrer') {
                        return '';
                }

                if (this[INTERNALS].referrer === 'client') {
                        return 'about:client';
                }

                if (this[INTERNALS].referrer) {
                        return this[INTERNALS].referrer.toString();
                }

                return undefined;
        }

        get referrerPolicy() {
                return this[INTERNALS].referrerPolicy;
        }

        set referrerPolicy(referrerPolicy) {
                this[INTERNALS].referrerPolicy = validateReferrerPolicy(referrerPolicy);
        }

        /**
         * Clone this request
         *
         * @return  Request
         */
        clone() {
                return new Request(this);
        }

        get [Symbol.toStringTag]() {
                return 'Request';
        }
}

Object.defineProperties(Request.prototype, {
        method: {enumerable: true},
        url: {enumerable: true},
        headers: {enumerable: true},
        redirect: {enumerable: true},
        clone: {enumerable: true},
        signal: {enumerable: true},
        referrer: {enumerable: true},
        referrerPolicy: {enumerable: true}
});

/**
 * Convert a Request to Node.js http request options.
 *
 * @param {Request} request - A Request instance
 * @return The options object to be passed to http.request
 */
const getNodeRequestOptions = request => {
        const {parsedURL} = request[INTERNALS];
        const headers = new Headers(request[INTERNALS].headers);

        // Fetch step 1.3
        if (!headers.has('Accept')) {
                headers.set('Accept', '*/*');
        }

        // HTTP-network-or-cache fetch steps 2.4-2.7
        let contentLengthValue = null;
        if (request.body === null && /^(post|put)$/i.test(request.method)) {
                contentLengthValue = '0';
        }

        if (request.body !== null) {
                const totalBytes = getTotalBytes(request);
                // Set Content-Length if totalBytes is a number (that is not NaN)
                if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
                        contentLengthValue = String(totalBytes);
                }
        }

        if (contentLengthValue) {
                headers.set('Content-Length', contentLengthValue);
        }

        // 4.1. Main fetch, step 2.6
        // > If request's referrer policy is the empty string, then set request's referrer policy to the
        // > default referrer policy.
        if (request.referrerPolicy === '') {
                request.referrerPolicy = DEFAULT_REFERRER_POLICY;
        }

        // 4.1. Main fetch, step 2.7
        // > If request's referrer is not "no-referrer", set request's referrer to the result of invoking
        // > determine request's referrer.
        if (request.referrer && request.referrer !== 'no-referrer') {
                request[INTERNALS].referrer = determineRequestsReferrer(request);
        } else {
                request[INTERNALS].referrer = 'no-referrer';
        }

        // 4.5. HTTP-network-or-cache fetch, step 6.9
        // > If httpRequest's referrer is a URL, then append `Referer`/httpRequest's referrer, serialized
        // >  and isomorphic encoded, to httpRequest's header list.
        if (request[INTERNALS].referrer instanceof URL) {
                headers.set('Referer', request.referrer);
        }

        // HTTP-network-or-cache fetch step 2.11
        if (!headers.has('User-Agent')) {
                headers.set('User-Agent', 'node-fetch');
        }

        // HTTP-network-or-cache fetch step 2.15
        if (request.compress && !headers.has('Accept-Encoding')) {
                headers.set('Accept-Encoding', 'gzip, deflate, br');
        }

        let {agent} = request;
        if (typeof agent === 'function') {
                agent = agent(parsedURL);
        }

        // HTTP-network fetch step 4.2
        // chunked encoding is handled by Node.js

        const search = getSearch(parsedURL);

        // Pass the full URL directly to request(), but overwrite the following
        // options:
        const options = {
                // Overwrite search to retain trailing ? (issue #776)
                path: parsedURL.pathname + search,
                // The following options are not expressed in the URL
                method: request.method,
                headers: headers[Symbol.for('nodejs.util.inspect.custom')](),
                insecureHTTPParser: request.insecureHTTPParser,
                agent
        };

        return {
                /** @type {URL} */
                parsedURL,
                options
        };
};

/**
 * AbortError interface for cancelled requests
 */
class AbortError extends FetchBaseError {
        constructor(message, type = 'aborted') {
                super(message, type);
        }
}

const { stat } = fs.promises;

/**
 * @param {string} path filepath on the disk
 * @param {string} [type] mimetype to use
 */
const blobFromSync = (path, type) => fromBlob(fs.statSync(path), path, type);

/**
 * @param {string} path filepath on the disk
 * @param {string} [type] mimetype to use
 * @returns {Promise<Blob>}
 */
const blobFrom = (path, type) => stat(path).then(stat => fromBlob(stat, path, type));

/**
 * @param {string} path filepath on the disk
 * @param {string} [type] mimetype to use
 * @returns {Promise<File>}
 */
const fileFrom = (path, type) => stat(path).then(stat => fromFile(stat, path, type));

/**
 * @param {string} path filepath on the disk
 * @param {string} [type] mimetype to use
 */
const fileFromSync = (path, type) => fromFile(fs.statSync(path), path, type);

// @ts-ignore
const fromBlob = (stat, path, type = '') => new Blob([new BlobDataItem({
  path,
  size: stat.size,
  lastModified: stat.mtimeMs,
  start: 0
})], { type });

// @ts-ignore
const fromFile = (stat, path$1, type = '') => new File([new BlobDataItem({
  path: path$1,
  size: stat.size,
  lastModified: stat.mtimeMs,
  start: 0
})], path.basename(path$1), { type, lastModified: stat.mtimeMs });

/**
 * This is a blob backed up by a file on the disk
 * with minium requirement. Its wrapped around a Blob as a blobPart
 * so you have no direct access to this.
 *
 * @private
 */
class BlobDataItem {
  #path
  #start

  constructor (options) {
    this.#path = options.path;
    this.#start = options.start;
    this.size = options.size;
    this.lastModified = options.lastModified;
  }

  /**
   * Slicing arguments is first validated and formatted
   * to not be out of range by Blob.prototype.slice
   */
  slice (start, end) {
    return new BlobDataItem({
      path: this.#path,
      lastModified: this.lastModified,
      size: end - start,
      start: this.#start + start
    })
  }

  async * stream () {
    const { mtimeMs } = await stat(this.#path);
    if (mtimeMs > this.lastModified) {
      throw new DOMException('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError')
    }
    yield * fs.createReadStream(this.#path, {
      start: this.#start,
      end: this.#start + this.size - 1
    });
  }

  get [Symbol.toStringTag] () {
    return 'Blob'
  }
}

/**
 * Index.js
 *
 * a request API compatible with window.fetch
 *
 * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
 */


const supportedSchemas = new Set(['data:', 'http:', 'https:']);

/**
 * Fetch function
 *
 * @param   {string | URL | import('./request').default} url - Absolute url or Request instance
 * @param   {*} [options_] - Fetch options
 * @return  {Promise<import('./response').default>}
 */
async function fetch(url, options_) {
        return new Promise((resolve, reject) => {
                // Build request object
                const request = new Request(url, options_);
                const {parsedURL, options} = getNodeRequestOptions(request);
                if (!supportedSchemas.has(parsedURL.protocol)) {
                        throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, '')}" is not supported.`);
                }

                if (parsedURL.protocol === 'data:') {
                        const data = dataUriToBuffer(request.url);
                        const response = new Response(data, {headers: {'Content-Type': data.typeFull}});
                        resolve(response);
                        return;
                }

                // Wrap http.request into fetch
                const send = (parsedURL.protocol === 'https:' ? https : http).request;
                const {signal} = request;
                let response = null;

                const abort = () => {
                        const error = new AbortError('The operation was aborted.');
                        reject(error);
                        if (request.body && request.body instanceof Stream.Readable) {
                                request.body.destroy(error);
                        }

                        if (!response || !response.body) {
                                return;
                        }

                        response.body.emit('error', error);
                };

                if (signal && signal.aborted) {
                        abort();
                        return;
                }

                const abortAndFinalize = () => {
                        abort();
                        finalize();
                };

                // Send request
                const request_ = send(parsedURL.toString(), options);

                if (signal) {
                        signal.addEventListener('abort', abortAndFinalize);
                }

                const finalize = () => {
                        request_.abort();
                        if (signal) {
                                signal.removeEventListener('abort', abortAndFinalize);
                        }
                };

                request_.on('error', error => {
                        reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, 'system', error));
                        finalize();
                });

                fixResponseChunkedTransferBadEnding(request_, error => {
                        if (response && response.body) {
                                response.body.destroy(error);
                        }
                });

                /* c8 ignore next 18 */
                if (process.version < 'v14') {
                        // Before Node.js 14, pipeline() does not fully support async iterators and does not always
                        // properly handle when the socket close/end events are out of order.
                        request_.on('socket', s => {
                                let endedWithEventsCount;
                                s.prependListener('end', () => {
                                        endedWithEventsCount = s._eventsCount;
                                });
                                s.prependListener('close', hadError => {
                                        // if end happened before close but the socket didn't emit an error, do it now
                                        if (response && endedWithEventsCount < s._eventsCount && !hadError) {
                                                const error = new Error('Premature close');
                                                error.code = 'ERR_STREAM_PREMATURE_CLOSE';
                                                response.body.emit('error', error);
                                        }
                                });
                        });
                }

                request_.on('response', response_ => {
                        request_.setTimeout(0);
                        const headers = fromRawHeaders(response_.rawHeaders);

                        // HTTP fetch step 5
                        if (isRedirect(response_.statusCode)) {
                                // HTTP fetch step 5.2
                                const location = headers.get('Location');

                                // HTTP fetch step 5.3
                                let locationURL = null;
                                try {
                                        locationURL = location === null ? null : new URL(location, request.url);
                                } catch {
                                        // error here can only be invalid URL in Location: header
                                        // do not throw when options.redirect == manual
                                        // let the user extract the errorneous redirect URL
                                        if (request.redirect !== 'manual') {
                                                reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect'));
                                                finalize();
                                                return;
                                        }
                                }

                                // HTTP fetch step 5.5
                                switch (request.redirect) {
                                        case 'error':
                                                reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
                                                finalize();
                                                return;
                                        case 'manual':
                                                // Nothing to do
                                                break;
                                        case 'follow': {
                                                // HTTP-redirect fetch step 2
                                                if (locationURL === null) {
                                                        break;
                                                }

                                                // HTTP-redirect fetch step 5
                                                if (request.counter >= request.follow) {
                                                        reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
                                                        finalize();
                                                        return;
                                                }

                                                // HTTP-redirect fetch step 6 (counter increment)
                                                // Create a new Request object.
                                                const requestOptions = {
                                                        headers: new Headers(request.headers),
                                                        follow: request.follow,
                                                        counter: request.counter + 1,
                                                        agent: request.agent,
                                                        compress: request.compress,
                                                        method: request.method,
                                                        body: clone(request),
                                                        signal: request.signal,
                                                        size: request.size,
                                                        referrer: request.referrer,
                                                        referrerPolicy: request.referrerPolicy
                                                };

                                                // when forwarding sensitive headers like "Authorization",
                                                // "WWW-Authenticate", and "Cookie" to untrusted targets,
                                                // headers will be ignored when following a redirect to a domain
                                                // that is not a subdomain match or exact match of the initial domain.
                                                // For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
                                                // will forward the sensitive headers, but a redirect to "bar.com" will not.
                                                // headers will also be ignored when following a redirect to a domain using
                                                // a different protocol. For example, a redirect from "https://foo.com" to "http://foo.com"
                                                // will not forward the sensitive headers
                                                if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
                                                        for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
                                                                requestOptions.headers.delete(name);
                                                        }
                                                }

                                                // HTTP-redirect fetch step 9
                                                if (response_.statusCode !== 303 && request.body && options_.body instanceof Stream.Readable) {
                                                        reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
                                                        finalize();
                                                        return;
                                                }

                                                // HTTP-redirect fetch step 11
                                                if (response_.statusCode === 303 || ((response_.statusCode === 301 || response_.statusCode === 302) && request.method === 'POST')) {
                                                        requestOptions.method = 'GET';
                                                        requestOptions.body = undefined;
                                                        requestOptions.headers.delete('content-length');
                                                }

                                                // HTTP-redirect fetch step 14
                                                const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
                                                if (responseReferrerPolicy) {
                                                        requestOptions.referrerPolicy = responseReferrerPolicy;
                                                }

                                                // HTTP-redirect fetch step 15
                                                resolve(fetch(new Request(locationURL, requestOptions)));
                                                finalize();
                                                return;
                                        }

                                        default:
                                                return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
                                }
                        }

                        // Prepare response
                        if (signal) {
                                response_.once('end', () => {
                                        signal.removeEventListener('abort', abortAndFinalize);
                                });
                        }

                        let body = Stream.pipeline(response_, new Stream.PassThrough(), error => {
                                if (error) {
                                        reject(error);
                                }
                        });
                        // see https://github.com/nodejs/node/pull/29376
                        /* c8 ignore next 3 */
                        if (process.version < 'v12.10') {
                                response_.on('aborted', abortAndFinalize);
                        }

                        const responseOptions = {
                                url: request.url,
                                status: response_.statusCode,
                                statusText: response_.statusMessage,
                                headers,
                                size: request.size,
                                counter: request.counter,
                                highWaterMark: request.highWaterMark
                        };

                        // HTTP-network fetch step 12.1.1.3
                        const codings = headers.get('Content-Encoding');

                        // HTTP-network fetch step 12.1.1.4: handle content codings

                        // in following scenarios we ignore compression support
                        // 1. compression support is disabled
                        // 2. HEAD request
                        // 3. no Content-Encoding header
                        // 4. no content response (204)
                        // 5. content not modified response (304)
                        if (!request.compress || request.method === 'HEAD' || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
                                response = new Response(body, responseOptions);
                                resolve(response);
                                return;
                        }

                        // For Node v6+
                        // Be less strict when decoding compressed responses, since sometimes
                        // servers send slightly invalid responses that are still accepted
                        // by common browsers.
                        // Always using Z_SYNC_FLUSH is what cURL does.
                        const zlibOptions = {
                                flush: zlib.Z_SYNC_FLUSH,
                                finishFlush: zlib.Z_SYNC_FLUSH
                        };

                        // For gzip
                        if (codings === 'gzip' || codings === 'x-gzip') {
                                body = Stream.pipeline(body, zlib.createGunzip(zlibOptions), error => {
                                        if (error) {
                                                reject(error);
                                        }
                                });
                                response = new Response(body, responseOptions);
                                resolve(response);
                                return;
                        }

                        // For deflate
                        if (codings === 'deflate' || codings === 'x-deflate') {
                                // Handle the infamous raw deflate response from old servers
                                // a hack for old IIS and Apache servers
                                const raw = Stream.pipeline(response_, new Stream.PassThrough(), error => {
                                        if (error) {
                                                reject(error);
                                        }
                                });
                                raw.once('data', chunk => {
                                        // See http://stackoverflow.com/questions/37519828
                                        if ((chunk[0] & 0x0F) === 0x08) {
                                                body = Stream.pipeline(body, zlib.createInflate(), error => {
                                                        if (error) {
                                                                reject(error);
                                                        }
                                                });
                                        } else {
                                                body = Stream.pipeline(body, zlib.createInflateRaw(), error => {
                                                        if (error) {
                                                                reject(error);
                                                        }
                                                });
                                        }

                                        response = new Response(body, responseOptions);
                                        resolve(response);
                                });
                                raw.once('end', () => {
                                        // Some old IIS servers return zero-length OK deflate responses, so
                                        // 'data' is never emitted. See https://github.com/node-fetch/node-fetch/pull/903
                                        if (!response) {
                                                response = new Response(body, responseOptions);
                                                resolve(response);
                                        }
                                });
                                return;
                        }

                        // For br
                        if (codings === 'br') {
                                body = Stream.pipeline(body, zlib.createBrotliDecompress(), error => {
                                        if (error) {
                                                reject(error);
                                        }
                                });
                                response = new Response(body, responseOptions);
                                resolve(response);
                                return;
                        }

                        // Otherwise, use response as-is
                        response = new Response(body, responseOptions);
                        resolve(response);
                });

                // eslint-disable-next-line promise/prefer-await-to-then
                writeToStream(request_, request).catch(reject);
        });
}

function fixResponseChunkedTransferBadEnding(request, errorCallback) {
        const LAST_CHUNK = buffer.Buffer.from('0\r\n\r\n');

        let isChunkedTransfer = false;
        let properLastChunkReceived = false;
        let previousChunk;

        request.on('response', response => {
                const {headers} = response;
                isChunkedTransfer = headers['transfer-encoding'] === 'chunked' && !headers['content-length'];
        });

        request.on('socket', socket => {
                const onSocketClose = () => {
                        if (isChunkedTransfer && !properLastChunkReceived) {
                                const error = new Error('Premature close');
                                error.code = 'ERR_STREAM_PREMATURE_CLOSE';
                                errorCallback(error);
                        }
                };

                const onData = buf => {
                        properLastChunkReceived = buffer.Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;

                        // Sometimes final 0-length chunk and end of message code are in separate packets
                        if (!properLastChunkReceived && previousChunk) {
                                properLastChunkReceived = (
                                        buffer.Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 &&
                                        buffer.Buffer.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0
                                );
                        }

                        previousChunk = buf;
                };

                socket.prependListener('close', onSocketClose);
                socket.on('data', onData);

                request.on('close', () => {
                        socket.removeListener('close', onSocketClose);
                        socket.removeListener('data', onData);
                });
        });
}

exports.AbortError = AbortError;
exports.Blob = Blob;
exports.FetchError = FetchError;
exports.File = File;
exports.FormData = FormData;
exports.Headers = Headers;
exports.Request = Request;
exports.Response = Response;
exports.blobFrom = blobFrom;
exports.blobFromSync = blobFromSync;
exports.default = fetch;
exports.fileFrom = fileFrom;
exports.fileFromSync = fileFromSync;
exports.isRedirect = isRedirect;
/* eslint-enable */
//# sourceMappingURL=index.js.map