@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/undici/lib/web/websocket/events.js

@@ -1,10 +1,9 @@
 'use strict'
 
-const { webidl } = require('../webidl')
+const { webidl } = require('../fetch/webidl')
 const { kEnumerableProperty } = require('../../core/util')
 const { kConstruct } = require('../../core/symbols')
-
-let createFastMessageEvent
+const { MessagePort } = require('node:worker_threads')
 
 /**
  * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
@@ -32,31 +31,31 @@ class MessageEvent extends Event {
   }
 
   get data () {
-    webidl.brandCheck(this, webidl.is.MessageEvent)
+    webidl.brandCheck(this, MessageEvent)
 
     return this.#eventInit.data
   }
 
   get origin () {
-    webidl.brandCheck(this, webidl.is.MessageEvent)
+    webidl.brandCheck(this, MessageEvent)
 
     return this.#eventInit.origin
   }
 
   get lastEventId () {
-    webidl.brandCheck(this, webidl.is.MessageEvent)
+    webidl.brandCheck(this, MessageEvent)
 
     return this.#eventInit.lastEventId
   }
 
   get source () {
-    webidl.brandCheck(this, webidl.is.MessageEvent)
+    webidl.brandCheck(this, MessageEvent)
 
     return this.#eventInit.source
   }
 
   get ports () {
-    webidl.brandCheck(this, webidl.is.MessageEvent)
+    webidl.brandCheck(this, MessageEvent)
 
     if (!Object.isFrozen(this.#eventInit.ports)) {
       Object.freeze(this.#eventInit.ports)
@@ -75,7 +74,7 @@ class MessageEvent extends Event {
     source = null,
     ports = []
   ) {
-    webidl.brandCheck(this, webidl.is.MessageEvent)
+    webidl.brandCheck(this, MessageEvent)
 
     webidl.argumentLengthCheck(arguments, 1, 'MessageEvent.initMessageEvent')
 
@@ -84,24 +83,21 @@ class MessageEvent extends Event {
     })
   }
 
-  static {
-    createFastMessageEvent = (type, init) => {
-      const messageEvent = new MessageEvent(kConstruct, type, init)
-      messageEvent.#eventInit = init
-      messageEvent.#eventInit.data ??= null
-      messageEvent.#eventInit.origin ??= ''
-      messageEvent.#eventInit.lastEventId ??= ''
-      messageEvent.#eventInit.source ??= null
-      messageEvent.#eventInit.ports ??= []
-      return messageEvent
-    }
-
-    webidl.is.MessageEvent = (arg) => {
-      return arg != null && typeof arg === 'object' && #eventInit in arg
-    }
+  static createFastMessageEvent (type, init) {
+    const messageEvent = new MessageEvent(kConstruct, type, init)
+    messageEvent.#eventInit = init
+    messageEvent.#eventInit.data ??= null
+    messageEvent.#eventInit.origin ??= ''
+    messageEvent.#eventInit.lastEventId ??= ''
+    messageEvent.#eventInit.source ??= null
+    messageEvent.#eventInit.ports ??= []
+    return messageEvent
   }
 }
 
+const { createFastMessageEvent } = MessageEvent
+delete MessageEvent.createFastMessageEvent
+
 /**
  * @see https://websockets.spec.whatwg.org/#the-closeevent-interface
  */
@@ -122,28 +118,22 @@ class CloseEvent extends Event {
   }
 
   get wasClean () {
-    webidl.brandCheck(this, webidl.is.CloseEvent)
+    webidl.brandCheck(this, CloseEvent)
 
     return this.#eventInit.wasClean
   }
 
   get code () {
-    webidl.brandCheck(this, webidl.is.CloseEvent)
+    webidl.brandCheck(this, CloseEvent)
 
     return this.#eventInit.code
   }
 
   get reason () {
-    webidl.brandCheck(this, webidl.is.CloseEvent)
+    webidl.brandCheck(this, CloseEvent)
 
     return this.#eventInit.reason
   }
