Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::EventSubclassKind;
use moli_webapi_declare::WebApiObject;
use crate::context_bootstrap::events::modifiers::EventModifierInit;
use crate::context_bootstrap::file_api::is_branded_data_transfer_object;
use crate::util::throw_type_error;
use crate::web_api_interfaces;
use crate::webidl;
const POINTER_EVENT_COALESCED_EVENTS_SLOT: &str = "__moliPointerEventCoalescedEvents";
const POINTER_EVENT_PREDICTED_EVENTS_SLOT: &str = "__moliPointerEventPredictedEvents";
#[derive(WebApiObject)]
#[webapi(plain)]
struct PointerEventSequences<'s> {
#[webapi(slot = POINTER_EVENT_COALESCED_EVENTS_SLOT)]
coalesced_events: Vec<v8::Local<'s, v8::Object>>,
#[webapi(slot = POINTER_EVENT_PREDICTED_EVENTS_SLOT)]
predicted_events: Vec<v8::Local<'s, v8::Object>>,
}
/// MouseEventInit includes the CSSOM View and Pointer Lock double members.
/// Each derived dictionary delegates to this base before reading its own members.
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "MouseEventInit")]
pub(super) struct MouseEventInit<'s> {
#[webidl(inherit)]
modifiers: EventModifierInit<'s>,
#[webidl(default = 0)]
button: i16,
#[webidl(default = 0)]
buttons: u16,
#[webidl(default = 0.0, converter = "double")]
client_x: f64,
#[webidl(default = 0.0, converter = "double")]
client_y: f64,
#[webidl(default = 0.0, converter = "double")]
movement_x: f64,
#[webidl(default = 0.0, converter = "double")]
movement_y: f64,
// Blink still converts the obsolete hit-region member, without exposing it.
#[webidl(name = "region", nullable, converter = "raw")]
_region: Option<webidl::DomString16>,
#[webidl(nullable, interface = web_api_interfaces::EventTarget)]
related_target: Option<v8::Local<'s, v8::Object>>,
#[webidl(default = 0.0, converter = "double")]
screen_x: f64,
#[webidl(default = 0.0, converter = "double")]
screen_y: f64,
}
impl<'s> MouseEventInit<'s> {
pub(super) fn event_flags(&self) -> (bool, bool, bool) {
self.modifiers.event_flags()
}
pub(super) fn initialize(
&self,
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
self.modifiers.initialize(scope, event);
MouseEventBaseInitDeclaration::new(
self.screen_x,
self.screen_y,
self.client_x,
self.client_y,
self.client_x,
self.client_y,
self.client_x,
self.client_y,
self.button,
self.buttons,
self.movement_x,
self.movement_y,
)
.initialize(scope, event)
.expect("MouseEvent state should initialize");
let related_target = self
.related_target
.map(Into::into)
.unwrap_or_else(|| v8::null(scope).into());
MouseEventRelatedTargetDeclaration::new(related_target)
.initialize(scope, event)
.expect("MouseEvent relatedTarget should initialize");
}
}
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "WheelEventInit")]
pub(super) struct WheelEventInit<'s> {
#[webidl(inherit)]
mouse: MouseEventInit<'s>,
#[webidl(default = 0)]
delta_mode: u32,
#[webidl(default = 0.0, converter = "double")]
delta_x: f64,
#[webidl(default = 0.0, converter = "double")]
delta_y: f64,
#[webidl(default = 0.0, converter = "double")]
delta_z: f64,
#[webidl(default = 0)]
wheel_delta_x: i32,
#[webidl(default = 0)]
wheel_delta_y: i32,
}
impl<'s> WheelEventInit<'s> {
pub(super) fn event_flags(&self) -> (bool, bool, bool) {
self.mouse.event_flags()
}
pub(super) fn initialize(
self,
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
self.mouse.initialize(scope, event);
// Legacy deltas use their nonzero initializer or a saturating,
// truncating projection of the CSSOM delta. This follows Blink's
// constructor and is separate from WebIDL's wrapping long conversion.
let wheel_delta_x = if self.wheel_delta_x != 0 {
self.wheel_delta_x
} else {
self.delta_x as i32
};
let wheel_delta_y = if self.wheel_delta_y != 0 {
self.wheel_delta_y
} else {
self.delta_y as i32
};
WheelEventDeltaInitDeclaration::new(
self.delta_x,
self.delta_y,
self.delta_z,
self.delta_mode,
wheel_delta_x,
wheel_delta_y,
if wheel_delta_y != 0 {
wheel_delta_y
} else {
wheel_delta_x
},
)
.initialize(scope, event)
.expect("WheelEvent state should initialize");
}
}
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "PointerEventInit")]
pub(super) struct PointerEventInit<'s> {
#[webidl(inherit)]
mouse: MouseEventInit<'s>,
#[webidl(converter = "double")]
altitude_angle: Option<f64>,
#[webidl(converter = "double")]
azimuth_angle: Option<f64>,
#[webidl(sequence, interface = web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]
coalesced_events: Vec<v8::Local<'s, v8::Object>>,
#[webidl(default = 1.0, converter = "double")]
height: f64,
#[webidl(default = false)]
is_primary: bool,
#[webidl(default = 0)]
persistent_device_id: i32,
#[webidl(default = 0)]
pointer_id: i32,
#[webidl(default = webidl::DomString16(Vec::new()), converter = "raw")]
pointer_type: webidl::DomString16,
#[webidl(sequence, interface = web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]
predicted_events: Vec<v8::Local<'s, v8::Object>>,
#[webidl(default = 0.0)]
pressure: f32,
#[webidl(default = 0.0)]
tangential_pressure: f32,
tilt_x: Option<i32>,
tilt_y: Option<i32>,
#[webidl(default = 0)]
twist: i32,
#[webidl(default = 1.0, converter = "double")]
width: f64,
}
impl<'s> PointerEventInit<'s> {
pub(super) fn event_flags(&self) -> (bool, bool, bool) {
self.mouse.event_flags()
}
pub(super) fn initialize(
self,
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
self.mouse.initialize(scope, event);
let angles = pointer_event_angle_init(&self);
PointerEventNumberInitDeclaration::new(
self.pointer_id,
self.width,
self.height,
self.pressure,
self.tangential_pressure,
angles.tilt_x,
angles.tilt_y,
angles.azimuth_angle,
angles.altitude_angle,
self.twist,
self.persistent_device_id,
)
.initialize(scope, event)
.expect("PointerEvent state should initialize");
let pointer_type = crate::util::v8_string_from_utf16_units(scope, &self.pointer_type.0)
.expect("PointerEvent pointerType should fit in a V8 string");
PointerEventTailInitDeclaration::new(self.is_primary, pointer_type)
.initialize(scope, event)
.expect("PointerEvent tail should initialize");
PointerEventSequences {
coalesced_events: self.coalesced_events,
predicted_events: self.predicted_events,
}
.initialize(scope, event)
.expect("PointerEvent sequence state");
}
}
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "DragEventInit")]
pub(super) struct DragEventInit<'s> {
#[webidl(inherit)]
mouse: MouseEventInit<'s>,
#[webidl(nullable, interface = web_api_interfaces::DataTransfer, brand_check = is_branded_data_transfer_object)]
data_transfer: Option<v8::Local<'s, v8::Object>>,
}
impl<'s> DragEventInit<'s> {
pub(super) fn event_flags(&self) -> (bool, bool, bool) {
self.mouse.event_flags()
}
pub(super) fn initialize(
self,
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
self.mouse.initialize(scope, event);
let data_transfer = self
.data_transfer
.map(Into::into)
.unwrap_or_else(|| v8::null(scope).into());
DragEventInitDeclaration::new(data_transfer)
.initialize(scope, event)
.expect("DragEvent state should initialize");
}
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct DragEventInitDeclaration<'s> {
data_transfer: v8::Local<'s, v8::Value>,
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct MouseEventBaseInitDeclaration {
screen_x: f64,
screen_y: f64,
client_x: f64,
client_y: f64,
x: f64,
y: f64,
page_x: f64,
page_y: f64,
button: i16,
buttons: u16,
movement_x: f64,
movement_y: f64,
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct MouseEventRelatedTargetDeclaration<'scope> {
related_target: v8::Local<'scope, v8::Value>,
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct WheelEventDeltaInitDeclaration {
delta_x: f64,
delta_y: f64,
delta_z: f64,
delta_mode: u32,
wheel_delta_x: i32,
wheel_delta_y: i32,
wheel_delta: i32,
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct PointerEventNumberInitDeclaration {
pointer_id: i32,
width: f64,
height: f64,
pressure: f32,
tangential_pressure: f32,
tilt_x: i32,
tilt_y: i32,
azimuth_angle: f64,
altitude_angle: f64,
twist: i32,
persistent_device_id: i32,
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct PointerEventTailInitDeclaration<'scope> {
is_primary: bool,
pointer_type: v8::Local<'scope, v8::String>,
}
#[derive(Clone, Copy)]
struct PointerEventAngleInit {
tilt_x: i32,
tilt_y: i32,
azimuth_angle: f64,
altitude_angle: f64,
}
fn normalized_tilt_degrees(tilt_degrees: i32) -> i32 {
if (-90..=90).contains(&tilt_degrees) {
return tilt_degrees;
}
let mut normalized = tilt_degrees % 180;
if normalized > 90 {
normalized -= 180;
} else if normalized < -90 {
normalized += 180;
}
normalized
}
fn normalized_azimuth_angle(azimuth_angle: f64) -> f64 {
if (0.0..=std::f64::consts::TAU).contains(&azimuth_angle) {
return azimuth_angle;
}
azimuth_angle.rem_euclid(std::f64::consts::TAU)
}
fn normalized_altitude_angle(altitude_angle: f64) -> f64 {
if (0.0..=std::f64::consts::FRAC_PI_2).contains(&altitude_angle) {
return altitude_angle;
}
altitude_angle.rem_euclid(std::f64::consts::FRAC_PI_2)
}
fn azimuth_angle_from_tilt(tilt_x_degrees: i32, tilt_y_degrees: i32) -> f64 {
if tilt_x_degrees == 0 {
return match tilt_y_degrees.cmp(&0) {
std::cmp::Ordering::Greater => std::f64::consts::FRAC_PI_2,
std::cmp::Ordering::Less => 3.0 * std::f64::consts::FRAC_PI_2,
std::cmp::Ordering::Equal => 0.0,
};
}
if tilt_y_degrees == 0 {
return if tilt_x_degrees < 0 {
std::f64::consts::PI
} else {
0.0
};
}
if tilt_x_degrees.abs() == 90 || tilt_y_degrees.abs() == 90 {
return 0.0;
}
let tilt_x_radians = f64::from(tilt_x_degrees).to_radians();
let tilt_y_radians = f64::from(tilt_y_degrees).to_radians();
tilt_y_radians
.tan()
.atan2(tilt_x_radians.tan())
.rem_euclid(std::f64::consts::TAU)
}
fn altitude_angle_from_tilt(tilt_x_degrees: i32, tilt_y_degrees: i32) -> f64 {
let tilt_x_radians = f64::from(tilt_x_degrees).to_radians();
let tilt_y_radians = f64::from(tilt_y_degrees).to_radians();
if tilt_x_degrees.abs() == 90 || tilt_y_degrees.abs() == 90 {
return 0.0;
}
if tilt_x_degrees == 0 {
return std::f64::consts::FRAC_PI_2 - tilt_y_radians.abs();
}
if tilt_y_degrees == 0 {
return std::f64::consts::FRAC_PI_2 - tilt_x_radians.abs();
}
(1.0 / (tilt_x_radians.tan().powi(2) + tilt_y_radians.tan().powi(2)).sqrt()).atan()
}
fn javascript_round(value: f64) -> i32 {
(value + 0.5).floor() as i32
}
fn tilt_x_from_spherical(azimuth_angle: f64, altitude_angle: f64) -> i32 {
if altitude_angle != 0.0 {
return javascript_round(
(azimuth_angle.cos() / altitude_angle.tan())
.atan()
.to_degrees(),
);
}
if azimuth_angle == std::f64::consts::FRAC_PI_2
|| azimuth_angle == 3.0 * std::f64::consts::FRAC_PI_2
{
0
} else if !(std::f64::consts::FRAC_PI_2..=3.0 * std::f64::consts::FRAC_PI_2)
.contains(&azimuth_angle)
{
90
} else {
-90
}
}
fn tilt_y_from_spherical(azimuth_angle: f64, altitude_angle: f64) -> i32 {
if altitude_angle != 0.0 {
return javascript_round(
(azimuth_angle.sin() / altitude_angle.tan())
.atan()
.to_degrees(),
);
}
if azimuth_angle == 0.0
|| azimuth_angle == std::f64::consts::PI
|| azimuth_angle == std::f64::consts::TAU
{
0
} else if azimuth_angle < std::f64::consts::PI {
90
} else {
-90
}
}
fn pointer_event_angle_init(init: &PointerEventInit<'_>) -> PointerEventAngleInit {
let tilt_x = init.tilt_x;
let tilt_y = init.tilt_y;
let azimuth_angle = init.azimuth_angle;
let altitude_angle = init.altitude_angle;
let has_tilt = tilt_x.is_some() || tilt_y.is_some();
let has_spherical_angles = azimuth_angle.is_some() || altitude_angle.is_some();
let mut angles = PointerEventAngleInit {
tilt_x: tilt_x.unwrap_or(0),
tilt_y: tilt_y.unwrap_or(0),
azimuth_angle: azimuth_angle.unwrap_or(0.0),
altitude_angle: altitude_angle.unwrap_or(std::f64::consts::FRAC_PI_2),
};
if has_tilt && !has_spherical_angles {
let normalized_tilt_x = normalized_tilt_degrees(angles.tilt_x);
let normalized_tilt_y = normalized_tilt_degrees(angles.tilt_y);
angles.azimuth_angle = azimuth_angle_from_tilt(normalized_tilt_x, normalized_tilt_y);
angles.altitude_angle = altitude_angle_from_tilt(normalized_tilt_x, normalized_tilt_y);
} else if has_spherical_angles && !has_tilt {
let normalized_azimuth = normalized_azimuth_angle(angles.azimuth_angle);
let normalized_altitude = normalized_altitude_angle(angles.altitude_angle);
angles.tilt_x = tilt_x_from_spherical(normalized_azimuth, normalized_altitude);
angles.tilt_y = tilt_y_from_spherical(normalized_azimuth, normalized_altitude);
}
angles
}
fn pointer_event_sequence_copy<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
slot: &'static str,
) -> v8::Local<'s, v8::Array> {
let Some(stored) = crate::context_bootstrap::event_private_value(scope, event, slot)
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
else {
return v8::Array::new(scope, 0);
};
let entries = (0..stored.length())
.filter_map(|index| stored.get_index(scope, index))
.collect::<Vec<_>>();
v8::Array::new_with_elements(scope, &entries)
}
fn pointer_event_sequence_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
slot: &'static str,
method: &'static str,
) {
if super::super::event_subclass_kind(scope, args.this())
!= Some(EventSubclassKind::PointerEvent)
{
throw_type_error(
scope,
&format!("Failed to execute '{method}' on 'PointerEvent': Illegal invocation"),
);
return;
}
rv.set(pointer_event_sequence_copy(scope, args.this(), slot).into());
}
pub(in crate::context_bootstrap) fn pointer_event_get_coalesced_events_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
rv: v8::ReturnValue<'_, v8::Value>,
) {
pointer_event_sequence_callback(
scope,
args,
rv,
POINTER_EVENT_COALESCED_EVENTS_SLOT,
"getCoalescedEvents",
);
}
pub(in crate::context_bootstrap) fn pointer_event_get_predicted_events_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
rv: v8::ReturnValue<'_, v8::Value>,
) {
pointer_event_sequence_callback(
scope,
args,
rv,
POINTER_EVENT_PREDICTED_EVENTS_SLOT,
"getPredictedEvents",
);
}
fn is_pointer_event_sequence_item<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> bool {
super::super::event_subclass_kind(scope, event) == Some(super::EventSubclassKind::PointerEvent)
}
pub(super) enum PointerEventInitPayload<'s> {
Mouse(MouseEventInit<'s>),
Wheel(WheelEventInit<'s>),
Pointer(PointerEventInit<'s>),
Drag(DragEventInit<'s>),
}
impl<'s> PointerEventInitPayload<'s> {
pub(super) fn parse(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
kind: super::EventSubclassKind,
) -> Option<Self> {
use super::super::parse_event_dictionary;
use super::EventSubclassKind;
Some(match kind {
EventSubclassKind::MouseEvent => {
Self::Mouse(parse_event_dictionary(scope, args, "MouseEvent")?)
}
EventSubclassKind::WheelEvent => {
Self::Wheel(parse_event_dictionary(scope, args, "WheelEvent")?)
}
EventSubclassKind::PointerEvent => {
Self::Pointer(parse_event_dictionary(scope, args, "PointerEvent")?)
}
EventSubclassKind::DragEvent => {
Self::Drag(parse_event_dictionary(scope, args, "DragEvent")?)
}
_ => unreachable!("only pointing event kinds use PointerEventInitPayload"),
})
}
pub(super) fn event_flags(&self) -> (bool, bool, bool) {
match self {
Self::Mouse(init) => init.event_flags(),
Self::Wheel(init) => init.event_flags(),
Self::Pointer(init) => init.event_flags(),
Self::Drag(init) => init.event_flags(),
}
}
pub(super) fn initialize(
self,
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
match self {
Self::Mouse(init) => init.initialize(scope, event),
Self::Wheel(init) => init.initialize(scope, event),
Self::Pointer(init) => init.initialize(scope, event),
Self::Drag(init) => init.initialize(scope, event),
}
}
}