@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/undici/docs/docs/api/api-lifecycle.md

@@ -1,56 +1,34 @@
 # Client Lifecycle
 
-<!--type=misc-->
-
-A {Client} can be understood as a state machine. As requests are dispatched,
-processed, and drained, the client moves through a well-defined set of states
-until it is eventually destroyed. This document describes those states and the
-transitions between them.
-
-The {Client} class is not literally implemented as a state machine, so the
-actual execution may deviate slightly from what is described here. Treat this
-guide as a conceptual model for reasoning about a client's behavior rather than
-as a formal specification.
-
-## State transition overview
-
-* A {Client} begins in the **idle** state with no socket connection and no
-  queued requests.
-  * The *connect* transition moves the {Client} to the **pending** state, where
-    requests can be queued before they are processed.
-  * Calling [`client.close()`][] or [`client.destroy()`][] moves the {Client}
-    to the **destroyed** state. Because there are no queued requests in this
-    state, *close* transitions straight to **destroyed**.
-* The **pending** state indicates that the underlying socket connection has been
-  established and that requests are queueing.
-  * The *process* transition moves the {Client} to the **processing** state,
-    where requests are processed.
-  * If requests are queued, *close* transitions to **processing**; otherwise it
-    transitions to **destroyed**.
-  * The *destroy* transition moves the {Client} to **destroyed**.
-* The **processing** state initializes to the **processing.running** sub-state.
-  * If the current request body requires draining, *needDrain* moves the
-    {Client} into the **processing.busy** sub-state, which returns to
-    **processing.running** once *drainComplete* fires.
-  * After all queued requests complete, *keepalive* moves the {Client} back to
-    the **pending** state. If no requests are queued before the socket times
-    out, the {Client} transitions to **idle**.
-  * If *close* is fired while the {Client} still has queued requests, the
-    {Client} transitions to **processing.closing**, where it completes all
-    outstanding requests before firing *done*.
-  * The *done* transition moves the {Client} gracefully to **destroyed**.
-  * At any time, *destroy* moves the {Client} from **processing** to
-    **destroyed**, aborting any queued requests.
-* The **destroyed** state is final; the {Client} is no longer functional.
-
-A state diagram representing a {Client} instance:
+An Undici [Client](Client.md) can be best described as a state machine. The following list is a summary of the various state transitions the `Client` will go through in its lifecycle. This document also contains detailed breakdowns of each state.
+
+> This diagram is not a perfect representation of the undici Client. Since the Client class is not actually implemented as a state-machine, actual execution may deviate slightly from what is described below. Consider this as a general resource for understanding the inner workings of the Undici client rather than some kind of formal specification.
+
+## State Transition Overview
+
+* A `Client` begins in the **idle** state with no socket connection and no requests in queue.
+  * The *connect* event transitions the `Client` to the **pending** state where requests can be queued prior to processing.
+  * The *close* and *destroy* events transition the `Client` to the **destroyed** state. Since there are no requests in the queue, the *close* event immediately transitions to the **destroyed** state.
+* The **pending** state indicates the underlying socket connection has been successfully established and requests are queueing.
+  * The *process* event transitions the `Client` to the **processing** state where requests are processed.
+  * If requests are queued, the *close* event transitions to the **processing** state; otherwise, it transitions to the **destroyed** state.
+  * The *destroy* event transitions to the **destroyed** state.
+* The **processing** state initializes to the **processing.running** state.
+  * If the current request requires draining, the *needDrain* event transitions the `Client` into the **processing.busy** state which will return to the **processing.running** state with the *drainComplete* event.
+  * After all queued requests are completed, the *keepalive* event transitions the `Client` back to the **pending** state. If no requests are queued during the timeout, the **close** event transitions the `Client` to the **destroyed** state.
+  * If the *close* event is fired while the `Client` still has queued requests, the `Client` transitions to the **process.closing** state where it will complete all existing requests before firing the *done* event.
+  * The *done* event gracefully transitions the `Client` to the **destroyed** state.
+  * At any point in time, the *destroy* event will transition the `Client` from the **processing** state to the **destroyed** state, destroying any queued requests.
+* The **destroyed** state is a final state and the `Client` is no longer functional.
+
+A state diagram representing an Undici Client instance:
 
 ```mermaid
 stateDiagram-v2
   [*] --> idle
   idle --> pending : connect
   idle --> destroyed : destroy/close
-
+  
   pending --> idle : timeout
   pending --> destroyed : destroy
 
@@ -76,84 +54,38 @@ stateDiagram-v2
       closing --> [*] : done
   }
 ```
