@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/undici/lib/core/util.js

@@ -5,13 +5,16 @@ const { kDestroyed, kBodyUsed, kListeners, kBody } = require('./symbols')
 const { IncomingMessage } = require('node:http')
 const stream = require('node:stream')
 const net = require('node:net')
+const { Blob } = require('node:buffer')
+const nodeUtil = require('node:util')
 const { stringify } = require('node:querystring')
-const { EventEmitter: EE, addAbortListener: addAbortListenerNative } = require('node:events')
-const timers = require('../util/timers')
-const { InvalidArgumentError, ConnectTimeoutError } = require('./errors')
+const { EventEmitter: EE } = require('node:events')
+const { InvalidArgumentError } = require('./errors')
 const { headerNameLowerCasedRecord } = require('./constants')
 const { tree } = require('./tree')
 
+const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
+
 class BodyAsyncIterable {
   constructor (body) {
     this[kBody] = body
@@ -25,12 +28,6 @@ class BodyAsyncIterable {
   }
 }
 
-function noop () {}
-
-/**
- * @param {*} body
- * @returns {*}
- */
 function wrapRequestBody (body) {
   if (isStream(body)) {
     // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
@@ -56,8 +53,6 @@ function wrapRequestBody (body) {
     // to determine whether or not it has been disturbed. This is just
     // a workaround.
     return new BodyAsyncIterable(body)
-  } else if (body && isFormDataLike(body)) {
-    return body
   } else if (
     body &&
     typeof body !== 'string' &&
@@ -72,40 +67,32 @@ function wrapRequestBody (body) {
   }
 }
 
-/**
- * @param {*} obj
- * @returns {obj is import('node:stream').Stream}
- */
+function nop () {}
+
 function isStream (obj) {
   return obj && typeof obj === 'object' && typeof obj.pipe === 'function' && typeof obj.on === 'function'
 }
 
-/**
- * @param {*} object
- * @returns {object is Blob}
- */
+// based on https://github.com/node-fetch/fetch-blob/blob/8ab587d34080de94140b54f07168451e7d0b655e/index.js#L229-L241 (MIT License)
 function isBlobLike (object) {
-  return object instanceof Blob
-}
+  if (object === null) {
+    return false
+  } else if (object instanceof Blob) {
+    return true
+  } else if (typeof object !== 'object') {
+    return false
+  } else {
+    const sTag = object[Symbol.toStringTag]
 
-/**
- * @param {string} url The path to check for query strings or fragments.
- * @returns {boolean} Returns true if the path contains a query string or fragment.
- */
-function pathHasQueryOrFragment (url) {
-  return (
-    url.includes('?') ||
-    url.includes('#')
-  )
+    return (sTag === 'Blob' || sTag === 'File') && (
+      ('stream' in object && typeof object.stream === 'function') ||
+      ('arrayBuffer' in object && typeof object.arrayBuffer === 'function')
+    )
+  }
 }
 
-/**
- * @param {string} url The URL to add the query params to
- * @param {import('node:querystring').ParsedUrlQueryInput} queryParams The object to serialize into a URL query string
- * @returns {string} The URL with the query params added
- */
-function serializePathWithQuery (url, queryParams) {
-  if (pathHasQueryOrFragment(url)) {
+function buildURL (url, queryParams) {
+  if (url.includes('?') || url.includes('#')) {
     throw new Error('Query params cannot be passed when url already contains "?" or "#".')
   }
 
@@ -118,10 +105,6 @@ function serializePathWithQuery (url, queryParams) {
   return url
 }
 
-/**
- * @param {number|string|undefined} port
- * @returns {boolean}
- */
 function isValidPort (port) {
   const value = parseInt(port, 10)
   return (
@@ -131,12 +114,6 @@ function isValidPort (port) {
   )
 }
 
-/**
- * Check if the value is a valid http or https prefixed string.
- *
- * @param {string} value
- * @returns {boolean}
- */
 function isHttpOrHttpsPrefixed (value) {
   return (
     value != null &&
@@ -154,15 +131,8 @@ function isHttpOrHttpsPrefixed (value) {
   )
 }
 
-/**
- * @param {string|URL|Record<string,string>} url
- * @returns {URL}
- */
 function parseURL (url) {
   if (typeof url === 'string') {
-    /**
-     * @type {URL}
-     */
     url = new URL(url)
 
     if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
@@ -232,10 +202,6 @@ function parseURL (url) {
   return url
 }
 
-/**
- * @param {string|URL|Record<string, string>} url
- * @returns {URL}
- */
 function parseOrigin (url) {
   url = parseURL(url)
 
@@ -246,10 +212,6 @@ function parseOrigin (url) {
   return url
 }
 
-/**
- * @param {string} host
- * @returns {string}
- */
 function getHostname (host) {
   if (host[0] === '[') {
     const idx = host.indexOf(']')
@@ -264,12 +226,8 @@ function getHostname (host) {
   return host.substring(0, idx)
 }
 
-/**
- * IP addresses are not valid server names per RFC6066
- * Currently, the only server names supported are DNS hostnames
- * @param {string|null} host
- * @returns {string|null}
- */
+// IP addresses are not valid server names per RFC6066
+// > Currently, the only server names supported are DNS hostnames
 function getServerName (host) {
   if (!host) {
     return null
@@ -285,50 +243,18 @@ function getServerName (host) {
   return servername
 }
 
-/**
- * @function
- * @template T
- * @param {T} obj
- * @returns {T}
- */
 function deepClone (obj) {
   return JSON.parse(JSON.stringify(obj))
 }
 
-/**
- * @param {*} obj
- * @returns {obj is AsyncIterable}
- */
 function isAsyncIterable (obj) {
   return !!(obj != null && typeof obj[Symbol.asyncIterator] === 'function')
 }
 
-/**
- * @param {*} obj
- * @returns {obj is Iterable}
- */
 function isIterable (obj) {
   return !!(obj != null && (typeof obj[Symbol.iterator] === 'function' || typeof obj[Symbol.asyncIterator] === 'function'))
 }
 
-/**
- * Checks whether an object has a safe Symbol.iterator — i.e. one that is
- * either own or inherited from a non-Object.prototype chain.  This prevents
- * prototype-pollution attacks from injecting a fake iterator on
- * Object.prototype.
- * @param {object} obj
- * @returns {boolean}
- */
-function hasSafeIterator (obj) {
-  const prototype = Object.getPrototypeOf(obj)
-  const ownIterator = Object.hasOwn(obj, Symbol.iterator)
-  return ownIterator || (prototype != null && prototype !== Object.prototype && typeof obj[Symbol.iterator] === 'function')
-}
-
-/**
- * @param {Blob|Buffer|import ('stream').Stream} body
- * @returns {number|null}
- */
 function bodyLength (body) {
   if (body == null) {
     return 0
@@ -346,19 +272,10 @@ function bodyLength (body) {
   return null
 }
 
-/**
- * @param {import ('stream').Stream} body
- * @returns {boolean}
- */
 function isDestroyed (body) {
   return body && !!(body.destroyed || body[kDestroyed] || (stream.isDestroyed?.(body)))
 }
 
-/**
- * @param {import ('stream').Stream} stream
- * @param {Error} [err]
- * @returns {void}
- */
 function destroy (stream, err) {
   if (stream == null || !isStream(stream) || isDestroyed(stream)) {
     return
@@ -370,12 +287,7 @@ function destroy (stream, err) {
       stream.socket = null
     }
 
-    try {
-      stream.destroy(err)
-    } catch {
-      // stream.destroy may throw on managed sockets (e.g., http2).
-      // Silently ignore — the socket lifecycle is handled by the subsystem.
-    }
+    stream.destroy(err)
   } else if (err) {
     queueMicrotask(() => {
       stream.emit('error', err)
@@ -388,12 +300,8 @@ function destroy (stream, err) {
 }
 
 const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/
-/**
- * @param {string} val
- * @returns {number | null}
- */
 function parseKeepAliveTimeout (val) {
-  const m = val.match(KEEPALIVE_TIMEOUT_EXPR)
+  const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR)
   return m ? parseInt(m[1], 10) * 1000 : null
 }
 
@@ -418,219 +326,131 @@ function bufferToLowerCasedHeaderName (value) {
 }
 
 /**
- * @param {(Buffer | string)[]} headers
+ * @param {Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]} headers
  * @param {Record<string, string | string[]>} [obj]
  * @returns {Record<string, string | string[]>}
  */
 function parseHeaders (headers, obj) {
   if (obj === undefined) obj = {}
-
   for (let i = 0; i < headers.length; i += 2) {
     const key = headerNameToString(headers[i])
     let val = obj[key]
 
-    if (val !== undefined) {
-      if (!Object.hasOwn(obj, key)) {
-        const headersValue = typeof headers[i + 1] === 'string'
-          ? headers[i + 1]
-          : Array.isArray(headers[i + 1])
-            ? headers[i + 1].map(x => x.toString('latin1'))
-            : headers[i + 1].toString('latin1')
-
-        if (key === '__proto__') {
-          Object.defineProperty(obj, key, {
-            value: headersValue,
-            enumerable: true,
-            configurable: true,
-            writable: true
-          })
-        } else {
-          obj[key] = headersValue
-        }
-      } else {
-        if (typeof val === 'string') {
-          val = [val]
-          obj[key] = val
-        }
-        val.push(headers[i + 1].toString('latin1'))
+    if (val) {
+      if (typeof val === 'string') {
+        val = [val]
+        obj[key] = val
       }
+      val.push(headers[i + 1].toString('utf8'))
     } else {
-      const headersValue = typeof headers[i + 1] === 'string'
-        ? headers[i + 1]
-        : Array.isArray(headers[i + 1])
-          ? headers[i + 1].map(x => x.toString('latin1'))
-          : headers[i + 1].toString('latin1')
-
-      obj[key] = headersValue
+      const headersValue = headers[i + 1]
+      if (typeof headersValue === 'string') {
+        obj[key] = headersValue
+      } else {
+        obj[key] = Array.isArray(headersValue) ? headersValue.map(x => x.toString('utf8')) : headersValue.toString('utf8')
+      }
     }
   }
 
+  // See https://github.com/nodejs/node/pull/46528
+  if ('content-length' in obj && 'content-disposition' in obj) {
+    obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
+  }
+
   return obj
 }
 
-/**
- * @param {Buffer[] | string[] | Record<string, string | string[]> | null | undefined} headers
- * @returns {string[]}
- */
 function parseRawHeaders (headers) {
-  if (headers == null) {
-    return []
-  }
-
-  if (!Array.isArray(headers)) {
-    const rawHeaders = []
-
-    for (const [name, value] of Object.entries(headers)) {
-      if (Array.isArray(value)) {
-        for (const entry of value) {
-          rawHeaders.push(name, `${entry}`)
-        }
-      } else {
-        rawHeaders.push(name, `${value}`)
-      }
-    }
-
-    return rawHeaders
-  }
-
-  const headersLength = headers.length
-  /**
-   * @type {string[]}
-   */
-  const ret = new Array(headersLength)
+  const len = headers.length
+  const ret = new Array(len)
 
+  let hasContentLength = false
+  let contentDispositionIdx = -1
   let key
   let val
+  let kLen = 0
 
-  for (let n = 0; n < headersLength; n += 2) {
+  for (let n = 0; n < headers.length; n += 2) {
     key = headers[n]
     val = headers[n + 1]
 
     typeof key !== 'string' && (key = key.toString())
-    typeof val !== 'string' && (val = val.toString('latin1'))
+    typeof val !== 'string' && (val = val.toString('utf8'))
 
+    kLen = key.length
+    if (kLen === 14 && key[7] === '-' && (key === 'content-length' || key.toLowerCase() === 'content-length')) {
+      hasContentLength = true
+    } else if (kLen === 19 && key[7] === '-' && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) {
+      contentDispositionIdx = n + 1
+    }
     ret[n] = key
     ret[n + 1] = val
   }
 
-  return ret
-}
-
-/**
- * @param {Record<string, string | string[]>} headers
- * @returns {Buffer[]}
- */
-function toRawHeaders (headers) {
-  const rawHeaders = []
-
-  for (const [name, value] of Object.entries(headers)) {
-    if (Array.isArray(value)) {
-      for (const entry of value) {
-        rawHeaders.push(Buffer.from(name, 'latin1'), Buffer.from(`${entry}`, 'latin1'))
-      }
-    } else {
-      rawHeaders.push(Buffer.from(name, 'latin1'), Buffer.from(`${value}`, 'latin1'))
-    }
+  // See https://github.com/nodejs/node/pull/46528
+  if (hasContentLength && contentDispositionIdx !== -1) {
+    ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString('latin1')
   }
 
-  return rawHeaders
-}
-
-/**
- * @param {string[]} headers
- * @param {Buffer[]} headers
- */
-function encodeRawHeaders (headers) {
-  if (!Array.isArray(headers)) {
-    throw new TypeError('expected headers to be an array')
-  }
-  return headers.map(x => Buffer.from(x))
+  return ret
 }
 
-/**
- * @param {*} buffer
- * @returns {buffer is Buffer}
- */
 function isBuffer (buffer) {
   // See, https://github.com/mcollina/undici/pull/319
   return buffer instanceof Uint8Array || Buffer.isBuffer(buffer)
 }
 
-/**
- * Asserts that the handler object is a request handler.
- *
- * @param {object} handler
- * @param {string} method
- * @param {string} [upgrade]
- * @returns {asserts handler is import('../api/api-request').RequestHandler}
- */
-function assertRequestHandler (handler, method, upgrade) {
+function validateHandler (handler, method, upgrade) {
   if (!handler || typeof handler !== 'object') {
     throw new InvalidArgumentError('handler must be an object')
   }
 
-  if (typeof handler.onRequestStart !== 'function') {
-    throw new InvalidArgumentError('invalid onRequestStart method')
+  if (typeof handler.onConnect !== 'function') {
+    throw new InvalidArgumentError('invalid onConnect method')
   }
 
-  if (typeof handler.onResponseError !== 'function') {
-    throw new InvalidArgumentError('invalid onResponseError method')
+  if (typeof handler.onError !== 'function') {
+    throw new InvalidArgumentError('invalid onError method')
   }
 
   if (typeof handler.onBodySent !== 'function' && handler.onBodySent !== undefined) {
     throw new InvalidArgumentError('invalid onBodySent method')
   }
 
-  if (typeof handler.onRequestSent !== 'function' && handler.onRequestSent !== undefined) {
-    throw new InvalidArgumentError('invalid onRequestSent method')
-  }
-
   if (upgrade || method === 'CONNECT') {
-    if (typeof handler.onRequestUpgrade !== 'function') {
-      throw new InvalidArgumentError('invalid onRequestUpgrade method')
+    if (typeof handler.onUpgrade !== 'function') {
+      throw new InvalidArgumentError('invalid onUpgrade method')
     }
   } else {
-    if (typeof handler.onResponseStart !== 'function') {
-      throw new InvalidArgumentError('invalid onResponseStart method')
+    if (typeof handler.onHeaders !== 'function') {
+      throw new InvalidArgumentError('invalid onHeaders method')
     }
 
-    if (typeof handler.onResponseData !== 'function') {
-      throw new InvalidArgumentError('invalid onResponseData method')
+    if (typeof handler.onData !== 'function') {
+      throw new InvalidArgumentError('invalid onData method')
     }
 
-    if (typeof handler.onResponseEnd !== 'function') {
-      throw new InvalidArgumentError('invalid onResponseEnd method')
+    if (typeof handler.onComplete !== 'function') {
+      throw new InvalidArgumentError('invalid onComplete method')
     }
   }
 }
 
-/**
- * A body is disturbed if it has been read from and it cannot be re-used without
- * losing state or data.
- * @param {import('node:stream').Readable} body
- * @returns {boolean}
- */
+// A body is disturbed if it has been read from and it cannot
+// be re-used without losing state or data.
 function isDisturbed (body) {
   // TODO (fix): Why is body[kBodyUsed] needed?
   return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]))
 }
 
-/**
- * @typedef {object} SocketInfo
- * @property {string} [localAddress]
- * @property {number} [localPort]
- * @property {string} [remoteAddress]
- * @property {number} [remotePort]
- * @property {string} [remoteFamily]
- * @property {number} [timeout]
- * @property {number} bytesWritten
- * @property {number} bytesRead
- */
+function isErrored (body) {
+  return !!(body && stream.isErrored(body))
+}
+
+function isReadable (body) {
+  return !!(body && stream.isReadable(body))
+}
 
-/**
- * @param {import('net').Socket} socket
- * @returns {SocketInfo}
- */
 function getSocketInfo (socket) {
   return {
     localAddress: socket.localAddress,
@@ -644,12 +464,41 @@ function getSocketInfo (socket) {
   }
 }
 
-/**
- * The object should be a FormData instance and contains all the required
- * methods.
- * @param {*} object
- * @returns {object is FormData}
- */
+/** @type {globalThis['ReadableStream']} */
+function ReadableStreamFrom (iterable) {
+  // We cannot use ReadableStream.from here because it does not return a byte stream.
+
+  let iterator
+  return new ReadableStream(
+    {
+      async start () {
+        iterator = iterable[Symbol.asyncIterator]()
+      },
+      async pull (controller) {
+        const { done, value } = await iterator.next()
+        if (done) {
+          queueMicrotask(() => {
+            controller.close()
+            controller.byobRequest?.respond(0)
+          })
+        } else {
+          const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
+          if (buf.byteLength) {
+            controller.enqueue(new Uint8Array(buf))
+          }
+        }
+        return controller.desiredSize > 0
+      },
+      async cancel (reason) {
+        await iterator.return()
+      },
+      type: 'bytes'
+    }
+  )
+}
+
+// The chunk should be a FormData instance and contains
+// all the required methods.
 function isFormDataLike (object) {
   return (
     object &&
@@ -665,58 +514,72 @@ function isFormDataLike (object) {
 }
 
 function addAbortListener (signal, listener) {
-  if (!signal || 'aborted' in signal) {
-    return addAbortListenerNative(signal, listener)[Symbol.dispose]
-  }
-
-  if (typeof signal.addEventListener === 'function') {
+  if ('addEventListener' in signal) {
     signal.addEventListener('abort', listener, { once: true })
     return () => signal.removeEventListener('abort', listener)
   }
-  signal.once('abort', listener)
+  signal.addListener('abort', listener)
   return () => signal.removeListener('abort', listener)
 }
 
-const validTokenChars = new Uint8Array([
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0-15
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
-  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32-47 (!"#$%&'()*+,-./)
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48-63 (0-9:;<=>?)
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64-79 (@A-O)
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80-95 (P-Z[\]^_)
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96-111 (`a-o)
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, // 112-127 (p-z{|}~)
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 128-143
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 144-159
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 160-175
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 176-191
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 192-207
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 208-223
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 224-239
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  // 240-255
-])
+const hasToWellFormed = typeof String.prototype.toWellFormed === 'function'
+const hasIsWellFormed = typeof String.prototype.isWellFormed === 'function'
+
+/**
+ * @param {string} val
+ */
+function toUSVString (val) {
+  return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val)
+}
+
+/**
+ * @param {string} val
+ */
+// TODO: move this to webidl
+function isUSVString (val) {
+  return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`
+}
 
 /**
  * @see https://tools.ietf.org/html/rfc7230#section-3.2.6
  * @param {number} c
- * @returns {boolean}
  */
 function isTokenCharCode (c) {
-  return (validTokenChars[c] === 1)
+  switch (c) {
+    case 0x22:
+    case 0x28:
+    case 0x29:
+    case 0x2c:
+    case 0x2f:
+    case 0x3a:
+    case 0x3b:
+    case 0x3c:
+    case 0x3d:
+    case 0x3e:
+    case 0x3f:
+    case 0x40:
+    case 0x5b:
+    case 0x5c:
+    case 0x5d:
+    case 0x7b:
+    case 0x7d:
+      // DQUOTE and "(),/:;<=>?@[\]{}"
+      return false
+    default:
+      // VCHAR %x21-7E
+      return c >= 0x21 && c <= 0x7e
+  }
 }
 
-const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/
-
 /**
  * @param {string} characters
- * @returns {boolean}
  */
 function isValidHTTPToken (characters) {
-  if (characters.length >= 12) return tokenRegExp.test(characters)
-  if (characters.length === 0) return false
-
-  for (let i = 0; i < characters.length; i++) {
-    if (validTokenChars[characters.charCodeAt(i)] !== 1) {
+  if (characters.length === 0) {
+    return false
+  }
+  for (let i = 0; i < characters.length; ++i) {
+    if (!isTokenCharCode(characters.charCodeAt(i))) {
       return false
     }
   }
@@ -736,48 +599,26 @@ const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/
 
 /**
  * @param {string} characters
- * @returns {boolean}
  */
 function isValidHeaderValue (characters) {
   return !headerCharRegex.test(characters)
 }
 
-const rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+|\*)?$/
-
-/**
- * @typedef {object} RangeHeader
- * @property {number} start
- * @property {number | null} end
- * @property {number | null} size
- */
-
-/**
- * Parse accordingly to RFC 9110
- * @see https://www.rfc-editor.org/rfc/rfc9110#field.content-range
- * @param {string} [range]
- * @returns {RangeHeader|null}
- */
+// Parsed accordingly to RFC 9110
+// https://www.rfc-editor.org/rfc/rfc9110#field.content-range
 function parseRangeHeader (range) {
   if (range == null || range === '') return { start: 0, end: null, size: null }
-  if (!range) return null
 
-  const m = rangeHeaderRegex.exec(range)
+  const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null
   return m
     ? {
         start: parseInt(m[1]),
         end: m[2] ? parseInt(m[2]) : null,
-        size: m[3] && m[3] !== '*' ? parseInt(m[3]) : null
+        size: m[3] ? parseInt(m[3]) : null
       }
     : null
 }
 
-/**
- * @template {import("events").EventEmitter} T
- * @param {T} obj
- * @param {string} name
- * @param {(...args: any[]) => void} listener
- * @returns {T}
- */
 function addListener (obj, name, listener) {
   const listeners = (obj[kListeners] ??= [])
   listeners.push([name, listener])
@@ -785,156 +626,24 @@ function addListener (obj, name, listener) {
   return obj
 }
 
-/**
- * @template {import("events").EventEmitter} T
- * @param {T} obj
- * @returns {T}
- */
 function removeAllListeners (obj) {
-  if (obj[kListeners] != null) {
-    for (const [name, listener] of obj[kListeners]) {
-      obj.removeListener(name, listener)
-    }
-    obj[kListeners] = null
+  for (const [name, listener] of obj[kListeners] ?? []) {
+    obj.removeListener(name, listener)
   }
-  return obj
+  obj[kListeners] = null
 }
 
-/**
- * @param {import ('../dispatcher/client')} client
- * @param {import ('../core/request')} request
- * @param {Error} err
- */
 function errorRequest (client, request, err) {
   try {
-    request.onResponseError(err)
+    request.onError(err)
     assert(request.aborted)
   } catch (err) {
     client.emit('error', err)
   }
 }
 
-/**
- * @param {WeakRef<net.Socket>} socketWeakRef
- * @param {object} opts
- * @param {number} opts.timeout
- * @param {string} opts.hostname
- * @param {number} opts.port
- * @returns {() => void}
- */
-const setupConnectTimeout = process.platform === 'win32'
-  ? (socketWeakRef, opts) => {
-      if (!opts.timeout) {
-        return noop
-      }
-
-      let s1 = null
-      let s2 = null
-      const fastTimer = timers.setFastTimeout(() => {
-      // setImmediate is added to make sure that we prioritize socket error events over timeouts
-        s1 = setImmediate(() => {
-        // Windows needs an extra setImmediate probably due to implementation differences in the socket logic
-          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts))
-        })
-      }, opts.timeout)
-      return () => {
-        timers.clearFastTimeout(fastTimer)
-        clearImmediate(s1)
-        clearImmediate(s2)
-      }
-    }
-  : (socketWeakRef, opts) => {
-      if (!opts.timeout) {
-        return noop
-      }
-
-      let s1 = null
-      const fastTimer = timers.setFastTimeout(() => {
-      // setImmediate is added to make sure that we prioritize socket error events over timeouts
-        s1 = setImmediate(() => {
-          onConnectTimeout(socketWeakRef.deref(), opts)
-        })
-      }, opts.timeout)
-      return () => {
-        timers.clearFastTimeout(fastTimer)
-        clearImmediate(s1)
-      }
-    }
-
-/**
- * @param {net.Socket} socket
- * @param {object} opts
- * @param {number} opts.timeout
- * @param {string} opts.hostname
- * @param {number} opts.port
- */
-function onConnectTimeout (socket, opts) {
-  // The socket could be already garbage collected
-  if (socket == null) {
-    return
-  }
-
-  let message = 'Connect Timeout Error'
-  if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
-    message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`
-  } else {
-    message += ` (attempted address: ${opts.hostname}:${opts.port},`
-  }
-
-  message += ` timeout: ${opts.timeout}ms)`
-
-  destroy(socket, new ConnectTimeoutError(message))
-}
-
-let lastUrlString = null
-let lastProtocol = null
-
-/**
- * @param {string} urlString
- * @returns {string}
- */
-function getProtocolFromUrlString (urlString) {
-  // Requests are typically dispatched against the same origin over and over,
-  // so cache the last (urlString, protocol) pair to skip re-parsing.
-  if (urlString === lastUrlString) {
-    return lastProtocol
-  }
-
-  const protocol = getProtocolFromUrlStringSlow(urlString)
-  lastUrlString = urlString
-  lastProtocol = protocol
-
-  return protocol
-}
-
-/**
- * @param {string} urlString
- * @returns {string}
- */
-function getProtocolFromUrlStringSlow (urlString) {
-  if (
-    urlString[0] === 'h' &&
-    urlString[1] === 't' &&
-    urlString[2] === 't' &&
-    urlString[3] === 'p'
-  ) {
-    switch (urlString[4]) {
-      case ':':
-        return 'http:'
-      case 's':
-        if (urlString[5] === ':') {
-          return 'https:'
-        }
-    }
-  }
-  // fallback if none of the usual suspects
-  return urlString.slice(0, urlString.indexOf(':') + 1)
-}
-
-const kEnumerableProperty = {
-  __proto__: null,
-  enumerable: true
-}
+const kEnumerableProperty = Object.create(null)
+kEnumerableProperty.enumerable = true
 
 const normalizedMethodRecordsBase = {
   delete: 'DELETE',
@@ -948,9 +657,7 @@ const normalizedMethodRecordsBase = {
   post: 'POST',
   POST: 'POST',
   put: 'PUT',
-  PUT: 'PUT',
-  query: 'QUERY',
-  QUERY: 'QUERY'
+  PUT: 'PUT'
 }
 
 const normalizedMethodRecords = {
@@ -965,14 +672,18 @@ Object.setPrototypeOf(normalizedMethodRecords, null)
 
 module.exports = {
   kEnumerableProperty,
+  nop,
   isDisturbed,
+  isErrored,
+  isReadable,
+  toUSVString,
+  isUSVString,
   isBlobLike,
   parseOrigin,
   parseURL,
   getServerName,
   isStream,
   isIterable,
-  hasSafeIterator,
   isAsyncIterable,
   isDestroyed,
   headerNameToString,
@@ -981,19 +692,17 @@ module.exports = {
   removeAllListeners,
   errorRequest,
   parseRawHeaders,
-  toRawHeaders,
-  encodeRawHeaders,
   parseHeaders,
   parseKeepAliveTimeout,
   destroy,
   bodyLength,
   deepClone,
+  ReadableStreamFrom,
   isBuffer,
-  assertRequestHandler,
+  validateHandler,
   getSocketInfo,
   isFormDataLike,
-  pathHasQueryOrFragment,
-  serializePathWithQuery,
+  buildURL,
   addAbortListener,
   isValidHTTPToken,
   isValidHeaderValue,
@@ -1003,8 +712,8 @@ module.exports = {
   normalizedMethodRecords,
   isValidPort,
   isHttpOrHttpsPrefixed,
-  safeHTTPMethods: Object.freeze(['GET', 'HEAD', 'OPTIONS', 'TRACE']),
-  wrapRequestBody,
-  setupConnectTimeout,
-  getProtocolFromUrlString
+  nodeMajor,
+  nodeMinor,
+  safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  wrapRequestBody
 }