Method from_value

modules/llrt_fetch/src/headers.rs:356–447

(ctx: &Ctx<'js>, value: Value<'js>, guard: HeadersGuard)

    }

    pub fn from_http_headers(header_map: &HeaderMap, guard: HeadersGuard) -> Result<Self> {
        let mut headers = Vec::with_capacity(header_map.keys_len());
        for (n, v) in header_map.iter() {
            headers.push((
                n.as_str().into(),
                String::from_utf8_lossy(v.as_bytes()).into(),
            ));
        }
        Ok(Self { headers, guard })
    }

    pub fn from_value<'js>(ctx: &Ctx<'js>, value: Value<'js>, guard: HeadersGuard) -> Result<Self> {
        if value.is_array() {
            let array = unsafe { value.into_array().unwrap_unchecked() };
            return Self::from_array(ctx, array, guard);
        }

        if let Some(obj) = value.as_object() {
            if obj
                .get::<_, Value>(Symbol::iterator(ctx.clone()))?
                .is_function()
            {
                let array: Array = BasePrimordials::get(ctx)?
                    .function_array_from
                    .call((value,))?;
                return Self::from_array(ctx, array, guard);
            } else {
                // WebIDL record conversion: keys via Reflect.ownKeys (preserves
                // Symbols, unlike rquickjs's Atom-based iterator which stringifies
                // them), then per-key gopd → enumerable check → get. Ordering
                // matters for Proxy traps (WPT headers-record.any.js).
                let (get_own_property_desc_fn, own_keys_fn) = {
                    let primordials = BasePrimordials::get(ctx)?;
                    let get_own_property_desc_fn =
                        &primordials.function_get_own_property_descriptor;
                    let own_keys_fn = &primordials.function_reflect_own_keys;
                    (get_own_property_desc_fn.clone(), own_keys_fn.clone())
                };

                let keys: Array = own_keys_fn.call((obj.clone(),))?;

                let mut headers: Vec<(ImmutableString, ImmutableString)> =
                    Vec::with_capacity(keys.len());
                for i in 0..keys.len() {
                    let key_val: Value = keys.get(i)?;
                    let desc: Value =
                        get_own_property_desc_fn.call((obj.clone(), key_val.clone()))?;
                    let Some(desc) = desc.as_object() else {
                        continue;
                    };
                    if !desc
                        .get::<_, bool>(PredefinedAtom::Enumerable)
                        .unwrap_or(false)
                    {
                        continue;
                    }
                    if key_val.is_symbol() {
                        return Err(Exception::throw_type(