send(body, close_connection) {
        // Ensure response connection is still active
        if (!this.completed) {
            // If this request has a writable stream with some data in it, we must schedule this send() as the last chunk after which the stream will be flushed
            if (this._writable && this._writable.writableLength) {
                // If we have some body data, queue it as the last chunk of the body to be written
                if (body) this._writable.write(body);

                // Mark the writable stream as ended
                this._writable.end();

                // Return this to make the Router chainable
                return this;
            }

            // If the response has not been corked yet, cork it and wait for the next tick to send the response
            if (this._cork && !this._corked) {
                this._corked = true;
                return this.atomic(() => this.send(body, close_connection));
            }

            // Initiate the response to begin writing the status code and headers
            this._initiate_response();

            // Determine if the request still has not fully received the whole request body yet
            if (!this._wrapped_request.received) {
                // Instruct the request to stop accepting any more data as a response is being sent
                this._wrapped_request._body_parser_stop();

                // Wait for the request to fully receive the whole request body before sending the response
                return this._wrapped_request.once('received', () =>
                    // Because 'received' will be emitted asynchronously, we need to cork the response to ensure the response is sent in the correct order
                    this.atomic(() => this.send(body, close_connection))
                );
            }

            // If we have no body and are not streaming and have a custom content-length header, we need to send a response without a body with the custom content-length header
            const custom_length = this._headers['content-length'];
            if (!(body !== undefined || this._streaming || !custom_length)) {
                // We can only use one of the content-lengths, so we will use the last one if there are multiple
                const content_length =
                    typeof custom_length == 'string' ? custom_length : custom_length[custom_length.length - 1];

                // Send the response with the uWS.HttpResponse.endWithoutBody() method as we have no body data
                // NOTE: This method is completely undocumented by uWS but exists in the source code to solve the problem of no body being sent with a custom content-length
                this._raw_response.endWithoutBody(content_length, close_connection);
            } else {
                // Send the response with the uWS.HttpResponse.end(body, close_connection) method as we have some body data
                this._raw_response.end(body, close_connection);
            }

            // Emit the 'finish' event to signify that the response has been sent without streaming
            if (this._writable && !this._streaming) this.emit('finish', this._wrapped_request, this);

            // Mark request as completed as it has been sent
            this.completed = true;

            // Decrement the pending request count
            this.route.app._resolve_pending_request();

            // Emit the 'close' event to signify that the response has been completed
            if (this._writable) this.emit('close', this._wrapped_request, this);
        }

        // Make chainable
        return this;
    }
This method is used to end the current request and send response with specified body and headers.

@param {String|Buffer|ArrayBuffer=} body Optional
@param {Boolean=} close_connection
@returns {Response}