_body_parser_get_received_data() {
        // Return the current promise if it exists
        if (this._received_data_promise) return this._received_data_promise;

        // If this is not a chunked transfer and we have no expected body length, we will return an empty buffer as we have no body data to parse
        if (!this._body_chunked_transfer && this._body_expected_bytes <= 0) return Promise.resolve(new Uint8Array(0));

        // Create a new promise which will be resolved once all incoming body data has been received
        this._received_data_promise = new Promise((resolve) => {
            // Determine if this is a chunked transfer
            if (this._body_chunked_transfer) {
                // Since we don't know how many or how much each chunk will be, we have to store all the chunks
                // After all the chunks have been received, we will concatenate them into a single Uint8Array
                const chunks = [];

                // Define a passthrough callback which will be called for each incoming chunk
                this._body_parser_passthrough = (chunk, is_last) => {
                    // Push the chunk to the chunks array
                    chunks.push(chunk);

                    // If this is the last chunk, call the callback with the body buffer
                    if (is_last) {
                        // Initialize a new Uint8Array of size received bytes
                        let offset = 0;
                        const buffer = new Uint8Array(this._body_received_bytes);
                        for (const chunk of chunks) {
                            // Write the chunk into the body buffer at the current offset
                            buffer.set(chunk, offset);
                            offset += chunk.byteLength;
                        }

                        // Resolve the promise with the body buffer
                        resolve(buffer);
                    }
                };
            } else {
                // Initialize the full size body Uint8Array buffer based on the expected body length
                // We will copy all volatile chunk data onto this stable buffer for memory efficiency
                const buffer = new Uint8Array(this._body_expected_bytes);

                // Define a passthrough callback which will be called for each incoming chunk
                let offset = 0;
                this._body_parser_passthrough = (chunk, is_last) => {
                    // Write the chunk into the body buffer at the current offset
                    buffer.set(chunk, offset);

                    // Increment the offset by the byteLength of the incoming chunk
                    offset += chunk.byteLength;

                    // If this is the last chunk, call the callback with the body buffer
                    if (is_last) resolve(buffer);
                };
            }

            // Set the body parser mode to buffering mode as we want to receive all incoming chunks through the passthrough callback
            this._body_parser_mode = 1;

            // Flush the buffered chunks so the passthrough callback receives all buffered data through its callback
            this._body_parser_flush_buffered();
        });

        // Return the data promise
        return this._received_data_promise;
    }
Returns a single Uint8Array buffer which contains all incoming body data.
@private
@returns {Promise<Uint8Array>}