undici 7.0.0-alpha.1 → 7.0.0-alpha.2

package/lib/web/websocket/websocket.js

@@ -3,7 +3,7 @@
 const { webidl } = require('../fetch/webidl')
 const { URLSerializer } = require('../fetch/data-url')
 const { environmentSettingsObject } = require('../fetch/util')
-const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes, emptyBuffer } = require('./constants')
+const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes } = require('./constants')
 const {
   isConnecting,
   isEstablished,
@@ -13,7 +13,7 @@ const {
   failWebsocketConnection,
   utf8Decode,
   toArrayBuffer,
-  isClosed
+  getURLRecord
 } = require('./util')
 const { establishWebSocketConnection, closeWebSocketConnection } = require('./connection')
 const { ByteParser } = require('./receiver')
@@ -22,15 +22,13 @@ const { getGlobalDispatcher } = require('../../global')
 const { types } = require('node:util')
 const { ErrorEvent, CloseEvent, createFastMessageEvent } = require('./events')
 const { SendQueue } = require('./sender')
-const { WebsocketFrameSend } = require('./frame')
 const { channels } = require('../../core/diagnostics')
 
 /**
  * @typedef {object} Handler
  * @property {(response: any, extensions?: string[]) => void} onConnectionEstablished
- * @property {(reason: any) => void} onFail
+ * @property {(code: number, reason: any) => void} onFail
  * @property {(opcode: number, data: Buffer) => void} onMessage
- * @property {(code: number, reason: any, reasonByteLength: number) => void} onClose
  * @property {(error: Error) => void} onParserError
  * @property {() => void} onParserDrain
  * @property {(chunk: Buffer) => void} onSocketData
@@ -39,8 +37,9 @@ const { channels } = require('../../core/diagnostics')
  *
  * @property {number} readyState
  * @property {import('stream').Duplex} socket
- * @property {number} closeState
- * @property {boolean} receivedClose
+ * @property {Set<number>} closeState
+ * @property {import('../fetch/index').Fetch} controller
+ * @property {boolean} [wasEverConnected=false]
  */
 
 // https://websockets.spec.whatwg.org/#interface-definition
@@ -62,10 +61,9 @@ class WebSocket extends EventTarget {
   /** @type {Handler} */
   #handler = {
     onConnectionEstablished: (response, extensions) => this.#onConnectionEstablished(response, extensions),
-    onFail: (reason) => this.#onFail(reason),
+    onFail: (code, reason) => this.#onFail(code, reason),
     onMessage: (opcode, data) => this.#onMessage(opcode, data),
-    onClose: (code, reason, reasonByteLength) => this.#onClose(code, reason, reasonByteLength),
-    onParserError: (err) => this.#onParserError(err),
+    onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
     onParserDrain: () => this.#onParserDrain(),
     onSocketData: (chunk) => {
       if (!this.#parser.write(chunk)) {
@@ -85,12 +83,12 @@ class WebSocket extends EventTarget {
 
     readyState: states.CONNECTING,
     socket: null,
-    closeState: sentCloseFrameState.NOT_SENT,
-    receivedClose: false
+    closeState: new Set(),
+    controller: null,
+    wasEverConnected: false
   }
 
   #url
-  #controller
   #binaryType
   /** @type {import('./receiver').ByteParser} */
   #parser
@@ -113,45 +111,16 @@ class WebSocket extends EventTarget {
     // 1. Let baseURL be this's relevant settings object's API base URL.
     const baseURL = environmentSettingsObject.settingsObject.baseUrl
 
-    // 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
-    let urlRecord
+    // 2. Let urlRecord be the result of getting a URL record given url and baseURL.
+    const urlRecord = getURLRecord(url, baseURL)
 
-    try {
-      urlRecord = new URL(url, baseURL)
-    } catch (e) {
-      // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
-      throw new DOMException(e, 'SyntaxError')
-    }
-
-    // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
-    if (urlRecord.protocol === 'http:') {
-      urlRecord.protocol = 'ws:'
-    } else if (urlRecord.protocol === 'https:') {
-      // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
-      urlRecord.protocol = 'wss:'
-    }
-
-    // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
-    if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
-      throw new DOMException(
-        `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
-        'SyntaxError'
-      )
-    }
-
-    // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
-    //    DOMException.
-    if (urlRecord.hash || urlRecord.href.endsWith('#')) {
-      throw new DOMException('Got fragment', 'SyntaxError')
-    }
-
-    // 8. If protocols is a string, set protocols to a sequence consisting
+    // 3. If protocols is a string, set protocols to a sequence consisting
     //    of just that string.
     if (typeof protocols === 'string') {
       protocols = [protocols]
     }
 
-    // 9. If any of the values in protocols occur more than once or otherwise
+    // 4. If any of the values in protocols occur more than once or otherwise
     //    fail to match the requirements for elements that comprise the value
     //    of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
     //    protocol, then throw a "SyntaxError" DOMException.
@@ -163,17 +132,16 @@ class WebSocket extends EventTarget {
       throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
     }
 
-    // 10. Set this's url to urlRecord.
+    // 5. Set this's url to urlRecord.
     this.#url = new URL(urlRecord.href)
 
-    // 11. Let client be this's relevant settings object.
+    // 6. Let client be this's relevant settings object.
     const client = environmentSettingsObject.settingsObject
 
-    // 12. Run this step in parallel:
-
-    //    1. Establish a WebSocket connection given urlRecord, protocols,
-    //       and client.
-    this.#controller = establishWebSocketConnection(
+    // 7. Run this step in parallel:
+    // 7.1. Establish a WebSocket connection given urlRecord, protocols,
+    //      and client.
+    this.#handler.controller = establishWebSocketConnection(
       urlRecord,
       protocols,
       client,
@@ -186,8 +154,6 @@ class WebSocket extends EventTarget {
     // be CONNECTING (0).
     this.#handler.readyState = WebSocket.CONNECTING
 
-    this.#handler.closeState = sentCloseFrameState.NOT_SENT
-
     // The extensions attribute must initially return the empty string.
 
     // The protocol attribute must initially return the empty string.
@@ -215,34 +181,14 @@ class WebSocket extends EventTarget {
       reason = webidl.converters.USVString(reason)
     }
 
-    // 1. If code is present, but is neither an integer equal to 1000 nor an
-    //    integer in the range 3000 to 4999, inclusive, throw an
-    //    "InvalidAccessError" DOMException.
-    if (code !== undefined) {
-      if (code !== 1000 && (code < 3000 || code > 4999)) {
-        throw new DOMException('invalid code', 'InvalidAccessError')
-      }
-    }
-
-    let reasonByteLength = 0
+    // 1. If code is the special value "missing", then set code to null.
+    code ??= null
 
-    // 2. If reason is present, then run these substeps:
-    if (reason !== undefined) {
-      // 1. Let reasonBytes be the result of encoding reason.
-      // 2. If reasonBytes is longer than 123 bytes, then throw a
-      //    "SyntaxError" DOMException.
-      reasonByteLength = Buffer.byteLength(reason)
-
-      if (reasonByteLength > 123) {
-        throw new DOMException(
-          `Reason must be less than 123 bytes; received ${reasonByteLength}`,
-          'SyntaxError'
-        )
-      }
-    }
+    // 2. If reason is the special value "missing", then set reason to the empty string.
+    reason ??= ''
 
-    // 3. Run the first matching steps from the following list:
-    closeWebSocketConnection(this.#handler, code, reason, reasonByteLength)
+    // 3. Close the WebSocket with this, code, and reason.
+    closeWebSocketConnection(this.#handler, code, reason, true)
   }
 
   /**
@@ -324,7 +270,7 @@ class WebSocket extends EventTarget {
       this.#sendQueue.add(data, () => {
         this.#bufferedAmount -= data.byteLength
       }, sendHints.typedArray)
-    } else if (data instanceof Blob) {
+    } else if (webidl.is.Blob(data)) {
       // If the WebSocket connection is established, and the WebSocket
       // closing handshake has not yet started, then the user agent must
       // send a WebSocket Message comprised of data using a binary frame
@@ -515,15 +461,7 @@ class WebSocket extends EventTarget {
     fireEvent('open', this)
   }
 
-  #onFail (reason) {
-    this.#controller.abort()
-
-    if (this.#handler.socket && !this.#handler.socket.destroyed) {
-      this.#handler.socket.destroy()
-    }
-
-    this.#handler.readyState = states.CLOSED
-
+  #onFail (code, reason) {
     if (reason) {
       // TODO: process.nextTick
       fireEvent('error', this, (type, init) => new ErrorEvent(type, init), {
@@ -531,6 +469,16 @@ class WebSocket extends EventTarget {
         message: reason
       })
     }
+
+    if (!this.#handler.wasEverConnected) {
+      this.#handler.readyState = states.CLOSED
+
+      // If the WebSocket connection could not be established, it is also said
+      // that _The WebSocket Connection is Closed_, but not _cleanly_.
+      fireEvent('close', this, (type, init) => new CloseEvent(type, init), {
+        wasClean: false, code, reason
+      })
+    }
   }
 
   #onMessage (type, data) {
@@ -548,7 +496,7 @@ class WebSocket extends EventTarget {
       try {
         dataForEvent = utf8Decode(data)
       } catch {
-        failWebsocketConnection(this.#handler, 'Received invalid UTF-8 in text frame.')
+        failWebsocketConnection(this.#handler, 1007, 'Received invalid UTF-8 in text frame.')
         return
       }
     } else if (type === opcodes.BINARY) {
@@ -574,81 +522,6 @@ class WebSocket extends EventTarget {
     })
   }
 
-  #onClose (code, reason, reasonByteLength) {
-    if (isClosing(this.#handler.readyState) || isClosed(this.#handler.readyState)) {
-      // If this's ready state is CLOSING (2) or CLOSED (3)
-      // Do nothing.
-    } else if (!isEstablished(this.#handler.readyState)) {
-      // If the WebSocket connection is not yet established
-      // Fail the WebSocket connection and set this's ready state
-      // to CLOSING (2).
-      failWebsocketConnection(this.#handler, 'Connection was closed before it was established.')
-      this.#handler.readyState = states.CLOSING
-    } else if (this.#handler.closeState === sentCloseFrameState.NOT_SENT) {
-      // If the WebSocket closing handshake has not yet been started
-      // Start the WebSocket closing handshake and set this's ready
-      // state to CLOSING (2).
-      // - If neither code nor reason is present, the WebSocket Close
-      //   message must not have a body.
-      // - If code is present, then the status code to use in the
-      //   WebSocket Close message must be the integer given by code.
-      // - If reason is also present, then reasonBytes must be
-      //   provided in the Close message after the status code.
-
-      this.#handler.closeState = sentCloseFrameState.PROCESSING
-
-      const frame = new WebsocketFrameSend()
-
-      // If neither code nor reason is present, the WebSocket Close
-      // message must not have a body.
-
-      // If code is present, then the status code to use in the
-      // WebSocket Close message must be the integer given by code.
-      if (code !== undefined && reason === undefined) {
-        frame.frameData = Buffer.allocUnsafe(2)
-        frame.frameData.writeUInt16BE(code, 0)
-      } else if (code !== undefined && reason !== undefined) {
-        // If reason is also present, then reasonBytes must be
-        // provided in the Close message after the status code.
-        frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
-        frame.frameData.writeUInt16BE(code, 0)
-        // the body MAY contain UTF-8-encoded data with value /reason/
-        frame.frameData.write(reason, 2, 'utf-8')
-      } else {
-        frame.frameData = emptyBuffer
-      }
-
-      this.#handler.socket.write(frame.createFrame(opcodes.CLOSE))
-
-      this.#handler.closeState = sentCloseFrameState.SENT
-
-      // Upon either sending or receiving a Close control frame, it is said
-      // that _The WebSocket Closing Handshake is Started_ and that the
-      // WebSocket connection is in the CLOSING state.
-      this.#handler.readyState = states.CLOSING
-    } else {
-      // Otherwise
-      // Set this's ready state to CLOSING (2).
-      this.#handler.readyState = states.CLOSING
-    }
-  }
-
-  #onParserError (err) {
-    let message
-    let code
-
-    if (err instanceof CloseEvent) {
-      message = err.reason
-      code = err.code
-    } else {
-      message = err.message
-    }
-
-    fireEvent('error', this, () => new ErrorEvent('error', { error: err, message }))
-
-    closeWebSocketConnection(this.#handler, code)
-  }
-
   #onParserDrain () {
     this.#handler.socket.resume()
   }
@@ -661,7 +534,9 @@ class WebSocket extends EventTarget {
     // If the TCP connection was closed after the
     // WebSocket closing handshake was completed, the WebSocket connection
     // is said to have been closed _cleanly_.
-    const wasClean = this.#handler.closeState === sentCloseFrameState.SENT && this.#handler.receivedClose
+    const wasClean =
+      this.#handler.closeState.has(sentCloseFrameState.SENT) &&
+      this.#handler.closeState.has(sentCloseFrameState.RECEIVED)
 
     let code = 1005
     let reason = ''
@@ -671,7 +546,7 @@ class WebSocket extends EventTarget {
     if (result && !result.error) {
       code = result.code ?? 1005
       reason = result.reason
-    } else if (!this.#handler.receivedClose) {
+    } else if (!this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
       // If _The WebSocket
       // Connection is Closed_ and no Close control frame was received by the
       // endpoint (such as could occur if the underlying transport connection
@@ -793,7 +668,7 @@ webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = functio
 
 webidl.converters.WebSocketSendData = function (V) {
   if (webidl.util.Type(V) === webidl.util.Types.OBJECT) {
-    if (V instanceof Blob) {
+    if (webidl.is.Blob(V)) {
       return V
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-alpha.2",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -62,7 +62,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "build:node": "npx esbuild@0.19.10 index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
+    "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
     "prebuild:wasm": "node build/wasm.js --prebuild",
     "build:wasm": "node build/wasm.js --docker",
     "generate-pem": "node scripts/generate-pem.js",
@@ -105,12 +105,13 @@
     "@fastify/busboy": "3.0.0",
     "@matteo.collina/tspl": "^0.1.1",
     "@sinonjs/fake-timers": "^11.1.0",
-    "@types/node": "~18.17.19",
+    "@types/node": "^18.19.50",
     "abort-controller": "^3.0.0",
     "borp": "^0.17.0",
     "c8": "^10.0.0",
     "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
+    "esbuild": "^0.24.0",
     "eslint": "^9.9.0",
     "fast-check": "^3.17.1",
     "https-pem": "^3.0.0",
@@ -118,10 +119,9 @@
     "jest": "^29.0.2",
     "neostandard": "^0.11.2",
     "node-forge": "^1.3.1",
-    "pre-commit": "^1.2.2",
     "proxy": "^2.1.1",
-    "tsd": "^0.31.0",
-    "typescript": "^5.0.2",
+    "tsd": "^0.31.2",
+    "typescript": "^5.6.2",
     "ws": "^8.11.0"
   },
   "engines": {

package/types/interceptors.d.ts

@@ -1,5 +1,6 @@
 import Dispatcher from './dispatcher'
 import RetryHandler from './retry-handler'
+import { LookupOptions } from 'node:dns'
 
 export default Interceptors
 
@@ -7,11 +8,24 @@ declare namespace Interceptors {
   export type DumpInterceptorOpts = { maxSize?: number }
   export type RetryInterceptorOpts = RetryHandler.RetryOptions
   export type RedirectInterceptorOpts = { maxRedirections?: number }
+
   export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
+  // DNS interceptor
+  export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
+  export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
+  export type DNSInterceptorOpts = {
+    maxTTL?: number
+    maxItems?: number
+    lookup?: (hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
+    pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord
+    dualStack?: boolean
+    affinity?: 4 | 6
+  }
 
   export function createRedirectInterceptor (opts: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function retry (opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function redirect (opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
 }

package/types/mock-agent.d.ts

@@ -46,5 +46,8 @@ declare namespace MockAgent {
   export interface Options extends Agent.Options {
     /** A custom agent to be encapsulated by the MockAgent. */
     agent?: Dispatcher;
+
+    /** Ignore trailing slashes in the path */
+    ignoreTrailingSlash?: boolean;
   }
 }

package/types/readable.d.ts

@@ -4,11 +4,13 @@ import { Blob } from 'buffer'
 export default BodyReadable
 
 declare class BodyReadable extends Readable {
-  constructor (
-    resume?: (this: Readable, size: number) => void | null,
-    abort?: () => void | null,
-    contentType?: string
-  )
+  constructor (opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  })
 
   /** Consumes and returns the body as a string
    *  https://fetch.spec.whatwg.org/#dom-body-text
@@ -59,7 +61,8 @@ declare class BodyReadable extends Readable {
   readonly body: never | undefined
 
   /** Dumps the response body by reading `limit` number of bytes.
-   * @param opts.limit Number of bytes to read (optional) - Default: 262144
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
    */
-  dump (opts?: { limit: number }): Promise<void>
+  dump (opts?: { limit: number; signal?: AbortSignal }): Promise<void>
 }

package/types/webidl.d.ts

@@ -1,4 +1,5 @@
 // These types are not exported, and are only used internally
+import * as undici from './index'
 
 /**
  * Take in an unknown value and return one that is of type T
@@ -49,7 +50,7 @@ interface WebidlUtil {
   /**
    * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
    */
-  Type (object: unknown): WebIDLTypes
+  Type (object: unknown): WebIDLTypes[keyof WebIDLTypes]
 
   TypeValueToString (o: unknown):
     | 'Undefined'
@@ -82,6 +83,8 @@ interface WebidlUtil {
    * Stringifies {@param V}
    */
   Stringify (V: any): string
+
+  MakeTypeAssertion <T extends { prototype: T }>(Prototype: T['prototype']): (arg: any) => arg is T
 }
 
 interface WebidlConverters {
@@ -173,10 +176,27 @@ interface WebidlConverters {
   [Key: string]: (...args: any[]) => unknown
 }
 
+type IsAssertion<T> = (arg: any) => arg is T
+
+interface WebidlIs {
+  Request: IsAssertion<undici.Request>
+  Response: IsAssertion<undici.Response>
+  ReadableStream: IsAssertion<ReadableStream>
+  Blob: IsAssertion<Blob>
+  URLSearchParams: IsAssertion<URLSearchParams>
+  File: IsAssertion<File>
+  FormData: IsAssertion<undici.FormData>
+  URL: IsAssertion<URL>
+  WebSocketError: IsAssertion<undici.WebSocketError>
+  AbortSignal: IsAssertion<AbortSignal>
+  MessagePort: IsAssertion<MessagePort>
+}
+
 export interface Webidl {
   errors: WebidlErrors
   util: WebidlUtil
   converters: WebidlConverters
+  is: WebidlIs
 
   /**
    * @description Performs a brand-check on {@param V} to ensure it is a
@@ -184,7 +204,7 @@ export interface Webidl {
    */
   brandCheck <Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface
 
-  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (V: unknown, list: Interfaces): asserts V is Interfaces[number]
+  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (list: Interfaces): (V: any) => asserts V is Interfaces[number]
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-sequence
@@ -207,11 +227,11 @@ export interface Webidl {
    * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
    * interfaces are allowed.
    */
-  interfaceConverter <Interface>(cls: Interface): (
+  interfaceConverter <Interface>(typeCheck: IsAssertion<Interface>, name: string): (
     V: unknown,
     prefix: string,
     argument: string
-  ) => asserts V is typeof cls
+  ) => asserts V is Interface
 
   // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
   // from the converters given?

package/types/websocket.d.ts

@@ -148,3 +148,36 @@ interface WebSocketInit {
   dispatcher?: Dispatcher,
   headers?: HeadersInit
 }
+
+interface WebSocketStreamOptions {
+  protocols?: string | string[]
+  signal?: AbortSignal
+}
+
+interface WebSocketCloseInfo {
+  closeCode: number
+  reason: string
+}
+
+interface WebSocketStream {
+  closed: Promise<WebSocketCloseInfo>
+  opened: Promise<{
+    extensions: string
+    protocol: string
+    readable: ReadableStream
+    writable: WritableStream
+  }>
+  url: string
+}
+
+export declare const WebSocketStream: {
+  prototype: WebSocketStream
+  new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream
+}
+
+interface WebSocketError extends Event, WebSocketCloseInfo {}
+
+export declare const WebSocketError: {
+  prototype: WebSocketError
+  new (type: string, init?: WebSocketCloseInfo): WebSocketError
+}

package/lib/mock/pluralizer.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const singulars = {
-  pronoun: 'it',
-  is: 'is',
-  was: 'was',
-  this: 'this'
-}
-
-const plurals = {
-  pronoun: 'they',
-  is: 'are',
-  was: 'were',
-  this: 'these'
-}
-
-module.exports = class Pluralizer {
-  constructor (singular, plural) {
-    this.singular = singular
-    this.plural = plural
-  }
-
-  pluralize (count) {
-    const one = count === 1
-    const keys = one ? singulars : plurals
-    const noun = one ? this.singular : this.plural
-    return { ...keys, count, noun }
-  }
-}

package/lib/web/cache/symbols.js

@@ -1,5 +0,0 @@
-'use strict'
-
-module.exports = {
-  kConstruct: require('../../core/symbols').kConstruct
-}

package/lib/web/fetch/symbols.js

@@ -1,8 +0,0 @@
-'use strict'
-
-module.exports = {
-  kHeaders: Symbol('headers'),
-  kSignal: Symbol('signal'),
-  kState: Symbol('state'),
-  kDispatcher: Symbol('dispatcher')
-}