Basic usage example:

const res = await fetch('https://example.com')

const json = await res.json()

You can pass an optional dispatcher to `fetch` as:

In this implementation of fetch, ```request.body``` now accepts ```Async Iterables```. It is not present in the [Fetch Standard.](https://fetch.spec.whatwg.org)

const data = {

async *[Symbol.asyncIterator]() {

},

Nodejs has two kinds of streams: [web streams](https://nodejs.org/dist/latest-v16.x/docs/api/webstreams.html), which follow the API of the WHATWG web standard found in browsers, and an older Node-specific [streams API](https://nodejs.org/api/stream.html). `response.body` returns a readable web stream. If you would prefer to work with a Node stream you can convert a web stream using `.fromWeb()`.

const response = await fetch('https://example.com')

Returns: `Dispatcher`

* **port** `string | number` (optional)

* **factory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Pool(origin, opts)`

* **maxRedirections** `Integer` - Default: `0`. The number of HTTP redirection to follow unless otherwise specified in `DispatchOptions`.

* **pipelining** `number | null` (optional) - Default: `1` - The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Carefully consider your workload and environment before enabling concurrent requests as pipelining may reduce performance if used incorrectly. Pipelining is sensitive to network stack settings as well as head of line blocking caused by e.g. long running requests. Set to `0` to disable keep-alive connections.

* **connect** `ConnectOptions | Function | null` (optional) - Default: `null`.

* **strictContentLength** `Boolean` (optional) - Default: `true` - Whether to treat request content length mismatches as errors. If true, an error is thrown when the request content-length header doesn't match the length of the request body.

* **path** `string | RegExp | (path: string) => boolean` - a matcher for the HTTP request path.

* **body** `string | RegExp | (body: string) => boolean` - (optional) - a matcher for the HTTP request body.

* **headers** `Record<string, string | RegExp | (body: string) => boolean`> - (optional) - a matcher for the HTTP request headers. To be intercepted, a request must match all defined headers. Extra headers not defined here may (or may not) be included in the request and do not affect the interception in any way.

* **query** `Record<string, any> | null` - (optional) - a matcher for the HTTP request query string params.

* **factory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Client(origin, opts)`

* **connections** `number | null` (optional) - Default: `null` - The number of `Client` instances to create. When set to `null`, the `Pool` instance will create an unlimited amount of `Client` instances.

const { getGlobalDispatcher } = require('./lib/global')

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

const dispatcher = (arguments[1] && arguments[1].dispatcher) || getGlobalDispatcher()

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

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

import Dispatcher = require('./types/dispatcher')

import { setGlobalDispatcher, getGlobalDispatcher } from './types/global-dispatcher'

import Pool = require('./types/pool')

import BalancedPool = require('./types/balanced-pool')

import Client = require('./types/client')

import buildConnector = require('./types/connector')

export * from './types/diagnostics-channel'

export { Interceptable } from './types/mock-interceptor'

export default Undici

declare namespace Undici {

var Dispatcher: typeof import('./types/dispatcher')

var Pool: typeof import('./types/pool');

var BalancedPool: typeof import('./types/balanced-pool');

var Client: typeof import('./types/client');

var buildConnector: typeof import('./types/connector');

const mockErrors = require('./lib/mock/mock-errors')

const ProxyAgent = require('./lib/proxy-agent')

const { getGlobalDispatcher, setGlobalDispatcher } = require('./lib/global')

const nodeVersion = process.versions.node.split('.')

const nodeMajor = Number(nodeVersion[0])

module.exports.Agent = Agent

module.exports.ProxyAgent = ProxyAgent

module.exports.buildConnector = buildConnector

module.exports.errors = errors

let fetchImpl = null

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

if (!fetchImpl) {

}

const dispatcher = (arguments[1] && arguments[1].dispatcher) || getGlobalDispatcher()

}

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.request = makeDispatcher(api.request)

const { InvalidArgumentError } = require('./core/errors')

const DispatcherBase = require('./dispatcher-base')

const Pool = require('./pool')

const Client = require('./client')

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

const { WeakRef, FinalizationRegistry } = require('./compat/dispatcher-weakref')()

const kOnConnect = Symbol('onConnect')

connect = { ...connect }

}

this[kOptions] = { ...util.deepClone(options), connect }

this[kMaxRedirections] = maxRedirections

this[kFactory] = factory

this[kClients] = new Map()

this[kFinalizer].register(dispatcher, key)

}

return dispatcher.dispatch(opts, handler)

}