-
-  static {
-    webidl.is.CloseEvent = (arg) => {
-      return arg != null && typeof arg === 'object' && #eventInit in arg
-    }
-  }
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface
@@ -164,40 +154,34 @@ class ErrorEvent extends Event {
   }
 
   get message () {
-    webidl.brandCheck(this, webidl.is.ErrorEvent)
+    webidl.brandCheck(this, ErrorEvent)
 
     return this.#eventInit.message
   }
 
   get filename () {
-    webidl.brandCheck(this, webidl.is.ErrorEvent)
+    webidl.brandCheck(this, ErrorEvent)
 
     return this.#eventInit.filename
   }
 
   get lineno () {
-    webidl.brandCheck(this, webidl.is.ErrorEvent)
+    webidl.brandCheck(this, ErrorEvent)
 
     return this.#eventInit.lineno
   }
 
   get colno () {
-    webidl.brandCheck(this, webidl.is.ErrorEvent)
+    webidl.brandCheck(this, ErrorEvent)
 
     return this.#eventInit.colno
   }
 
   get error () {
-    webidl.brandCheck(this, webidl.is.ErrorEvent)
+    webidl.brandCheck(this, ErrorEvent)
 
     return this.#eventInit.error
   }
-
-  static {
-    webidl.is.ErrorEvent = (arg) => {
-      return arg != null && typeof arg === 'object' && #eventInit in arg
-    }
-  }
 }
 
 Object.defineProperties(MessageEvent.prototype, {
@@ -235,10 +219,7 @@ Object.defineProperties(ErrorEvent.prototype, {
   error: kEnumerableProperty
 })
 
-webidl.converters.MessagePort = webidl.interfaceConverter(
-  webidl.is.MessagePort,
-  'MessagePort'
-)
+webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort)
 
 webidl.converters['sequence<MessagePort>'] = webidl.sequenceConverter(
   webidl.converters.MessagePort
@@ -289,7 +270,7 @@ webidl.converters.MessageEventInit = webidl.dictionaryConverter([
   {
     key: 'ports',
     converter: webidl.converters['sequence<MessagePort>'],
-    defaultValue: () => []
+    defaultValue: () => new Array(0)
   }
 ])
 

package/node_modules/undici/lib/web/websocket/frame.js

@@ -1,21 +1,33 @@
 'use strict'
 
-const { runtimeFeatures } = require('../../util/runtime-features')
-const { maxUnsigned16Bit, opcodes } = require('./constants')
+const { maxUnsigned16Bit } = require('./constants')
 
-const BUFFER_SIZE = 8 * 1024
+const BUFFER_SIZE = 16386
 
+/** @type {import('crypto')} */
+let crypto
 let buffer = null
 let bufIdx = BUFFER_SIZE
 
-const randomFillSync = runtimeFeatures.has('crypto')
-  ? require('node:crypto').randomFillSync
-  : null
+try {
+  crypto = require('node:crypto')
+/* c8 ignore next 3 */
+} catch {
+  crypto = {
+    // not full compatibility, but minimum.
+    randomFillSync: function randomFillSync (buffer, _offset, _size) {
+      for (let i = 0; i < buffer.length; ++i) {
+        buffer[i] = Math.random() * 255 | 0
+      }
+      return buffer
+    }
+  }
+}
 
 function generateMask () {
   if (bufIdx === BUFFER_SIZE) {
     bufIdx = 0
-    randomFillSync((buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE)), 0, BUFFER_SIZE)
+    crypto.randomFillSync((buffer ??= Buffer.allocUnsafe(BUFFER_SIZE)), 0, BUFFER_SIZE)
   }
   return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]
 }
@@ -77,51 +89,8 @@ class WebsocketFrameSend {
 
     return buffer
   }
-
-  /**
-   * @param {Uint8Array} buffer
-   */
-  static createFastTextFrame (buffer) {
-    const maskKey = generateMask()
-
-    const bodyLength = buffer.length
-
-    // mask body
-    for (let i = 0; i < bodyLength; ++i) {
-      buffer[i] ^= maskKey[i & 3]
-    }
-
-    let payloadLength = bodyLength
-    let offset = 6
-
-    if (bodyLength > maxUnsigned16Bit) {
-      offset += 8 // payload length is next 8 bytes
-      payloadLength = 127
-    } else if (bodyLength > 125) {
-      offset += 2 // payload length is next 2 bytes
-      payloadLength = 126
-    }
-    const head = Buffer.allocUnsafeSlow(offset)
-
-    head[0] = 0x80 /* FIN */ | opcodes.TEXT /* opcode TEXT */
-    head[1] = payloadLength | 0x80 /* MASK */
-    head[offset - 4] = maskKey[0]
-    head[offset - 3] = maskKey[1]
-    head[offset - 2] = maskKey[2]
-    head[offset - 1] = maskKey[3]
-
-    if (payloadLength === 126) {
-      head.writeUInt16BE(bodyLength, 2)
-    } else if (payloadLength === 127) {
-      head[2] = head[3] = 0
-      head.writeUIntBE(bodyLength, 4, 6)
-    }
-
-    return [head, buffer]
-  }
 }
 
 module.exports = {
-  WebsocketFrameSend,
-  generateMask // for benchmark
+  WebsocketFrameSend
 }

