async stream(readable, total_size) {
        // Ensure readable is an instance of a stream.Readable
        if (!(readable instanceof stream.Readable))
            this.throw(
                new Error('HyperExpress: Response.stream(readable, total_size) -> readable must be a Readable stream.')
            );

        // Do not allow streaming if response has already been aborted or completed
        if (!this.completed) {
            // Bind an 'close' event handler which will destroy the consumed stream if request is closed
            this.once('close', () => (!readable.destroyed ? readable.destroy() : null));

            // Define a while loop to consume chunks from the readable stream until it is fully consumed or the response has been completed
            while (!this.completed && !(readable.readableEnded || readable.destroyed)) {
                // Attempt to read a chunk from the readable stream
                let chunk = readable.read();
                if (!chunk) {
                    // Wait for the readable stream to emit a 'readable' event if no chunk was available in our initial read attempt
                    await new Promise((resolve) => {
                        // Bind a 'end' handler in case the readable stream ends before emitting a 'readable' event
                        readable.once('end', resolve);

                        // Bind a 'readable' handler to resolve the promise once a chunk is available to read
                        readable.once('readable', () => {
                            // Unbind the 'end' handler as we have a chunk available to read
                            readable.removeListener('end', resolve);

                            // Resolve the promise to continue the while loop
                            resolve();
                        });
                    });

                    // Attempt to read a chunk from the readable stream again
                    chunk = readable.read();
                }

                // Stream the chunk to the client
                if (chunk) await this._stream_chunk(chunk, total_size);
            }

            // If we had no total size and the response is still not completed, we need to end the response
            // This is because no total size means we served with chunked encoding and we need to end the response as it is a unbounded stream
            if (!this.completed) {
                // Determine if we have a total size or not
                if (total_size) {
                    // We must call the decrement method as a conventional close would not be detected
                    this.route.app._resolve_pending_request();
                } else {
                    // We must manually close the response as this stream operation is unbounded
                    this.send();
                }
            }
        }
    }
This method is used to serve a readable stream as response body and send response.
By default, this method will use chunked encoding transfer to stream data.
If your use-case requires a content-length header, you must specify the total payload size.

@param {stream.Readable} readable A Readable stream which will be consumed as response body
@param {Number=} total_size Total size of the Readable stream source in bytes (Optional)
@returns {Promise} a Promise which resolves once the stream has been fully consumed and response has been sent