@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/docs/docs/api/Connector.md

@@ -1,87 +1,48 @@
 # Connector
 
-<!--introduced_in=v4.3.0-->
-<!--type=module-->
-<!-- source_link=lib/core/connect.js -->
+Undici creates the underlying socket via the connector builder.
+Normally, this happens automatically and you don't need to care about this,
+but if you need to perform some additional check over the currently used socket,
+this is the right place.
 
-> Stability: 2 - Stable
+If you want to create a custom connector, you must import the `buildConnector` utility.
 
-undici opens the underlying socket for every request through a *connector*. By
-default this is handled internally, so most applications never interact with the
-connector directly. When a request needs additional control over the socket —
-for example to inspect a TLS certificate, pin a CA fingerprint, or tunnel the
-connection — a custom connector can be supplied through the `connect` option of
-a [`Dispatcher`][].
+#### Parameter: `buildConnector.BuildOptions`
 
-Use the `buildConnector` helper to construct a connector with sensible defaults
-and then wrap it:
+Every Tls option, see [here](https://nodejs.org/api/tls.html#tls_tls_connect_options_callback).
+Furthermore, the following options can be passed:
 
-```mjs
-import { buildConnector } from 'undici'
+* **socketPath** `string | null` (optional) - Default: `null` - An IPC endpoint, either Unix domain socket or Windows named pipe.
+* **maxCachedSessions** `number | null` (optional) - Default: `100` - Maximum number of TLS cached sessions. Use 0 to disable TLS session caching. Default: `100`.
+* **timeout** `number | null` (optional) -  In milliseconds. Default `10e3`.
+* **servername** `string | null` (optional)
 
-const connector = buildConnector({ rejectUnauthorized: false })
-```
+Once you call `buildConnector`, it will return a connector function, which takes the following parameters.
+
+#### Parameter: `connector.Options`
+
+* **hostname** `string` (required)
+* **host** `string` (optional)
+* **protocol** `string` (required)
+* **port** `string` (required)
+* **servername** `string` (optional)
+* **localAddress** `string | null` (optional) Local address the socket should connect from.
+* **httpSocket** `Socket` (optional) Establish secure connection on a given socket rather than creating a new socket. It can only be sent on TLS update.
+
+### Basic example
+
+```js
+'use strict'
 
-`buildConnector` accepts the same TLS options as
-[`tls.connect()`][tls.connect] in addition to the undici-specific options listed
-below, and returns a [`connector`](#connectoroptions-callback) function that
-undici invokes for each new connection.
-
-## `buildConnector([options])`
-
-<!-- YAML
-added: v5.23.4
--->
-
-* `options` {buildConnector.BuildOptions} (optional) Connection options. In
-  addition to every [`tls.connect()`][tls.connect] option, the following fields
-  are supported:
-  * `allowH2` {boolean} Whether to offer HTTP/2 (`h2`) during TLS ALPN
-    negotiation. **Default:** `true`.
-  * `preferH2` {boolean} Only effective together with `allowH2`. When `true`,
-    ALPN is offered as `['h2', 'http/1.1']` (HTTP/2 first) instead of the default
-    `['http/1.1', 'h2']`. Use this when the server selects the ALPN protocol by
-    *client* preference (for example, some load balancers) so that HTTP/2 is
-    negotiated whenever the server supports it. If the server does not support
-    HTTP/2, ALPN transparently falls back to `http/1.1`. **Default:** `false`.
-  * `maxCachedSessions` {number|null} Maximum number of TLS sessions to cache for
-    reuse. Use `0` to disable TLS session caching. Must be a non-negative
-    integer. **Default:** `100`.
-  * `socketPath` {string|null} An IPC endpoint, either a Unix domain socket or a
-    Windows named pipe. **Default:** `null`.
-  * `timeout` {number|null} The connection timeout in milliseconds. A
-    [`ConnectTimeoutError`][] is raised when the socket fails to connect within
-    this period. **Default:** `10e3`.
-  * `port` {number} The port to connect to when one is not provided to the
-    connector. Defaults to `443` for `https:` and `80` otherwise.
-  * `keepAlive` {boolean|null} Whether to enable TCP keep-alive on the socket.
-    **Default:** `true`.
-  * `keepAliveInitialDelay` {number|null} The delay in milliseconds before the
-    first TCP keep-alive probe is sent on an idle socket. **Default:** `60e3`.
-  * `typeOfService` {number|null} The IP Type of Service (ToS) value to set on
-    the socket. **Default:** `null`.
-* Returns: {buildConnector.connector} A
-  [`connector`](#connectoroptions-callback) function bound to the supplied
-  options.
-
-Builds a connector function. `maxCachedSessions` must be a non-negative integer
-or an [`InvalidArgumentError`][] is thrown.
-
-The returned function may be passed directly as the `connect` option of a
-[`Dispatcher`][], or wrapped to perform extra validation on each socket before it
-is handed back to undici.
-
-```mjs
 import { Client, buildConnector } from 'undici'
 
 const connector = buildConnector({ rejectUnauthorized: false })
-
 const client = new Client('https://localhost:3000', {
   connect (opts, cb) {
     connector(opts, (err, socket) => {
       if (err) {
         cb(err)
-      } else if (/* assertion */ false) {
+      } else if (/* assertion */) {
         socket.destroy()
         cb(new Error('kaboom'))
       } else {
@@ -92,53 +53,15 @@ const client = new Client('https://localhost:3000', {
 })
 ```
 
-## `connector(options, callback)`
-
-<!-- YAML
-added: v4.3.0
--->
-
-* `options` {Object} Per-connection options provided by undici.
-  * `hostname` {string} The host to connect to.
-  * `host` {string} (optional) The value of the request `Host` header, used to
-    derive the TLS `servername` when one is not supplied.
-  * `protocol` {string} The request protocol, for example `'https:'` or
-    `'http:'`. A value of `'https:'` establishes a TLS connection.
-  * `port` {string} The port to connect to. Defaults to `443` for `https:` and
-    `80` otherwise.
-  * `servername` {string} (optional) The TLS Server Name Indication (SNI) value.
-    Derived from `host` when omitted.
-  * `localAddress` {string|null} (optional) The local address the socket should
-    connect from.
-  * `httpSocket` {Socket} (optional) An existing socket on which to establish the
-    secure connection rather than creating a new one. May only be supplied for a
-    TLS upgrade (`protocol` of `'https:'`).
-* `callback` {Function} Called once the socket has connected or failed.
-  * `err` {Error|null} The connection error, or `null` on success.
-  * `socket` {Socket|TLSSocket|null} The connected socket, or `null` on failure.
-* Returns: {Socket|TLSSocket} The socket being established.
-
-The function returned by [`buildConnector()`](#buildconnectoroptions). undici
-calls it for every new connection. It opens a [`net.Socket`][] for `http:`
-targets or a [`tls.TLSSocket`][] for `https:` targets, applies TCP keep-alive and
-the connect timeout, and invokes `callback` once the socket connects or errors.
-The socket is also returned synchronously.
-
-When connecting over TLS, established sessions are cached (subject to
-`maxCachedSessions`) and reused for subsequent connections to the same
-`servername` or `hostname`.
-
 ### Example: validate the CA fingerprint
 
-A custom connector is a convenient place to verify the server certificate before
-any request is sent over the socket.
+```js
+'use strict'
 
-```mjs
 import { Client, buildConnector } from 'undici'
 
 const caFingerprint = 'FO:OB:AR'
 const connector = buildConnector({ rejectUnauthorized: false })
-
 const client = new Client('https://localhost:3000', {
   connect (opts, cb) {
     connector(opts, (err, socket) => {
@@ -173,26 +96,20 @@ client.request({
 function getIssuerCertificate (socket) {
   let certificate = socket.getPeerCertificate(true)
   while (certificate && Object.keys(certificate).length > 0) {
-    // Invalid certificate.
+    // invalid certificate
     if (certificate.issuerCertificate == null) {
       return null
     }
 
-    // We have reached the root certificate. In case of self-signed
-    // certificates, `issuerCertificate` may be a circular reference.
+    // We have reached the root certificate.
+    // In case of self-signed certificates, `issuerCertificate` may be a circular reference.
     if (certificate.fingerprint256 === certificate.issuerCertificate.fingerprint256) {
       break
     }
 
+    // continue the loop
     certificate = certificate.issuerCertificate
   }
   return certificate
 }
 ```
-
-[`ConnectTimeoutError`]: Errors.md#class-connecttimeouterror
-[`Dispatcher`]: Dispatcher.md#class-dispatcher
-[`InvalidArgumentError`]: Errors.md#class-invalidargumenterror
-[`net.Socket`]: https://nodejs.org/api/net.html#class-netsocket
-[`tls.TLSSocket`]: https://nodejs.org/api/tls.html#class-tlstlssocket
-[tls.connect]: https://nodejs.org/api/tls.html#tlsconnectoptions-callback

package/node_modules/undici/docs/docs/api/ContentType.md

@@ -1,51 +1,19 @@
 # MIME Type Parsing
 
-<!--introduced_in=v4.13.0-->
-<!--type=module-->
-<!-- source_link=lib/web/fetch/data-url.js -->
+## `MIMEType` interface
 
-> Stability: 2 - Stable
+* **type** `string`
+* **subtype** `string`
+* **parameters** `Map<string, string>`
+* **essence** `string`
 
-undici exposes helpers for parsing and serializing MIME types according to the
-WHATWG [MIME Sniffing Standard][]. These are the same primitives undici uses
-internally to interpret `Content-Type` headers and `data:` URLs.
-
-Import the functions from `'undici'`:
-
-```mjs
-import { parseMIMEType, serializeAMimeType } from 'undici'
-```
-
-A parsed MIME type is represented as a plain object with the following shape:
+## `parseMIMEType(input)`
 
-* `type` {string} The lowercased type, for example `'text'`.
-* `subtype` {string} The lowercased subtype, for example `'html'`.
-* `parameters` {Map<string, string>} The parameters, keyed by lowercased
-  parameter name.
-* `essence` {string} The concatenation of `type`, `'/'`, and `subtype`, for
-  example `'text/html'`.
+Implements [parse a MIME type](https://mimesniff.spec.whatwg.org/#parse-a-mime-type).
 
-## `parseMIMEType(input)`
+Parses a MIME type, returning its type, subtype, and any associated parameters. If the parser can't parse an input it returns the string literal `'failure'`.
 
-<!-- YAML
-added: v4.13.0
--->
-
-* `input` {string} The MIME type string to parse.
-* Returns: {Object|string} A parsed MIME type record, or the string literal
-  `'failure'` when `input` cannot be parsed.
-  * `type` {string} The lowercased type.
-  * `subtype` {string} The lowercased subtype.
-  * `parameters` {Map<string, string>} The parsed parameters, keyed by
-    lowercased parameter name.
-  * `essence` {string} The MIME type essence, `` `${type}/${subtype}` ``.
-
-Implements the WHATWG [parse a MIME type][] algorithm. The `type` and `subtype`
-are lowercased, and only the first occurrence of a duplicate parameter name is
-retained. When `input` is empty, lacks a `/`, or otherwise violates the grammar,
-the string literal `'failure'` is returned instead of a record.
-
-```mjs
+```js
 import { parseMIMEType } from 'undici'
 
 parseMIMEType('text/html; charset=gbk')
@@ -55,31 +23,21 @@ parseMIMEType('text/html; charset=gbk')
 //   parameters: Map(1) { 'charset' => 'gbk' },
 //   essence: 'text/html'
 // }
-
-parseMIMEType('not a mime type')
-// 'failure'
 ```
 
-## `serializeAMimeType(mimeType)`
+Arguments:
+
+* **input** `string`
+
+Returns: `MIMEType|'failure'`
 
-<!-- YAML
-added: v5.11.0
--->
+## `serializeAMimeType(input)`
 
-* `mimeType` {Object} A MIME type record, as returned by [`parseMIMEType()`][].
-  * `type` {string} The type.
-  * `subtype` {string} The subtype.
-  * `parameters` {Map<string, string>} The parameters to serialize, in
-    insertion order.
-  * `essence` {string} The MIME type essence, `` `${type}/${subtype}` ``.
-* Returns: {string} The serialized MIME type.
+Implements [serialize a MIME type](https://mimesniff.spec.whatwg.org/#serialize-a-mime-type).
 
-Implements the WHATWG [serialize a MIME type][] algorithm. The essence is
-emitted followed by each parameter as `;name=value`. A parameter value that
-contains characters outside the HTTP token set is quoted, and any `"` or `\`
-characters within it are escaped.
+Serializes a MIMEType object.
 
-```mjs
+```js
 import { serializeAMimeType } from 'undici'
 
 serializeAMimeType({
@@ -88,10 +46,12 @@ serializeAMimeType({
   parameters: new Map([['charset', 'gbk']]),
   essence: 'text/html'
 })
-// 'text/html;charset=gbk'
+// text/html;charset=gbk
+
 ```
 
-[MIME Sniffing Standard]: https://mimesniff.spec.whatwg.org/
-[`parseMIMEType()`]: #parsemimetypeinput
-[parse a MIME type]: https://mimesniff.spec.whatwg.org/#parse-a-mime-type
-[serialize a MIME type]: https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
+Arguments:
+
+* **mimeType** `MIMEType`
+
+Returns: `string`

package/node_modules/undici/docs/docs/api/Cookies.md

@@ -1,58 +1,44 @@
-# Cookies
+# Cookie Handling
 
-<!--introduced_in=v5.15.0-->
-<!--type=module-->
-<!-- source_link=lib/web/cookies/index.js -->
+## `Cookie` interface
 
-> Stability: 2 - Stable
+* **name** `string`
+* **value** `string`
+* **expires** `Date|number` (optional)
+* **maxAge** `number` (optional)
+* **domain** `string` (optional)
+* **path** `string` (optional)
+* **secure** `boolean` (optional)
+* **httpOnly** `boolean` (optional)
+* **sameSite** `'String'|'Lax'|'None'` (optional)
+* **unparsed** `string[]` (optional) Left over attributes that weren't parsed.
 
-A set of helpers for reading and writing HTTP cookies on a [`Headers`][]
-instance, following the [RFC 6265bis][] cookie parsing and serialization
-algorithm. They operate on the `Cookie` request header and the `Set-Cookie`
-response header.
+## `deleteCookie(headers, name[, attributes])`
+
+Sets the expiry time of the cookie to the unix epoch, causing browsers to delete it when received.
+
+```js
+import { deleteCookie, Headers } from 'undici'
 
-```mjs
-import { getCookies, setCookie, deleteCookie, getSetCookies, parseCookie } from 'undici'
+const headers = new Headers()
+deleteCookie(headers, 'name')
+
+console.log(headers.get('set-cookie')) // name=; Expires=Thu, 01 Jan 1970 00:00:00 GMT
 ```
 
-These functions do not manage a cookie jar or perform any network activity; they
-only read from and mutate the supplied `Headers` object.
-
-## `Cookie`
-
-The `Cookie` object describes a single cookie and its attributes. It is the
-return shape of [`parseCookie()`][] and [`getSetCookies()`][], and the input
-shape accepted by [`setCookie()`][].
-
-* `name` {string} The cookie name.
-* `value` {string} The cookie value.
-* `expires` {Date|number} The cookie expiry time, as a `Date` or a Unix
-  timestamp in seconds. (optional)
-* `maxAge` {number} The number of seconds until the cookie expires. (optional)
-* `domain` {string} The hosts the cookie is sent to. (optional)
-* `path` {string} The URL path that must exist for the cookie to be sent.
-  (optional)
-* `secure` {boolean} Whether the cookie is only sent over HTTPS. (optional)
-* `httpOnly` {boolean} Whether the cookie is inaccessible to client-side
-  JavaScript. (optional)
-* `sameSite` {string} Controls whether the cookie is sent with cross-site
-  requests. One of `'Strict'`, `'Lax'`, or `'None'`. (optional)
-* `unparsed` {string[]} Any attributes that were present in the `Set-Cookie`
-  header but not recognized, each formatted as `` `name=value` ``. (optional)
+Arguments:
 
-## `getCookies(headers)`
+* **headers** `Headers`
+* **name** `string`
+* **attributes** `{ path?: string, domain?: string }` (optional)
 
-<!-- YAML
-added: v5.15.0
--->
+Returns: `void`
 
-* `headers` {Headers} The `Headers` to read the `Cookie` header from.
-* Returns: {Record<string, string>} A map of cookie names to values.
+## `getCookies(headers)`
 
-Parses the `Cookie` header of `headers` and returns its name/value pairs as a
-plain object. An empty object is returned when no `Cookie` header is present.
+Parses the `Cookie` header and returns a list of attributes and values.
 
-```mjs
+```js
 import { getCookies, Headers } from 'undici'
 
 const headers = new Headers({
@@ -62,48 +48,17 @@ const headers = new Headers({
 console.log(getCookies(headers)) // { get: 'cookies', and: 'attributes' }
 ```
 
-## `deleteCookie(headers, name[, attributes])`
-
-<!-- YAML
-added: v5.15.0
--->
+Arguments:
 
-* `headers` {Headers} The `Headers` to append the expiring cookie to.
-* `name` {string} The name of the cookie to delete.
-* `attributes` {Object} (optional)
-  * `path` {string} The path the cookie was scoped to. **Default:** `null`.
-  * `domain` {string} The domain the cookie was scoped to. **Default:** `null`.
-* Returns: {undefined}
+* **headers** `Headers`
 
-Appends a `Set-Cookie` header to `headers` that expires the named cookie by
-setting its expiry time to the Unix epoch, causing a client to delete it on
-receipt. The optional `path` and `domain` must match those of the cookie being
-removed.
-
-```mjs
-import { deleteCookie, Headers } from 'undici'
-
-const headers = new Headers()
-deleteCookie(headers, 'name')
-
-console.log(headers.get('set-cookie')) // name=; Expires=Thu, 01 Jan 1970 00:00:00 GMT
-```
+Returns: `Record<string, string>`
 
 ## `getSetCookies(headers)`
 
-<!-- YAML
-added: v5.15.0
--->
+Parses all `Set-Cookie` headers.
 
-* `headers` {Headers} The `Headers` to read the `Set-Cookie` headers from.
-* Returns: {Cookie[]} The parsed cookies, or an empty array when none are
-  present.
-
-Parses every `Set-Cookie` header of `headers` and returns the resulting
-[`Cookie`][] objects. A header that fails to parse yields a `null` entry at its
-position in the returned array.
-
-```mjs
+```js
 import { getSetCookies, Headers } from 'undici'
 
 const headers = new Headers({ 'set-cookie': 'undici=getSetCookies; Secure' })
@@ -116,23 +71,20 @@ console.log(getSetCookies(headers))
 //     secure: true
 //   }
 // ]
+
 ```
 
-## `setCookie(headers, cookie)`
+Arguments:
 
-<!-- YAML
-added: v5.15.0
--->
+* **headers** `Headers`
 
-* `headers` {Headers} The `Headers` to append the `Set-Cookie` header to.
-* `cookie` {Cookie} The cookie to serialize. See [`Cookie`][].
-* Returns: {undefined}
+Returns: `Cookie[]`
 
-Serializes `cookie` and appends it to the `Set-Cookie` header of `headers`. When
-the cookie name is empty, serialization yields no value and no header is
-appended.
+## `setCookie(headers, cookie)`
+
+Appends a cookie to the `Set-Cookie` header.
 
-```mjs
+```js
 import { setCookie, Headers } from 'undici'
 
 const headers = new Headers()
@@ -141,39 +93,9 @@ setCookie(headers, { name: 'undici', value: 'setCookie' })
 console.log(headers.get('Set-Cookie')) // undici=setCookie
 ```
 
-## `parseCookie(cookie)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `cookie` {string} A `Set-Cookie` header value.
-* Returns: {Cookie|null} The parsed cookie, or `null` if `cookie` is invalid.
+Arguments:
 
-Parses a single `Set-Cookie` header value into a [`Cookie`][] object. `null` is
-returned when the value contains control characters or otherwise cannot be
-parsed.
-
-```mjs
-import { parseCookie } from 'undici'
-
-console.log(parseCookie('undici=getSetCookies; Secure; SameSite=Lax'))
-// {
-//   name: 'undici',
-//   value: 'getSetCookies',
-//   secure: true,
-//   sameSite: 'Lax'
-// }
-```
+* **headers** `Headers`
+* **cookie** `Cookie`
 
-The cookie value is returned exactly as it appears in the header; percent-encoded
-sequences such as `%20` or `%0D%0A` are not decoded. The `sameSite` attribute is
-only set when the value is a case-insensitive match for `Strict`, `Lax`, or
-`None`.
-
-[RFC 6265bis]: https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis
-[`Cookie`]: #cookie
-[`Headers`]: https://developer.mozilla.org/en-US/docs/Web/API/Headers
-[`getSetCookies()`]: #getsetcookiesheaders
-[`parseCookie()`]: #parsecookiecookie
-[`setCookie()`]: #setcookieheaders-cookie
+Returns: `void`

package/node_modules/undici/docs/docs/api/Debug.md

@@ -1,78 +1,62 @@
 # Debug
 
-<!--type=misc-->
+Undici (and subsenquently `fetch` and `websocket`) exposes a debug statement that can be enabled by setting `NODE_DEBUG` within the environment.
 
-Undici emits human-readable debug logs through Node.js' built-in
-[`util.debuglog()`][]. The logs are disabled by default and are turned on by
-listing one or more namespaces in the `NODE_DEBUG` environment variable. Because
-`util.debuglog()` reads `NODE_DEBUG` once, when the namespace is first used, the
-variable must be set before the process starts.
-
-Each log line is prefixed with the namespace (uppercased) and the process id,
-for example `UNDICI 16241: connecting to nodejs.org using https:h1`. Multiple
-namespaces can be enabled at once by separating them with commas, for example
-`NODE_DEBUG=undici,websocket`.
-
-The following sections describe the namespaces exposed by undici.
+The flags availabile are:
 
 ## `undici`
 
-Enables debug logs for the core undici library, covering connection setup,
-request dispatch, responses, and trailers. The `fetch` and `websocket` APIs are
-built on top of this core, so enabling `undici` also surfaces activity that
-originates from them.
+This flag enables debug statements for the core undici library.
+
+```sh
+NODE_DEBUG=undici node script.js
 
-```console
-$ NODE_DEBUG=undici node script.js
 UNDICI 16241: connecting to nodejs.org using https:h1
 UNDICI 16241: connecting to nodejs.org using https:h1
 UNDICI 16241: connected to nodejs.org using https:h1
-UNDICI 16241: sending request to GET https://nodejs.org/
-UNDICI 16241: received response to GET https://nodejs.org/ - HTTP 307
+UNDICI 16241: sending request to GET https://nodejs.org//
+UNDICI 16241: received response to GET https://nodejs.org// - HTTP 307
 UNDICI 16241: connecting to nodejs.org using https:h1
-UNDICI 16241: trailers received from GET https://nodejs.org/
+UNDICI 16241: trailers received from GET https://nodejs.org//
 UNDICI 16241: connected to nodejs.org using https:h1
-UNDICI 16241: sending request to GET https://nodejs.org/en
-UNDICI 16241: received response to GET https://nodejs.org/en - HTTP 200
-UNDICI 16241: trailers received from GET https://nodejs.org/en
+UNDICI 16241: sending request to GET https://nodejs.org//en
+UNDICI 16241: received response to GET https://nodejs.org//en - HTTP 200
+UNDICI 16241: trailers received from GET https://nodejs.org//en
 ```
 
 ## `fetch`
 
-Enables debug logs scoped to the `fetch` API. The output mirrors the `undici`
-namespace but is emitted only for requests made through [`fetch()`][], which
-makes it useful for isolating `fetch` traffic from other undici activity.
+This flag enables debug statements for the `fetch` API.
+
+> **Note**: statements are pretty similar to the ones in the `undici` flag, but scoped to `fetch`
+
+```sh
+NODE_DEBUG=fetch node script.js
 
-```console
-$ NODE_DEBUG=fetch node script.js
 FETCH 16241: connecting to nodejs.org using https:h1
 FETCH 16241: connecting to nodejs.org using https:h1
 FETCH 16241: connected to nodejs.org using https:h1
-FETCH 16241: sending request to GET https://nodejs.org/
-FETCH 16241: received response to GET https://nodejs.org/ - HTTP 307
+FETCH 16241: sending request to GET https://nodejs.org//
+FETCH 16241: received response to GET https://nodejs.org// - HTTP 307
 FETCH 16241: connecting to nodejs.org using https:h1
-FETCH 16241: trailers received from GET https://nodejs.org/
+FETCH 16241: trailers received from GET https://nodejs.org//
 FETCH 16241: connected to nodejs.org using https:h1
-FETCH 16241: sending request to GET https://nodejs.org/en
-FETCH 16241: received response to GET https://nodejs.org/en - HTTP 200
-FETCH 16241: trailers received from GET https://nodejs.org/en
+FETCH 16241: sending request to GET https://nodejs.org//en
+FETCH 16241: received response to GET https://nodejs.org//en - HTTP 200
+FETCH 16241: trailers received from GET https://nodejs.org//en
 ```
 
 ## `websocket`
 
-Enables debug logs scoped to the [`WebSocket`][] API, covering the opening
-handshake and connection lifecycle. When the `undici` or `fetch` namespace is
-also enabled, some lines may appear under both namespaces because the handshake
-is performed through the core library.
+This flag enables debug statements for the `Websocket` API.
+
+> **Note**: statements can overlap with `UNDICI` ones if `undici` or `fetch` flag has been enabled as well.
+
+```sh
+NODE_DEBUG=websocket node script.js
 
-```console
-$ NODE_DEBUG=websocket node script.js
 WEBSOCKET 18309: connecting to echo.websocket.org using https:h1
 WEBSOCKET 18309: connected to echo.websocket.org using https:h1
-WEBSOCKET 18309: sending request to GET https://echo.websocket.org/
+WEBSOCKET 18309: sending request to GET https://echo.websocket.org//
 WEBSOCKET 18309: connection opened <ip_address>
 ```
-
-[`WebSocket`]: WebSocket.md#class-websocket
-[`fetch()`]: Fetch.md
-[`util.debuglog()`]: https://nodejs.org/api/util.html#utildebuglogsection-callback