Method clone

modules/llrt_fetch/src/request.rs:493–555

(&self, ctx: Ctx<'js>)

    }

    fn clone(&self, ctx: Ctx<'js>) -> Result<Self> {
        let headers = if let Some(headers) = &self.headers {
            Some(Class::<Headers>::instance(
                ctx.clone(),
                headers.borrow().clone(),
            )?)
        } else {
            None
        };

        let body_guard = self.body.read().unwrap();
        let cloned_body = match &*body_guard {
            BodyVariant::Provided(provided) => {
                let Some(provided) = provided else {
                    return Err(Exception::throw_type(
                        &ctx,
                        "Cannot clone request after body has been used",
                    ));
                };
                // For ReadableStream bodies, use tee() to create two branches
                if let Some(stream) = provided
                    .as_object()
                    .and_then(Class::<ReadableStream>::from_object)
                {
                    let (branch1, branch2) =
                        llrt_stream_web::tee_readable_stream(ctx.clone(), stream.clone())?;

                    // Update original body to use branch1
                    drop(body_guard);
                    let mut body_write = self.body.write().unwrap();
                    *body_write = BodyVariant::Provided(Some(branch1.into_value()));
                    *self.body_stream.write().unwrap() = None;

                    return Ok(Self {
                        url: self.url.clone(),
                        method: self.method.clone(),
                        headers,
                        body: RwLock::new(BodyVariant::Provided(Some(branch2.into_value()))),
                        body_stream: RwLock::new(None),
                        signal: self.signal.clone(),
                        mode: self.mode.clone(),
                        keepalive: self.keepalive,
                        agent: self.agent.clone(),
                    });
                }
                BodyVariant::Provided(Some(provided.clone()))
            },
            BodyVariant::Empty => BodyVariant::Empty,
        };
        drop(body_guard);

        Ok(Self {
            url: self.url.clone(),
            method: self.method.clone(),
            headers,
            body: RwLock::new(cloned_body),
            body_stream: RwLock::new(None),
            signal: self.signal.clone(),