undici 6.19.8 → 7.0.0-alpha.1

package/lib/web/websocket/websocket.js

@@ -3,30 +3,45 @@
 const { webidl } = require('../fetch/webidl')
 const { URLSerializer } = require('../fetch/data-url')
 const { environmentSettingsObject } = require('../fetch/util')
-const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require('./constants')
-const {
-  kWebSocketURL,
-  kReadyState,
-  kController,
-  kBinaryType,
-  kResponse,
-  kSentClose,
-  kByteParser
-} = require('./symbols')
+const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes, emptyBuffer } = require('./constants')
 const {
   isConnecting,
   isEstablished,
   isClosing,
   isValidSubprotocol,
-  fireEvent
+  fireEvent,
+  failWebsocketConnection,
+  utf8Decode,
+  toArrayBuffer,
+  isClosed
 } = require('./util')
 const { establishWebSocketConnection, closeWebSocketConnection } = require('./connection')
 const { ByteParser } = require('./receiver')
-const { kEnumerableProperty, isBlobLike } = require('../../core/util')
+const { kEnumerableProperty } = require('../../core/util')
 const { getGlobalDispatcher } = require('../../global')
 const { types } = require('node:util')
-const { ErrorEvent, CloseEvent } = require('./events')
+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 {(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
+ * @property {(err: Error) => void} onSocketError
+ * @property {() => void} onSocketClose
+ *
+ * @property {number} readyState
+ * @property {import('stream').Duplex} socket
+ * @property {number} closeState
+ * @property {boolean} receivedClose
+ */
 
 // https://websockets.spec.whatwg.org/#interface-definition
 class WebSocket extends EventTarget {
@@ -44,6 +59,42 @@ class WebSocket extends EventTarget {
   /** @type {SendQueue} */
   #sendQueue
 
+  /** @type {Handler} */
+  #handler = {
+    onConnectionEstablished: (response, extensions) => this.#onConnectionEstablished(response, extensions),
+    onFail: (reason) => this.#onFail(reason),
+    onMessage: (opcode, data) => this.#onMessage(opcode, data),
+    onClose: (code, reason, reasonByteLength) => this.#onClose(code, reason, reasonByteLength),
+    onParserError: (err) => this.#onParserError(err),
+    onParserDrain: () => this.#onParserDrain(),
+    onSocketData: (chunk) => {
+      if (!this.#parser.write(chunk)) {
+        this.#handler.socket.pause()
+      }
+    },
+    onSocketError: (err) => {
+      this.#handler.readyState = states.CLOSING
+
+      if (channels.socketError.hasSubscribers) {
+        channels.socketError.publish(err)
+      }
+
+      this.#handler.socket.destroy()
+    },
+    onSocketClose: () => this.#onSocketClose(),
+
+    readyState: states.CONNECTING,
+    socket: null,
+    closeState: sentCloseFrameState.NOT_SENT,
+    receivedClose: false
+  }
+
+  #url
+  #controller
+  #binaryType
+  /** @type {import('./receiver').ByteParser} */
+  #parser
+
   /**
    * @param {string} url
    * @param {string|string[]} protocols
@@ -56,7 +107,7 @@ class WebSocket extends EventTarget {
 
     const options = webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'](protocols, prefix, 'options')
 
-    url = webidl.converters.USVString(url, prefix, 'url')
+    url = webidl.converters.USVString(url)
     protocols = options.protocols
 
     // 1. Let baseURL be this's relevant settings object's API base URL.
@@ -113,7 +164,7 @@ class WebSocket extends EventTarget {
     }
 
     // 10. Set this's url to urlRecord.
-    this[kWebSocketURL] = new URL(urlRecord.href)
+    this.#url = new URL(urlRecord.href)
 
     // 11. Let client be this's relevant settings object.
     const client = environmentSettingsObject.settingsObject
@@ -122,21 +173,20 @@ class WebSocket extends EventTarget {
 
     //    1. Establish a WebSocket connection given urlRecord, protocols,
     //       and client.
-    this[kController] = establishWebSocketConnection(
+    this.#controller = establishWebSocketConnection(
       urlRecord,
       protocols,
       client,
-      this,
-      (response, extensions) => this.#onConnectionEstablished(response, extensions),
+      this.#handler,
       options
     )
 
     // Each WebSocket object has an associated ready state, which is a
     // number representing the state of the connection. Initially it must
     // be CONNECTING (0).
-    this[kReadyState] = WebSocket.CONNECTING
+    this.#handler.readyState = WebSocket.CONNECTING
 
-    this[kSentClose] = sentCloseFrameState.NOT_SENT
+    this.#handler.closeState = sentCloseFrameState.NOT_SENT
 
     // The extensions attribute must initially return the empty string.
 
@@ -144,7 +194,7 @@ class WebSocket extends EventTarget {
 
     // Each WebSocket object has an associated binary type, which is a
     // BinaryType. Initially it must be "blob".
-    this[kBinaryType] = 'blob'
+    this.#binaryType = 'blob'
   }
 
   /**
@@ -162,7 +212,7 @@ class WebSocket extends EventTarget {
     }
 
     if (reason !== undefined) {
-      reason = webidl.converters.USVString(reason, prefix, 'reason')
+      reason = webidl.converters.USVString(reason)
     }
 
     // 1. If code is present, but is neither an integer equal to 1000 nor an
@@ -192,7 +242,7 @@ class WebSocket extends EventTarget {
     }
 
     // 3. Run the first matching steps from the following list:
-    closeWebSocketConnection(this, code, reason, reasonByteLength)
+    closeWebSocketConnection(this.#handler, code, reason, reasonByteLength)
   }
 
   /**
@@ -209,7 +259,7 @@ class WebSocket extends EventTarget {
 
     // 1. If this's ready state is CONNECTING, then throw an
     //    "InvalidStateError" DOMException.
-    if (isConnecting(this)) {
+    if (isConnecting(this.#handler.readyState)) {
       throw new DOMException('Sent before connected.', 'InvalidStateError')
     }
 
@@ -217,7 +267,7 @@ class WebSocket extends EventTarget {
     // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
     // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
 
-    if (!isEstablished(this) || isClosing(this)) {
+    if (!isEstablished(this.#handler.readyState) || isClosing(this.#handler.readyState)) {
       return
     }
 
@@ -234,12 +284,12 @@ class WebSocket extends EventTarget {
       // the bufferedAmount attribute by the number of bytes needed to
       // express the argument as UTF-8.
 
-      const length = Buffer.byteLength(data)
+      const buffer = Buffer.from(data)
 
-      this.#bufferedAmount += length
-      this.#sendQueue.add(data, () => {
-        this.#bufferedAmount -= length
-      }, sendHints.string)
+      this.#bufferedAmount += buffer.byteLength
+      this.#sendQueue.add(buffer, () => {
+        this.#bufferedAmount -= buffer.byteLength
+      }, sendHints.text)
     } else if (types.isArrayBuffer(data)) {
       // If the WebSocket connection is established, and the WebSocket
       // closing handshake has not yet started, then the user agent must
@@ -274,7 +324,7 @@ class WebSocket extends EventTarget {
       this.#sendQueue.add(data, () => {
         this.#bufferedAmount -= data.byteLength
       }, sendHints.typedArray)
-    } else if (isBlobLike(data)) {
+    } else if (data instanceof Blob) {
       // 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
@@ -297,7 +347,7 @@ class WebSocket extends EventTarget {
     webidl.brandCheck(this, WebSocket)
 
     // The readyState getter steps are to return this's ready state.
-    return this[kReadyState]
+    return this.#handler.readyState
   }
 
   get bufferedAmount () {
@@ -310,7 +360,7 @@ class WebSocket extends EventTarget {
     webidl.brandCheck(this, WebSocket)
 
     // The url getter steps are to return this's url, serialized.
-    return URLSerializer(this[kWebSocketURL])
+    return URLSerializer(this.#url)
   }
 
   get extensions () {
@@ -412,16 +462,16 @@ class WebSocket extends EventTarget {
   get binaryType () {
     webidl.brandCheck(this, WebSocket)
 
-    return this[kBinaryType]
+    return this.#binaryType
   }
 
   set binaryType (type) {
     webidl.brandCheck(this, WebSocket)
 
     if (type !== 'blob' && type !== 'arraybuffer') {
-      this[kBinaryType] = 'blob'
+      this.#binaryType = 'blob'
     } else {
-      this[kBinaryType] = type
+      this.#binaryType = type
     }
   }
 
@@ -431,19 +481,17 @@ class WebSocket extends EventTarget {
   #onConnectionEstablished (response, parsedExtensions) {
     // processResponse is called when the "response’s header list has been received and initialized."
     // once this happens, the connection is open
-    this[kResponse] = response
+    this.#handler.socket = response.socket
 
-    const parser = new ByteParser(this, parsedExtensions)
-    parser.on('drain', onParserDrain)
-    parser.on('error', onParserError.bind(this))
-
-    response.socket.ws = this
-    this[kByteParser] = parser
+    const parser = new ByteParser(this.#handler, parsedExtensions)
+    parser.on('drain', () => this.#handler.onParserDrain())
+    parser.on('error', (err) => this.#handler.onParserError(err))
 
+    this.#parser = parser
     this.#sendQueue = new SendQueue(response.socket)
 
     // 1. Change the ready state to OPEN (1).
-    this[kReadyState] = states.OPEN
+    this.#handler.readyState = states.OPEN
 
     // 2. Change the extensions attribute’s value to the extensions in use, if
     //    it is not the null value.
@@ -466,6 +514,202 @@ class WebSocket extends EventTarget {
     // 4. Fire an event named open at the WebSocket object.
     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
+
+    if (reason) {
+      // TODO: process.nextTick
+      fireEvent('error', this, (type, init) => new ErrorEvent(type, init), {
+        error: new Error(reason),
+        message: reason
+      })
+    }
+  }
+
+  #onMessage (type, data) {
+    // 1. If ready state is not OPEN (1), then return.
+    if (this.#handler.readyState !== states.OPEN) {
+      return
+    }
+
+    // 2. Let dataForEvent be determined by switching on type and binary type:
+    let dataForEvent
+
+    if (type === opcodes.TEXT) {
+      // -> type indicates that the data is Text
+      //      a new DOMString containing data
+      try {
+        dataForEvent = utf8Decode(data)
+      } catch {
+        failWebsocketConnection(this.#handler, 'Received invalid UTF-8 in text frame.')
+        return
+      }
+    } else if (type === opcodes.BINARY) {
+      if (this.#binaryType === 'blob') {
+        // -> type indicates that the data is Binary and binary type is "blob"
+        //      a new Blob object, created in the relevant Realm of the WebSocket
+        //      object, that represents data as its raw data
+        dataForEvent = new Blob([data])
+      } else {
+        // -> type indicates that the data is Binary and binary type is "arraybuffer"
+        //      a new ArrayBuffer object, created in the relevant Realm of the
+        //      WebSocket object, whose contents are data
+        dataForEvent = toArrayBuffer(data)
+      }
+    }
+
+    // 3. Fire an event named message at the WebSocket object, using MessageEvent,
+    //    with the origin attribute initialized to the serialization of the WebSocket
+    //    object’s url's origin, and the data attribute initialized to dataForEvent.
+    fireEvent('message', this, createFastMessageEvent, {
+      origin: this.#url.origin,
+      data: dataForEvent
+    })
+  }
+
+  #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()
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+   * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
+   */
+  #onSocketClose () {
+    // 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
+
+    let code = 1005
+    let reason = ''
+
+    const result = this.#parser.closingInfo
+
+    if (result && !result.error) {
+      code = result.code ?? 1005
+      reason = result.reason
+    } else if (!this.#handler.receivedClose) {
+      // 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
+      // is lost), _The WebSocket Connection Close Code_ is considered to be
+      // 1006.
+      code = 1006
+    }
+
+    // 1. Change the ready state to CLOSED (3).
+    this.#handler.readyState = states.CLOSED
+
+    // 2. If the user agent was required to fail the WebSocket
+    //    connection, or if the WebSocket connection was closed
+    //    after being flagged as full, fire an event named error
+    //    at the WebSocket object.
+    // TODO
+
+    // 3. Fire an event named close at the WebSocket object,
+    //    using CloseEvent, with the wasClean attribute
+    //    initialized to true if the connection closed cleanly
+    //    and false otherwise, the code attribute initialized to
+    //    the WebSocket connection close code, and the reason
+    //    attribute initialized to the result of applying UTF-8
+    //    decode without BOM to the WebSocket connection close
+    //    reason.
+    // TODO: process.nextTick
+    fireEvent('close', this, (type, init) => new CloseEvent(type, init), {
+      wasClean, code, reason
+    })
+
+    if (channels.close.hasSubscribers) {
+      channels.close.publish({
+        websocket: this,
+        code,
+        reason
+      })
+    }
+  }
 }
 
 // https://websockets.spec.whatwg.org/#dom-websocket-connecting
@@ -514,7 +758,7 @@ webidl.converters['sequence<DOMString>'] = webidl.sequenceConverter(
 )
 
 webidl.converters['DOMString or sequence<DOMString>'] = function (V, prefix, argument) {
-  if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) {
+  if (webidl.util.Type(V) === webidl.util.Types.OBJECT && Symbol.iterator in V) {
     return webidl.converters['sequence<DOMString>'](V)
   }
 
@@ -540,7 +784,7 @@ webidl.converters.WebSocketInit = webidl.dictionaryConverter([
 ])
 
 webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = function (V) {
-  if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) {
+  if (webidl.util.Type(V) === webidl.util.Types.OBJECT && !(Symbol.iterator in V)) {
     return webidl.converters.WebSocketInit(V)
   }
 
@@ -548,39 +792,19 @@ webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = functio
 }
 
 webidl.converters.WebSocketSendData = function (V) {
-  if (webidl.util.Type(V) === 'Object') {
-    if (isBlobLike(V)) {
-      return webidl.converters.Blob(V, { strict: false })
+  if (webidl.util.Type(V) === webidl.util.Types.OBJECT) {
+    if (V instanceof Blob) {
+      return V
     }
 
     if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
-      return webidl.converters.BufferSource(V)
+      return V
     }
   }
 
   return webidl.converters.USVString(V)
 }
 
-function onParserDrain () {
-  this.ws[kResponse].socket.resume()
-}
-
-function 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, code)
-}
-
 module.exports = {
   WebSocket
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "6.19.8",
+  "version": "7.0.0-alpha.1",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -65,19 +65,19 @@
     "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",
     "prebuild:wasm": "node build/wasm.js --prebuild",
     "build:wasm": "node build/wasm.js --docker",
-    "lint": "standard | snazzy",
-    "lint:fix": "standard --fix | snazzy",
+    "generate-pem": "node scripts/generate-pem.js",
+    "lint": "eslint --cache",
+    "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE=  npm run test:typescript",
-    "test:javascript": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:jest",
-    "test:javascript:withoutintl": "node scripts/generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:fetch:nobuild && npm run test:cache && npm run test:interceptors && npm run test:cookies && npm run test:eventsource:nobuild && npm run test:wpt:withoutintl && npm run test:node-test",
+    "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test",
+    "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp -p \"test/busboy/*.js\"",
     "test:cache": "borp -p \"test/cache/*.js\"",
     "test:cookies": "borp -p \"test/cookie/*.js\"",
-    "test:eventsource": "npm run build:node && npm run test:eventsource:nobuild",
-    "test:eventsource:nobuild": "borp --expose-gc -p \"test/eventsource/*.js\"",
+    "test:eventsource": "npm run build:node && borp --expose-gc -p \"test/eventsource/*.js\"",
     "test:fuzzing": "node test/fuzzing/fuzzing.test.js",
-    "test:fetch": "npm run build:node && npm run test:fetch:nobuild",
-    "test:fetch:nobuild": "borp --timeout 180000 --expose-gc --concurrency 1 -p \"test/fetch/*.js\" && npm run test:webidl && npm run test:busboy",
+    "test:fetch": "npm run build:node && borp --timeout 180000 --expose-gc --concurrency 1 -p \"test/fetch/*.js\" && npm run test:webidl && npm run test:busboy",
     "test:interceptors": "borp -p \"test/interceptors/*.js\"",
     "test:jest": "cross-env NODE_V8_COVERAGE= jest",
     "test:unit": "borp --expose-gc -p \"test/*.js\"",
@@ -85,12 +85,12 @@
     "test:node-test": "borp -p \"test/node-test/**/*.js\"",
     "test:tdd": "borp --expose-gc -p \"test/*.js\"",
     "test:tdd:node-test": "borp -p \"test/node-test/**/*.js\" -w",
-    "test:typescript": "tsd && tsc test/imports/undici-import.ts --typeRoots ./types && tsc ./types/*.d.ts --noEmit --typeRoots ./types",
+    "test:typescript": "tsd && tsc test/imports/undici-import.ts --typeRoots ./types --noEmit && tsc ./types/*.d.ts --noEmit --typeRoots ./types",
     "test:webidl": "borp -p \"test/webidl/*.js\"",
     "test:websocket": "borp -p \"test/websocket/*.js\"",
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
-    "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-FileAPI.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
+    "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
     "test:wpt:withoutintl": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
@@ -102,27 +102,24 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "2.1.1",
+    "@fastify/busboy": "3.0.0",
     "@matteo.collina/tspl": "^0.1.1",
     "@sinonjs/fake-timers": "^11.1.0",
-    "@types/node": "^18.0.3",
+    "@types/node": "~18.17.19",
     "abort-controller": "^3.0.0",
-    "borp": "^0.15.0",
+    "borp": "^0.17.0",
     "c8": "^10.0.0",
     "cross-env": "^7.0.3",
     "dns-packet": "^5.4.0",
+    "eslint": "^9.9.0",
     "fast-check": "^3.17.1",
-    "form-data": "^4.0.0",
-    "formdata-node": "^6.0.3",
     "https-pem": "^3.0.0",
     "husky": "^9.0.7",
     "jest": "^29.0.2",
-    "jsdom": "^24.0.0",
+    "neostandard": "^0.11.2",
     "node-forge": "^1.3.1",
     "pre-commit": "^1.2.2",
     "proxy": "^2.1.1",
-    "snazzy": "^9.0.0",
-    "standard": "^17.0.0",
     "tsd": "^0.31.0",
     "typescript": "^5.0.2",
     "ws": "^8.11.0"
@@ -130,16 +127,6 @@
   "engines": {
     "node": ">=18.17"
   },
-  "standard": {
-    "env": [
-      "jest"
-    ],
-    "ignore": [
-      "lib/llhttp/constants.js",
-      "lib/llhttp/utils.js",
-      "test/fixtures/wpt"
-    ]
-  },
   "tsd": {
     "directory": "test/types",
     "compilerOptions": {

package/scripts/strip-comments.js

@@ -3,6 +3,8 @@
 const { readFileSync, writeFileSync } = require('node:fs')
 const { transcode } = require('node:buffer')
 
-const buffer = transcode(readFileSync('./undici-fetch.js'), 'utf8', 'latin1')
+const buffer = transcode
+  ? transcode(readFileSync('./undici-fetch.js'), 'utf8', 'latin1')
+  : readFileSync('./undici-fetch.js')
 
 writeFileSync('./undici-fetch.js', buffer.toString('latin1'))