_body_parser_on_chunk(response, chunk, is_last) {
        // If this chunk has no length and is not the last chunk, we will ignore it
        if (!chunk.byteLength && !is_last) return;

        // Increment the received bytes counter by the byteLength of the incoming chunk
        this._body_received_bytes += chunk.byteLength;

        // Determine if the body parser is active / not flushing
        if (!this._body_parser_flushing) {
            // Enforce the body parser limit as the number of incoming bytes may have exceeded the limit
            const limited = this._body_parser_enforce_limit(response);
            if (!limited) {
                // Process this chunk depending on the current body parser mode
                switch (this._body_parser_mode) {
                    // Awaiting mode - Awaiting the user to do something with the incoming body data
                    case 0:
                        // Buffer a COPIED Uint8Array chunk from the uWS volatile ArrayBuffer chunk
                        this._body_parser_buffered.push(copy_array_buffer_to_uint8array(chunk));

                        // If we have exceeded the Server.options.max_body_buffer number of buffered bytes, then pause the request to prevent more buffering
                        if (this._body_received_bytes > this.app._options.max_body_buffer) this.pause();
                        break;
                    // Buffering mode - Internal use only
                    case 1:
                        // Pass through the uWS volatile ArrayBuffer chunk to the passthrough callback as a volatile Uint8Array chunk
                        this._body_parser_passthrough(
                            // If this is a chunked transfer, we need to COPY the chunk as any passthrough consumer will have no immediate way of processing
                            // hence this chunk needs to stick around across multiple cycles without being deallocated by uWS
                            this._body_chunked_transfer
                                ? copy_array_buffer_to_uint8array(chunk)
                                : new Uint8Array(chunk),
                            is_last
                        );
                        break;
                    // Streaming mode - External use only
                    case 2:
                        // Attempt to push a COPIED Uint8Array chunk from the uWS volatile ArrayBuffer chunk to the readable stream
                        // Pause the request if we have reached the highWaterMark to prevent backpressure
                        if (!this.push(copy_array_buffer_to_uint8array(chunk))) this.pause();

                        // If this is the last chunk, push a null chunk to indicate the end of the stream
                        if (is_last) this.push(null);
                        break;
                }
            }
        }

        // Determine if this is the last chunk of the incoming body data to perform final closing operations
        if (is_last) {
            // Mark the request as fully received as we have flushed all incoming body data
            this.received = true;

            // Emit the 'received' event that indicates how many bytes were received in total from the incoming body
            if (this._readable) this.emit('received', this._body_received_bytes);

            // Enforce the body parser limit one last time in case the request is waiting for the body to be flushed before sending a response
            if (this._body_parser_flushing) this._body_parser_enforce_limit(response);
        }
    }
Processes incoming raw body data chunks from the uWS HttpResponse.

@private
@param {import('./Response.js')} response
@param {ArrayBuffer} chunk
@param {Boolean} is_last