@nxtedition/nxt-undici 2.2.7 → 3.0.1

package/lib/index.js

@@ -1,10 +1,5 @@
-import assert from 'node:assert'
-import createError from 'http-errors'
-import undici from 'undici'
-import { parseHeaders, AbortError, isStream } from './utils.js'
-import { BodyReadable } from './readable.js'
-
-export { parseHeaders } from './utils.js'
+import undici from '@nxtedition/undici'
+import { parseHeaders } from './utils.js'
 
 const dispatcherCache = new WeakMap()
 
@@ -18,6 +13,7 @@ export const interceptors = {
   proxy: (await import('./interceptor/proxy.js')).default,
   cache: (await import('./interceptor/cache.js')).default,
   requestId: (await import('./interceptor/request-id.js')).default,
+  dns: (await import('./interceptor/dns.js')).default,
 }
 
 export async function request(url, opts) {
@@ -55,180 +51,44 @@ export async function request(url, opts) {
     headers['user-agent'] = userAgent
   }
 
-  if (method === 'CONNECT') {
-    throw new createError.MethodNotAllowed()
-  }
-
-  // TODO (fix): Move into undici?
-  if (
-    headers != null &&
-    (method === 'HEAD' || method === 'GET') &&
-    (parseInt(headers['content-length']) > 0 || headers['transfer-encoding'])
-  ) {
-    throw new createError.BadRequest('HEAD and GET cannot have body')
-  }
-
-  // TODO (fix): Move into undici?
-  if (
-    opts.body != null &&
-    (opts.body.size > 0 || opts.body.length > 0) &&
-    (method === 'HEAD' || method === 'GET')
-  ) {
-    throw new createError.BadRequest('HEAD and GET cannot have body')
-  }
-
-  const expectsPayload = opts.method === 'PUT' || opts.method === 'POST' || opts.method === 'PATCH'
-
-  if (headers != null && headers['content-length'] === '0' && !expectsPayload) {
-    // https://tools.ietf.org/html/rfc7230#section-3.3.2
-    // A user agent SHOULD NOT send a Content-Length header field when
-    // the request message does not contain a payload body and the method
-    // semantics do not anticipate such a body.
-
-    // undici will error if provided an unexpected content-length: 0 header.
-    delete headers['content-length']
-  }
-
-  if (isStream(opts.body)) {
-    // TODO (fix): Remove this somehow?
-    // Workaround: https://github.com/nodejs/undici/pull/2497
-    opts.body.on('error', () => {})
+  const baseDispatcher = opts.dispatcher ?? undici.getGlobalDispatcher()
+
+  let dispatcher = dispatcherCache.get(baseDispatcher)
+  if (dispatcher == null) {
+    dispatcher = baseDispatcher.compose(
+      interceptors.responseError(),
+      interceptors.requestBodyFactory(),
+      interceptors.log(),
+      interceptors.dns(),
+      interceptors.requestId(),
+      interceptors.responseRetry(),
+      interceptors.responseVerify(),
+      interceptors.redirect(),
+      interceptors.cache(),
+      interceptors.proxy(),
+    )
+    dispatcherCache.set(baseDispatcher, dispatcher)
   }
 
-  const dispatcher = opts.dispatcher ?? undici.getGlobalDispatcher()
-
-  let dispatch = dispatcherCache.get(dispatcher)
-  if (dispatch == null) {
-    dispatch = (opts, handler) => dispatcher.dispatch(opts, handler)
-    dispatch = interceptors.responseError(dispatch)
-    dispatch = interceptors.requestBodyFactory(dispatch)
-    dispatch = interceptors.log(dispatch)
-    dispatch = interceptors.requestId(dispatch)
-    dispatch = interceptors.responseRetry(dispatch)
-    dispatch = interceptors.responseVerify(dispatch)
-    dispatch = interceptors.redirect(dispatch)
-    dispatch = interceptors.cache(dispatch)
-    dispatch = interceptors.proxy(dispatch)
-    dispatcherCache.set(dispatcher, dispatch)
-  }
-
-  return await new Promise((resolve, reject) =>
-    dispatch(
-      {
-        id: opts.id,
-        url,
-        method,
-        body: opts.body,
-        query: opts.query,
-        headers,
-        origin: url.origin,
-        path: url.path ?? (url.search ? `${url.pathname}${url.search ?? ''}` : url.pathname),
-        reset: opts.reset ?? false,
-        blocking: opts.blocking ?? false,
-        headersTimeout: opts.headersTimeout,
-        bodyTimeout: opts.bodyTimeout,
-        idempotent: opts.idempotent,
-        retry: opts.retry ?? 8,
-        proxy: opts.proxy ?? false,
-        cache: opts.cache ?? false,
-        upgrade: opts.upgrade ?? false,
-        follow: opts.follow ?? 8,
-        error: opts.error ?? true,
-        verify: opts.verify ?? true,
-        logger: opts.logger ?? null,
-        startTime: performance.now(),
-      },
-      {
-        resolve,
-        reject,
-        method,
-        highWaterMark: opts.highWaterMark ?? 128 * 1024,
-        logger: opts.logger,
-        signal: opts.signal,
-        /** @type {Function | null} */ abort: null,
-        /** @type {stream.Readable | null} */ body: null,
-        onConnect(abort) {
-          if (this.signal?.aborted) {
-            abort(this.signal.reason)
-          } else {
-            this.abort = abort
-
-            if (this.signal) {
-              this.onAbort = () => {
-                if (this.body) {
-                  this.body.destroy(this.signal.reason ?? new AbortError())
-                } else {
-                  this.abort(this.signal.reason)
-                }
-              }
-              this.signal.addEventListener('abort', this.onAbort)
-            }
-          }
-        },
-        onUpgrade(statusCode, rawHeaders, socket, headers = parseHeaders(rawHeaders)) {
-          if (statusCode !== 101) {
-            this.abort(createError(statusCode, { headers }))
-          } else {
-            this.resolve({ headers, socket })
-            this.resolve = null
-          }
-        },
-        onHeaders(
-          statusCode,
-          rawHeaders,
-          resume,
-          statusMessage,
-          headers = parseHeaders(rawHeaders),
-        ) {
-          assert(statusCode >= 200)
-
-          const contentLength = headers['content-length']
-          const contentType = headers['content-type']
-
-          this.body = new BodyReadable(this, {
-            resume,
-            abort: this.abort,
-            highWaterMark: this.highWaterMark,
-            method: this.method,
-            statusCode,
-            statusMessage,
-            contentType: typeof contentType === 'string' ? contentType : undefined,
-            headers,
-            size: Number.isFinite(contentLength) ? contentLength : null,
-          })
-
-          if (this.signal) {
-            this.body.on('close', () => {
-              this.signal?.removeEventListener('abort', this.onAbort)
-              this.signal = null
-            })
-          }
-
-          this.resolve(this.body)
-          this.resolve = null
-          this.reject = null
-
-          return true
-        },
-        onData(chunk) {
-          return this.body.push(chunk)
-        },
-        onComplete() {
-          this.body.push(null)
-        },
-        onError(err) {
-          this.signal?.removeEventListener('abort', this.onAbort)
-          this.signal = null
-
-          if (this.body) {
-            this.body.destroy(err)
-          } else {
-            this.reject(err)
-            this.resolve = null
-            this.reject = null
-          }
-        },
-      },
-    ),
-  )
+  return await undici.request(url, {
+    method,
+    dispatcher,
+    body: opts.body,
+    query: opts.query,
+    headers,
+    signal: opts.signal,
+    reset: opts.reset ?? false,
+    blocking: opts.blocking ?? false,
+    headersTimeout: opts.headersTimeout,
+    bodyTimeout: opts.bodyTimeout,
+    idempotent: opts.idempotent,
+    retry: opts.retry ?? 8,
+    proxy: opts.proxy ?? false,
+    cache: opts.cache ?? false,
+    upgrade: opts.upgrade ?? false,
+    follow: opts.follow ?? 8,
+    error: opts.error ?? true,
+    verify: opts.verify ?? true,
+    logger: opts.logger ?? null,
+  })
 }

package/lib/interceptor/cache.js

@@ -1,7 +1,6 @@
 import assert from 'node:assert'
 import { LRUCache } from 'lru-cache'
-import { parseHeaders, parseCacheControl } from '../utils.js'
-import { DecoratorHandler } from 'undici'
+import { DecoratorHandler, parseHeaders, parseCacheControl } from '../utils.js'
 
 class CacheHandler extends DecoratorHandler {
   #handler
@@ -121,7 +120,7 @@ function makeKey(opts) {
 
 const DEFAULT_CACHE_STORE = new CacheStore({ maxSize: 128 * 1024, maxEntrySize: 1024 })
 
-export default (dispatch) => (opts, handler) => {
+export default (opts) => (dispatch) => (opts, handler) => {
   if (!opts.cache || opts.upgrade) {
     return dispatch(opts, handler)
   }

package/lib/interceptor/dns.js

@@ -0,0 +1,68 @@
+import assert from 'node:assert'
+import { DecoratorHandler } from '../utils.js'
+import CacheableLookup from 'cacheable-lookup'
+
+let DEFAULT_DNS
+
+class Handler extends DecoratorHandler {
+  #handler
+  #opts
+  #hostname
+
+  constructor(opts, hostname, { handler }) {
+    super(handler)
+
+    this.#handler = handler
+    this.#opts = opts
+    this.#hostname = hostname
+  }
+
+  onError(err) {
+    if (
+      err.code &&
+      [
+        'ECONNRESET',
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ENETDOWN',
+        'ENETUNREACH',
+        'EHOSTDOWN',
+        'EHOSTUNREACH',
+        'EPIPE',
+      ].includes(err.code)
+    ) {
+      this.#opts.dns.clear(this.#hostname)
+    }
+
+    return this.#handler.onError(err)
+  }
+}
+
+export default (opts) => (dispatch) => (opts, handler) => {
+  const dns = opts.dns ?? (DEFAULT_DNS ??= new CacheableLookup())
+
+  if (!dns) {
+    dispatch(opts, handler)
+    return
+  }
+
+  try {
+    assert(typeof dns.lookup === 'function')
+    assert(typeof dns.clear === 'function')
+
+    const url = new URL(opts.origin)
+    const hostname = url.hostname
+    dns.lookup(hostname, (err, address) => {
+      if (err) {
+        handler.onConnect(() => {})
+        handler.onError(err)
+      } else {
+        url.hostname = address
+        dispatch({ ...opts, origin: url.origin }, new Handler(opts, hostname, { handler }))
+      }
+    })
+  } catch (err) {
+    handler.onConnect(() => {})
+    handler.onError(err)
+  }
+}

package/lib/interceptor/log.js

@@ -1,6 +1,4 @@
-import { performance } from 'node:perf_hooks'
-import { parseHeaders } from '../utils.js'
-import { DecoratorHandler } from 'undici'
+import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 class Handler extends DecoratorHandler {
   #handler
@@ -114,5 +112,5 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (dispatch) => (opts, handler) =>
+export default (opts) => (dispatch) => (opts, handler) =>
   opts.logger ? dispatch(opts, new Handler(opts, { handler })) : dispatch(opts, handler)

package/lib/interceptor/proxy.js

@@ -1,6 +1,6 @@
 import net from 'node:net'
 import createError from 'http-errors'
-import { DecoratorHandler } from 'undici'
+import { DecoratorHandler } from '../utils.js'
 
 class Handler extends DecoratorHandler {
   #handler
@@ -55,11 +55,17 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (dispatch) => (opts, handler) => {
+export default (opts) => (dispatch) => (opts, handler) => {
   if (!opts.proxy) {
     return dispatch(opts, handler)
   }
 
+  const expectsPayload =
+    opts.method === 'PUT' ||
+    opts.method === 'POST' ||
+    opts.method === 'PATCH' ||
+    opts.method === 'QUERY'
+
   const headers = reduceHeaders(
     {
       headers: opts.headers ?? {},
@@ -68,7 +74,18 @@ export default (dispatch) => (opts, handler) => {
       proxyName: opts.proxy.name,
     },
     (obj, key, val) => {
-      obj[key] = val
+      if (key === 'content-length' && !expectsPayload) {
+        // https://tools.ietf.org/html/rfc7230#section-3.3.2
+        // A user agent SHOULD NOT send a Content-Length header field when
+        // the request message does not contain a payload body and the method
+        // semantics do not anticipate such a body.
+        // undici will error if provided an unexpected content-length: 0 header.
+      }
+      if (key === 'expect') {
+        // undici doesn't support expect header.
+      } else {
+        obj[key] = val
+      }
       return obj
     },
     {},

package/lib/interceptor/redirect.js

@@ -1,6 +1,5 @@
 import assert from 'node:assert'
-import { isDisturbed, parseHeaders, parseURL } from '../utils.js'
-import { DecoratorHandler } from 'undici'
+import { DecoratorHandler, isDisturbed, parseHeaders, parseURL } from '../utils.js'
 
 const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
@@ -185,5 +184,5 @@ function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
   return ret
 }
 
-export default (dispatch) => (opts, handler) =>
+export default (opts) => (dispatch) => (opts, handler) =>
   opts.follow ? dispatch(opts, new Handler(opts, { handler, dispatch })) : dispatch(opts, handler)

package/lib/interceptor/request-body-factory.js

@@ -1,27 +1,26 @@
-export default (dispatch) => (opts, handler) => {
+export default (opts) => (dispatch) => (opts, handler) => {
   if (typeof opts.body !== 'function') {
     return dispatch(opts, handler)
   }
 
-  // TODO (fix): Can we do signal in a better way using
-  // a handler?
+  try {
+    const body = opts.body({ signal: opts.signal })
 
-  const body = opts.body({ signal: opts.signal })
-
-  if (typeof body?.then === 'function') {
-    body.then(
-      (body) => {
-        // Workaround: https://github.com/nodejs/undici/pull/2497
-        body.on('error', () => {})
-
-        dispatch({ ...opts, body }, handler)
-      },
-      (err) => {
-        handler.onConnect(() => {})
-        handler.onError(err)
-      },
-    )
-  } else {
-    dispatch({ ...opts, body }, handler)
+    if (typeof body?.then === 'function') {
+      body.then(
+        (body) => {
+          dispatch({ ...opts, body }, handler)
+        },
+        (err) => {
+          handler.onConnect(() => {})
+          handler.onError(err)
+        },
+      )
+    } else {
+      dispatch({ ...opts, body }, handler)
+    }
+  } catch (err) {
+    handler.onConnect(() => {})
+    handler.onError(err)
   }
 }

package/lib/interceptor/request-id.js

@@ -11,8 +11,8 @@ function genReqId() {
   return `req-${nextReqId.toString(36)}`
 }
 
-export default (dispatch) => (opts, handler) => {
-  let id = opts.id ?? opts.headers?.['request-id']
+export default (opts) => (dispatch) => (opts, handler) => {
+  let id = opts.headers?.['request-id']
   id = id ? `${id},${genReqId()}` : genReqId()
 
   return dispatch(

package/lib/interceptor/response-error.js

@@ -1,6 +1,5 @@
-import { parseHeaders } from '../utils.js'
 import createHttpError from 'http-errors'
-import { DecoratorHandler } from 'undici'
+import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 class Handler extends DecoratorHandler {
   #handler
@@ -95,7 +94,7 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (dispatch) => (opts, handler) =>
+export default (opts) => (dispatch) => (opts, handler) =>
   opts.error !== false && opts.throwOnError !== false
     ? dispatch(opts, new Handler(opts, { handler }))
     : dispatch(opts, handler)

package/lib/interceptor/response-retry.js

@@ -1,6 +1,11 @@
 import assert from 'node:assert'
-import { isDisturbed, parseHeaders, parseRangeHeader, retry as retryFn } from '../utils.js'
-import { DecoratorHandler } from 'undici'
+import {
+  DecoratorHandler,
+  isDisturbed,
+  parseHeaders,
+  parseRangeHeader,
+  retry as retryFn,
+} from '../utils.js'
 
 // TODO (fix): What about onUpgrade?
 class Handler extends DecoratorHandler {
@@ -200,9 +205,8 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (dispatch) => (opts, handler) => {
+export default (opts) => (dispatch) => (opts, handler) =>
   // TODO (fix): HEAD, PUT, PATCH, DELETE, OPTIONS?
-  return opts.retry !== false && opts.method === 'GET' && !opts.upgrade
+  opts.retry !== false && opts.method === 'GET' && !opts.upgrade
     ? dispatch(opts, new Handler(opts, { handler, dispatch }))
     : dispatch(opts, handler)
-}

package/lib/interceptor/response-verify.js

@@ -1,7 +1,6 @@
 import crypto from 'node:crypto'
 import assert from 'node:assert'
-import { parseHeaders } from '../utils.js'
-import { DecoratorHandler } from 'undici'
+import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 const DEFAULT_OPTS = { hash: null }
 
@@ -83,7 +82,7 @@ class Handler extends DecoratorHandler {
   }
 }
 
-export default (dispatch) => (opts, handler) =>
+export default (opts) => (dispatch) => (opts, handler) =>
   !opts.upgrade && opts.verify !== false
     ? dispatch(opts, new Handler(opts, { handler }))
     : dispatch(opts, handler)

package/lib/utils.js

@@ -1,16 +1,12 @@
 import tp from 'node:timers/promises'
 import cacheControlParser from 'cache-control-parser'
 import stream from 'node:stream'
-import { util } from 'undici'
+import { util } from '@nxtedition/undici'
 
 export function parseCacheControl(str) {
   return str ? cacheControlParser.parse(str) : null
 }
 
-export function headerNameToString(name) {
-  return util.headerNameToString(name)
-}
-
 // Parsed accordingly to RFC 9110
 // https://www.rfc-editor.org/rfc/rfc9110#field.content-range
 export function parseRangeHeader(range) {
@@ -204,84 +200,7 @@ export function parseOrigin(url) {
  * @returns {Record<string, string | string[]>}
  */
 export function parseHeaders(headers, obj) {
-  if (obj == null) {
-    obj = {}
-  } else {
-    // TODO (fix): assert obj values type?
-  }
-
-  if (Array.isArray(headers)) {
-    for (let i = 0; i < headers.length; i += 2) {
-      const key2 = headers[i]
-      const val2 = headers[i + 1]
-
-      // TODO (fix): assert key2 type?
-      // TODO (fix): assert val2 type?
-
-      if (val2 == null) {
-        continue
-      }
-
-      const key = headerNameToString(key2)
-      let val = obj[key]
-
-      if (val) {
-        if (!Array.isArray(val)) {
-          val = [val]
-          obj[key] = val
-        }
-
-        if (Array.isArray(val2)) {
-          val.push(...val2.filter((x) => x != null).map((x) => `${x}`))
-        } else {
-          val.push(`${val2}`)
-        }
-      } else {
-        obj[key] = Array.isArray(val2)
-          ? val2.filter((x) => x != null).map((x) => `${x}`)
-          : `${val2}`
-      }
-    }
-  } else if (typeof headers === 'object' && headers !== null) {
-    for (const key2 of Object.keys(headers)) {
-      const val2 = headers[key2]
-
-      // TODO (fix): assert key2 type?
-      // TODO (fix): assert val2 type?
-
-      if (val2 == null) {
-        continue
-      }
-
-      const key = headerNameToString(key2)
-      let val = obj[key]
-
-      if (val) {
-        if (!Array.isArray(val)) {
-          val = [val]
-          obj[key] = val
-        }
-        if (Array.isArray(val2)) {
-          val.push(...val2.filter((x) => x != null).map((x) => `${x}`))
-        } else {
-          val.push(`${val2}`)
-        }
-      } else if (val2 != null) {
-        obj[key] = Array.isArray(val2)
-          ? val2.filter((x) => x != null).map((x) => `${x}`)
-          : `${val2}`
-      }
-    }
-  } else if (headers != null) {
-    throw new Error('invalid argument: headers')
-  }
-
-  // See https://github.com/nodejs/node/pull/46528
-  if ('content-length' in obj && 'content-disposition' in obj) {
-    obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
-  }
-
-  return obj
+  return util.parseHeaders(headers, obj)
 }
 
 export class AbortError extends Error {
@@ -328,3 +247,46 @@ export function bodyLength(body) {
 
   return null
 }
+
+export class DecoratorHandler {
+  #handler
+
+  constructor(handler) {
+    if (typeof handler !== 'object' || handler === null) {
+      throw new TypeError('handler must be an object')
+    }
+    this.#handler = handler
+  }
+
+  onConnect(...args) {
+    return this.#handler.onConnect?.(...args)
+  }
+
+  onError(...args) {
+    return this.#handler.onError?.(...args)
+  }
+
+  onUpgrade(...args) {
+    return this.#handler.onUpgrade?.(...args)
+  }
+
+  onResponseStarted(...args) {
+    return this.#handler.onResponseStarted?.(...args)
+  }
+
+  onHeaders(...args) {
+    return this.#handler.onHeaders?.(...args)
+  }
+
+  onData(...args) {
+    return this.#handler.onData?.(...args)
+  }
+
+  onComplete(...args) {
+    return this.#handler.onComplete?.(...args)
+  }
+
+  onBodySent(...args) {
+    return this.#handler.onBodySent?.(...args)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "2.2.7",
+  "version": "3.0.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",
@@ -9,14 +9,14 @@
     "lib/*"
   ],
   "dependencies": {
+    "@nxtedition/undici": "^7.0.1",
     "cache-control-parser": "^2.0.6",
     "cacheable-lookup": "^7.0.0",
     "http-errors": "^2.0.0",
-    "lru-cache": "^10.2.0",
-    "undici": "^6.18.2"
+    "lru-cache": "^10.2.0"
   },
   "devDependencies": {
-    "@types/node": "^20.14.2",
+    "@types/node": "^20.14.8",
     "eslint": "^8.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.0.0",

package/lib/readable.js

@@ -1,382 +0,0 @@
-import assert from 'node:assert'
-import { Readable } from 'node:stream'
-import { errors as undiciErrors } from 'undici'
-import { isDisturbed } from './utils.js'
-
-const { RequestAbortedError, NotSupportedError, InvalidArgumentError } = undiciErrors
-
-const kConsume = Symbol('kConsume')
-const kReading = Symbol('kReading')
-const kBody = Symbol('kBody')
-const kAbort = Symbol('abort')
-const kContentType = Symbol('kContentType')
-const kReadLength = Symbol('kReadLength')
-
-const kStatusCode = Symbol('kStatusCode')
-const kStatusMessage = Symbol('kStatusMessage')
-const kHeaders = Symbol('kHeaders')
-const kSize = Symbol('kSize')
-const kHandler = Symbol('kHandler')
-const kMethod = Symbol('kMethod')
-
-const noop = () => {}
-
-let ABORT_ERROR
-
-export class BodyReadable extends Readable {
-  constructor(
-    handler,
-    {
-      contentType = '',
-      method,
-      statusCode,
-      statusMessage,
-      headers,
-      size,
-      abort,
-      highWaterMark,
-      resume,
-    },
-  ) {
-    super({
-      autoDestroy: true,
-      read: resume,
-      highWaterMark,
-    })
-
-    this._readableState.dataEmitted = false
-
-    this[kHandler] = handler
-    this[kStatusCode] = statusCode
-    this[kStatusMessage] = statusMessage
-    this[kHeaders] = headers
-    this[kSize] = Number.isFinite(size) ? size : null
-    this[kAbort] = abort
-    this[kReadLength] = 0
-
-    this[kConsume] = null
-    this[kBody] = null
-    this[kContentType] = contentType
-    this[kMethod] = method
-
-    // Is stream being consumed through Readable API?
-    // This is an optimization so that we avoid checking
-    // for 'data' and 'readable' listeners in the hot path
-    // inside push().
-    this[kReading] = false
-  }
-
-  get statusCode() {
-    return this[kStatusCode]
-  }
-
-  get statusMessage() {
-    return this[kStatusMessage]
-  }
-
-  get headers() {
-    return this[kHeaders]
-  }
-
-  get size() {
-    return this[kSize]
-  }
-
-  get body() {
-    return this
-  }
-
-  _destroy(err, callback) {
-    if (!err && !this._readableState.endEmitted) {
-      err = ABORT_ERROR ??= new RequestAbortedError()
-    }
-
-    if (err) {
-      this[kAbort]()
-    }
-
-    if (this[kHandler].signal) {
-      this[kHandler].signal.removeEventListener('abort', this[kHandler].onAbort)
-      this[kHandler].signal = null
-    }
-
-    if (!this[kReading]) {
-      // Workaround for Node "bug". If the stream is destroyed in same
-      // tick as it is created, then a user who is waiting for a
-      // promise (i.e micro tick) for installing a 'error' listener will
-      // never get a chance and will always encounter an unhandled exception.
-      // - tick => process.nextTick(fn)
-      // - micro tick => queueMicrotask(fn)
-      setImmediate(() => callback(err))
-    } else {
-      callback(err)
-    }
-  }
-
-  on(ev, ...args) {
-    if (ev === 'data' || ev === 'readable') {
-      this[kReading] = true
-    }
-    return super.on(ev, ...args)
-  }
-
-  addListener(ev, ...args) {
-    return this.on(ev, ...args)
-  }
-
-  off(ev, ...args) {
-    const ret = super.off(ev, ...args)
-    if (ev === 'data' || ev === 'readable') {
-      this[kReading] = this.listenerCount('data') > 0 || this.listenerCount('readable') > 0
-    }
-    return ret
-  }
-
-  removeListener(ev, ...args) {
-    return this.off(ev, ...args)
-  }
-
-  setEncoding(encoding) {
-    if (encoding) {
-      throw new Error('not supported')
-    }
-    return super.setEncoding(encoding)
-  }
-
-  push(chunk) {
-    if (chunk != null) {
-      this[kReadLength] += chunk.length
-    }
-
-    if (this[kConsume] && chunk !== null) {
-      consumePush(this[kConsume], chunk)
-      return this[kReading] ? super.push(chunk) : true
-    }
-
-    return super.push(chunk)
-  }
-
-  // https://fetch.spec.whatwg.org/#dom-body-text
-  async text() {
-    return consume(this, 'text')
-  }
-
-  // https://fetch.spec.whatwg.org/#dom-body-json
-  async json() {
-    return consume(this, 'json')
-  }
-
-  // https://fetch.spec.whatwg.org/#dom-body-blob
-  async blob() {
-    return consume(this, 'blob')
-  }
-
-  // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
-  async arrayBuffer() {
-    return consume(this, 'arrayBuffer')
-  }
-
-  // https://fetch.spec.whatwg.org/#dom-body-formdata
-  async formData() {
-    // TODO: Implement.
-    throw new NotSupportedError()
-  }
-
-  // https://fetch.spec.whatwg.org/#dom-body-bodyused
-  get bodyUsed() {
-    return isDisturbed(this)
-  }
-
-  async dump(opts) {
-    let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
-    const signal = opts?.signal
-
-    if (this[kSize] != null && this[kSize] - this[kReadLength] > limit) {
-      this.destroy(signal.reason ?? new RequestAbortedError())
-    }
-
-    if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
-      throw new InvalidArgumentError('signal must be an AbortSignal')
-    }
-
-    signal?.throwIfAborted()
-
-    if (this._readableState.closeEmitted) {
-      return null
-    }
-
-    const contentLength = this.headers['content-length']
-      ? Number(this.headers['content-length'])
-      : null
-
-    if (this[kMethod] !== 'HEAD' && contentLength != null && contentLength >= limit) {
-      this.on('error', () => {}).destroy()
-      return
-    }
-
-    return await new Promise((resolve, reject) => {
-      const onAbort = () => {
-        this.destroy(signal.reason ?? new RequestAbortedError())
-      }
-      signal?.addEventListener('abort', onAbort)
-
-      this.on('close', function () {
-        signal?.removeEventListener('abort', onAbort)
-        if (signal?.aborted) {
-          reject(signal.reason ?? new RequestAbortedError())
-        } else {
-          resolve(null)
-        }
-      })
-        .on('error', noop)
-        .on('data', function (chunk) {
-          limit -= chunk.length
-          if (limit <= 0) {
-            this.destroy()
-          }
-        })
-        .resume()
-    })
-  }
-}
-
-// https://streams.spec.whatwg.org/#readablestream-locked
-function isLocked(self) {
-  // Consume is an implicit lock.
-  return (self[kBody] && self[kBody].locked === true) || self[kConsume]
-}
-
-// https://fetch.spec.whatwg.org/#body-unusable
-function isUnusable(self) {
-  return isDisturbed(self) || isLocked(self)
-}
-
-async function consume(stream, type) {
-  assert(!stream[kConsume])
-
-  return new Promise((resolve, reject) => {
-    if (isUnusable(stream)) {
-      const rState = stream._readableState
-      if (rState.destroyed && rState.closeEmitted === false) {
-        stream
-          .on('error', (err) => {
-            reject(err)
-          })
-          .on('close', () => {
-            reject(new TypeError('unusable'))
-          })
-      } else {
-        reject(rState.errored ?? new TypeError('unusable'))
-      }
-    } else {
-      queueMicrotask(() => {
-        stream[kConsume] = {
-          type,
-          stream,
-          resolve,
-          reject,
-          length: 0,
-          body: [],
-        }
-
-        stream
-          .on('error', function (err) {
-            consumeFinish(this[kConsume], err)
-          })
-          .on('close', function () {
-            if (this[kConsume].body !== null) {
-              consumeFinish(this[kConsume], new RequestAbortedError())
-            }
-          })
-
-        consumeStart(stream[kConsume])
-      })
-    }
-  })
-}
-
-function consumeStart(consume) {
-  if (consume.body === null) {
-    return
-  }
-
-  const { _readableState: state } = consume.stream
-
-  if (state.bufferIndex) {
-    const start = state.bufferIndex
-    const end = state.buffer.length
-    for (let n = start; n < end; n++) {
-      consumePush(consume, state.buffer[n])
-    }
-  } else {
-    for (const chunk of state.buffer) {
-      consumePush(consume, chunk)
-    }
-  }
-
-  if (state.endEmitted) {
-    consumeEnd(this[kConsume])
-  } else {
-    consume.stream.on('end', function () {
-      consumeEnd(this[kConsume])
-    })
-  }
-
-  consume.stream.resume()
-
-  while (consume.stream.read() != null) {
-    // Loop
-  }
-}
-
-function consumeEnd(consume) {
-  const { type, body, resolve, stream, length } = consume
-
-  try {
-    if (type === 'text') {
-      resolve(Buffer.concat(body).toString().toWellFormed())
-    } else if (type === 'json') {
-      resolve(JSON.parse(Buffer.concat(body)))
-    } else if (type === 'arrayBuffer') {
-      const dst = new Uint8Array(length)
-
-      let pos = 0
-      for (const buf of body) {
-        dst.set(buf, pos)
-        pos += buf.byteLength
-      }
-
-      resolve(dst.buffer)
-    } else if (type === 'blob') {
-      resolve(new Blob(body, { type: stream[kContentType] }))
-    }
-
-    consumeFinish(consume)
-  } catch (err) {
-    stream.destroy(err)
-  }
-}
-
-function consumePush(consume, chunk) {
-  consume.length += chunk.length
-  consume.body.push(chunk)
-}
-
-function consumeFinish(consume, err) {
-  if (consume.body === null) {
-    return
-  }
-
-  if (err) {
-    consume.reject(err)
-  } else {
-    consume.resolve()
-  }
-
-  consume.type = null
-  consume.stream = null
-  consume.resolve = null
-  consume.reject = null
-  consume.length = 0
-  consume.body = null
-}