Crate boa_engine
source ·Expand description
Boa’s boa_engine
crate implements ECMAScript’s standard library of builtin objects
and an ECMAScript context, bytecompiler, and virtual machine for code execution.
Example usage
You can find multiple examples of the usage of Boa in the boa_examples
crate. In
order to use Boa in your project, you will need to add the boa_engine
crate to your
Cargo.toml
file. You will need to use a Source
structure to handle the JavaScript code
to execute, and a Context
structure to execute the code:
use boa_engine::{Context, Source};
let js_code = r#"
let two = 1 + 1;
let definitely_not_four = two + "2";
definitely_not_four
"#;
// Instantiate the execution context
let mut context = Context::default();
// Parse the source code
match context.eval(Source::from_bytes(js_code)) {
Ok(res) => {
println!(
"{}",
res.to_string(&mut context).unwrap().to_std_string_escaped()
);
}
Err(e) => {
// Pretty print the error
eprintln!("Uncaught {e}");
}
};
Crate Features
- serde - Enables serialization and deserialization of the AST (Abstract Syntax Tree).
- profiler - Enables profiling with measureme (this is mostly internal).
- intl - Enables
boa
’s ECMA-402 Internationalization API (Intl
object)
About Boa
Boa is an open-source, experimental ECMAScript Engine written in Rust for lexing, parsing and executing ECMAScript/JavaScript. Currently, Boa supports some of the language. More information can be viewed at Boa’s website.
Try out the most recent release with Boa’s live demo playground.
Boa Crates
boa_ast
- Boa’s ECMAScript Abstract Syntax Tree.boa_engine
- Boa’s implementation of ECMAScript builtin objects and execution.boa_gc
- Boa’s garbage collector.boa_interner
- Boa’s string interner.boa_parser
- Boa’s lexer and parser.boa_profiler
- Boa’s code profiler.boa_icu_provider
- Boa’s ICU4X data provider.boa_runtime
- Boa’s WebAPI features.
Modules
- Boa’s implementation of ECMAScript’s bigint primitive type.
- Boa’s ECMAScript built-in object implementations, e.g. Object, String, Math, Array, etc.
- This module contains the bytecode compiler.
- Traits and structs for implementing native classes.
- The ECMAScript context.
- Boa’s implementation of ECMAScript’s
Environment Records
. - Error-related types and conversions.
- Boa’s API to create and customize
ECMAScript
jobs and job queues. - Boa’s implementation of the ECMAScript’s module system.
- Boa’s wrappers for native Rust functions to be compatible with ECMAScript calls.
- Boa’s representation of a JavaScript object and builtin object wrappers
- Implements optimizations.
- A convenience module that re-exports the most commonly-used Boa APIs
- Boa’s implementation of ECMAScript’s Property Descriptor.
- Boa’s implementation of ECMAScript’s
Realm Records
- Boa’s implementation of ECMAScript’s Scripts.
- A UTF-16–encoded, reference counted, immutable string.
- Boa’s implementation of ECMAScript’s global
Symbol
object. - Boa’s ECMAScript Value implementation.
- Boa’s ECMAScript Virtual Machine
Macros
- Utility macro to create a
JsString
.
Structs
- ECMAScript context. It is the primary way to interact with the runtime.
- JavaScript bigint primitive rust type.
- The error type returned by all operations related to the execution of Javascript code.
- Native representation of an ideal
Error
object from Javascript. - Garbage collected
Object
. - A UTF-16–encoded, reference counted, immutable string.
- This represents a JavaScript symbol primitive.
- ECMAScript’s Abstract module record.
- A callable Rust function that can be invoked by the engine.
- ECMAScript’s Script Record.
- A source of ECMAScript code.
Enums
- The list of possible error types a
JsNativeError
can be. - A Javascript value
Traits
- A utility trait to make working with function arguments easier.
Type Aliases
- The result of a Javascript expression is represented like this so it can succeed (
Ok
) or fail (Err
)