boa_engine 0.21.1

Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Conversions from JavaScript values into Rust values, and the other way around.

use super::{JsBigInt, JsObject, JsString, JsSymbol, JsValue};
use crate::value::inner::InnerValue;
use crate::{js_string, string::JsStr};

mod either;
pub(super) mod nullable;
mod serde_json;
pub(super) mod try_from_js;
pub(super) mod try_into_js;

pub(super) mod convert;

impl From<JsStr<'_>> for JsValue {
    fn from(value: JsStr<'_>) -> Self {
        Self::from_inner(InnerValue::string(value.into()))
    }
}

impl From<JsString> for JsValue {
    fn from(value: JsString) -> Self {
        Self::from_inner(InnerValue::string(value))
    }
}

impl From<char> for JsValue {
    #[inline]
    fn from(value: char) -> Self {
        let mut buf: [u16; 2] = [0; 2];

        let out = value.encode_utf16(&mut buf);

        Self::from(js_string!(&*out))
    }
}

impl From<JsSymbol> for JsValue {
    #[inline]
    fn from(value: JsSymbol) -> Self {
        Self::from_inner(InnerValue::symbol(value))
    }
}

impl From<f32> for JsValue {
    #[inline]
    fn from(value: f32) -> Self {
        Self::rational(f64::from(value))
    }
}

impl From<f64> for JsValue {
    #[inline]
    fn from(value: f64) -> Self {
        Self::rational(value)
    }
}

macro_rules! impl_from_integer {
    ( $( $type_:ty ),* ) => {
        $(
            impl From<$type_> for JsValue {
                #[inline]
                #[allow(clippy::cast_lossless)]
                fn from(value: $type_) -> Self {

                    i32::try_from(value)
                        .map_or_else(
                            |_| Self::rational(value as f64),
                            |value| Self::from_inner(InnerValue::integer32(value)),
                        )
                }
            }
        )*
    };
}

impl_from_integer!(u8, i8, u16, i16, u32, i32, u64, i64, usize, isize);

impl From<JsBigInt> for JsValue {
    #[inline]
    fn from(value: JsBigInt) -> Self {
        Self::from_inner(InnerValue::bigint(value))
    }
}

impl From<bool> for JsValue {
    #[inline]
    fn from(value: bool) -> Self {
        Self::from_inner(InnerValue::boolean(value))
    }
}

impl From<JsObject> for JsValue {
    #[inline]
    fn from(object: JsObject) -> Self {
        Self::from_inner(InnerValue::object(object))
    }
}

impl From<()> for JsValue {
    #[inline]
    #[allow(clippy::pedantic)] // didn't want to increase our MSRV for just a lint.
    fn from((): ()) -> Self {
        Self::null()
    }
}

/// Converts an `Option<T>` into a `JsValue`.
///
/// It will convert the `None` variant to `JsValue::undefined()`, and the `Some()` variant into a
/// `JsValue` using the `Into` trait.
pub(crate) trait IntoOrUndefined {
    /// Converts an `Option<T>` into a `JsValue`.
    fn into_or_undefined(self) -> JsValue;
}

impl<T> IntoOrUndefined for Option<T>
where
    T: Into<JsValue>,
{
    #[inline]
    fn into_or_undefined(self) -> JsValue {
        match self {
            Some(value) => value.into(),
            None => JsValue::undefined(),
        }
    }
}