package/node_modules/undici/lib/web/websocket/receiver.js

@@ -3,20 +3,28 @@
 const { Writable } = require('node:stream')
 const assert = require('node:assert')
 const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require('./constants')
+const { kReadyState, kSentClose, kResponse, kReceivedClose } = require('./symbols')
+const { channels } = require('../../core/diagnostics')
 const {
   isValidStatusCode,
   isValidOpcode,
+  failWebsocketConnection,
   websocketMessageReceived,
   utf8Decode,
   isControlFrame,
   isTextBinaryFrame,
   isContinuationFrame
 } = require('./util')
-const { failWebsocketConnection } = require('./connection')
 const { WebsocketFrameSend } = require('./frame')
+const { closeWebSocketConnection } = require('./connection')
 const { PerMessageDeflate } = require('./permessage-deflate')
 const { MessageSizeExceededError } = require('../../core/errors')
 
+function failWebsocketConnectionWithCode (ws, code, reason) {
+  closeWebSocketConnection(ws, code, reason, Buffer.byteLength(reason))
+  failWebsocketConnection(ws, reason)
+}
+
 // This code was influenced by ws released under the MIT license.
 // Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
 // Copyright (c) 2013 Arnout Kazemier and contributors
@@ -36,9 +44,6 @@ class ByteParser extends Writable {
   /** @type {Map<string, PerMessageDeflate>} */
   #extensions
 
-  /** @type {import('./websocket').Handler} */
-  #handler
-
   /** @type {number} */
   #maxFragments
 
@@ -46,14 +51,14 @@ class ByteParser extends Writable {
   #maxPayloadSize
 
   /**
-   * @param {import('./websocket').Handler} handler
+   * @param {import('./websocket').WebSocket} ws
    * @param {Map<string, string>|null} extensions
-   * @param {{ maxPayloadSize?: number }} [options]
+   * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
    */
-  constructor (handler, extensions, options = {}) {
+  constructor (ws, extensions, options = {}) {
     super()
 
-    this.#handler = handler
+    this.ws = ws
     this.#extensions = extensions == null ? new Map() : extensions
     this.#maxFragments = options.maxFragments ?? 0
     this.#maxPayloadSize = options.maxPayloadSize ?? 0
@@ -81,7 +86,7 @@ class ByteParser extends Writable {
       !isControlFrame(this.#info.opcode) &&
       this.#info.payloadLength + this.#fragmentsBytes > this.#maxPayloadSize
     ) {
-      failWebsocketConnection(this.#handler, 1009, 'Payload size exceeds maximum allowed size')
+      failWebsocketConnectionWithCode(this.ws, 1009, 'Payload size exceeds maximum allowed size')
       return false
     }
 
@@ -114,12 +119,12 @@ class ByteParser extends Writable {
         const rsv3 = buffer[0] & 0x10
 
         if (!isValidOpcode(opcode)) {
-          failWebsocketConnection(this.#handler, 1002, 'Invalid opcode received')
+          failWebsocketConnection(this.ws, 'Invalid opcode received')
           return callback()
         }
 
         if (masked) {
-          failWebsocketConnection(this.#handler, 1002, 'Frame cannot be masked')
+          failWebsocketConnection(this.ws, 'Frame cannot be masked')
           return callback()
         }
 
@@ -133,43 +138,43 @@ class ByteParser extends Writable {
         // WebSocket connection where a PMCE is in use, this bit indicates
         // whether a message is compressed or not.
         if (rsv1 !== 0 && !this.#extensions.has('permessage-deflate')) {
-          failWebsocketConnection(this.#handler, 1002, 'Expected RSV1 to be clear.')
+          failWebsocketConnection(this.ws, 'Expected RSV1 to be clear.')
           return
         }
 
         if (rsv2 !== 0 || rsv3 !== 0) {
-          failWebsocketConnection(this.#handler, 1002, 'RSV1, RSV2, RSV3 must be clear')
+          failWebsocketConnection(this.ws, 'RSV1, RSV2, RSV3 must be clear')
           return
         }
 
         if (fragmented && !isTextBinaryFrame(opcode)) {
           // Only text and binary frames can be fragmented
-          failWebsocketConnection(this.#handler, 1002, 'Invalid frame type was fragmented.')
+          failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
           return
         }
 
         // If we are already parsing a text/binary frame and do not receive either
         // a continuation frame or close frame, fail the connection.
         if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
-          failWebsocketConnection(this.#handler, 1002, 'Expected continuation frame')
+          failWebsocketConnection(this.ws, 'Expected continuation frame')
           return
         }
 
         if (this.#info.fragmented && fragmented) {
           // A fragmented frame can't be fragmented itself
-          failWebsocketConnection(this.#handler, 1002, 'Fragmented frame exceeded 125 bytes.')
+          failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
           return
         }
 
         // "All control frames MUST have a payload length of 125 bytes or less
         // and MUST NOT be fragmented."
         if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
-          failWebsocketConnection(this.#handler, 1002, 'Control frame either too large or fragmented')
+          failWebsocketConnection(this.ws, 'Control frame either too large or fragmented')
           return
         }
 
         if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
-          failWebsocketConnection(this.#handler, 1002, 'Unexpected continuation frame')
+          failWebsocketConnection(this.ws, 'Unexpected continuation frame')
           return
         }
 
@@ -224,7 +229,7 @@ class ByteParser extends Writable {
         // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
         // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
         if (upper !== 0 || lower > 2 ** 31 - 1) {
-          failWebsocketConnection(this.#handler, 1009, 'Received payload length > 2^31 bytes.')
+          failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
           return
         }
 
@@ -250,12 +255,17 @@ class ByteParser extends Writable {
               return
             }
 
+            if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
+              failWebsocketConnectionWithCode(this.ws, 1009, new MessageSizeExceededError().message)
+              return
+            }
+
             // If the frame is not fragmented, a message has been received.
             // If the frame is fragmented, it will terminate with a fin bit set
             // and an opcode of 0 (continuation), therefore we handle that when
             // parsing continuation frames, not here.
             if (!this.#info.fragmented && this.#info.fin) {
-              websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments())
+              websocketMessageReceived(this.ws, this.#info.binaryType, this.consumeFragments())
             }
 
             this.#state = parserStates.INFO
@@ -266,7 +276,7 @@ class ByteParser extends Writable {
               (error, data) => {
                 if (error) {
                   const code = error instanceof MessageSizeExceededError ? 1009 : 1007
-                  failWebsocketConnection(this.#handler, code, error.message)
+                  failWebsocketConnectionWithCode(this.ws, code, error.message)
                   return
                 }
 
@@ -274,9 +284,8 @@ class ByteParser extends Writable {
                   return
                 }
 
-                // Check cumulative fragment size
                 if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
-                  failWebsocketConnection(this.#handler, 1009, new MessageSizeExceededError().message)
+                  failWebsocketConnectionWithCode(this.ws, 1009, new MessageSizeExceededError().message)
                   return
                 }
 
@@ -287,13 +296,12 @@ class ByteParser extends Writable {
                   return
                 }
 
-                websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments())
+                websocketMessageReceived(this.ws, this.#info.binaryType, this.consumeFragments())
 
                 this.#loop = true
                 this.#state = parserStates.INFO
                 this.run(callback)
-              },
-              this.#fragmentsBytes
+              }
             )
 
             this.#loop = false
@@ -316,40 +324,34 @@ class ByteParser extends Writable {
       return emptyBuffer
     }
 
-    this.#byteOffset -= n
+    if (this.#buffers[0].length === n) {
+      this.#byteOffset -= this.#buffers[0].length
+      return this.#buffers.shift()
+    }
 
-    const first = this.#buffers[0]
+    const buffer = Buffer.allocUnsafe(n)
+    let offset = 0
 
-    if (first.length > n) {
-      // replace with remaining buffer
-      this.#buffers[0] = first.subarray(n, first.length)
-      return first.subarray(0, n)
-    } else if (first.length === n) {
-      // prefect match
-      return this.#buffers.shift()
-    } else {
-      let offset = 0
-      // If Buffer.allocUnsafe is used, extra copies will be made because the offset is non-zero.
-      const buffer = Buffer.allocUnsafeSlow(n)
-      while (offset !== n) {
-        const next = this.#buffers[0]
-        const length = next.length
-
-        if (length + offset === n) {
-          buffer.set(this.#buffers.shift(), offset)
-          break
-        } else if (length + offset > n) {
-          buffer.set(next.subarray(0, n - offset), offset)
-          this.#buffers[0] = next.subarray(n - offset)
-          break
-        } else {
-          buffer.set(this.#buffers.shift(), offset)
-          offset += length
-        }
+    while (offset !== n) {
+      const next = this.#buffers[0]
+      const { length } = next
+
+      if (length + offset === n) {
+        buffer.set(this.#buffers.shift(), offset)
+        break
+      } else if (length + offset > n) {
+        buffer.set(next.subarray(0, n - offset), offset)
+        this.#buffers[0] = next.subarray(n - offset)
+        break
+      } else {
+        buffer.set(this.#buffers.shift(), offset)
+        offset += next.length
       }
-
-      return buffer
     }
+
+    this.#byteOffset -= n
+
+    return buffer
   }
 
   writeFragments (fragment) {
@@ -357,7 +359,7 @@ class ByteParser extends Writable {
       this.#maxFragments > 0 &&
       this.#fragments.length === this.#maxFragments
     ) {
-      failWebsocketConnection(this.#handler, 1008, 'Too many message fragments')
+      failWebsocketConnectionWithCode(this.ws, 1008, 'Too many message fragments')
       return false
     }
 
@@ -369,24 +371,12 @@ class ByteParser extends Writable {
   consumeFragments () {
     const fragments = this.#fragments
 
-    this.#info.compressed = false
-
     if (fragments.length === 1) {
-      // single fragment
       this.#fragmentsBytes = 0
       return fragments.shift()
     }
 
-    let offset = 0
-    // If Buffer.allocUnsafe is used, extra copies will be made because the offset is non-zero.
-    const output = Buffer.allocUnsafeSlow(this.#fragmentsBytes)
-
-    for (let i = 0; i < fragments.length; ++i) {
-      const buffer = fragments[i]
-      output.set(buffer, offset)
-      offset += buffer.length
-    }
-
+    const output = Buffer.concat(fragments, this.#fragmentsBytes)
     this.#fragments = []
     this.#fragmentsBytes = 0
 
@@ -438,7 +428,7 @@ class ByteParser extends Writable {
 
     if (opcode === opcodes.CLOSE) {
       if (payloadLength === 1) {
-        failWebsocketConnection(this.#handler, 1002, 'Received close frame with a 1-byte body.')
+        failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
         return false
       }
 
@@ -447,13 +437,12 @@ class ByteParser extends Writable {
       if (this.#info.closeInfo.error) {
         const { code, reason } = this.#info.closeInfo
 
-        failWebsocketConnection(this.#handler, code, reason)
+        closeWebSocketConnection(this.ws, code, reason, reason.length)
+        failWebsocketConnection(this.ws, reason)
         return false
       }
 
-      // Upon receiving such a frame, the other peer sends a
-      // Close frame in response, if it hasn't already sent one.
-      if (!this.#handler.closeState.has(sentCloseFrameState.SENT) && !this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
+      if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
         // If an endpoint receives a Close frame and did not previously send a
         // Close frame, the endpoint MUST send a Close frame in response.  (When
         // sending a Close frame in response, the endpoint typically echos the
@@ -465,15 +454,21 @@ class ByteParser extends Writable {
         }
         const closeFrame = new WebsocketFrameSend(body)
 
-        this.#handler.socket.write(closeFrame.createFrame(opcodes.CLOSE))
-        this.#handler.closeState.add(sentCloseFrameState.SENT)
+        this.ws[kResponse].socket.write(
+          closeFrame.createFrame(opcodes.CLOSE),
+          (err) => {
+            if (!err) {
+              this.ws[kSentClose] = 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
-      this.#handler.closeState.add(sentCloseFrameState.RECEIVED)
+      this.ws[kReadyState] = states.CLOSING
+      this.ws[kReceivedClose] = true
 
       return false
     } else if (opcode === opcodes.PING) {
@@ -482,18 +477,27 @@ class ByteParser extends Writable {
       // A Pong frame sent in response to a Ping frame must have identical
       // "Application data"
 
-      if (!this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
+      if (!this.ws[kReceivedClose]) {
         const frame = new WebsocketFrameSend(body)
 
-        this.#handler.socket.write(frame.createFrame(opcodes.PONG))
+        this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG))
 
-        this.#handler.onPing(body)
+        if (channels.ping.hasSubscribers) {
+          channels.ping.publish({
+            payload: body
+          })
+        }
       }
     } else if (opcode === opcodes.PONG) {
       // A Pong frame MAY be sent unsolicited.  This serves as a
       // unidirectional heartbeat.  A response to an unsolicited Pong frame is
       // not expected.
-      this.#handler.onPong(body)
+
+      if (channels.pong.hasSubscribers) {
+        channels.pong.publish({
+          payload: body
+        })
+      }
     }
 
     return true