Removes an upstream that was previously added.

* **onConnect** `(abort: () => void, context: object) => void` - Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails.

* **onError** `(error: Error) => void` - Invoked when an error has occurred. May not throw.

* **onUpgrade** `(statusCode: number, headers: Buffer[], socket: Duplex) => void` (optional) - Invoked when request is upgraded. Required if `DispatchOptions.upgrade` is defined or `DispatchOptions.method === 'CONNECT'`.

* **onResponseStarted** `() => void` (optional) - Invoked when response is received, before headers have been read.

* **onHeaders** `(statusCode: number, headers: Buffer[], resume: () => void, statusText: string) => boolean` - Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. Not required for `upgrade` requests.

* **onData** `(chunk: Buffer) => boolean` - Invoked when response payload data is received. Not required for `upgrade` requests.

* **onComplete** `(trailers: Buffer[]) => void` - Invoked when response payload and trailers have been received and the request has completed. Not required for `upgrade` requests.

Utility API for third-party implementations of the dispatcher API.

Receives a header object and returns the parsed value.

Arguments:

- **headers** `Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]` (required) - Header object.

- **obj** `Record<string, string | string[]>` (optional) - Object to specify a proxy object. The parsed value is assigned to this object. But, if **headers** is an object, it is not used.

Returns: `Record<string, string | string[]>` If **headers** is an object, it is **headers**. Otherwise, if **obj** is specified, it is equivalent to **obj**.

Retrieves a header name and returns its lowercase value.

Arguments:

- **value** `string | Buffer` (required) - Header name.

Returns: `string`

module.exports.buildConnector = buildConnector

module.exports.errors = errors

module.exports.util = {

parseHeaders: util.parseHeaders,

headerNameToString: util.headerNameToString

function makeDispatcher (fn) {

return (url, opts, handler) => {

module.exports.setGlobalDispatcher = setGlobalDispatcher

module.exports.getGlobalDispatcher = getGlobalDispatcher

let fetchImpl = null

module.exports.fetch = async function fetch (resource) {

if (!fetchImpl) {

fetchImpl = require('./lib/fetch').fetch

}

try {

return await fetchImpl(...arguments)

} catch (err) {

if (typeof err === 'object') {

Error.captureStackTrace(err, this)

}

throw err

}

module.exports.Headers = require('./lib/fetch/headers').Headers

module.exports.Response = require('./lib/fetch/response').Response

module.exports.Request = require('./lib/fetch/request').Request

module.exports.FormData = require('./lib/fetch/formdata').FormData

module.exports.File = require('./lib/fetch/file').File

module.exports.FileReader = require('./lib/fileapi/filereader').FileReader

const { setGlobalOrigin, getGlobalOrigin } = require('./lib/fetch/global')

module.exports.setGlobalOrigin = setGlobalOrigin

module.exports.getGlobalOrigin = getGlobalOrigin

const { CacheStorage } = require('./lib/cache/cachestorage')

const { kConstruct } = require('./lib/cache/symbols')

module.exports.caches = new CacheStorage(kConstruct)

const { deleteCookie, getCookies, getSetCookies, setCookie } = require('./lib/cookies')

module.exports.deleteCookie = deleteCookie

module.exports.getCookies = getCookies

module.exports.getSetCookies = getSetCookies

module.exports.setCookie = setCookie

const { parseMIMEType, serializeAMimeType } = require('./lib/fetch/dataURL')

module.exports.parseMIMEType = parseMIMEType

module.exports.serializeAMimeType = serializeAMimeType

if (hasCrypto) {

const { WebSocket } = require('./lib/websocket/websocket')

module.exports.WebSocket = WebSocket

const Client = require('./client')

const util = require('./core/util')

const createRedirectInterceptor = require('./interceptor/redirectInterceptor')

const kOnConnect = Symbol('onConnect')

const kOnDisconnect = Symbol('onDisconnect')

const kOnConnectionError = Symbol('onConnectionError')

const kMaxRedirections = Symbol('maxRedirections')

const kOnDrain = Symbol('onDrain')

const kFactory = Symbol('factory')

const kOptions = Symbol('options')

function defaultFactory (origin, opts) {

this[kMaxRedirections] = maxRedirections

this[kFactory] = factory

this[kClients] = new Map()

const agent = this

get [kRunning] () {

let ret = 0

for (const client of this[kClients].values()) {

ret += client[kRunning]

}

return ret

}

throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')

}

let dispatcher = this[kClients].get(key)

if (!dispatcher) {

dispatcher = this[kFactory](opts.origin, this[kOptions])

.on('drain', this[kOnDrain])

.on('connect', this[kOnConnect])

.on('disconnect', this[kOnDisconnect])

.on('connectionError', this[kOnConnectionError])

// This introduces a tiny memory leak, as dispatchers are never removed from the map.

// TODO(mcollina): remove te timer when the client/pool do not have any more

// active connections.

this[kClients].set(key, dispatcher)

}

return dispatcher.dispatch(opts, handler)

}

async [kClose] () {

const closePromises = []

for (const client of this[kClients].values()) {

closePromises.push(client.close())

}

this[kClients].clear()

await Promise.all(closePromises)

}

async [kDestroy] (err) {

const destroyPromises = []

for (const client of this[kClients].values()) {

destroyPromises.push(client.destroy(err))

}

this[kClients].clear()

await Promise.all(destroyPromises)

}