-
 ## State details
 
 ### idle
 
-**idle** is the initial state of a {Client} instance. Although an `origin` is
-required to construct a {Client}, the underlying socket connection is not
-established until a request is queued through [`client.dispatch()`][]. Calling
-`client.dispatch()` directly, or through one of its higher-level wrappers
-([`client.connect()`][], [`client.pipeline()`][], [`client.request()`][],
-[`client.stream()`][], or [`client.upgrade()`][]), moves the {Client} from
-**idle** to **pending**, and then usually directly on to **processing**.
+The **idle** state is the initial state of a `Client` instance. While an `origin` is required for instantiating a `Client` instance, the underlying socket connection will not be established until a request is queued using [`Client.dispatch()`](Client.md#clientdispatchoptions-handlers). By calling `Client.dispatch()` directly or using one of the multiple implementations ([`Client.connect()`](Client.md#clientconnectoptions-callback), [`Client.pipeline()`](Client.md#clientpipelineoptions-handler), [`Client.request()`](Client.md#clientrequestoptions-callback), [`Client.stream()`](Client.md#clientstreamoptions-factory-callback), and [`Client.upgrade()`](Client.md#clientupgradeoptions-callback)), the `Client` instance will transition from **idle** to [**pending**](#pending) and then most likely directly to [**processing**](#processing).
 
-Calling [`client.close()`][] or [`client.destroy()`][] in this state moves the
-{Client} straight to **destroyed**, since there are no queued requests.
+Calling [`Client.close()`](Client.md#clientclosecallback) or [`Client.destroy()`](Client.md#clientdestroyerror-callback) transitions directly to the [**destroyed**](#destroyed) state since the `Client` instance will have no queued requests in this state.
 
 ### pending
 
-**pending** signifies a connected but non-processing {Client}. On entering this
-state, the {Client} establishes a socket connection and emits the
-[`'connect'`][] event, signalling that a connection to the `origin` supplied at
-construction time has been established. The internal queue starts empty, and
-requests can begin queueing.
+The **pending** state signifies a non-processing `Client`. Upon entering this state, the `Client` establishes a socket connection and emits the [`'connect'`](Client.md#event-connect) event signalling a connection was successfully established with the `origin` provided during `Client` instantiation. The internal queue is initially empty, and requests can start queueing.
 
-Calling [`client.close()`][] with queued requests moves the {Client} to the
-**processing** state; without queued requests it moves to **destroyed**.
+Calling [`Client.close()`](Client.md#clientclosecallback) with queued requests, transitions the `Client` to the [**processing**](#processing) state. Without queued requests, it transitions to the [**destroyed**](#destroyed) state.
 
-Calling [`client.destroy()`][] moves the {Client} directly to **destroyed**,
-regardless of any queued requests.
+Calling [`Client.destroy()`](Client.md#clientdestroyerror-callback) transitions directly to the [**destroyed**](#destroyed) state regardless of existing requests.
 
 ### processing
 
-**processing** is itself a sub-state machine that initializes to the
-**processing.running** sub-state. [`client.dispatch()`][], [`client.close()`][],
-and [`client.destroy()`][] can all be called while the {Client} is in this
-state. `client.dispatch()` queues additional requests while existing ones
-continue to be processed, `client.close()` moves the {Client} to the
-**processing.closing** sub-state, and `client.destroy()` moves it to
-**destroyed**.
+The **processing** state is a state machine within itself. It initializes to the [**processing.running**](#running) state. The [`Client.dispatch()`](Client.md#clientdispatchoptions-handlers), [`Client.close()`](Client.md#clientclosecallback), and [`Client.destroy()`](Client.md#clientdestroyerror-callback) can be called at any time while the `Client` is in this state. `Client.dispatch()` will add more requests to the queue while existing requests continue to be processed. `Client.close()` will transition to the [**processing.closing**](#closing) state. And `Client.destroy()` will transition to [**destroyed**](#destroyed).
 
 #### running
 
-In **processing.running**, queued requests are processed in FIFO order. If a
-request body requires draining, *needDrain* moves the {Client} to the
-**processing.busy** sub-state. The *close* transition moves the {Client} to the
-**processing.closing** sub-state. When all queued requests have completed and
-neither [`client.close()`][] nor [`client.destroy()`][] has been called, the
-*keepalive* transition moves the {Client} back to the **pending** state. There
-the {Client} waits for the socket connection to time out; once it does, the
-{Client} returns to the **idle** state.
+In the **processing.running** sub-state, queued requests are being processed in a FIFO order. If a request body requires draining, the *needDrain* event transitions to the [**processing.busy**](#busy) sub-state. The *close* event transitions the Client to the [**process.closing**](#closing) sub-state. If all queued requests are processed and neither [`Client.close()`](Client.md#clientclosecallback) nor [`Client.destroy()`](Client.md#clientdestroyerror-callback) are called, then the [**processing**](#processing) machine will trigger a *keepalive* event transitioning the `Client` back to the [**pending**](#pending) state. During this time, the `Client` is waiting for the socket connection to timeout, and once it does, it triggers the *timeout* event and transitions to the [**idle**](#idle) state.
 
 #### busy
 
-This sub-state is entered only when a request body is a {stream.Readable} that
-requires draining. The {Client} cannot process additional requests while in
-this state and waits until the current request body has been fully drained
-before returning to **processing.running**.
+This sub-state is only entered when a request body is an instance of [Stream](https://nodejs.org/api/stream.html) and requires draining. The `Client` cannot process additional requests while in this state and must wait until the currently processing request body is completely drained before transitioning back to [**processing.running**](#running).
 
 #### closing
 
-This sub-state is entered only when a {Client} has queued requests and
-[`client.close()`][] is called. The {Client} continues to process requests as
-usual, except that no additional requests may be queued. Once all queued
-requests have been processed, *done* fires and the {Client} moves gracefully to
-**destroyed** without an error.
+This sub-state is only entered when a `Client` instance has queued requests and the [`Client.close()`](Client.md#clientclosecallback) method is called. In this state, the `Client` instance continues to process requests as usual, with the one exception that no additional requests can be queued. Once all of the queued requests are processed, the `Client` will trigger the *done* event gracefully entering the [**destroyed**](#destroyed) state without an error.
 
 ### destroyed
 
-**destroyed** is the final state of a {Client} instance. Once in this state, the
-{Client} is no longer functional, and calling any further {Client} method
-rejects or fails with a {ClientDestroyedError}.
-
-[`'connect'`]: Client.md#event-connect
-[`client.close()`]: Client.md#clientclosecallback
-[`client.connect()`]: Client.md#clientconnectoptions-callback
-[`client.destroy()`]: Client.md#clientdestroyerror-callback
-[`client.dispatch()`]: Client.md#clientdispatchoptions-handlers
-[`client.pipeline()`]: Client.md#clientpipelineoptions-handler
-[`client.request()`]: Client.md#clientrequestoptions-callback
-[`client.stream()`]: Client.md#clientstreamoptions-factory-callback
-[`client.upgrade()`]: Client.md#clientupgradeoptions-callback
+The **destroyed** state is a final state for the `Client` instance. Once in this state, a `Client` is nonfunctional. Calling any other `Client` methods will result in an `ClientDestroyedError`.

package/node_modules/undici/docs/docs/best-practices/client-certificate.md

@@ -1,7 +1,5 @@
 # Client certificate
 
-<!--type=misc-->
-
 Client certificate authentication can be configured with the `Client`, the required options are passed along through the `connect` option.
 
 The client certificates must be signed by a trusted CA. The Node.js default is to trust the well-known CAs curated by Mozilla.

package/node_modules/undici/docs/docs/best-practices/mocking-request.md

@@ -1,7 +1,5 @@
 # Mocking Request
 
-<!--type=misc-->
-
 Undici has its own mocking [utility](../api/MockAgent.md). It allow us to intercept undici HTTP requests and return mocked values instead. It can be useful for testing purposes.
 
 Example:
@@ -31,7 +29,7 @@ And this is what the test file looks like:
 
 ```js
 // index.test.mjs
-import { strict as assert } from 'node:assert'
+import { strict as assert } from 'assert'
 import { MockAgent, setGlobalDispatcher, } from 'undici'
 import { bankTransfer } from './bank.mjs'
 
@@ -77,60 +75,6 @@ assert.deepEqual(badRequest, { message: 'bank account not found' })
 
 Explore other MockAgent functionality [here](../api/MockAgent.md)
 
-## Access agent call history
-
-Using a MockAgent also allows you to make assertions on the configuration used to make your request in your application.
-
-Here is an example :
-
-```js
-// index.test.mjs
-import { strict as assert } from 'node:assert'
-import { MockAgent, setGlobalDispatcher, fetch } from 'undici'
-import { app } from './app.mjs'
-
-// given an application server running on http://localhost:3000
-await app.start()
-
-// enable call history at instantiation
-const mockAgent = new MockAgent({ enableCallHistory: true })
-// or after instantiation
-mockAgent.enableCallHistory()
-
-setGlobalDispatcher(mockAgent)
-
-// this call is made (not intercepted)
-await fetch(`http://localhost:3000/endpoint?query='hello'`, {
-  method: 'POST',
-  headers: { 'content-type': 'application/json' },
-  body: JSON.stringify({ data: '' })
-})
-
-// access to the call history of the MockAgent (which register every call made intercepted or not)
-assert.ok(mockAgent.getCallHistory()?.calls().length === 1)
-assert.strictEqual(mockAgent.getCallHistory()?.firstCall()?.fullUrl, `http://localhost:3000/endpoint?query='hello'`)
-assert.strictEqual(mockAgent.getCallHistory()?.firstCall()?.body, JSON.stringify({ data: '' }))
-assert.deepStrictEqual(mockAgent.getCallHistory()?.firstCall()?.searchParams, { query: 'hello' })
-assert.strictEqual(mockAgent.getCallHistory()?.firstCall()?.port, '3000')
-assert.strictEqual(mockAgent.getCallHistory()?.firstCall()?.host, 'localhost:3000')
-assert.strictEqual(mockAgent.getCallHistory()?.firstCall()?.method, 'POST')
-assert.strictEqual(mockAgent.getCallHistory()?.firstCall()?.path, '/endpoint')
-assert.deepStrictEqual(mockAgent.getCallHistory()?.firstCall()?.headers, { 'content-type': 'application/json' })
-
-// clear all call history logs
-mockAgent.clearCallHistory()
-
-assert.ok(mockAgent.getCallHistory()?.calls().length === 0)
-```
-
-Calling `mockAgent.close()` will automatically clear and delete every call history for you.
-
-Explore other MockAgent functionality [here](../api/MockAgent.md)
-
-Explore other MockCallHistory functionality [here](../api/MockCallHistory.md)
-
-Explore other MockCallHistoryLog functionality [here](../api/MockCallHistoryLog.md)
-
 ## Debug Mock Value
 
 When the interceptor and the request options are not the same, undici will automatically make a real HTTP request. To prevent real requests from being made, use `mockAgent.disableNetConnect()`:
@@ -181,7 +125,7 @@ mockPool.intercept({
 
 in this case opts will be
 
-```js
+```
 {
   method: 'POST',
   headers: { 'X-TOKEN-SECRET': 'SuperSecretToken' },

package/node_modules/undici/docs/docs/best-practices/proxy.md

@@ -1,10 +1,8 @@
 # Connecting through a proxy
 
-<!--type=misc-->
-
 Connecting through a proxy is possible by:
 
-- Using {ProxyAgent}.
+- Using [ProxyAgent](../api/ProxyAgent.md).
 - Configuring `Client` or `Pool` constructor.
 
 The proxy url should be passed to the `Client` or `Pool` constructor, while the upstream server url

package/node_modules/undici/docs/docs/best-practices/writing-tests.md

@@ -1,7 +1,5 @@
 # Writing tests
 
-<!--type=misc-->
-
 Undici is tuned for a production use case and its default will keep
 a socket open for a few seconds after an HTTP request is completed to
 remove the overhead of opening up a new socket. These settings that makes
@@ -20,46 +18,3 @@ const agent = new Agent({
 
 setGlobalDispatcher(agent)
 ```
-
-## Guarding against unexpected disconnects
-
-Undici's `Client` automatically reconnects after a socket error. This means
-a test can silently disconnect, reconnect, and still pass. Unfortunately, 
-this could mask bugs like unexpected parser errors or protocol violations.
-To catch these silent reconnections, add a disconnect guard after creating 
-a `Client`:
-
-```js
-const { Client } = require('undici')
-const { test, after } = require('node:test')
-const { tspl } = require('@matteo.collina/tspl')
-
-test('example with disconnect guard', async (t) => {
-  t = tspl(t, { plan: 1 })
-
-  const client = new Client('http://localhost:3000')
-  after(() => client.close())
-
-  client.on('disconnect', () => {
-    if (!client.closed && !client.destroyed) {
-      t.fail('unexpected disconnect')
-    }
-  })
-
-  // ... test logic ...
-})
-```
-
-`client.close()` and `client.destroy()` both emit `'disconnect'` events, but
-those are expected. The guard only fails when a disconnect happens during the
-active test (i.e., `!client.closed && !client.destroyed` is true).
-
-Skip the guard for tests where a disconnect is expected behavior, such as:
-
-- Signal aborts (`signal.emit('abort')`, `ac.abort()`)
-- Server-side destruction (`res.destroy()`, `req.socket.destroy()`)
-- Client-side body destruction mid-stream (`data.body.destroy()`)
-- Timeout errors (`HeadersTimeoutError`, `BodyTimeoutError`)
-- Successful upgrades (the socket is detached from the `Client`)
-- Retry/reconnect tests where the disconnect triggers the retry
-- HTTP parser errors from malformed responses (`HTTPParserError`)

package/node_modules/undici/index-fetch.js

@@ -4,40 +4,10 @@ const { getGlobalDispatcher, setGlobalDispatcher } = require('./lib/global')
 const EnvHttpProxyAgent = require('./lib/dispatcher/env-http-proxy-agent')
 const fetchImpl = require('./lib/web/fetch').fetch
 
-// Capture __filename at module load time for stack trace augmentation.
-// This may be undefined when bundled in environments like Node.js internals.
-const currentFilename = typeof __filename !== 'undefined' ? __filename : undefined
-
-function appendFetchStackTrace (err, filename) {
-  if (!err || typeof err !== 'object') {
-    return
-  }
-
-  const stack = typeof err.stack === 'string' ? err.stack : ''
-  const normalizedFilename = filename.replace(/\\/g, '/')
-
-  if (stack && (stack.includes(filename) || stack.includes(normalizedFilename))) {
-    return
-  }
-
-  const capture = {}
-  Error.captureStackTrace(capture, appendFetchStackTrace)
-
-  if (!capture.stack) {
-    return
-  }
-
-  const captureLines = capture.stack.split('\n').slice(1).join('\n')
-
-  err.stack = stack ? `${stack}\n${captureLines}` : capture.stack
-}
-
-module.exports.fetch = function fetch (init, options = undefined) {
-  return fetchImpl(init, options).catch(err => {
-    if (currentFilename) {
-      appendFetchStackTrace(err, currentFilename)
-    } else if (err && typeof err === 'object') {
-      Error.captureStackTrace(err, module.exports.fetch)
+module.exports.fetch = function fetch (resource, init = undefined) {
+  return fetchImpl(resource, init).catch((err) => {
+    if (err && typeof err === 'object') {
+      Error.captureStackTrace(err)
     }
     throw err
   })

package/node_modules/undici/index.d.ts

@@ -1,3 +1,3 @@
+export * from './types/index'
 import Undici from './types/index'
 export default Undici
-export * from './types/index'

package/node_modules/undici/index.js

@@ -4,29 +4,24 @@ const Client = require('./lib/dispatcher/client')
 const Dispatcher = require('./lib/dispatcher/dispatcher')
 const Pool = require('./lib/dispatcher/pool')
 const BalancedPool = require('./lib/dispatcher/balanced-pool')
-const RoundRobinPool = require('./lib/dispatcher/round-robin-pool')
 const Agent = require('./lib/dispatcher/agent')
-const Dispatcher1Wrapper = require('./lib/dispatcher/dispatcher1-wrapper')
 const ProxyAgent = require('./lib/dispatcher/proxy-agent')
-const Socks5ProxyAgent = require('./lib/dispatcher/socks5-proxy-agent')
 const EnvHttpProxyAgent = require('./lib/dispatcher/env-http-proxy-agent')
 const RetryAgent = require('./lib/dispatcher/retry-agent')
-const H2CClient = require('./lib/dispatcher/h2c-client')
 const errors = require('./lib/core/errors')
 const util = require('./lib/core/util')
 const { InvalidArgumentError } = errors
 const api = require('./lib/api')
 const buildConnector = require('./lib/core/connect')
 const MockClient = require('./lib/mock/mock-client')
-const { MockCallHistory, MockCallHistoryLog } = require('./lib/mock/mock-call-history')
 const MockAgent = require('./lib/mock/mock-agent')
 const MockPool = require('./lib/mock/mock-pool')
-const SnapshotAgent = require('./lib/mock/snapshot-agent')
 const mockErrors = require('./lib/mock/mock-errors')
 const RetryHandler = require('./lib/handler/retry-handler')
 const { getGlobalDispatcher, setGlobalDispatcher } = require('./lib/global')
 const DecoratorHandler = require('./lib/handler/decorator-handler')
 const RedirectHandler = require('./lib/handler/redirect-handler')
+const createRedirectInterceptor = require('./lib/interceptor/redirect-interceptor')
 
 Object.assign(Dispatcher.prototype, api)
 
@@ -34,36 +29,22 @@ module.exports.Dispatcher = Dispatcher
 module.exports.Client = Client
 module.exports.Pool = Pool
 module.exports.BalancedPool = BalancedPool
-module.exports.RoundRobinPool = RoundRobinPool
 module.exports.Agent = Agent
-module.exports.Dispatcher1Wrapper = Dispatcher1Wrapper
 module.exports.ProxyAgent = ProxyAgent
-module.exports.Socks5ProxyAgent = Socks5ProxyAgent
 module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent
 module.exports.RetryAgent = RetryAgent
-module.exports.H2CClient = H2CClient
 module.exports.RetryHandler = RetryHandler
 
 module.exports.DecoratorHandler = DecoratorHandler
 module.exports.RedirectHandler = RedirectHandler
+module.exports.createRedirectInterceptor = createRedirectInterceptor
 module.exports.interceptors = {
   redirect: require('./lib/interceptor/redirect'),
-  responseError: require('./lib/interceptor/response-error'),
   retry: require('./lib/interceptor/retry'),
   dump: require('./lib/interceptor/dump'),
-  dns: require('./lib/interceptor/dns'),
-  cache: require('./lib/interceptor/cache'),
-  decompress: require('./lib/interceptor/decompress'),
-  deduplicate: require('./lib/interceptor/deduplicate')
+  dns: require('./lib/interceptor/dns')
 }
 
-module.exports.cacheStores = {
-  MemoryCacheStore: require('./lib/cache/memory-cache-store')
-}
-
-const SqliteCacheStore = require('./lib/cache/sqlite-cache-store')
-module.exports.cacheStores.SqliteCacheStore = SqliteCacheStore
-
 module.exports.buildConnector = buildConnector
 module.exports.errors = errors
 module.exports.util = {
@@ -105,14 +86,14 @@ function makeDispatcher (fn) {
       url = util.parseURL(url)
     }
 
-    const { agent, dispatcher = getGlobalDispatcher(), ...restOpts } = opts
+    const { agent, dispatcher = getGlobalDispatcher() } = opts
 
     if (agent) {
       throw new InvalidArgumentError('unsupported opts.agent. Did you mean opts.client?')
     }
 
     return fn.call(dispatcher, {
-      ...restOpts,
+      ...opts,
       origin: url.origin,
       path: url.search ? `${url.pathname}${url.search}` : url.pathname,
       method: opts.method || (opts.body ? 'PUT' : 'GET')
@@ -124,49 +105,23 @@ module.exports.setGlobalDispatcher = setGlobalDispatcher
 module.exports.getGlobalDispatcher = getGlobalDispatcher
 
 const fetchImpl = require('./lib/web/fetch').fetch
-
-// Capture __filename at module load time for stack trace augmentation.
-// This may be undefined when bundled in environments like Node.js internals.
-const currentFilename = typeof __filename !== 'undefined' ? __filename : undefined
-
-function appendFetchStackTrace (err, filename) {
-  if (!err || typeof err !== 'object') {
-    return
-  }
-
-  const stack = typeof err.stack === 'string' ? err.stack : ''
-  const normalizedFilename = filename.replace(/\\/g, '/')
-
-  if (stack && (stack.includes(filename) || stack.includes(normalizedFilename))) {
-    return
-  }
-
-  const capture = {}
-  Error.captureStackTrace(capture, appendFetchStackTrace)
-
-  if (!capture.stack) {
-    return
-  }
-
-  const captureLines = capture.stack.split('\n').slice(1).join('\n')
-
-  err.stack = stack ? `${stack}\n${captureLines}` : capture.stack
-}
-
-module.exports.fetch = function fetch (init, options = undefined) {
-  return fetchImpl(init, options).catch(err => {
-    if (currentFilename) {
-      appendFetchStackTrace(err, currentFilename)
-    } else if (err && typeof err === 'object') {
-      Error.captureStackTrace(err, module.exports.fetch)
+module.exports.fetch = async function fetch (init, options = undefined) {
+  try {
+    return await fetchImpl(init, options)
+  } catch (err) {
+    if (err && typeof err === 'object') {
+      Error.captureStackTrace(err)
     }
+
     throw err
-  })
+  }
 }
 module.exports.Headers = require('./lib/web/fetch/headers').Headers
 module.exports.Response = require('./lib/web/fetch/response').Response
 module.exports.Request = require('./lib/web/fetch/request').Request
 module.exports.FormData = require('./lib/web/fetch/formdata').FormData
+module.exports.File = globalThis.File ?? require('node:buffer').File
+module.exports.FileReader = require('./lib/web/fileapi/filereader').FileReader
 
 const { setGlobalOrigin, getGlobalOrigin } = require('./lib/web/fetch/global')
 
@@ -174,17 +129,18 @@ module.exports.setGlobalOrigin = setGlobalOrigin
 module.exports.getGlobalOrigin = getGlobalOrigin
 
 const { CacheStorage } = require('./lib/web/cache/cachestorage')
-const { kConstruct } = require('./lib/core/symbols')
+const { kConstruct } = require('./lib/web/cache/symbols')
 
+// Cache & CacheStorage are tightly coupled with fetch. Even if it may run
+// in an older version of Node, it doesn't have any use without fetch.
 module.exports.caches = new CacheStorage(kConstruct)
 
-const { deleteCookie, getCookies, getSetCookies, setCookie, parseCookie } = require('./lib/web/cookies')
+const { deleteCookie, getCookies, getSetCookies, setCookie } = require('./lib/web/cookies')
 
 module.exports.deleteCookie = deleteCookie
 module.exports.getCookies = getCookies
 module.exports.getSetCookies = getSetCookies
 module.exports.setCookie = setCookie
-module.exports.parseCookie = parseCookie
 
 const { parseMIMEType, serializeAMimeType } = require('./lib/web/fetch/data-url')
 
@@ -192,15 +148,10 @@ module.exports.parseMIMEType = parseMIMEType
 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.WebSocket = require('./lib/web/websocket/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
 
 module.exports.request = makeDispatcher(api.request)
 module.exports.stream = makeDispatcher(api.stream)
@@ -209,28 +160,10 @@ module.exports.connect = makeDispatcher(api.connect)
 module.exports.upgrade = makeDispatcher(api.upgrade)
 
 module.exports.MockClient = MockClient
-module.exports.MockCallHistory = MockCallHistory
-module.exports.MockCallHistoryLog = MockCallHistoryLog
 module.exports.MockPool = MockPool
 module.exports.MockAgent = MockAgent
-module.exports.SnapshotAgent = SnapshotAgent
 module.exports.mockErrors = mockErrors
 
 const { EventSource } = require('./lib/web/eventsource/eventsource')
 
 module.exports.EventSource = EventSource
-
-function install () {
-  globalThis.fetch = module.exports.fetch
-  globalThis.Headers = module.exports.Headers
-  globalThis.Response = module.exports.Response
-  globalThis.Request = module.exports.Request
-  globalThis.FormData = module.exports.FormData
-  globalThis.WebSocket = module.exports.WebSocket
-  globalThis.CloseEvent = module.exports.CloseEvent
-  globalThis.ErrorEvent = module.exports.ErrorEvent
-  globalThis.MessageEvent = module.exports.MessageEvent
-  globalThis.EventSource = module.exports.EventSource
-}
-
-module.exports.install = install

package/node_modules/undici/lib/api/abort-signal.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { addAbortListener } = require('../core/util')
 const { RequestAbortedError } = require('../core/errors')