- You want zero dependencies

- Building isomorphic code that runs in browsers and Node.js

- Publishing to npm and want to maximize compatibility with JS runtimes

- Simple HTTP requests without advanced configuration

- You're publishing to npm and you want to maximize compatiblity

- You don't depend on features from a specific version of undici

- You need the latest undici features and performance improvements

- `fetch` - The fetch function

- `Headers` - HTTP headers management

- `Response` - HTTP response representation

- `Request` - HTTP request representation

- `FormData` - Form data handling

- `WebSocket` - WebSocket client

- `CloseEvent`, `ErrorEvent`, `MessageEvent` - WebSocket events

import diagnosticsChannel from 'diagnostics_channel'

diagnosticsChannel.channel('undici:websocket:open').subscribe(({ address, protocol, extensions, websocket }) => {

console.log(address) // address, family, and port

console.log(protocol) // negotiated subprotocols

console.log(extensions) // negotiated extensions

console.log(websocket) // the WebSocket instance

})

import diagnosticsChannel from 'diagnostics_channel'

diagnosticsChannel.channel('undici:websocket:close').subscribe(({ websocket, code, reason }) => {

console.log(websocket) // the WebSocket instance

console.log(code) // the closing status code

console.log(reason) // the closing reason

})

import diagnosticsChannel from 'diagnostics_channel'

diagnosticsChannel.channel('undici:websocket:ping').subscribe(({ payload, websocket }) => {

// a Buffer or undefined, containing the optional application data of the frame

console.log(payload)

console.log(websocket) // the WebSocket instance

})

import diagnosticsChannel from 'diagnostics_channel'

diagnosticsChannel.channel('undici:websocket:pong').subscribe(({ payload, websocket }) => {

// a Buffer or undefined, containing the optional application data of the frame

console.log(payload)

console.log(websocket) // the WebSocket instance

})

- `store` - The [`CacheStore`](/docs/docs/api/CacheStore.md) to store and retrieve responses from. Default is [`MemoryCacheStore`](/docs/docs/api/CacheStore.md#memorycachestore).

- `methods` - The [**safe** HTTP methods](https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1) to cache the response of.

- `cacheByDefault` - The default expiration time to cache responses by if they don't have an explicit expiration and cannot have an heuristic expiry computed. If this isn't present, responses neither with an explicit expiration nor heuristically cacheable will not be cached. Default `undefined`.

- `type` - The [type of cache](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Caching#types_of_caches) for Undici to act as. Can be `shared` or `private`. Default `shared`. `private` implies privately cacheable responses will be cached and potentially shared with other users of your application.

Arguments:

* **websocket** `WebSocket` - The WebSocket instance to send the ping frame on

* **payload** `Buffer|undefined` (optional) - Optional payload data to include with the ping frame. Must not exceed 125 bytes.

Sends a ping frame to the WebSocket server. The server must respond with a pong frame containing the same payload data. This can be used for keepalive purposes or to verify that the connection is still active.

import { WebSocket, ping } from 'undici'

const ws = new WebSocket('wss://echo.websocket.events')

ws.addEventListener('open', () => {

// Send ping with no payload

ping(ws)

// Send ping with payload

const payload = Buffer.from('hello')

ping(ws, payload)

})

**Note**: A ping frame cannot have a payload larger than 125 bytes. The ping will only be sent if the WebSocket connection is in the OPEN state.

- [MDN - WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)

module.exports.serializeAMimeType = serializeAMimeType

const { CloseEvent, ErrorEvent, MessageEvent } = require('./lib/web/websocket/events')

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

module.exports.WebSocket = WebSocket

module.exports.CloseEvent = CloseEvent

module.exports.ErrorEvent = ErrorEvent

module.exports.MessageEvent = MessageEvent

module.exports.ping = ping

module.exports.WebSocketStream = require('./lib/web/websocket/stream/websocketstream').WebSocketStream

module.exports.WebSocketError = require('./lib/web/websocket/stream/websocketerror').WebSocketError

// promise (i.e micro tick) for installing an 'error' listener will

// never get a chance and will always encounter an unhandled exception.

if (!this[kUsed]) {

setImmediate(callback, err)

} else {

callback(err)

}

reset,

expectContinue,

servername,

throwOnError,

maxRedirections

}, handler) {

if (typeof path !== 'string') {

throw new InvalidArgumentError('path must be a string')

throw new InvalidArgumentError('invalid throwOnError')

}

if (maxRedirections != null && maxRedirections !== 0) {

throw new InvalidArgumentError('maxRedirections is not supported, use the redirect interceptor')

}

this.headersTimeout = headersTimeout

this.bodyTimeout = bodyTimeout

/**

search (key) {

const keylength = key.length

let extractBody

function lazyllhttp () {

const llhttpWasmData = process.env.JEST_WORKER_ID ? require('../llhttp/llhttp-wasm.js') : undefined

let mod

try {

mod = new WebAssembly.Module(require('../llhttp/llhttp_simd-wasm.js'))

} catch (e) {

/* istanbul ignore next */

// We could check if the error was caused by the simd option not

// being enabled, but the occurring of this other error

// * https://github.com/emscripten-core/emscripten/issues/11495

// got me to remove that check to avoid breaking Node 12.

mod = new WebAssembly.Module(llhttpWasmData || require('../llhttp/llhttp-wasm.js'))

}

return new WebAssembly.Instance(mod, {

env: {

/**

let llhttpInstance = null

// We must wait a full event loop cycle to reuse this socket to make sure

// that non-spec compliant servers are not closing the connection even if they

// said they won't.

setImmediate(client[kResume])

} else {

client[kResume]()

}

client[kSocket] = socket

if (!llhttpInstance) {

llhttpInstance = lazyllhttp()

}

if (socket.errored) {

.on('error', onFinished)

if (body.errorEmitted ?? body.errored) {

setImmediate(onFinished, body.errored)

} else if (body.endEmitted ?? body.readableEnded) {

setImmediate(onFinished, null)

}

if (body.closeEmitted ?? body.closed) {