deps: update undici to 5.12.0

PR-URL: #45236
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Mohammed Keyvanzadeh <mohammadkeyvanzade94@gmail.com>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>

Author: nodejs-github-bot

deps/undici/src/docs/api/Client.md

@@ -23,6 +23,7 @@ Returns: `Client`
 * **keepAliveTimeout** `number | null` (optional) - Default: `4e3` - The timeout after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. See [MDN: HTTP - Headers - Keep-Alive directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Keep-Alive#directives) for more details. Defaults to 4 seconds.
 * **keepAliveTimeoutThreshold** `number | null` (optional) - Default: `1e3` - A number subtracted from server *keep-alive* hints when overriding `keepAliveTimeout` to account for timing inaccuracies caused by e.g. transport latency. Defaults to 1 second.
 * **maxHeaderSize** `number | null` (optional) - Default: `16384` - The maximum length of request headers in bytes. Defaults to 16KiB.
+* **maxResponseSize** `number | null` (optional) - Default: `-1` - The maximum length of response body in bytes. Set to `-1` to disable.
 * **pipelining** `number | null` (optional) - Default: `1` - The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Carefully consider your workload and environment before enabling concurrent requests as pipelining may reduce performance if used incorrectly. Pipelining is sensitive to network stack settings as well as head of line blocking caused by e.g. long running requests. Set to `0` to disable keep-alive connections.
 * **connect** `ConnectOptions | Function | null` (optional) - Default: `null`.
 * **strictContentLength** `Boolean` (optional) - Default: `true` - Whether to treat request content length mismatches as errors. If true, an error is thrown when the request content-length header doesn't match the length of the request body.

deps/undici/src/docs/api/Errors.md

@@ -19,6 +19,7 @@ import { errors } from 'undici'
 | `RequestContentLengthMismatchError`  | `UND_ERR_REQ_CONTENT_LENGTH_MISMATCH` | request body does not match content-length header  |
 | `ResponseContentLengthMismatchError` | `UND_ERR_RES_CONTENT_LENGTH_MISMATCH` | response body does not match content-length header |
 | `InformationalError`                 | `UND_ERR_INFO`                        | expected error with reason                         |
+| `ResponseExceededMaxSizeError`       | `UND_ERR_RES_EXCEEDED_MAX_SIZE`       | response body exceed the max size allowed          |
 
 ### `SocketError`
 

deps/undici/src/docs/api/ProxyAgent.md

@@ -17,6 +17,8 @@ Returns: `ProxyAgent`
 Extends: [`AgentOptions`](Agent.md#parameter-agentoptions)
 
 * **uri** `string` (required) - It can be passed either by a string or a object containing `uri` as string.
+* **token** `string` (optional) - It can be passed by a string of token for authentication.
+* **auth** `string` (**deprecated**) - Use token.
 
 Examples:
 
@@ -74,6 +76,26 @@ for await (const data of body) {
 }
 ```
 
+#### Example - Basic Proxy Request with authentication
+
+```js
+import { setGlobalDispatcher, request, ProxyAgent } from 'undici';
+
+const proxyAgent = new ProxyAgent({
+  uri: 'my.proxy.server',
+  token: 'Bearer xxxx'
+});
+setGlobalDispatcher(proxyAgent);
+
+const { statusCode, body } = await request('http://localhost:3000/foo');
+
+console.log('response received', statusCode); // response received 200
+
+for await (const data of body) {
+  console.log('data', data.toString('utf8')); // data foo
+}
+```
+
 ### `ProxyAgent.close()`
 
 Closes the proxy agent and waits for registered pools and clients to also close before resolving.

deps/undici/src/index-fetch.js

@@ -1,12 +1,10 @@
 'use strict'
 
-const { getGlobalDispatcher } = require('./lib/global')
 const fetchImpl = require('./lib/fetch').fetch
 
 module.exports.fetch = async function fetch (resource) {
-  const dispatcher = (arguments[1] && arguments[1].dispatcher) || getGlobalDispatcher()
   try {
-    return await fetchImpl.apply(dispatcher, arguments)
+    return await fetchImpl(...arguments)
   } catch (err) {
     Error.captureStackTrace(err, this)
     throw err

deps/undici/src/index.d.ts

@@ -18,6 +18,7 @@ import { request, pipeline, stream, connect, upgrade } from './types/api'
 
 export * from './types/fetch'
 export * from './types/file'
+export * from './types/filereader'
 export * from './types/formdata'
 export * from './types/diagnostics-channel'
 export { Interceptable } from './types/mock-interceptor'

deps/undici/src/index.js

@@ -98,9 +98,9 @@ if (nodeMajor > 16 || (nodeMajor === 16 && nodeMinor >= 8)) {
     if (!fetchImpl) {
       fetchImpl = require('./lib/fetch').fetch
     }
-    const dispatcher = (arguments[1] && arguments[1].dispatcher) || getGlobalDispatcher()
+
     try {
-      return await fetchImpl.apply(dispatcher, arguments)
+      return await fetchImpl(...arguments)
     } catch (err) {
       Error.captureStackTrace(err, this)
       throw err
@@ -111,6 +111,7 @@ if (nodeMajor > 16 || (nodeMajor === 16 && nodeMinor >= 8)) {
   module.exports.Request = require('./lib/fetch/request').Request
   module.exports.FormData = require('./lib/fetch/formdata').FormData
   module.exports.File = require('./lib/fetch/file').File
+  module.exports.FileReader = require('./lib/fileapi/filereader').FileReader
 
   const { setGlobalOrigin, getGlobalOrigin } = require('./lib/fetch/global')
 

deps/undici/src/lib/api/api-stream.js

@@ -106,7 +106,7 @@ class StreamHandler extends AsyncResource {
     }
 
     res.on('drain', resume)
-    // TODO: Avoid finished. It registers an unecessary amount of listeners.
+    // TODO: Avoid finished. It registers an unnecessary amount of listeners.
     finished(res, { readable: false }, (err) => {
       const { callback, res, opaque, trailers, abort } = this
 

deps/undici/src/lib/client.js

@@ -17,7 +17,8 @@ const {
   SocketError,
   InformationalError,
   BodyTimeoutError,
-  HTTPParserError
+  HTTPParserError,
+  ResponseExceededMaxSizeError
 } = require('./core/errors')
 const buildConnector = require('./core/connect')
 const {
@@ -60,7 +61,9 @@ const {
   kClose,
   kDestroy,
   kDispatch,
-  kInterceptors
+  kInterceptors,
+  kLocalAddress,
+  kMaxResponseSize
 } = require('./core/symbols')
 
 const kClosedResolve = Symbol('kClosedResolve')
@@ -102,7 +105,9 @@ class Client extends DispatcherBase {
     maxCachedSessions,
     maxRedirections,
     connect,
-    maxRequestsPerClient
+    maxRequestsPerClient,
+    localAddress,
+    maxResponseSize
   } = {}) {
     super()
 
@@ -170,6 +175,14 @@ class Client extends DispatcherBase {
       throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')
     }
 
+    if (localAddress != null && (typeof localAddress !== 'string' || net.isIP(localAddress) === 0)) {
+      throw new InvalidArgumentError('localAddress must be valid string IP address')
+    }
+
+    if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
+      throw new InvalidArgumentError('maxResponseSize must be a positive number')
+    }
+
     if (typeof connect !== 'function') {
       connect = buildConnector({
         ...tls,
@@ -193,6 +206,7 @@ class Client extends DispatcherBase {
     this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold
     this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]
     this[kServerName] = null
+    this[kLocalAddress] = localAddress != null ? localAddress : null
     this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming
     this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming
     this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`
@@ -202,6 +216,7 @@ class Client extends DispatcherBase {
     this[kMaxRedirections] = maxRedirections
     this[kMaxRequests] = maxRequestsPerClient
     this[kClosedResolve] = null
+    this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1
 
     // kQueue is built up of 3 sections separated by
     // the kRunningIdx and kPendingIdx indices.
@@ -426,6 +441,7 @@ class Parser {
 
     this.keepAlive = ''
     this.contentLength = ''
+    this.maxResponseSize = client[kMaxResponseSize]
   }
 
   setTimeout (value, type) {
@@ -542,19 +558,6 @@ class Parser {
     }
   }
 
-  finish () {
-    try {
-      try {
-        currentParser = this
-      } finally {
-        currentParser = null
-      }
-    } catch (err) {
-      /* istanbul ignore next: difficult to make a test case for */
-      util.destroy(this.socket, err)
-    }
-  }
-
   destroy () {
     assert(this.ptr != null)
     assert(currentParser == null)
@@ -783,7 +786,7 @@ class Parser {
   }
 
   onBody (buf) {
-    const { client, socket, statusCode } = this
+    const { client, socket, statusCode, maxResponseSize } = this
 
     if (socket.destroyed) {
       return -1
@@ -802,6 +805,11 @@ class Parser {
 
     assert(statusCode >= 200)
 
+    if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
+      util.destroy(socket, new ResponseExceededMaxSizeError())
+      return -1
+    }
+
     this.bytesRead += buf.length
 
     try {
@@ -917,7 +925,7 @@ function onSocketError (err) {
   // to the user.
   if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
     // We treat all incoming data so for as a valid response.
-    parser.finish()
+    parser.onMessageComplete()
     return
   }
 
@@ -951,7 +959,7 @@ function onSocketEnd () {
 
   if (parser.statusCode && !parser.shouldKeepAlive) {
     // We treat all incoming data so far as a valid response.
-    parser.finish()
+    parser.onMessageComplete()
     return
   }
 
@@ -961,6 +969,11 @@ function onSocketEnd () {
 function onSocketClose () {
   const { [kClient]: client } = this
 
+  if (!this[kError] && this[kParser].statusCode && !this[kParser].shouldKeepAlive) {
+    // We treat all incoming data so far as a valid response.
+    this[kParser].onMessageComplete()
+  }
+
   this[kParser].destroy()
   this[kParser] = null
 
@@ -1020,7 +1033,8 @@ async function connect (client) {
         hostname,
         protocol,
         port,
-        servername: client[kServerName]
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
       },
       connector: client[kConnector]
     })
@@ -1033,7 +1047,8 @@ async function connect (client) {
         hostname,
         protocol,
         port,
-        servername: client[kServerName]
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
       }, (err, socket) => {
         if (err) {
           reject(err)
@@ -1076,7 +1091,8 @@ async function connect (client) {
           hostname,
           protocol,
           port,
-          servername: client[kServerName]
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
         },
         connector: client[kConnector],
         socket
@@ -1093,7 +1109,8 @@ async function connect (client) {
           hostname,
           protocol,
           port,
-          servername: client[kServerName]
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
         },
         connector: client[kConnector],
         error: err

deps/undici/src/lib/core/connect.js

@@ -21,7 +21,7 @@ function buildConnector ({ maxCachedSessions, socketPath, timeout, ...opts }) {
   timeout = timeout == null ? 10e3 : timeout
   maxCachedSessions = maxCachedSessions == null ? 100 : maxCachedSessions
 
-  return function connect ({ hostname, host, protocol, port, servername, httpSocket }, callback) {
+  return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
     let socket
     if (protocol === 'https:') {
       if (!tls) {
@@ -39,6 +39,7 @@ function buildConnector ({ maxCachedSessions, socketPath, timeout, ...opts }) {
         ...options,
         servername,
         session,
+        localAddress,
         socket: httpSocket, // upgrade socket connection
         port: port || 443,
         host: hostname
@@ -70,6 +71,7 @@ function buildConnector ({ maxCachedSessions, socketPath, timeout, ...opts }) {
       socket = net.connect({
         highWaterMark: 64 * 1024, // Same as nodejs fs streams.
         ...options,
+        localAddress,
         port: port || 80,
         host: hostname
       })

deps/undici/src/lib/core/errors.js

@@ -183,6 +183,16 @@ class HTTPParserError extends Error {
   }
 }
 
+class ResponseExceededMaxSizeError extends UndiciError {
+  constructor (message) {
+    super(message)
+    Error.captureStackTrace(this, ResponseExceededMaxSizeError)
+    this.name = 'ResponseExceededMaxSizeError'
+    this.message = message || 'Response content exceeded max size'
+    this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+  }
+}
+
 module.exports = {
   HTTPParserError,
   UndiciError,
@@ -201,5 +211,6 @@ module.exports = {
   SocketError,
   NotSupportedError,
   ResponseContentLengthMismatchError,
-  BalancedPoolMissingUpstreamError
+  BalancedPoolMissingUpstreamError,
+  ResponseExceededMaxSizeError
 }

deps/undici/src/lib/core/symbols.js

@@ -17,6 +17,7 @@ module.exports = {
   kHeadersTimeout: Symbol('headers timeout'),
   kBodyTimeout: Symbol('body timeout'),
   kServerName: Symbol('server name'),
+  kLocalAddress: Symbol('local address'),
   kHost: Symbol('host'),
   kNoRef: Symbol('no ref'),
   kBodyUsed: Symbol('used'),
@@ -49,5 +50,6 @@ module.exports = {
   kMaxRequests: Symbol('maxRequestsPerClient'),
   kProxy: Symbol('proxy agent options'),
   kCounter: Symbol('socket request counter'),
-  kInterceptors: Symbol('dispatch interceptors')
+  kInterceptors: Symbol('dispatch interceptors'),
+  kMaxResponseSize: Symbol('max response size')
 }

deps/undici/src/lib/fetch/body.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { MessageChannel, receiveMessageOnPort } = require('worker_threads')
+
 const corsSafeListedMethods = ['GET', 'HEAD', 'POST']
 
 const nullBodyStatus = [101, 204, 205, 304]
@@ -71,8 +73,30 @@ const DOMException = globalThis.DOMException ?? (() => {
   }
 })()
 
+let channel
+
+/** @type {globalThis['structuredClone']} */
+const structuredClone =
+  globalThis.structuredClone ??
+  // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
+  // structuredClone was added in v17.0.0, but fetch supports v16.8
+  function structuredClone (value, options = undefined) {
+    if (arguments.length === 0) {
+      throw new TypeError('missing argument')
+    }
+
+    if (!channel) {
+      channel = new MessageChannel()
+    }
+    channel.port1.unref()
+    channel.port2.unref()
+    channel.port1.postMessage(value, options?.transfer)
+    return receiveMessageOnPort(channel.port2).message
+  }
+
 module.exports = {
   DOMException,
+  structuredClone,
   subresource,
   forbiddenMethods,
   requestBodyHeader,

deps/undici/src/lib/fetch/constants.js

@@ -135,7 +135,7 @@ function URLSerializer (url, excludeFragment = false) {
     }
 
     // 3. Append url’s host, serialized, to output.
-    output += decodeURIComponent(url.host)
+    output += decodeURIComponent(url.hostname)
 
     // 4. If url’s port is non-null, append U+003A (:) followed by url’s port,
     // serialized, to output.
@@ -305,7 +305,7 @@ function parseMIMEType (input) {
   )
 
   // 8. Remove any trailing HTTP whitespace from subtype.
-  subtype = subtype.trim()
+  subtype = subtype.trimEnd()
 
   // 9. If subtype is the empty string or does not solely
   // contain HTTP token code points, then return failure.
@@ -321,7 +321,11 @@ function parseMIMEType (input) {
     type: type.toLowerCase(),
     subtype: subtype.toLowerCase(),
     /** @type {Map<string, string>} */
-    parameters: new Map()
+    parameters: new Map(),
+    // https://mimesniff.spec.whatwg.org/#mime-type-essence
+    get essence () {
+      return `${this.type}/${this.subtype}`
+    }
   }
 
   // 11. While position is not past the end of input:

deps/undici/src/lib/fetch/dataURL.js

@@ -5,6 +5,8 @@ const { types } = require('util')
 const { kState } = require('./symbols')
 const { isBlobLike } = require('./util')
 const { webidl } = require('./webidl')
+const { parseMIMEType, serializeAMimeType } = require('./dataURL')
+const { kEnumerableProperty } = require('../core/util')
 
 class File extends Blob {
   constructor (fileBits, fileName, options = {}) {
@@ -34,13 +36,29 @@ class File extends Blob {
     //    outside the range U+0020 to U+007E, then set t to the empty string
     //    and return from these substeps.
     //    2. Convert every character in t to ASCII lowercase.
-    // Note: Blob handles both of these steps for us
+    let t = options.type
+    let d
 
-    //    3. If the lastModified member is provided, let d be set to the
-    //    lastModified dictionary member. If it is not provided, set d to the
-    //    current date and time represented as the number of milliseconds since
-    //    the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]).
-    const d = options.lastModified
+    // eslint-disable-next-line no-labels
+    substep: {
+      if (t) {
+        t = parseMIMEType(t)
+
+        if (t === 'failure') {
+          t = ''
+          // eslint-disable-next-line no-labels
+          break substep
+        }
+
+        t = serializeAMimeType(t).toLowerCase()
+      }
+
+      //    3. If the lastModified member is provided, let d be set to the
+      //    lastModified dictionary member. If it is not provided, set d to the
+      //    current date and time represented as the number of milliseconds since
+      //    the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]).
+      d = options.lastModified
+    }
 
     // 4. Return a new File object F such that:
     // F refers to the bytes byte sequence.
@@ -49,10 +67,11 @@ class File extends Blob {
     // F.type is set to t.
     // F.lastModified is set to d.
 
-    super(processBlobParts(fileBits, options), { type: options.type })
+    super(processBlobParts(fileBits, options), { type: t })
     this[kState] = {
       name: n,
-      lastModified: d
+      lastModified: d,
+      type: t
     }
   }
 
@@ -72,6 +91,14 @@ class File extends Blob {
     return this[kState].lastModified
   }
 
+  get type () {
+    if (!(this instanceof File)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kState].type
+  }
+
   get [Symbol.toStringTag] () {
     return this.constructor.name
   }
@@ -194,6 +221,11 @@ class FileLike {
   }
 }
 
+Object.defineProperties(File.prototype, {
+  name: kEnumerableProperty,
+  lastModified: kEnumerableProperty
+})
+
 webidl.converters.Blob = webidl.interfaceConverter(Blob)
 
 webidl.converters.BlobPart = function (V, opts) {
@@ -202,10 +234,15 @@ webidl.converters.BlobPart = function (V, opts) {
       return webidl.converters.Blob(V, { strict: false })
     }
 
-    return webidl.converters.BufferSource(V, opts)
-  } else {
-    return webidl.converters.USVString(V, opts)
+    if (
+      ArrayBuffer.isView(V) ||
+      types.isAnyArrayBuffer(V)
+    ) {
+      return webidl.converters.BufferSource(V, opts)
+    }
   }
+
+  return webidl.converters.USVString(V, opts)
 }
 
 webidl.converters['sequence<BlobPart>'] = webidl.sequenceConverter(

deps/undici/src/lib/fetch/file.js

@@ -11,11 +11,11 @@ class FormData {
   static name = 'FormData'
 
   constructor (form) {
-    if (arguments.length > 0 && form != null) {
+    if (form !== undefined) {
       webidl.errors.conversionFailed({
         prefix: 'FormData constructor',
         argument: 'Argument 1',
-        types: ['null']
+        types: ['undefined']
       })
     }
 
@@ -206,8 +206,9 @@ class FormData {
     }
 
     return makeIterator(
-      makeIterable(this[kState], 'entries'),
-      'FormData'
+      () => this[kState].map(pair => [pair.name, pair.value]),
+      'FormData',
+      'key+value'
     )
   }
 
@@ -217,8 +218,9 @@ class FormData {
     }
 
     return makeIterator(
-      makeIterable(this[kState], 'keys'),
-      'FormData'
+      () => this[kState].map(pair => [pair.name, pair.value]),
+      'FormData',
+      'key'
     )
   }
 
@@ -228,8 +230,9 @@ class FormData {
     }
 
     return makeIterator(
-      makeIterable(this[kState], 'values'),
-      'FormData'
+      () => this[kState].map(pair => [pair.name, pair.value]),
+      'FormData',
+      'value'
     )
   }
 
@@ -294,28 +297,20 @@ function makeEntry (name, value, filename) {
     // 2. If filename is given, then set value to a new File object,
     //    representing the same bytes, whose name attribute is filename.
     if (filename !== undefined) {
+      /** @type {FilePropertyBag} */
+      const options = {
+        type: value.type,
+        lastModified: value.lastModified
+      }
+
       value = value instanceof File
-        ? new File([value], filename, { type: value.type })
-        : new FileLike(value, filename, { type: value.type })
+        ? new File([value], filename, options)
+        : new FileLike(value, filename, options)
     }
   }
 
   // 4. Return an entry whose name is name and whose value is value.
   return { name, value }
 }
 
-function * makeIterable (entries, type) {
-  // The value pairs to iterate over are this’s entry list’s entries
-  // with the key being the name and the value being the value.
-  for (const { name, value } of entries) {
-    if (type === 'entries') {
-      yield [name, value]
-    } else if (type === 'values') {
-      yield value
-    } else {
-      yield name
-    }
-  }
-}
-
 module.exports = { FormData }

deps/undici/src/lib/fetch/formdata.js

@@ -147,20 +147,10 @@ class HeadersList {
     return this[kHeadersMap].has(name)
   }
 
-  keys () {
-    return this[kHeadersMap].keys()
-  }
-
-  values () {
-    return this[kHeadersMap].values()
-  }
-
-  entries () {
-    return this[kHeadersMap].entries()
-  }
-
-  [Symbol.iterator] () {
-    return this[kHeadersMap][Symbol.iterator]()
+  * [Symbol.iterator] () {
+    for (const pair of this[kHeadersMap]) {
+      yield pair
+    }
   }
 }
 
@@ -413,23 +403,35 @@ class Headers {
       throw new TypeError('Illegal invocation')
     }
 
-    return makeIterator(this[kHeadersSortedMap].keys(), 'Headers')
+    return makeIterator(
+      () => [...this[kHeadersSortedMap].entries()],
+      'Headers',
+      'key'
+    )
   }
 
   values () {
     if (!(this instanceof Headers)) {
       throw new TypeError('Illegal invocation')
     }
 
-    return makeIterator(this[kHeadersSortedMap].values(), 'Headers')
+    return makeIterator(
+      () => [...this[kHeadersSortedMap].entries()],
+      'Headers',
+      'value'
+    )
   }
 
   entries () {
     if (!(this instanceof Headers)) {
       throw new TypeError('Illegal invocation')
     }
 
-    return makeIterator(this[kHeadersSortedMap].entries(), 'Headers')
+    return makeIterator(
+      () => [...this[kHeadersSortedMap].entries()],
+      'Headers',
+      'key+value'
+    )
   }
 
   /**
@@ -478,7 +480,8 @@ Object.defineProperties(Headers.prototype, {
   keys: kEnumerableProperty,
   values: kEnumerableProperty,
   entries: kEnumerableProperty,
-  forEach: kEnumerableProperty
+  forEach: kEnumerableProperty,
+  [Symbol.iterator]: { enumerable: false }
 })
 
 webidl.converters.HeadersInit = function (V) {

deps/undici/src/lib/fetch/headers.js

@@ -35,11 +35,12 @@ const {
   isCancelled,
   isAborted,
   isErrorLike,
-  fullyReadBody
+  fullyReadBody,
+  readableStreamClose
 } = require('./util')
 const { kState, kHeaders, kGuard, kRealm } = require('./symbols')
 const assert = require('assert')
-const { safelyExtractBody, extractBody } = require('./body')
+const { safelyExtractBody } = require('./body')
 const {
   redirectStatus,
   nullBodyStatus,
@@ -54,9 +55,11 @@ const { Readable, pipeline } = require('stream')
 const { isErrored, isReadable } = require('../core/util')
 const { dataURLProcessor, serializeAMimeType } = require('./dataURL')
 const { TransformStream } = require('stream/web')
+const { getGlobalDispatcher } = require('../../index')
 
 /** @type {import('buffer').resolveObjectURL} */
 let resolveObjectURL
+/** @type {globalThis['ReadableStream']} */
 let ReadableStream
 
 const nodeVersion = process.versions.node.split('.')
@@ -71,6 +74,12 @@ class Fetch extends EE {
     this.connection = null
     this.dump = false
     this.state = 'ongoing'
+    // 2 terminated listeners get added per request,
+    // but only 1 gets removed. If there are 20 redirects,
+    // 21 listeners will be added.
+    // See https://github.com/nodejs/undici/issues/1711
+    // TODO (fix): Find and fix root cause for leaked listener.
+    this.setMaxListeners(21)
   }
 
   terminate (reason) {
@@ -83,16 +92,30 @@ class Fetch extends EE {
     this.emit('terminated', reason)
   }
 
-  abort () {
+  // https://fetch.spec.whatwg.org/#fetch-controller-abort
+  abort (error) {
     if (this.state !== 'ongoing') {
       return
     }
 
-    const reason = new DOMException('The operation was aborted.', 'AbortError')
-
+    // 1. Set controller’s state to "aborted".
     this.state = 'aborted'
-    this.connection?.destroy(reason)
-    this.emit('terminated', reason)
+
+    // 2. Let fallbackError be an "AbortError" DOMException.
+    // 3. Set error to fallbackError if it is not given.
+    if (!error) {
+      error = new DOMException('The operation was aborted.', 'AbortError')
+    }
+
+    // 4. Let serializedError be StructuredSerialize(error).
+    //    If that threw an exception, catch it, and let
+    //    serializedError be StructuredSerialize(fallbackError).
+
+    // 5. Set controller’s serialized abort reason to serializedError.
+    this.serializedAbortReason = error
+
+    this.connection?.destroy(error)
+    this.emit('terminated', error)
   }
 }
 
@@ -124,8 +147,9 @@ async function fetch (input, init = {}) {
 
   // 4. If requestObject’s signal’s aborted flag is set, then:
   if (requestObject.signal.aborted) {
-    // 1. Abort fetch with p, request, and null.
-    abortFetch(p, request, null)
+    // 1. Abort the fetch() call with p, request, null, and
+    //    requestObject’s signal’s abort reason.
+    abortFetch(p, request, null, requestObject.signal.reason)
 
     // 2. Return p.
     return p.promise
@@ -159,8 +183,9 @@ async function fetch (input, init = {}) {
       // 1. Set locallyAborted to true.
       locallyAborted = true
 
-      // 2. Abort fetch with p, request, and responseObject.
-      abortFetch(p, request, responseObject)
+      // 2. Abort the fetch() call with p, request, responseObject,
+      //    and requestObject’s signal’s abort reason.
+      abortFetch(p, request, responseObject, requestObject.signal.reason)
 
       // 3. If controller is not null, then abort controller.
       if (controller != null) {
@@ -185,10 +210,16 @@ async function fetch (input, init = {}) {
       return
     }
 
-    // 2. If response’s aborted flag is set, then abort fetch with p,
-    // request, and responseObject, and terminate these substeps.
+    // 2. If response’s aborted flag is set, then:
     if (response.aborted) {
-      abortFetch(p, request, responseObject)
+      // 1. Let deserializedError be the result of deserialize a serialized
+      //    abort reason given controller’s serialized abort reason and
+      //    relevantRealm.
+
+      // 2. Abort the fetch() call with p, request, responseObject, and
+      //    deserializedError.
+
+      abortFetch(p, request, responseObject, controller.serializedAbortReason)
       return
     }
 
@@ -218,7 +249,7 @@ async function fetch (input, init = {}) {
     request,
     processResponseEndOfBody: handleFetchDone,
     processResponse,
-    dispatcher: this // undici
+    dispatcher: init.dispatcher ?? getGlobalDispatcher() // undici
   })
 
   // 14. Return p.
@@ -296,14 +327,18 @@ function markResourceTiming (timingInfo, originalURL, initiatorType, globalThis,
 }
 
 // https://fetch.spec.whatwg.org/#abort-fetch
-function abortFetch (p, request, responseObject) {
-  // 1. Let error be an "AbortError" DOMException.
-  const error = new DOMException('The operation was aborted.', 'AbortError')
+function abortFetch (p, request, responseObject, error) {
+  // Note: AbortSignal.reason was added in node v17.2.0
+  // which would give us an undefined error to reject with.
+  // Remove this once node v16 is no longer supported.
+  if (!error) {
+    error = new DOMException('The operation was aborted.', 'AbortError')
+  }
 
-  // 2. Reject promise with error.
+  // 1. Reject promise with error.
   p.reject(error)
 
-  // 3. If request’s body is not null and is readable, then cancel request’s
+  // 2. If request’s body is not null and is readable, then cancel request’s
   // body with error.
   if (request.body != null && isReadable(request.body?.stream)) {
     request.body.stream.cancel(error).catch((err) => {
@@ -315,15 +350,15 @@ function abortFetch (p, request, responseObject) {
     })
   }
 
-  // 4. If responseObject is null, then return.
+  // 3. If responseObject is null, then return.
   if (responseObject == null) {
     return
   }
 
-  // 5. Let response be responseObject’s response.
+  // 4. Let response be responseObject’s response.
   const response = responseObject[kState]
 
-  // 6. If response’s body is not null and is readable, then error response’s
+  // 5. If response’s body is not null and is readable, then error response’s
   // body with error.
   if (response.body != null && isReadable(response.body?.stream)) {
     response.body.stream.cancel(error).catch((err) => {
@@ -399,8 +434,8 @@ function fetching ({
     crossOriginIsolatedCapability
   }
 
-  // 7. If request’s body is a byte sequence, then set request’s body to the
-  // first return value of safely extracting request’s body.
+  // 7. If request’s body is a byte sequence, then set request’s body to
+  //    request’s body as a body.
   // NOTE: Since fetching is only called from fetch, body should already be
   // extracted.
   assert(!request.body || request.body.stream)
@@ -730,8 +765,7 @@ async function mainFetch (fetchParams, recursive = false) {
         return
       }
 
-      // 2. Set response’s body to the first return value of safely
-      // extracting bytes.
+      // 2. Set response’s body to bytes as a body.
       response.body = safelyExtractBody(bytes)[0]
 
       // 3. Run fetch finale given fetchParams and response.
@@ -749,75 +783,73 @@ async function mainFetch (fetchParams, recursive = false) {
 // https://fetch.spec.whatwg.org/#concept-scheme-fetch
 // given a fetch params fetchParams
 async function schemeFetch (fetchParams) {
-  // let request be fetchParams’s request
+  // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+  if (isCancelled(fetchParams)) {
+    return makeAppropriateNetworkError(fetchParams)
+  }
+
+  // 2. Let request be fetchParams’s request.
   const { request } = fetchParams
 
-  const {
-    protocol: scheme,
-    pathname: path
-  } = requestCurrentURL(request)
+  const { protocol: scheme } = requestCurrentURL(request)
 
-  // switch on request’s current URL’s scheme, and run the associated steps:
+  // 3. Switch on request’s current URL’s scheme and run the associated steps:
   switch (scheme) {
     case 'about:': {
       // If request’s current URL’s path is the string "blank", then return a new response
       // whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) »,
-      // and body is the empty byte sequence.
-      if (path === 'blank') {
-        const resp = makeResponse({
-          statusText: 'OK',
-          headersList: [
-            ['content-type', 'text/html;charset=utf-8']
-          ]
-        })
-
-        resp.urlList = [new URL('about:blank')]
-        return resp
-      }
+      // and body is the empty byte sequence as a body.
 
       // Otherwise, return a network error.
-      return makeNetworkError('invalid path called')
+      return makeNetworkError('about scheme is not supported')
     }
     case 'blob:': {
-      resolveObjectURL = resolveObjectURL || require('buffer').resolveObjectURL
+      if (!resolveObjectURL) {
+        resolveObjectURL = require('buffer').resolveObjectURL
+      }
 
-      // 1. Run these steps, but abort when the ongoing fetch is terminated:
-      //    1. Let blob be request’s current URL’s blob URL entry’s object.
-      //       https://w3c.github.io/FileAPI/#blob-url-entry
-      //       P.S. Thank God this method is available in node.
-      const currentURL = requestCurrentURL(request)
+      // 1. Let blobURLEntry be request’s current URL’s blob URL entry.
+      const blobURLEntry = requestCurrentURL(request)
 
       // https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56
       // Buffer.resolveObjectURL does not ignore URL queries.
-      if (currentURL.search.length !== 0) {
+      if (blobURLEntry.search.length !== 0) {
         return makeNetworkError('NetworkError when attempting to fetch resource.')
       }
 
-      const blob = resolveObjectURL(currentURL.toString())
+      const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString())
 
-      //    2. If request’s method is not `GET` or blob is not a Blob object, then return a network error. [FILEAPI]
-      if (request.method !== 'GET' || !isBlobLike(blob)) {
+      // 2. If request’s method is not `GET`, blobURLEntry is null, or blobURLEntry’s
+      //    object is not a Blob object, then return a network error.
+      if (request.method !== 'GET' || !isBlobLike(blobURLEntryObject)) {
         return makeNetworkError('invalid method')
       }
 
-      //    3. Let response be a new response whose status message is `OK`.
-      const response = makeResponse({ statusText: 'OK', urlList: [currentURL] })
+      // 3. Let bodyWithType be the result of safely extracting blobURLEntry’s object.
+      const bodyWithType = safelyExtractBody(blobURLEntryObject)
 
-      //    4. Append (`Content-Length`, blob’s size attribute value) to response’s header list.
-      response.headersList.set('content-length', `${blob.size}`)
+      // 4. Let body be bodyWithType’s body.
+      const body = bodyWithType[0]
 
-      //    5. Append (`Content-Type`, blob’s type attribute value) to response’s header list.
-      response.headersList.set('content-type', blob.type)
+      // 5. Let length be body’s length, serialized and isomorphic encoded.
+      const length = `${body.length}`
 
-      //    6. Set response’s body to the result of performing the read operation on blob.
-      // TODO (fix): This needs to read?
-      response.body = extractBody(blob)[0]
+      // 6. Let type be bodyWithType’s type if it is non-null; otherwise the empty byte sequence.
+      const type = bodyWithType[1] ?? ''
 
-      //    7. Return response.
-      return response
+      // 7. Return a new response whose status message is `OK`, header list is
+      //    « (`Content-Length`, length), (`Content-Type`, type) », and body is body.
+      const response = makeResponse({
+        statusText: 'OK',
+        headersList: [
+          ['content-length', length],
+          ['content-type', type]
+        ]
+      })
 
-      // 2. If aborted, then return the appropriate network error for fetchParams.
-      // TODO
+      response.body = body
+
+      return response
     }
     case 'data:': {
       // 1. Let dataURLStruct be the result of running the
@@ -836,13 +868,13 @@ async function schemeFetch (fetchParams) {
 
       // 4. Return a response whose status message is `OK`,
       //    header list is « (`Content-Type`, mimeType) »,
-      //    and body is dataURLStruct’s body.
+      //    and body is dataURLStruct’s body as a body.
       return makeResponse({
         statusText: 'OK',
         headersList: [
           ['content-type', mimeType]
         ],
-        body: extractBody(dataURLStruct.body)[0]
+        body: safelyExtractBody(dataURLStruct.body)[0]
       })
     }
     case 'file:': {
@@ -930,6 +962,14 @@ async function fetchFinale (fetchParams, response) {
       start () {},
       transform: identityTransformAlgorithm,
       flush: processResponseEndOfBody
+    }, {
+      size () {
+        return 1
+      }
+    }, {
+      size () {
+        return 1
+      }
     })
 
     // 4. Set response’s body to the result of piping response’s body through transformStream.
@@ -1725,9 +1765,9 @@ async function httpNetworkFetch (
   }
 
   // 12. Let cancelAlgorithm be an algorithm that aborts fetchParams’s
-  // controller.
-  const cancelAlgorithm = () => {
-    fetchParams.controller.abort()
+  // controller with reason, given reason.
+  const cancelAlgorithm = (reason) => {
+    fetchParams.controller.abort(reason)
   }
 
   // 13. Let highWaterMark be a non-negative, non-NaN number, chosen by
@@ -1758,7 +1798,12 @@ async function httpNetworkFetch (
         await cancelAlgorithm(reason)
       }
     },
-    { highWaterMark: 0 }
+    {
+      highWaterMark: 0,
+      size () {
+        return 1
+      }
+    }
   )
 
   // 17. Run these steps, but abort when the ongoing fetch is terminated:
@@ -1814,14 +1859,7 @@ async function httpNetworkFetch (
         // body is done normally and stream is readable, then close
         // stream, finalize response for fetchParams and response, and
         // abort these in-parallel steps.
-        try {
-          fetchParams.controller.controller.close()
-        } catch (err) {
-          // TODO (fix): How/Why can this happen? Do we have a bug?
-          if (!/Controller is already closed/.test(err)) {
-            throw err
-          }
-        }
+        readableStreamClose(fetchParams.controller.controller)
 
         finalizeResponse(fetchParams, response)
 
@@ -1862,10 +1900,13 @@ async function httpNetworkFetch (
       // 1. Set response’s aborted flag.
       response.aborted = true
 
-      // 2. If stream is readable, error stream with an "AbortError" DOMException.
+      // 2. If stream is readable, then error stream with the result of
+      //    deserialize a serialized abort reason given fetchParams’s
+      //    controller’s serialized abort reason and an
+      //    implementation-defined realm.
       if (isReadable(stream)) {
         fetchParams.controller.controller.error(
-          new DOMException('The operation was aborted.', 'AbortError')
+          fetchParams.controller.serializedAbortReason
         )
       }
     } else {

deps/undici/src/lib/fetch/index.js

@@ -24,6 +24,7 @@ const { kEnumerableProperty } = util
 const { kHeaders, kSignal, kState, kGuard, kRealm } = require('./symbols')
 const { webidl } = require('./webidl')
 const { getGlobalOrigin } = require('./global')
+const { URLSerializer } = require('./dataURL')
 const { kHeadersList } = require('../core/symbols')
 const assert = require('assert')
 
@@ -472,15 +473,21 @@ class Request {
     // 38. If inputOrInitBody is non-null and inputOrInitBody’s source is
     // null, then:
     if (inputOrInitBody != null && inputOrInitBody.source == null) {
-      // 1. If this’s request’s mode is neither "same-origin" nor "cors",
+      // 1. If initBody is non-null and init["duplex"] does not exist,
+      //    then throw a TypeError.
+      if (initBody != null && init.duplex == null) {
+        throw new TypeError('RequestInit: duplex option is required when sending a body.')
+      }
+
+      // 2. If this’s request’s mode is neither "same-origin" nor "cors",
       // then throw a TypeError.
       if (request.mode !== 'same-origin' && request.mode !== 'cors') {
         throw new TypeError(
           'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
         )
       }
 
-      // 2. Set this’s request’s use-CORS-preflight flag.
+      // 3. Set this’s request’s use-CORS-preflight flag.
       request.useCORSPreflightFlag = true
     }
 
@@ -536,7 +543,7 @@ class Request {
     }
 
     // The url getter steps are to return this’s request’s URL, serialized.
-    return this[kState].url.toString()
+    return URLSerializer(this[kState].url)
   }
 
   // Returns a Headers object consisting of the headers associated with request.
@@ -705,6 +712,30 @@ class Request {
     return this[kSignal]
   }
 
+  get body () {
+    if (!this || !this[kState]) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kState].body ? this[kState].body.stream : null
+  }
+
+  get bodyUsed () {
+    if (!this || !this[kState]) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
+  }
+
+  get duplex () {
+    if (!(this instanceof Request)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return 'half'
+  }
+
   // Returns a clone of request.
   clone () {
     if (!(this instanceof Request)) {
@@ -821,7 +852,21 @@ Object.defineProperties(Request.prototype, {
   headers: kEnumerableProperty,
   redirect: kEnumerableProperty,
   clone: kEnumerableProperty,
-  signal: kEnumerableProperty
+  signal: kEnumerableProperty,
+  duplex: kEnumerableProperty,
+  destination: kEnumerableProperty,
+  body: kEnumerableProperty,
+  bodyUsed: kEnumerableProperty,
+  isHistoryNavigation: kEnumerableProperty,
+  isReloadNavigation: kEnumerableProperty,
+  keepalive: kEnumerableProperty,
+  integrity: kEnumerableProperty,
+  cache: kEnumerableProperty,
+  credentials: kEnumerableProperty,
+  attribute: kEnumerableProperty,
+  referrerPolicy: kEnumerableProperty,
+  referrer: kEnumerableProperty,
+  mode: kEnumerableProperty
 })
 
 webidl.converters.Request = webidl.interfaceConverter(
@@ -929,6 +974,11 @@ webidl.converters.RequestInit = webidl.dictionaryConverter([
   {
     key: 'window',
     converter: webidl.converters.any
+  },
+  {
+    key: 'duplex',
+    converter: webidl.converters.DOMString,
+    allowedValues: ['half']
   }
 ])
 

deps/undici/src/lib/fetch/request.js

@@ -5,7 +5,6 @@ const { extractBody, cloneBody, mixinBody } = require('./body')
 const util = require('../core/util')
 const { kEnumerableProperty } = util
 const {
-  responseURL,
   isValidReasonPhrase,
   isCancelled,
   isAborted,
@@ -22,6 +21,7 @@ const { kState, kHeaders, kGuard, kRealm } = require('./symbols')
 const { webidl } = require('./webidl')
 const { FormData } = require('./formdata')
 const { getGlobalOrigin } = require('./global')
+const { URLSerializer } = require('./dataURL')
 const { kHeadersList } = require('../core/symbols')
 const assert = require('assert')
 const { types } = require('util')
@@ -48,7 +48,7 @@ class Response {
   }
 
   // https://fetch.spec.whatwg.org/#dom-response-json
-  static json (data, init = {}) {
+  static json (data = undefined, init = {}) {
     if (arguments.length === 0) {
       throw new TypeError(
         'Failed to execute \'json\' on \'Response\': 1 argument required, but 0 present.'
@@ -189,21 +189,18 @@ class Response {
       throw new TypeError('Illegal invocation')
     }
 
+    const urlList = this[kState].urlList
+
     // The url getter steps are to return the empty string if this’s
     // response’s URL is null; otherwise this’s response’s URL,
     // serialized with exclude fragment set to true.
-    let url = responseURL(this[kState])
+    const url = urlList[urlList.length - 1] ?? null
 
-    if (url == null) {
+    if (url === null) {
       return ''
     }
 
-    if (url.hash) {
-      url = new URL(url)
-      url.hash = ''
-    }
-
-    return url.toString()
+    return URLSerializer(url, true)
   }
 
   // Returns whether response was obtained through a redirect.
@@ -259,6 +256,22 @@ class Response {
     return this[kHeaders]
   }
 
+  get body () {
+    if (!this || !this[kState]) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kState].body ? this[kState].body.stream : null
+  }
+
+  get bodyUsed () {
+    if (!this || !this[kState]) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
+  }
+
   // Returns a clone of response.
   clone () {
     if (!(this instanceof Response)) {
@@ -299,7 +312,15 @@ Object.defineProperties(Response.prototype, {
   redirected: kEnumerableProperty,
   statusText: kEnumerableProperty,
   headers: kEnumerableProperty,
-  clone: kEnumerableProperty
+  clone: kEnumerableProperty,
+  body: kEnumerableProperty,
+  bodyUsed: kEnumerableProperty
+})
+
+Object.defineProperties(Response, {
+  json: kEnumerableProperty,
+  redirect: kEnumerableProperty,
+  error: kEnumerableProperty
 })
 
 // https://fetch.spec.whatwg.org/#concept-response-clone

deps/undici/src/lib/fetch/response.js

@@ -532,8 +532,11 @@ function bytesMatch (bytes, metadataList) {
 
   // 4. Let metadata be the result of getting the strongest
   //    metadata from parsedMetadata.
-  // Note: this will only work for SHA- algorithms and it's lazy *at best*.
-  const metadata = parsedMetadata.sort((c, d) => d.algo.localeCompare(c.algo))
+  const list = parsedMetadata.sort((c, d) => d.algo.localeCompare(c.algo))
+  // get the strongest algorithm
+  const strongest = list[0].algo
+  // get all entries that use the strongest algorithm; ignore weaker
+  const metadata = list.filter((item) => item.algo === strongest)
 
   // 5. For each item in metadata:
   for (const item of metadata) {
@@ -544,7 +547,6 @@ function bytesMatch (bytes, metadataList) {
     const expectedValue = item.hash
 
     // 3. Let actualValue be the result of applying algorithm to bytes.
-    // Note: "applying algorithm to bytes" converts the result to base64
     const actualValue = crypto.createHash(algorithm).update(bytes).digest('base64')
 
     // 4. If actualValue is a case-sensitive match for expectedValue,
@@ -559,10 +561,9 @@ function bytesMatch (bytes, metadataList) {
 }
 
 // https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options
-// hash-algo is defined in Content Security Policy 2 Section 4.2
-// base64-value is similary defined there
-// VCHAR is defined https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
-const parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={1,2}))( +[\x21-\x7e]?)?/i
+// https://www.w3.org/TR/CSP2/#source-list-syntax
+// https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
+const parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/i
 
 /**
  * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
@@ -684,17 +685,61 @@ function serializeJavascriptValueToJSONString (value) {
 // https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object
 const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
 
-// https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
-function makeIterator (iterator, name) {
+/**
+ * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+ * @param {() => unknown[]} iterator
+ * @param {string} name name of the instance
+ * @param {'key'|'value'|'key+value'} kind
+ */
+function makeIterator (iterator, name, kind) {
+  const object = {
+    index: 0,
+    kind,
+    target: iterator
+  }
+
   const i = {
     next () {
+      // 1. Let interface be the interface for which the iterator prototype object exists.
+
+      // 2. Let thisValue be the this value.
+
+      // 3. Let object be ? ToObject(thisValue).
+
+      // 4. If object is a platform object, then perform a security
+      //    check, passing:
+
+      // 5. If object is not a default iterator object for interface,
+      //    then throw a TypeError.
       if (Object.getPrototypeOf(this) !== i) {
         throw new TypeError(
           `'next' called on an object that does not implement interface ${name} Iterator.`
         )
       }
 
-      return iterator.next()
+      // 6. Let index be object’s index.
+      // 7. Let kind be object’s kind.
+      // 8. Let values be object’s target's value pairs to iterate over.
+      const { index, kind, target } = object
+      const values = target()
+
+      // 9. Let len be the length of values.
+      const len = values.length
+
+      // 10. If index is greater than or equal to len, then return
+      //     CreateIterResultObject(undefined, true).
+      if (index >= len) {
+        return { value: undefined, done: true }
+      }
+
+      // 11. Let pair be the entry in values at index index.
+      const pair = values[index]
+
+      // 12. Set object’s index to index + 1.
+      object.index = index + 1
+
+      // 13. Return the iterator result for pair and kind.
+      return iteratorResult(pair, kind)
     },
     // The class string of an iterator prototype object for a given interface is the
     // result of concatenating the identifier of the interface and the string " Iterator".
@@ -708,6 +753,48 @@ function makeIterator (iterator, name) {
   return Object.setPrototypeOf({}, i)
 }
 
+// https://webidl.spec.whatwg.org/#iterator-result
+function iteratorResult (pair, kind) {
+  let result
+
+  // 1. Let result be a value determined by the value of kind:
+  switch (kind) {
+    case 'key': {
+      // 1. Let idlKey be pair’s key.
+      // 2. Let key be the result of converting idlKey to an
+      //    ECMAScript value.
+      // 3. result is key.
+      result = pair[0]
+      break
+    }
+    case 'value': {
+      // 1. Let idlValue be pair’s value.
+      // 2. Let value be the result of converting idlValue to
+      //    an ECMAScript value.
+      // 3. result is value.
+      result = pair[1]
+      break
+    }
+    case 'key+value': {
+      // 1. Let idlKey be pair’s key.
+      // 2. Let idlValue be pair’s value.
+      // 3. Let key be the result of converting idlKey to an
+      //    ECMAScript value.
+      // 4. Let value be the result of converting idlValue to
+      //    an ECMAScript value.
+      // 5. Let array be ! ArrayCreate(2).
+      // 6. Call ! CreateDataProperty(array, "0", key).
+      // 7. Call ! CreateDataProperty(array, "1", value).
+      // 8. result is array.
+      result = pair
+      break
+    }
+  }
+
+  // 2. Return CreateIterResultObject(result, false).
+  return { value: result, done: false }
+}
+
 /**
  * @see https://fetch.spec.whatwg.org/#body-fully-read
  */
@@ -755,6 +842,34 @@ async function fullyReadBody (body, processBody, processBodyError) {
   // 5. React to promise with fulfilledSteps and rejectedSteps.
 }
 
+/** @type {ReadableStream} */
+let ReadableStream = globalThis.ReadableStream
+
+function isReadableStreamLike (stream) {
+  if (!ReadableStream) {
+    ReadableStream = require('stream/web').ReadableStream
+  }
+
+  return stream instanceof ReadableStream || (
+    stream[Symbol.toStringTag] === 'ReadableStream' &&
+    typeof stream.tee === 'function'
+  )
+}
+
+/**
+ * @param {ReadableStreamController<Uint8Array>} controller
+ */
+function readableStreamClose (controller) {
+  try {
+    controller.close()
+  } catch (err) {
+    // TODO: add comment explaining why this error occurs.
+    if (!err.message.includes('Controller is already closed')) {
+      throw err
+    }
+  }
+}
+
 /**
  * Fetch supports node >= 16.8.0, but Object.hasOwn was added in v16.9.0.
  */
@@ -795,5 +910,7 @@ module.exports = {
   hasOwn,
   isErrorLike,
   fullyReadBody,
-  bytesMatch
+  bytesMatch,
+  isReadableStreamLike,
+  readableStreamClose
 }

deps/undici/src/lib/fetch/util.js

@@ -250,30 +250,64 @@ webidl.sequenceConverter = function (converter) {
   }
 }
 
+// https://webidl.spec.whatwg.org/#es-to-record
 webidl.recordConverter = function (keyConverter, valueConverter) {
-  return (V) => {
-    const record = {}
-    const type = webidl.util.Type(V)
-
-    if (type === 'Undefined' || type === 'Null') {
-      return record
-    }
-
-    if (type !== 'Object') {
+  return (O) => {
+    // 1. If Type(O) is not Object, throw a TypeError.
+    if (webidl.util.Type(O) !== 'Object') {
       webidl.errors.exception({
         header: 'Record',
-        message: `Expected ${V} to be an Object type.`
+        message: `Value of type ${webidl.util.Type(O)} is not an Object.`
       })
     }
 
-    for (let [key, value] of Object.entries(V)) {
-      key = keyConverter(key)
-      value = valueConverter(value)
+    // 2. Let result be a new empty instance of record<K, V>.
+    const result = {}
+
+    if (!types.isProxy(O)) {
+      // Object.keys only returns enumerable properties
+      const keys = Object.keys(O)
+
+      for (const key of keys) {
+        // 1. Let typedKey be key converted to an IDL value of type K.
+        const typedKey = keyConverter(key)
+
+        // 2. Let value be ? Get(O, key).
+        // 3. Let typedValue be value converted to an IDL value of type V.
+        const typedValue = valueConverter(O[key])
+
+        // 4. Set result[typedKey] to typedValue.
+        result[typedKey] = typedValue
+      }
+
+      // 5. Return result.
+      return result
+    }
+
+    // 3. Let keys be ? O.[[OwnPropertyKeys]]().
+    const keys = Reflect.ownKeys(O)
+
+    // 4. For each key of keys.
+    for (const key of keys) {
+      // 1. Let desc be ? O.[[GetOwnProperty]](key).
+      const desc = Reflect.getOwnPropertyDescriptor(O, key)
+
+      // 2. If desc is not undefined and desc.[[Enumerable]] is true:
+      if (desc?.enumerable) {
+        // 1. Let typedKey be key converted to an IDL value of type K.
+        const typedKey = keyConverter(key)
+
+        // 2. Let value be ? Get(O, key).
+        // 3. Let typedValue be value converted to an IDL value of type V.
+        const typedValue = valueConverter(O[key])
 
-      record[key] = value
+        // 4. Set result[typedKey] to typedValue.
+        result[typedKey] = typedValue
+      }
     }
 
-    return record
+    // 5. Return result.
+    return result
   }
 }
 
@@ -305,7 +339,9 @@ webidl.dictionaryConverter = function (converters) {
     const type = webidl.util.Type(dictionary)
     const dict = {}
 
-    if (type !== 'Null' && type !== 'Undefined' && type !== 'Object') {
+    if (type === 'Null' || type === 'Undefined') {
+      return dict
+    } else if (type !== 'Object') {
       webidl.errors.exception({
         header: 'Dictionary',
         message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
@@ -401,7 +437,7 @@ webidl.converters.ByteString = function (V) {
 
     if (charCode > 255) {
       throw new TypeError(
-        'Cannot convert argument to a ByteString because the character at' +
+        'Cannot convert argument to a ByteString because the character at ' +
         `index ${index} has a value of ${charCode} which is greater than 255.`
       )
     }
@@ -442,6 +478,16 @@ webidl.converters['long long'] = function (V, opts) {
   return x
 }
 
+// https://webidl.spec.whatwg.org/#es-unsigned-long-long
+webidl.converters['unsigned long long'] = function (V) {
+  // 1. Let x be ? ConvertToInt(V, 64, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 64, 'unsigned')
+
+  // 2. Return the IDL unsigned long long value that
+  //    represents the same numeric value as x.
+  return x
+}
+
 // https://webidl.spec.whatwg.org/#es-unsigned-short
 webidl.converters['unsigned short'] = function (V) {
   // 1. Let x be ? ConvertToInt(V, 16, "unsigned").

deps/undici/src/lib/fetch/webidl.js

@@ -0,0 +1,286 @@
+'use strict'
+
+/**
+ * @see https://encoding.spec.whatwg.org/#concept-encoding-get
+ * @param {string} label
+ */
+function getEncoding (label) {
+  // 1. Remove any leading and trailing ASCII whitespace from label.
+  // 2. If label is an ASCII case-insensitive match for any of the
+  //    labels listed in the table below, then return the
+  //    corresponding encoding; otherwise return failure.
+  switch (label.trim().toLowerCase()) {
+    case 'unicode-1-1-utf-8':
+    case 'unicode11utf8':
+    case 'unicode20utf8':
+    case 'utf-8':
+    case 'utf8':
+    case 'x-unicode20utf8':
+      return 'UTF-8'
+    case '866':
+    case 'cp866':
+    case 'csibm866':
+    case 'ibm866':
+      return 'IBM866'
+    case 'csisolatin2':
+    case 'iso-8859-2':
+    case 'iso-ir-101':
+    case 'iso8859-2':
+    case 'iso88592':
+    case 'iso_8859-2':
+    case 'iso_8859-2:1987':
+    case 'l2':
+    case 'latin2':
+      return 'ISO-8859-2'
+    case 'csisolatin3':
+    case 'iso-8859-3':
+    case 'iso-ir-109':
+    case 'iso8859-3':
+    case 'iso88593':
+    case 'iso_8859-3':
+    case 'iso_8859-3:1988':
+    case 'l3':
+    case 'latin3':
+      return 'ISO-8859-3'
+    case 'csisolatin4':
+    case 'iso-8859-4':
+    case 'iso-ir-110':
+    case 'iso8859-4':
+    case 'iso88594':
+    case 'iso_8859-4':
+    case 'iso_8859-4:1988':
+    case 'l4':
+    case 'latin4':
+      return 'ISO-8859-4'
+    case 'csisolatincyrillic':
+    case 'cyrillic':
+    case 'iso-8859-5':
+    case 'iso-ir-144':
+    case 'iso8859-5':
+    case 'iso88595':
+    case 'iso_8859-5':
+    case 'iso_8859-5:1988':
+      return 'ISO-8859-5'
+    case 'arabic':
+    case 'asmo-708':
+    case 'csiso88596e':
+    case 'csiso88596i':
+    case 'csisolatinarabic':
+    case 'ecma-114':
+    case 'iso-8859-6':
+    case 'iso-8859-6-e':
+    case 'iso-8859-6-i':
+    case 'iso-ir-127':
+    case 'iso8859-6':
+    case 'iso88596':
+    case 'iso_8859-6':
+    case 'iso_8859-6:1987':
+      return 'ISO-8859-6'
+    case 'csisolatingreek':
+    case 'ecma-118':
+    case 'elot_928':
+    case 'greek':
+    case 'greek8':
+    case 'iso-8859-7':
+    case 'iso-ir-126':
+    case 'iso8859-7':
+    case 'iso88597':
+    case 'iso_8859-7':
+    case 'iso_8859-7:1987':
+    case 'sun_eu_greek':
+      return 'ISO-8859-7'
+    case 'csiso88598e':
+    case 'csisolatinhebrew':
+    case 'hebrew':
+    case 'iso-8859-8':
+    case 'iso-8859-8-e':
+    case 'iso-ir-138':
+    case 'iso8859-8':
+    case 'iso88598':
+    case 'iso_8859-8':
+    case 'iso_8859-8:1988':
+    case 'visual':
+      return 'ISO-8859-8'
+    case 'csiso88598i':
+    case 'iso-8859-8-i':
+    case 'logical':
+      return 'ISO-8859-8-I'
+    case 'csisolatin6':
+    case 'iso-8859-10':
+    case 'iso-ir-157':
+    case 'iso8859-10':
+    case 'iso885910':
+    case 'l6':
+    case 'latin6':
+      return 'ISO-8859-10'
+    case 'iso-8859-13':
+    case 'iso8859-13':
+    case 'iso885913':
+      return 'ISO-8859-13'
+    case 'iso-8859-14':
+    case 'iso8859-14':
+    case 'iso885914':
+      return 'ISO-8859-14'
+    case 'csisolatin9':
+    case 'iso-8859-15':
+    case 'iso8859-15':
+    case 'iso885915':
+    case 'iso_8859-15':
+    case 'l9':
+      return 'ISO-8859-15'
+    case 'iso-8859-16':
+      return 'ISO-8859-16'
+    case 'cskoi8r':
+    case 'koi':
+    case 'koi8':
+    case 'koi8-r':
+    case 'koi8_r':
+      return 'KOI8-R'
+    case 'koi8-ru':
+    case 'koi8-u':
+      return 'KOI8-U'
+    case 'csmacintosh':
+    case 'mac':
+    case 'macintosh':
+    case 'x-mac-roman':
+      return 'macintosh'
+    case 'iso-8859-11':
+    case 'iso8859-11':
+    case 'iso885911':
+    case 'tis-620':
+    case 'windows-874':
+      return 'windows-874'
+    case 'cp1250':
+    case 'windows-1250':
+    case 'x-cp1250':
+      return 'windows-1250'
+    case 'cp1251':
+    case 'windows-1251':
+    case 'x-cp1251':
+      return 'windows-1251'
+    case 'ansi_x3.4-1968':
+    case 'ascii':
+    case 'cp1252':
+    case 'cp819':
+    case 'csisolatin1':
+    case 'ibm819':
+    case 'iso-8859-1':
+    case 'iso-ir-100':
+    case 'iso8859-1':
+    case 'iso88591':
+    case 'iso_8859-1':
+    case 'iso_8859-1:1987':
+    case 'l1':
+    case 'latin1':
+    case 'us-ascii':
+    case 'windows-1252':
+    case 'x-cp1252':
+      return 'windows-1252'
+    case 'cp1253':
+    case 'windows-1253':
+    case 'x-cp1253':
+      return 'windows-1253'
+    case 'cp1254':
+    case 'csisolatin5':
+    case 'iso-8859-9':
+    case 'iso-ir-148':
+    case 'iso8859-9':
+    case 'iso88599':
+    case 'iso_8859-9':
+    case 'iso_8859-9:1989':
+    case 'l5':
+    case 'latin5':
+    case 'windows-1254':
+    case 'x-cp1254':
+      return 'windows-1254'
+    case 'cp1255':
+    case 'windows-1255':
+    case 'x-cp1255':
+      return 'windows-1255'
+    case 'cp1256':
+    case 'windows-1256':
+    case 'x-cp1256':
+      return 'windows-1256'
+    case 'cp1257':
+    case 'windows-1257':
+    case 'x-cp1257':
+      return 'windows-1257'
+    case 'cp1258':
+    case 'windows-1258':
+    case 'x-cp1258':
+      return 'windows-1258'
+    case 'x-mac-cyrillic':
+    case 'x-mac-ukrainian':
+      return 'x-mac-cyrillic'
+    case 'chinese':
+    case 'csgb2312':
+    case 'csiso58gb231280':
+    case 'gb2312':
+    case 'gb_2312':
+    case 'gb_2312-80':
+    case 'gbk':
+    case 'iso-ir-58':
+    case 'x-gbk':
+      return 'GBK'
+    case 'gb18030':
+      return 'gb18030'
+    case 'big5':
+    case 'big5-hkscs':
+    case 'cn-big5':
+    case 'csbig5':
+    case 'x-x-big5':
+      return 'Big5'
+    case 'cseucpkdfmtjapanese':
+    case 'euc-jp':
+    case 'x-euc-jp':
+      return 'EUC-JP'
+    case 'csiso2022jp':
+    case 'iso-2022-jp':
+      return 'ISO-2022-JP'
+    case 'csshiftjis':
+    case 'ms932':
+    case 'ms_kanji':
+    case 'shift-jis':
+    case 'shift_jis':
+    case 'sjis':
+    case 'windows-31j':
+    case 'x-sjis':
+      return 'Shift_JIS'
+    case 'cseuckr':
+    case 'csksc56011987':
+    case 'euc-kr':
+    case 'iso-ir-149':
+    case 'korean':
+    case 'ks_c_5601-1987':
+    case 'ks_c_5601-1989':
+    case 'ksc5601':
+    case 'ksc_5601':
+    case 'windows-949':
+      return 'EUC-KR'
+    case 'csiso2022kr':
+    case 'hz-gb-2312':
+    case 'iso-2022-cn':
+    case 'iso-2022-cn-ext':
+    case 'iso-2022-kr':
+    case 'replacement':
+      return 'replacement'
+    case 'unicodefffe':
+    case 'utf-16be':
+      return 'UTF-16BE'
+    case 'csunicode':
+    case 'iso-10646-ucs-2':
+    case 'ucs-2':
+    case 'unicode':
+    case 'unicodefeff':
+    case 'utf-16':
+    case 'utf-16le':
+      return 'UTF-16LE'
+    case 'x-user-defined':
+      return 'x-user-defined'
+    default: return 'failure'
+  }
+}
+
+module.exports = {
+  getEncoding
+}

deps/undici/src/lib/fileapi/encoding.js

@@ -0,0 +1,368 @@
+'use strict'
+
+const {
+  staticPropertyDescriptors,
+  readOperation,
+  fireAProgressEvent
+} = require('./util')
+const {
+  kState,
+  kError,
+  kResult,
+  kEvents,
+  kAborted
+} = require('./symbols')
+const { webidl } = require('../fetch/webidl')
+const { kEnumerableProperty } = require('../core/util')
+
+class FileReader extends EventTarget {
+  constructor () {
+    super()
+
+    this[kState] = 'empty'
+    this[kResult] = null
+    this[kError] = null
+    this[kEvents] = {
+      loadend: null,
+      error: null,
+      abort: null,
+      load: null,
+      progress: null,
+      loadstart: null
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
+   * @param {import('buffer').Blob} blob
+   */
+  readAsArrayBuffer (blob) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (arguments.length === 0) {
+      throw new TypeError(
+        'Failed to execute \'readAsArrayBuffer\' on \'FileReader\': 1 argument required, but 0 present.'
+      )
+    }
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsArrayBuffer(blob) method, when invoked,
+    // must initiate a read operation for blob with ArrayBuffer.
+    readOperation(this, blob, 'ArrayBuffer')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#readAsBinaryString
+   * @param {import('buffer').Blob} blob
+   */
+  readAsBinaryString (blob) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (arguments.length === 0) {
+      throw new TypeError(
+        'Failed to execute \'readAsBinaryString\' on \'FileReader\': 1 argument required, but 0 present.'
+      )
+    }
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsBinaryString(blob) method, when invoked,
+    // must initiate a read operation for blob with BinaryString.
+    readOperation(this, blob, 'BinaryString')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#readAsDataText
+   * @param {import('buffer').Blob} blob
+   * @param {string?} encoding
+   */
+  readAsText (blob, encoding = undefined) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (arguments.length === 0) {
+      throw new TypeError(
+        'Failed to execute \'readAsText\' on \'FileReader\': 1 argument required, but 0 present.'
+      )
+    }
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    if (encoding !== undefined) {
+      encoding = webidl.converters.DOMString(encoding)
+    }
+
+    // The readAsText(blob, encoding) method, when invoked,
+    // must initiate a read operation for blob with Text and encoding.
+    readOperation(this, blob, 'Text', encoding)
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
+   * @param {import('buffer').Blob} blob
+   */
+  readAsDataURL (blob) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (arguments.length === 0) {
+      throw new TypeError(
+        'Failed to execute \'readAsDataURL\' on \'FileReader\': 1 argument required, but 0 present.'
+      )
+    }
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsDataURL(blob) method, when invoked, must
+    // initiate a read operation for blob with DataURL.
+    readOperation(this, blob, 'DataURL')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-abort
+   */
+  abort () {
+    // 1. If this's state is "empty" or if this's state is
+    //    "done" set this's result to null and terminate
+    //    this algorithm.
+    if (this[kState] === 'empty' || this[kState] === 'done') {
+      this[kResult] = null
+      return
+    }
+
+    // 2. If this's state is "loading" set this's state to
+    //    "done" and set this's result to null.
+    if (this[kState] === 'loading') {
+      this[kState] = 'done'
+      this[kResult] = null
+    }
+
+    // 3. If there are any tasks from this on the file reading
+    //    task source in an affiliated task queue, then remove
+    //    those tasks from that task queue.
+    this[kAborted] = true
+
+    // 4. Terminate the algorithm for the read method being processed.
+    // TODO
+
+    // 5. Fire a progress event called abort at this.
+    fireAProgressEvent('abort', this)
+
+    // 6. If this's state is not "loading", fire a progress
+    //    event called loadend at this.
+    if (this[kState] !== 'loading') {
+      fireAProgressEvent('loadend', this)
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
+   */
+  get readyState () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    switch (this[kState]) {
+      case 'empty': return this.EMPTY
+      case 'loading': return this.LOADING
+      case 'done': return this.DONE
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-result
+   */
+  get result () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    // The result attribute’s getter, when invoked, must return
+    // this's result.
+    return this[kResult]
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-error
+   */
+  get error () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    // The error attribute’s getter, when invoked, must return
+    // this's error.
+    return this[kError]
+  }
+
+  get onloadend () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kEvents].loadend
+  }
+
+  set onloadend (fn) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].loadend = fn
+    } else {
+      this[kEvents].loadend = null
+    }
+  }
+
+  get onerror () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kEvents].error
+  }
+
+  set onerror (fn) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].error = fn
+    } else {
+      this[kEvents].error = null
+    }
+  }
+
+  get onloadstart () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kEvents].loadstart
+  }
+
+  set onloadstart (fn) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].loadstart = fn
+    } else {
+      this[kEvents].loadstart = null
+    }
+  }
+
+  get onprogress () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kEvents].progress
+  }
+
+  set onprogress (fn) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].progress = fn
+    } else {
+      this[kEvents].progress = null
+    }
+  }
+
+  get onload () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kEvents].load
+  }
+
+  set onload (fn) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].load = fn
+    } else {
+      this[kEvents].load = null
+    }
+  }
+
+  get onabort () {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kEvents].abort
+  }
+
+  set onabort (fn) {
+    if (!(this instanceof FileReader)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].abort = fn
+    } else {
+      this[kEvents].abort = null
+    }
+  }
+}
+
+// https://w3c.github.io/FileAPI/#dom-filereader-empty
+FileReader.EMPTY = FileReader.prototype.EMPTY = 0
+// https://w3c.github.io/FileAPI/#dom-filereader-loading
+FileReader.LOADING = FileReader.prototype.LOADING = 1
+// https://w3c.github.io/FileAPI/#dom-filereader-done
+FileReader.DONE = FileReader.prototype.DONE = 2
+
+Object.defineProperties(FileReader.prototype, {
+  EMPTY: staticPropertyDescriptors,
+  LOADING: staticPropertyDescriptors,
+  DONE: staticPropertyDescriptors,
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  abort: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  result: kEnumerableProperty,
+  error: kEnumerableProperty,
+  onloadstart: kEnumerableProperty,
+  onprogress: kEnumerableProperty,
+  onload: kEnumerableProperty,
+  onabort: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onloadend: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'FileReader',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  }
+})
+
+Object.defineProperties(FileReader, {
+  EMPTY: staticPropertyDescriptors,
+  LOADING: staticPropertyDescriptors,
+  DONE: staticPropertyDescriptors
+})
+
+module.exports = {
+  FileReader
+}

deps/undici/src/lib/fileapi/filereader.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { webidl } = require('../fetch/webidl')
+
+const kState = Symbol('ProgressEvent state')
+
+/**
+ * @see https://xhr.spec.whatwg.org/#progressevent
+ */
+class ProgressEvent extends Event {
+  constructor (type, eventInitDict = {}) {
+    type = webidl.converters.DOMString(type)
+    eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {})
+
+    super(type, eventInitDict)
+
+    this[kState] = {
+      lengthComputable: eventInitDict.lengthComputable,
+      loaded: eventInitDict.loaded,
+      total: eventInitDict.total
+    }
+  }
+
+  get lengthComputable () {
+    if (!(this instanceof ProgressEvent)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kState].lengthComputable
+  }
+
+  get loaded () {
+    if (!(this instanceof ProgressEvent)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kState].loaded
+  }
+
+  get total () {
+    if (!(this instanceof ProgressEvent)) {
+      throw new TypeError('Illegal invocation')
+    }
+
+    return this[kState].total
+  }
+}
+
+webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
+  {
+    key: 'lengthComputable',
+    converter: webidl.converters.boolean,
+    defaultValue: false
+  },
+  {
+    key: 'loaded',
+    converter: webidl.converters['unsigned long long'],
+    defaultValue: 0
+  },
+  {
+    key: 'total',
+    converter: webidl.converters['unsigned long long'],
+    defaultValue: 0
+  },
+  {
+    key: 'bubbles',
+    converter: webidl.converters.boolean,
+    defaultValue: false
+  },
+  {
+    key: 'cancelable',
+    converter: webidl.converters.boolean,
+    defaultValue: false
+  },
+  {
+    key: 'composed',
+    converter: webidl.converters.boolean,
+    defaultValue: false
+  }
+])
+
+module.exports = {
+  ProgressEvent
+}

deps/undici/src/lib/fileapi/progressevent.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = {
+  kState: Symbol('FileReader state'),
+  kResult: Symbol('FileReader result'),
+  kError: Symbol('FileReader error'),
+  kLastProgressEventFired: Symbol('FileReader last progress event fired timestamp'),
+  kEvents: Symbol('FileReader events'),
+  kAborted: Symbol('FileReader aborted')
+}

deps/undici/src/lib/fileapi/symbols.js

@@ -0,0 +1,398 @@
+'use strict'
+
+const {
+  kState,
+  kError,
+  kResult,
+  kAborted,
+  kLastProgressEventFired
+} = require('./symbols')
+const { ProgressEvent } = require('./progressevent')
+const { getEncoding } = require('./encoding')
+const { DOMException } = require('../fetch/constants')
+const { serializeAMimeType, parseMIMEType } = require('../fetch/dataURL')
+const { types } = require('util')
+const { StringDecoder } = require('string_decoder')
+const { btoa } = require('buffer')
+
+/** @type {PropertyDescriptor} */
+const staticPropertyDescriptors = {
+  enumerable: true,
+  writable: false,
+  configurable: false
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#readOperation
+ * @param {import('./filereader').FileReader} fr
+ * @param {import('buffer').Blob} blob
+ * @param {string} type
+ * @param {string?} encodingName
+ */
+function readOperation (fr, blob, type, encodingName) {
+  // 1. If fr’s state is "loading", throw an InvalidStateError
+  //    DOMException.
+  if (fr[kState] === 'loading') {
+    throw new DOMException('Invalid state', 'InvalidStateError')
+  }
+
+  // 2. Set fr’s state to "loading".
+  fr[kState] = 'loading'
+
+  // 3. Set fr’s result to null.
+  fr[kResult] = null
+
+  // 4. Set fr’s error to null.
+  fr[kError] = null
+
+  // 5. Let stream be the result of calling get stream on blob.
+  /** @type {import('stream/web').ReadableStream} */
+  const stream = blob.stream()
+
+  // 6. Let reader be the result of getting a reader from stream.
+  const reader = stream.getReader()
+
+  // 7. Let bytes be an empty byte sequence.
+  /** @type {Uint8Array[]} */
+  const bytes = []
+
+  // 8. Let chunkPromise be the result of reading a chunk from
+  //    stream with reader.
+  let chunkPromise = reader.read()
+
+  // 9. Let isFirstChunk be true.
+  let isFirstChunk = true
+
+  // 10. In parallel, while true:
+  // Note: "In parallel" just means non-blocking
+  // Note 2: readOperation itself cannot be async as double
+  // reading the body would then reject the promise, instead
+  // of throwing an error.
+  ;(async () => {
+    while (!fr[kAborted]) {
+      // 1. Wait for chunkPromise to be fulfilled or rejected.
+      try {
+        const { done, value } = await chunkPromise
+
+        // 2. If chunkPromise is fulfilled, and isFirstChunk is
+        //    true, queue a task to fire a progress event called
+        //    loadstart at fr.
+        if (isFirstChunk && !fr[kAborted]) {
+          queueMicrotask(() => {
+            fireAProgressEvent('loadstart', fr)
+          })
+        }
+
+        // 3. Set isFirstChunk to false.
+        isFirstChunk = false
+
+        // 4. If chunkPromise is fulfilled with an object whose
+        //    done property is false and whose value property is
+        //    a Uint8Array object, run these steps:
+        if (!done && types.isUint8Array(value)) {
+          // 1. Let bs be the byte sequence represented by the
+          //    Uint8Array object.
+
+          // 2. Append bs to bytes.
+          bytes.push(value)
+
+          // 3. If roughly 50ms have passed since these steps
+          //    were last invoked, queue a task to fire a
+          //    progress event called progress at fr.
+          if (
+            (
+              fr[kLastProgressEventFired] === undefined ||
+              Date.now() - fr[kLastProgressEventFired] >= 50
+            ) &&
+            !fr[kAborted]
+          ) {
+            fr[kLastProgressEventFired] = Date.now()
+            queueMicrotask(() => {
+              fireAProgressEvent('progress', fr)
+            })
+          }
+
+          // 4. Set chunkPromise to the result of reading a
+          //    chunk from stream with reader.
+          chunkPromise = reader.read()
+        } else if (done) {
+          // 5. Otherwise, if chunkPromise is fulfilled with an
+          //    object whose done property is true, queue a task
+          //    to run the following steps and abort this algorithm:
+          queueMicrotask(() => {
+            // 1. Set fr’s state to "done".
+            fr[kState] = 'done'
+
+            // 2. Let result be the result of package data given
+            //    bytes, type, blob’s type, and encodingName.
+            try {
+              const result = packageData(bytes, type, blob.type, encodingName)
+
+              // 4. Else:
+
+              if (fr[kAborted]) {
+                return
+              }
+
+              // 1. Set fr’s result to result.
+              fr[kResult] = result
+
+              // 2. Fire a progress event called load at the fr.
+              fireAProgressEvent('load', fr)
+            } catch (error) {
+              // 3. If package data threw an exception error:
+
+              // 1. Set fr’s error to error.
+              fr[kError] = error
+
+              // 2. Fire a progress event called error at fr.
+              fireAProgressEvent('error', fr)
+            }
+
+            // 5. If fr’s state is not "loading", fire a progress
+            //    event called loadend at the fr.
+            if (fr[kState] !== 'loading') {
+              fireAProgressEvent('loadend', fr)
+            }
+          })
+
+          break
+        }
+      } catch (error) {
+        if (fr[kAborted]) {
+          return
+        }
+
+        // 6. Otherwise, if chunkPromise is rejected with an
+        //    error error, queue a task to run the following
+        //    steps and abort this algorithm:
+        queueMicrotask(() => {
+          // 1. Set fr’s state to "done".
+          fr[kState] = 'done'
+
+          // 2. Set fr’s error to error.
+          fr[kError] = error
+
+          // 3. Fire a progress event called error at fr.
+          fireAProgressEvent('error', fr)
+
+          // 4. If fr’s state is not "loading", fire a progress
+          //    event called loadend at fr.
+          if (fr[kState] !== 'loading') {
+            fireAProgressEvent('loadend', fr)
+          }
+        })
+
+        break
+      }
+    }
+  })()
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#fire-a-progress-event
+ * @param {string} e The name of the event
+ * @param {import('./filereader').FileReader} reader
+ */
+function fireAProgressEvent (e, reader) {
+  const event = new ProgressEvent(e, {
+    bubbles: false,
+    cancelable: false
+  })
+
+  reader.dispatchEvent(event)
+  try {
+    // eslint-disable-next-line no-useless-call
+    reader[`on${e}`]?.call(reader, event)
+  } catch (err) {
+    // Prevent the error from being swallowed
+    queueMicrotask(() => {
+      throw err
+    })
+  }
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#blob-package-data
+ * @param {Uint8Array[]} bytes
+ * @param {string} type
+ * @param {string?} mimeType
+ * @param {string?} encodingName
+ */
+function packageData (bytes, type, mimeType, encodingName) {
+  // 1. A Blob has an associated package data algorithm, given
+  //    bytes, a type, a optional mimeType, and a optional
+  //    encodingName, which switches on type and runs the
+  //    associated steps:
+
+  switch (type) {
+    case 'DataURL': {
+      // 1. Return bytes as a DataURL [RFC2397] subject to
+      //    the considerations below:
+      //  * Use mimeType as part of the Data URL if it is
+      //    available in keeping with the Data URL
+      //    specification [RFC2397].
+      //  * If mimeType is not available return a Data URL
+      //    without a media-type. [RFC2397].
+
+      // https://datatracker.ietf.org/doc/html/rfc2397#section-3
+      // dataurl    := "data:" [ mediatype ] [ ";base64" ] "," data
+      // mediatype  := [ type "/" subtype ] *( ";" parameter )
+      // data       := *urlchar
+      // parameter  := attribute "=" value
+      let dataURL = 'data:'
+
+      const parsed = parseMIMEType(mimeType || 'application/octet-stream')
+
+      if (parsed !== 'failure') {
+        dataURL += serializeAMimeType(parsed)
+      }
+
+      dataURL += ';base64,'
+
+      const decoder = new StringDecoder('latin1')
+
+      for (const chunk of bytes) {
+        dataURL += btoa(decoder.write(chunk))
+      }
+
+      dataURL += btoa(decoder.end())
+
+      return dataURL
+    }
+    case 'Text': {
+      // 1. Let encoding be failure
+      let encoding = 'failure'
+
+      // 2. If the encodingName is present, set encoding to the
+      //    result of getting an encoding from encodingName.
+      if (encodingName) {
+        encoding = getEncoding(encodingName)
+      }
+
+      // 3. If encoding is failure, and mimeType is present:
+      if (encoding === 'failure' && mimeType) {
+        // 1. Let type be the result of parse a MIME type
+        //    given mimeType.
+        const type = parseMIMEType(mimeType)
+
+        // 2. If type is not failure, set encoding to the result
+        //    of getting an encoding from type’s parameters["charset"].
+        if (type !== 'failure') {
+          encoding = getEncoding(type.parameters.get('charset'))
+        }
+      }
+
+      // 4. If encoding is failure, then set encoding to UTF-8.
+      if (encoding === 'failure') {
+        encoding = 'UTF-8'
+      }
+
+      // 5. Decode bytes using fallback encoding encoding, and
+      //    return the result.
+      return decode(bytes, encoding)
+    }
+    case 'ArrayBuffer': {
+      // Return a new ArrayBuffer whose contents are bytes.
+      const sequence = combineByteSequences(bytes)
+
+      return sequence.buffer
+    }
+    case 'BinaryString': {
+      // Return bytes as a binary string, in which every byte
+      //  is represented by a code unit of equal value [0..255].
+      let binaryString = ''
+
+      const decoder = new StringDecoder('latin1')
+
+      for (const chunk of bytes) {
+        binaryString += decoder.write(chunk)
+      }
+
+      binaryString += decoder.end()
+
+      return binaryString
+    }
+  }
+}
+
+/**
+ * @see https://encoding.spec.whatwg.org/#decode
+ * @param {Uint8Array[]} ioQueue
+ * @param {string} encoding
+ */
+function decode (ioQueue, encoding) {
+  const bytes = combineByteSequences(ioQueue)
+
+  // 1. Let BOMEncoding be the result of BOM sniffing ioQueue.
+  const BOMEncoding = BOMSniffing(bytes)
+
+  let slice = 0
+
+  // 2. If BOMEncoding is non-null:
+  if (BOMEncoding !== null) {
+    // 1. Set encoding to BOMEncoding.
+    encoding = BOMEncoding
+
+    // 2. Read three bytes from ioQueue, if BOMEncoding is
+    //    UTF-8; otherwise read two bytes.
+    //    (Do nothing with those bytes.)
+    slice = BOMEncoding === 'UTF-8' ? 3 : 2
+  }
+
+  // 3. Process a queue with an instance of encoding’s
+  //    decoder, ioQueue, output, and "replacement".
+
+  // 4. Return output.
+
+  const sliced = bytes.slice(slice)
+  return new TextDecoder(encoding).decode(sliced)
+}
+
+/**
+ * @see https://encoding.spec.whatwg.org/#bom-sniff
+ * @param {Uint8Array} ioQueue
+ */
+function BOMSniffing (ioQueue) {
+  // 1. Let BOM be the result of peeking 3 bytes from ioQueue,
+  //    converted to a byte sequence.
+  const [a, b, c] = ioQueue
+
+  // 2. For each of the rows in the table below, starting with
+  //    the first one and going down, if BOM starts with the
+  //    bytes given in the first column, then return the
+  //    encoding given in the cell in the second column of that
+  //    row. Otherwise, return null.
+  if (a === 0xEF && b === 0xBB && c === 0xBF) {
+    return 'UTF-8'
+  } else if (a === 0xFE && b === 0xFF) {
+    return 'UTF-16BE'
+  } else if (a === 0xFF && b === 0xFE) {
+    return 'UTF-16LE'
+  }
+
+  return null
+}
+
+/**
+ * @param {Uint8Array[]} sequences
+ */
+function combineByteSequences (sequences) {
+  const size = sequences.reduce((a, b) => {
+    return a + b.byteLength
+  }, 0)
+
+  let offset = 0
+
+  return sequences.reduce((a, b) => {
+    a.set(b, offset)
+    offset += b.byteLength
+    return a
+  }, new Uint8Array(size))
+}
+
+module.exports = {
+  staticPropertyDescriptors,
+  readOperation,
+  fireAProgressEvent
+}

deps/undici/src/lib/fileapi/util.js

@@ -109,6 +109,7 @@ class RedirectHandler {
     this.opts.path = path
     this.opts.origin = origin
     this.opts.maxRedirections = 0
+    this.opts.query = null
 
     // https://tools.ietf.org/html/rfc7231#section-6.4.4
     // In case of HTTP 303, always replace method to be either HEAD or GET

deps/undici/src/lib/handler/RedirectHandler.js

@@ -55,8 +55,13 @@ class ProxyAgent extends DispatcherBase {
     this[kProxyTls] = opts.proxyTls
     this[kProxyHeaders] = {}
 
-    if (opts.auth) {
+    if (opts.auth && opts.token) {
+      throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
+    } else if (opts.auth) {
+      /* @deprecated in favour of opts.token */
       this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
+    } else if (opts.token) {
+      this[kProxyHeaders]['proxy-authorization'] = opts.token
     }
 
     const resolvedUrl = new URL(opts.uri)

deps/undici/src/lib/llhttp/llhttp.wasm

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "5.11.0",
+  "version": "5.12.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -53,7 +53,7 @@
     "test:tap": "tap test/*.js test/diagnostics-channel/*.js",
     "test:tdd": "tap test/*.js test/diagnostics-channel/*.js -w",
     "test:typescript": "tsd",
-    "test:wpt": "node scripts/verifyVersion 18 || node test/wpt/runner/start.mjs",
+    "test:wpt": "node scripts/verifyVersion 18 || (node test/wpt/start-fetch.mjs && node test/wpt/start-FileAPI.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs)",
     "coverage": "nyc --reporter=text --reporter=html npm run test",
     "coverage:ci": "nyc --reporter=lcov npm run test",
     "bench": "PORT=3042 concurrently -k -s first npm:bench:server npm:bench:run",
@@ -66,7 +66,7 @@
   },
   "devDependencies": {
     "@sinonjs/fake-timers": "^9.1.2",
-    "@types/node": "^17.0.45",
+    "@types/node": "^18.0.3",
     "abort-controller": "^3.0.0",
     "atomic-sleep": "^1.0.0",
     "chai": "^4.3.4",
@@ -116,7 +116,8 @@
     "compilerOptions": {
       "esModuleInterop": true,
       "lib": [
-        "esnext"
+        "esnext",
+        "DOM"
       ]
     }
   },

deps/undici/src/lib/llhttp/llhttp.wasm.js

@@ -41,6 +41,8 @@ declare namespace Client {
     tls?: TlsOptions | null;
     /** */
     maxRequestsPerClient?: number;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number | null;
 
     interceptors?: {Client: readonly DispatchInterceptor[] | undefined}
   }

deps/undici/src/lib/llhttp/llhttp_simd.wasm

@@ -87,4 +87,10 @@ declare namespace Errors {
     name: 'NotSupportedError';
     code: 'UND_ERR_NOT_SUPPORTED';
   }
+
+  /** The response exceed the length allowed */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+  }
 }

deps/undici/src/lib/llhttp/llhttp_simd.wasm.js

@@ -114,6 +114,7 @@ export interface RequestInit {
   referrerPolicy?: ReferrerPolicy
   window?: null
   dispatcher?: Dispatcher
+  duplex?: RequestDuplex
 }
 
 export type ReferrerPolicy =
@@ -131,6 +132,8 @@ export type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
 
 export type RequestRedirect = 'error' | 'follow' | 'manual'
 
+export type RequestDuplex = 'half'
+
 export declare class Request implements BodyMixin {
   constructor (input: RequestInfo, init?: RequestInit)
 
@@ -147,6 +150,7 @@ export declare class Request implements BodyMixin {
 
   readonly keepalive: boolean
   readonly signal: AbortSignal
+  readonly duplex: RequestDuplex
 
   readonly body: ReadableStream | null
   readonly bodyUsed: boolean

deps/undici/src/lib/proxy-agent.js

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+
+import { Blob } from 'buffer'
+
+export declare class FileReader extends EventTarget {
+  constructor ()
+
+  readAsArrayBuffer (blob: Blob): void
+  readAsBinaryString (blob: Blob): void
+  readAsText (blob: Blob, encoding?: string): void
+  readAsDataURL (blob: Blob): void
+
+  abort (): void
+
+  static readonly EMPTY = 0
+  static readonly LOADING = 1
+  static readonly DONE = 2
+
+  readonly EMPTY = 0
+  readonly LOADING = 1
+  readonly DONE = 2
+
+  readonly readyState: number
+
+  readonly result: string | ArrayBuffer | null
+
+  readonly error: DOMException | null
+
+  onloadstart: null | ((this: FileReader, event: ProgressEvent) => void)
+  onprogress: null | ((this: FileReader, event: ProgressEvent) => void)
+  onload: null | ((this: FileReader, event: ProgressEvent) => void)
+  onabort: null |  ((this: FileReader, event: ProgressEvent) => void)
+  onerror: null | ((this: FileReader, event: ProgressEvent) => void)
+  onloadend: null | ((this: FileReader, event: ProgressEvent) => void)
+}
+
+export interface ProgressEventInit extends EventInit {
+  lengthComputable?: boolean
+  loaded?: number
+  total?: number
+}
+
+export declare class ProgressEvent extends Event {
+  constructor (type: string, eventInitDict?: ProgressEventInit)
+
+  readonly lengthComputable: boolean
+  readonly loaded: number
+  readonly total: number
+}

deps/undici/src/package.json

@@ -14,7 +14,11 @@ declare class ProxyAgent extends Dispatcher {
 declare namespace ProxyAgent {
   export interface Options extends Agent.Options {
     uri: string;
+    /**
+     * @deprecated use opts.token
+     */
     auth?: string;
+    token?: string;
     requestTls?: TlsOptions & { servername?: string };
     proxyTls?: TlsOptions & { servername?: string };
   }