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::*;
use crate::native_bridge::throw_dom_exception;
use crate::util::{callback_data_index_value, get_private_value, set_private_value};
use crate::web_api_interfaces;
use crate::webidl;
use moli_geometry::{
DOM_MATRIX_COMPONENT_COUNT, DomMatrixComponents, dom_matrix_components_from_values,
parse_dom_matrix_value,
};
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
use webidl::{SnapshotPrototype, WebIdlDictionarySerialize};
const DOM_POINT_X_SLOT: &str = "__moliDomPointX";
const DOM_POINT_Y_SLOT: &str = "__moliDomPointY";
const DOM_POINT_Z_SLOT: &str = "__moliDomPointZ";
const DOM_POINT_W_SLOT: &str = "__moliDomPointW";
const DOM_POINT_RESTRICTED_NUMBER_SLOT: &str = "__moliDomPointRestrictedNumber";
const DOM_POINT_READ_ONLY_SLOT: &str = "__moliDomPointReadOnly";
const DOM_MATRIX_M11_SLOT: &str = "__moliDomMatrixM11";
const DOM_MATRIX_M12_SLOT: &str = "__moliDomMatrixM12";
const DOM_MATRIX_M13_SLOT: &str = "__moliDomMatrixM13";
const DOM_MATRIX_M14_SLOT: &str = "__moliDomMatrixM14";
const DOM_MATRIX_M21_SLOT: &str = "__moliDomMatrixM21";
const DOM_MATRIX_M22_SLOT: &str = "__moliDomMatrixM22";
const DOM_MATRIX_M23_SLOT: &str = "__moliDomMatrixM23";
const DOM_MATRIX_M24_SLOT: &str = "__moliDomMatrixM24";
const DOM_MATRIX_M31_SLOT: &str = "__moliDomMatrixM31";
const DOM_MATRIX_M32_SLOT: &str = "__moliDomMatrixM32";
const DOM_MATRIX_M33_SLOT: &str = "__moliDomMatrixM33";
const DOM_MATRIX_M34_SLOT: &str = "__moliDomMatrixM34";
const DOM_MATRIX_M41_SLOT: &str = "__moliDomMatrixM41";
const DOM_MATRIX_M42_SLOT: &str = "__moliDomMatrixM42";
const DOM_MATRIX_M43_SLOT: &str = "__moliDomMatrixM43";
const DOM_MATRIX_M44_SLOT: &str = "__moliDomMatrixM44";
const DOM_MATRIX_TYPED_ARRAY_LENGTH: usize = DOM_MATRIX_COMPONENT_COUNT;
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::DOMPoint, fallback_to_string_tag = "DOMPoint")]
struct DomPointObjectDeclaration {}
macro_rules! dom_matrix_object_declaration {
($name:ident, $interface:ident) => {
#[derive(WebApiObject)]
#[webapi(
interface = web_api_interfaces::$interface,
fallback_to_string_tag = <web_api_interfaces::$interface>::DESCRIPTOR.name()
)]
struct $name {
#[webapi(slot = DOM_MATRIX_M11_SLOT)]
m11: f64,
#[webapi(slot = DOM_MATRIX_M12_SLOT)]
m12: f64,
#[webapi(slot = DOM_MATRIX_M13_SLOT)]
m13: f64,
#[webapi(slot = DOM_MATRIX_M14_SLOT)]
m14: f64,
#[webapi(slot = DOM_MATRIX_M21_SLOT)]
m21: f64,
#[webapi(slot = DOM_MATRIX_M22_SLOT)]
m22: f64,
#[webapi(slot = DOM_MATRIX_M23_SLOT)]
m23: f64,
#[webapi(slot = DOM_MATRIX_M24_SLOT)]
m24: f64,
#[webapi(slot = DOM_MATRIX_M31_SLOT)]
m31: f64,
#[webapi(slot = DOM_MATRIX_M32_SLOT)]
m32: f64,
#[webapi(slot = DOM_MATRIX_M33_SLOT)]
m33: f64,
#[webapi(slot = DOM_MATRIX_M34_SLOT)]
m34: f64,
#[webapi(slot = DOM_MATRIX_M41_SLOT)]
m41: f64,
#[webapi(slot = DOM_MATRIX_M42_SLOT)]
m42: f64,
#[webapi(slot = DOM_MATRIX_M43_SLOT)]
m43: f64,
#[webapi(slot = DOM_MATRIX_M44_SLOT)]
m44: f64,
}
impl $name {
fn from_components(components: DomMatrixComponents) -> Self {
Self {
m11: components.m11,
m12: components.m12,
m13: components.m13,
m14: components.m14,
m21: components.m21,
m22: components.m22,
m23: components.m23,
m24: components.m24,
m31: components.m31,
m32: components.m32,
m33: components.m33,
m34: components.m34,
m41: components.m41,
m42: components.m42,
m43: components.m43,
m44: components.m44,
}
}
}
};
}
dom_matrix_object_declaration!(DomMatrixObjectDeclaration, DOMMatrix);
dom_matrix_object_declaration!(DomMatrixReadOnlyObjectDeclaration, DOMMatrixReadOnly);
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct DomMatrixJsonDeclaration {
a: f64,
b: f64,
c: f64,
d: f64,
e: f64,
f: f64,
m11: f64,
m12: f64,
m13: f64,
m14: f64,
m21: f64,
m22: f64,
m23: f64,
m24: f64,
m31: f64,
m32: f64,
m33: f64,
m34: f64,
m41: f64,
m42: f64,
m43: f64,
m44: f64,
is_2d: bool,
is_identity: bool,
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMPoint, receiver)]
struct DomPointPrototypeAccessorsDeclaration {
#[webapi(
accessor_property,
getter = dom_point_getter_callback,
setter = dom_point_setter_callback,
data = callback_data_index_value(scope, 0),
enumerable
)]
x: (),
#[webapi(
accessor_property,
getter = dom_point_getter_callback,
setter = dom_point_setter_callback,
data = callback_data_index_value(scope, 1),
enumerable
)]
y: (),
#[webapi(
accessor_property,
getter = dom_point_getter_callback,
setter = dom_point_setter_callback,
data = callback_data_index_value(scope, 2),
enumerable
)]
z: (),
#[webapi(
accessor_property,
getter = dom_point_getter_callback,
setter = dom_point_setter_callback,
data = callback_data_index_value(scope, 3),
enumerable
)]
w: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMPoint, receiver)]
struct DomPointPrototypeMethodsDeclaration {
#[webapi(method = "toJSON", enumerable, callback = dom_point_to_json_callback)]
to_json: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMPoint, enumerable)]
struct DomPointConstructorDeclaration {
#[webapi(static_method = "fromPoint", length = 0, callback = dom_point_from_point_callback)]
from_point: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMMatrixReadOnly)]
struct DomMatrixReadOnlyPrototypeAccessorsDeclaration {
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 0), enumerable)]
a: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 1), enumerable)]
b: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 2), enumerable)]
c: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 3), enumerable)]
d: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 4), enumerable)]
e: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 5), enumerable)]
f: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 6), enumerable)]
m11: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 7), enumerable)]
m12: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 8), enumerable)]
m13: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 9), enumerable)]
m14: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 10), enumerable)]
m21: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 11), enumerable)]
m22: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 12), enumerable)]
m23: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 13), enumerable)]
m24: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 14), enumerable)]
m31: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 15), enumerable)]
m32: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 16), enumerable)]
m33: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 17), enumerable)]
m34: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 18), enumerable)]
m41: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 19), enumerable)]
m42: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 20), enumerable)]
m43: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 21), enumerable)]
m44: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 22), enumerable)]
is_2d: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, data = callback_data_index_value(scope, 23), enumerable)]
is_identity: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMMatrixReadOnly, enumerable)]
struct DomMatrixReadOnlyPrototypeMethodsDeclaration {
#[webapi(method = "toJSON", enumerable, callback = dom_matrix_to_json_callback)]
to_json: (),
#[webapi(method = "toString", callback = dom_matrix_to_string_callback)]
to_string: (),
#[webapi(method = "toFloat32Array", callback = dom_matrix_to_float32_array_callback)]
to_float32_array: (),
#[webapi(method = "toFloat64Array", callback = dom_matrix_to_float64_array_callback)]
to_float64_array: (),
#[webapi(method = "translate", callback = dom_matrix_translate_callback)]
translate: (),
#[webapi(method = "scale", callback = dom_matrix_scale_callback)]
scale: (),
#[webapi(method = "scaleNonUniform", callback = dom_matrix_scale_non_uniform_callback)]
scale_non_uniform: (),
#[webapi(method = "scale3d", callback = dom_matrix_scale_3d_callback)]
scale_3d: (),
#[webapi(method = "rotate", callback = dom_matrix_rotate_callback)]
rotate: (),
#[webapi(method = "rotateFromVector", callback = dom_matrix_rotate_from_vector_callback)]
rotate_from_vector: (),
#[webapi(method = "rotateAxisAngle", callback = dom_matrix_rotate_axis_angle_callback)]
rotate_axis_angle: (),
#[webapi(method = "skewX", callback = dom_matrix_skew_x_callback)]
skew_x: (),
#[webapi(method = "skewY", callback = dom_matrix_skew_y_callback)]
skew_y: (),
#[webapi(method = "multiply", callback = dom_matrix_multiply_callback)]
multiply: (),
#[webapi(method = "flipX", callback = dom_matrix_flip_x_callback)]
flip_x: (),
#[webapi(method = "flipY", callback = dom_matrix_flip_y_callback)]
flip_y: (),
#[webapi(method = "inverse", callback = dom_matrix_inverse_callback)]
inverse: (),
#[webapi(method = "transformPoint", callback = dom_matrix_transform_point_callback)]
transform_point: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMMatrixReadOnly, enumerable)]
struct DomMatrixReadOnlyConstructorDeclaration {
#[webapi(
static_method = "fromMatrix",
length = 0,
callback = dom_matrix_readonly_from_matrix_callback
)]
from_matrix: (),
#[webapi(
static_method = "fromFloat32Array",
length = 1,
callback = dom_matrix_readonly_from_float32_array_callback
)]
from_float32_array: (),
#[webapi(
static_method = "fromFloat64Array",
length = 1,
callback = dom_matrix_readonly_from_float64_array_callback
)]
from_float64_array: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMMatrix)]
struct DomMatrixPrototypeAccessorsDeclaration {
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 0), enumerable)]
a: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 1), enumerable)]
b: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 2), enumerable)]
c: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 3), enumerable)]
d: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 4), enumerable)]
e: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 5), enumerable)]
f: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 6), enumerable)]
m11: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 7), enumerable)]
m12: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 8), enumerable)]
m13: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 9), enumerable)]
m14: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 10), enumerable)]
m21: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 11), enumerable)]
m22: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 12), enumerable)]
m23: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 13), enumerable)]
m24: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 14), enumerable)]
m31: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 15), enumerable)]
m32: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 16), enumerable)]
m33: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 17), enumerable)]
m34: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 18), enumerable)]
m41: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 19), enumerable)]
m42: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 20), enumerable)]
m43: (),
#[webapi(accessor_property, getter = dom_matrix_getter_callback, setter = dom_matrix_setter_callback, data = callback_data_index_value(scope, 21), enumerable)]
m44: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMMatrix, enumerable)]
struct DomMatrixPrototypeMethodsDeclaration {
#[webapi(method = "translateSelf", callback = dom_matrix_translate_self_callback)]
translate_self: (),
#[webapi(method = "scaleSelf", callback = dom_matrix_scale_self_callback)]
scale_self: (),
#[webapi(method = "scale3dSelf", callback = dom_matrix_scale_3d_self_callback)]
scale_3d_self: (),
#[webapi(method = "rotateSelf", callback = dom_matrix_rotate_self_callback)]
rotate_self: (),
#[webapi(
method = "rotateFromVectorSelf",
callback = dom_matrix_rotate_from_vector_self_callback
)]
rotate_from_vector_self: (),
#[webapi(
method = "rotateAxisAngleSelf",
callback = dom_matrix_rotate_axis_angle_self_callback
)]
rotate_axis_angle_self: (),
#[webapi(method = "skewXSelf", callback = dom_matrix_skew_x_self_callback)]
skew_x_self: (),
#[webapi(method = "skewYSelf", callback = dom_matrix_skew_y_self_callback)]
skew_y_self: (),
#[webapi(method = "multiplySelf", callback = dom_matrix_multiply_self_callback)]
multiply_self: (),
#[webapi(method = "preMultiplySelf", callback = dom_matrix_pre_multiply_self_callback)]
pre_multiply_self: (),
#[webapi(method = "invertSelf", callback = dom_matrix_invert_self_callback)]
invert_self: (),
#[webapi(method = "setMatrixValue", length = 1, callback = dom_matrix_set_matrix_value_callback)]
set_matrix_value: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::DOMMatrix, enumerable)]
struct DomMatrixConstructorDeclaration {
#[webapi(
static_method = "fromMatrix",
length = 0,
callback = dom_matrix_from_matrix_callback
)]
from_matrix: (),
#[webapi(
static_method = "fromFloat32Array",
length = 1,
callback = dom_matrix_from_float32_array_callback
)]
from_float32_array: (),
#[webapi(
static_method = "fromFloat64Array",
length = 1,
callback = dom_matrix_from_float64_array_callback
)]
from_float64_array: (),
}
#[derive(Clone, Copy, webidl::WebIdlDictionary)]
#[webidl(prefix = "DOMPointInit", snapshot)]
pub(super) struct DomPointInit {
// WebIDL converts dictionary members in lexicographic order.
#[webidl(default = 1.0)]
#[webidl(snapshot_slot = DOM_POINT_W_SLOT, snapshot_order = 3)]
pub(super) w: f64,
#[webidl(default = 0.0)]
#[webidl(snapshot_slot = DOM_POINT_X_SLOT, snapshot_order = 0)]
pub(super) x: f64,
#[webidl(default = 0.0)]
#[webidl(snapshot_slot = DOM_POINT_Y_SLOT, snapshot_order = 1)]
pub(super) y: f64,
#[webidl(default = 0.0)]
#[webidl(snapshot_slot = DOM_POINT_Z_SLOT, snapshot_order = 2)]
pub(super) z: f64,
}
impl Default for DomPointInit {
fn default() -> Self {
Self {
w: 1.0,
x: 0.0,
y: 0.0,
z: 0.0,
}
}
}
pub(super) fn dom_point_constructor_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !args.is_construct_call() {
throw_type_error(
scope,
"Failed to construct 'DOMPoint': Please use the 'new' operator.",
);
return;
}
let Some(x) = geometry_number_arg(scope, &args, 0, 0.0, "DOMPoint") else {
return;
};
let Some(y) = geometry_number_arg(scope, &args, 1, 0.0, "DOMPoint") else {
return;
};
let Some(z) = geometry_number_arg(scope, &args, 2, 0.0, "DOMPoint") else {
return;
};
let Some(w) = geometry_number_arg(scope, &args, 3, 1.0, "DOMPoint") else {
return;
};
initialize_dom_point_object(scope, args.this(), x, y, z, w);
rv.set(args.this().into());
}
pub(super) fn dom_matrix_constructor_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !args.is_construct_call() {
throw_type_error(
scope,
"Failed to construct 'DOMMatrix': Please use the 'new' operator.",
);
return;
}
initialize_dom_matrix_identity_object(scope, args.this());
if args.length() > 0
&& !args.get(0).is_undefined()
&& !apply_dom_matrix_init(scope, args.this(), args.get(0))
{
return;
}
rv.set(args.this().into());
}
pub(in crate::context_bootstrap) fn initialize_dom_point_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
x: f64,
y: f64,
z: f64,
w: f64,
) {
DomPointInit { x, y, z, w }
.initialize_snapshot(scope, object)
.expect("DOMPoint state");
DomPointObjectDeclaration::new()
.initialize(scope, object)
.expect("DOMPoint declaration should initialize object");
}
pub(in crate::context_bootstrap) fn build_dom_point_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
x: f64,
y: f64,
z: f64,
w: f64,
) -> v8::Local<'s, v8::Object> {
let object = DomPointObjectDeclaration::new()
.bind(scope)
.expect("DOMPoint declaration should bind");
DomPointInit { x, y, z, w }
.initialize_snapshot(scope, object)
.expect("DOMPoint state");
object
}
pub(super) fn dom_point_init_from_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> DomPointInit {
DomPointInit {
x: dom_point_slot(scope, object, DOM_POINT_X_SLOT, 0.0),
y: dom_point_slot(scope, object, DOM_POINT_Y_SLOT, 0.0),
z: dom_point_slot(scope, object, DOM_POINT_Z_SLOT, 0.0),
w: dom_point_slot(scope, object, DOM_POINT_W_SLOT, 1.0),
}
}
pub(super) fn dom_point_clone_data<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> Option<(bool, [f64; 4])> {
if !web_api_interfaces::DOMPoint::is_instance(scope, object) {
return None;
}
let mutable = web_api_interfaces::DOMPoint::is_instance(scope, object);
Some((
mutable,
[
dom_point_slot(scope, object, DOM_POINT_X_SLOT, 0.0),
dom_point_slot(scope, object, DOM_POINT_Y_SLOT, 0.0),
dom_point_slot(scope, object, DOM_POINT_Z_SLOT, 0.0),
dom_point_slot(scope, object, DOM_POINT_W_SLOT, 1.0),
],
))
}
pub(in crate::context_bootstrap) fn build_svg_point_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
) -> v8::Local<'s, v8::Object> {
build_svg_point_object_with_values(scope, 0.0, 0.0)
}
pub(in crate::context_bootstrap) fn build_svg_point_object_with_values<'s>(
scope: &mut v8::PinScope<'s, '_>,
x: f64,
y: f64,
) -> v8::Local<'s, v8::Object> {
let object = build_dom_point_object(scope, x, y, 0.0, 1.0);
let restricted = v8::Boolean::new(scope, true);
set_private_value(
scope,
object,
DOM_POINT_RESTRICTED_NUMBER_SLOT,
restricted.into(),
);
object
}
pub(in crate::context_bootstrap) fn set_svg_point_read_only<'s>(
scope: &mut v8::PinScope<'s, '_>,
point: v8::Local<'s, v8::Object>,
read_only: bool,
) {
set_private_value(
scope,
point,
DOM_POINT_READ_ONLY_SLOT,
v8::Boolean::new(scope, read_only).into(),
);
}
fn build_dom_matrix_identity_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
) -> v8::Local<'s, v8::Object> {
build_dom_matrix_object(scope, DomMatrixComponents::identity())
}
pub(in crate::context_bootstrap) fn build_dom_matrix_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
components: DomMatrixComponents,
) -> v8::Local<'s, v8::Object> {
DomMatrixObjectDeclaration::from_components(components)
.bind(scope)
.expect("DOMMatrix declaration should bind")
}
fn build_dom_matrix_readonly_identity_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
) -> v8::Local<'s, v8::Object> {
DomMatrixReadOnlyObjectDeclaration::from_components(DomMatrixComponents::identity())
.bind(scope)
.expect("DOMMatrixReadOnly declaration should bind")
}
pub(in crate::context_bootstrap) fn install_geometry_template_bindings<'s>(
scope: &mut v8::PinScope<'s, '_, ()>,
template: v8::Local<'s, v8::FunctionTemplate>,
interface_name: &str,
) {
let prototype = template.prototype_template(scope);
match interface_name {
"DOMPoint" => {
DomPointConstructorDeclaration::initialize_template(scope, template);
DomPointPrototypeAccessorsDeclaration::initialize_prototype_template(scope, prototype);
DomPointPrototypeMethodsDeclaration::initialize_prototype_template(scope, prototype);
}
"DOMMatrixReadOnly" => {
DomMatrixReadOnlyConstructorDeclaration::initialize_template(scope, template);
DomMatrixReadOnlyPrototypeAccessorsDeclaration::initialize_prototype_template(
scope, prototype,
);
DomMatrixReadOnlyPrototypeMethodsDeclaration::initialize_prototype_template(
scope, prototype,
);
}
"DOMMatrix" => {
DomMatrixConstructorDeclaration::initialize_template(scope, template);
DomMatrixPrototypeAccessorsDeclaration::initialize_prototype_template(scope, prototype);
DomMatrixPrototypeMethodsDeclaration::initialize_prototype_template(scope, prototype);
}
_ => {}
}
}
fn dom_point_getter_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(slot) = callback_data_item(scope, &args, DOM_POINT_ATTRIBUTE_SLOTS, "DOMPoint slots")
else {
rv.set_undefined();
return;
};
rv.set(
get_private_value(scope, args.this(), slot).unwrap_or_else(|| v8::undefined(scope).into()),
);
}
fn dom_point_setter_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(slot) = callback_data_item(scope, &args, DOM_POINT_ATTRIBUTE_SLOTS, "DOMPoint slots")
else {
rv.set_undefined();
return;
};
if get_private_value(scope, args.this(), DOM_POINT_READ_ONLY_SLOT)
.is_some_and(|value| value.boolean_value(scope))
{
throw_dom_exception(
scope,
"NoModificationAllowedError",
7,
"The SVG point is read-only.",
);
return;
}
let context = webidl::Context::member("DOMPoint", slot);
let value = if get_private_value(scope, args.this(), DOM_POINT_RESTRICTED_NUMBER_SLOT)
.is_some_and(|value| value.boolean_value(scope))
{
match webidl::convert::<webidl::Double>(scope, args.get(0), context) {
Ok(value) => value.0,
Err(error) => {
webidl::throw_error(scope, &error);
return;
}
}
} else {
let Some(value) = geometry_number_value(scope, args.get(0), context) else {
return;
};
value
};
set_private_value(
scope,
args.this(),
slot,
v8::Number::new(scope, value).into(),
);
super::svg_runtime::reflect_svg_point_mutation(scope, args.this());
rv.set_undefined();
}
fn dom_matrix_getter_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(attribute) =
callback_data_item(scope, &args, DOM_MATRIX_ATTRIBUTES, "DOMMatrix attributes")
else {
rv.set_undefined();
return;
};
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
match attribute.kind {
DomMatrixAttributeKind::Number(slot) => {
let value = dom_matrix_slot(scope, args.this(), slot, attribute.default);
rv.set(v8::Number::new(scope, value).into());
}
DomMatrixAttributeKind::Is2D => rv.set_bool(dom_matrix_is_2d(scope, args.this())),
DomMatrixAttributeKind::IsIdentity => {
rv.set_bool(dom_matrix_is_identity(scope, args.this()))
}
}
}
fn dom_matrix_setter_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(attribute) = callback_data_item(
scope,
&args,
DOM_MATRIX_MUTABLE_ATTRIBUTES,
"DOMMatrix mutable attributes",
) else {
rv.set_undefined();
return;
};
let DomMatrixAttributeKind::Number(slot) = attribute.kind else {
rv.set_undefined();
return;
};
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(value) = geometry_number_value(
scope,
args.get(0),
webidl::Context::member("DOMMatrix", attribute.name),
) else {
return;
};
set_dom_matrix_slot(scope, args.this(), slot, value);
rv.set_undefined();
}
fn dom_point_from_point_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(init) = optional_dom_point_init_arg(scope, &args, 0, "DOMPoint.fromPoint") else {
return;
};
rv.set(build_dom_point_object(scope, init.x, init.y, init.z, init.w).into());
}
fn dom_matrix_from_matrix_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let matrix = build_dom_matrix_identity_object(scope);
if args.length() > 0
&& !args.get(0).is_undefined()
&& !apply_dom_matrix_init(scope, matrix, args.get(0))
{
return;
}
rv.set(matrix.into());
}
fn dom_matrix_readonly_from_matrix_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let matrix = build_dom_matrix_readonly_identity_object(scope);
if args.length() > 0
&& !args.get(0).is_undefined()
&& !apply_dom_matrix_init(scope, matrix, args.get(0))
{
return;
}
rv.set(matrix.into());
}
fn dom_matrix_from_float32_array_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(components) = dom_matrix_components_from_typed_array(
scope,
args.get(0),
DomMatrixTypedArrayKind::Float32,
) else {
return;
};
let matrix = build_dom_matrix_identity_object(scope);
set_dom_matrix_components(scope, matrix, components);
rv.set(matrix.into());
}
fn dom_matrix_from_float64_array_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(components) = dom_matrix_components_from_typed_array(
scope,
args.get(0),
DomMatrixTypedArrayKind::Float64,
) else {
return;
};
let matrix = build_dom_matrix_identity_object(scope);
set_dom_matrix_components(scope, matrix, components);
rv.set(matrix.into());
}
fn dom_matrix_readonly_from_float32_array_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(components) = dom_matrix_components_from_typed_array(
scope,
args.get(0),
DomMatrixTypedArrayKind::Float32,
) else {
return;
};
let matrix = build_dom_matrix_readonly_identity_object(scope);
set_dom_matrix_components(scope, matrix, components);
rv.set(matrix.into());
}
fn dom_matrix_readonly_from_float64_array_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(components) = dom_matrix_components_from_typed_array(
scope,
args.get(0),
DomMatrixTypedArrayKind::Float64,
) else {
return;
};
let matrix = build_dom_matrix_readonly_identity_object(scope);
set_dom_matrix_components(scope, matrix, components);
rv.set(matrix.into());
}
fn dom_point_to_json_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let this = args.this();
let point = dom_point_init_from_object(scope, this);
let Some(object) = point.to_js_snapshot(scope, SnapshotPrototype::Ordinary) else {
return;
};
rv.set(object.into());
}
fn dom_point_slot<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
slot: &'static str,
default: f64,
) -> f64 {
get_private_value(scope, object, slot)
.and_then(|value| value.number_value(scope))
.unwrap_or(default)
}
fn dom_matrix_require_readonly_receiver<'s>(
scope: &mut v8::PinScope<'s, '_>,
receiver: v8::Local<'s, v8::Object>,
) -> bool {
if web_api_interfaces::DOMMatrixReadOnly::is_instance(scope, receiver) {
return true;
}
throw_type_error(scope, "Illegal invocation");
false
}
fn dom_matrix_require_mutable_receiver<'s>(
scope: &mut v8::PinScope<'s, '_>,
receiver: v8::Local<'s, v8::Object>,
) -> bool {
if web_api_interfaces::DOMMatrix::is_instance(scope, receiver) {
return true;
}
throw_type_error(scope, "Illegal invocation");
false
}
fn dom_matrix_to_json_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let this = args.this();
if !dom_matrix_require_readonly_receiver(scope, this) {
return;
}
let declaration = DomMatrixJsonDeclaration {
a: dom_matrix_json_number(scope, this, DOM_MATRIX_M11_SLOT, 1.0),
b: dom_matrix_json_number(scope, this, DOM_MATRIX_M12_SLOT, 0.0),
c: dom_matrix_json_number(scope, this, DOM_MATRIX_M21_SLOT, 0.0),
d: dom_matrix_json_number(scope, this, DOM_MATRIX_M22_SLOT, 1.0),
e: dom_matrix_json_number(scope, this, DOM_MATRIX_M41_SLOT, 0.0),
f: dom_matrix_json_number(scope, this, DOM_MATRIX_M42_SLOT, 0.0),
m11: dom_matrix_json_number(scope, this, DOM_MATRIX_M11_SLOT, 1.0),
m12: dom_matrix_json_number(scope, this, DOM_MATRIX_M12_SLOT, 0.0),
m13: dom_matrix_json_number(scope, this, DOM_MATRIX_M13_SLOT, 0.0),
m14: dom_matrix_json_number(scope, this, DOM_MATRIX_M14_SLOT, 0.0),
m21: dom_matrix_json_number(scope, this, DOM_MATRIX_M21_SLOT, 0.0),
m22: dom_matrix_json_number(scope, this, DOM_MATRIX_M22_SLOT, 1.0),
m23: dom_matrix_json_number(scope, this, DOM_MATRIX_M23_SLOT, 0.0),
m24: dom_matrix_json_number(scope, this, DOM_MATRIX_M24_SLOT, 0.0),
m31: dom_matrix_json_number(scope, this, DOM_MATRIX_M31_SLOT, 0.0),
m32: dom_matrix_json_number(scope, this, DOM_MATRIX_M32_SLOT, 0.0),
m33: dom_matrix_json_number(scope, this, DOM_MATRIX_M33_SLOT, 1.0),
m34: dom_matrix_json_number(scope, this, DOM_MATRIX_M34_SLOT, 0.0),
m41: dom_matrix_json_number(scope, this, DOM_MATRIX_M41_SLOT, 0.0),
m42: dom_matrix_json_number(scope, this, DOM_MATRIX_M42_SLOT, 0.0),
m43: dom_matrix_json_number(scope, this, DOM_MATRIX_M43_SLOT, 0.0),
m44: dom_matrix_json_number(scope, this, DOM_MATRIX_M44_SLOT, 1.0),
is_2d: dom_matrix_is_2d(scope, this),
is_identity: dom_matrix_is_identity(scope, this),
};
let Ok(object) = declaration.bind(scope) else {
return;
};
rv.set(object.into());
}
fn dom_matrix_json_number<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
slot: &'static str,
default: f64,
) -> f64 {
dom_matrix_slot(scope, object, slot, default)
}
fn dom_matrix_to_string_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let Some(text) = dom_matrix_css_text(scope, args.this()) else {
return;
};
let Some(text) = v8_string(scope, &text) else {
return;
};
rv.set(text.into());
}
fn dom_matrix_to_float32_array_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let components = dom_matrix_components(scope, args.this());
let array = build_dom_matrix_float32_array(scope, components);
rv.set(array);
}
fn dom_matrix_to_float64_array_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let components = dom_matrix_components(scope, args.this());
let array = build_dom_matrix_float64_array(scope, components);
rv.set(array);
}
fn dom_matrix_translate_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(translation) = dom_matrix_translate_args(scope, &args) else {
return;
};
apply_dom_matrix_translate(scope, matrix, translation);
rv.set(matrix.into());
}
fn dom_matrix_translate_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(translation) = dom_matrix_translate_args(scope, &args) else {
return;
};
apply_dom_matrix_translate(scope, args.this(), translation);
rv.set(args.this().into());
}
fn dom_matrix_scale_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(scale) = dom_matrix_scale_args(scope, &args) else {
return;
};
apply_dom_matrix_scale(scope, matrix, scale);
rv.set(matrix.into());
}
fn dom_matrix_scale_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(scale) = dom_matrix_scale_args(scope, &args) else {
return;
};
apply_dom_matrix_scale(scope, args.this(), scale);
rv.set(args.this().into());
}
fn dom_matrix_scale_non_uniform_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(scale_x) = geometry_number_arg(scope, &args, 0, 1.0, "DOMMatrix") else {
return;
};
let Some(scale_y) = geometry_number_arg(scope, &args, 1, 1.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_scale_2d(scope, matrix, scale_x, scale_y);
rv.set(matrix.into());
}
fn dom_matrix_scale_3d_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some((scale, origin_x, origin_y, origin_z)) = dom_matrix_scale_3d_args(scope, &args) else {
return;
};
apply_dom_matrix_scale(
scope,
matrix,
(scale, scale, scale, origin_x, origin_y, origin_z),
);
rv.set(matrix.into());
}
fn dom_matrix_scale_3d_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some((scale, origin_x, origin_y, origin_z)) = dom_matrix_scale_3d_args(scope, &args) else {
return;
};
apply_dom_matrix_scale(
scope,
args.this(),
(scale, scale, scale, origin_x, origin_y, origin_z),
);
rv.set(args.this().into());
}
fn dom_matrix_rotate_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(rotation) = dom_matrix_rotation_args(scope, &args) else {
return;
};
apply_dom_matrix_rotate(scope, matrix, rotation);
rv.set(matrix.into());
}
fn dom_matrix_rotate_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(rotation) = dom_matrix_rotation_args(scope, &args) else {
return;
};
apply_dom_matrix_rotate(scope, args.this(), rotation);
rv.set(args.this().into());
}
fn dom_matrix_rotate_from_vector_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let Some(x) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
let Some(y) = geometry_number_arg(scope, &args, 1, 0.0, "DOMMatrix") else {
return;
};
let degrees = if x == 0.0 && y == 0.0 {
0.0
} else {
y.atan2(x).to_degrees()
};
let matrix = copied_dom_matrix(scope, args.this());
apply_dom_matrix_rotate_z(scope, matrix, degrees);
rv.set(matrix.into());
}
fn dom_matrix_rotate_from_vector_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(x) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
let Some(y) = geometry_number_arg(scope, &args, 1, 0.0, "DOMMatrix") else {
return;
};
let degrees = if x == 0.0 && y == 0.0 {
0.0
} else {
y.atan2(x).to_degrees()
};
apply_dom_matrix_rotate_z(scope, args.this(), degrees);
rv.set(args.this().into());
}
fn dom_matrix_rotate_axis_angle_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(x) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
let Some(y) = geometry_number_arg(scope, &args, 1, 0.0, "DOMMatrix") else {
return;
};
let Some(z) = geometry_number_arg(scope, &args, 2, 0.0, "DOMMatrix") else {
return;
};
let Some(degrees) = geometry_number_arg(scope, &args, 3, 0.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_rotate_axis_angle(scope, matrix, x, y, z, degrees);
rv.set(matrix.into());
}
fn dom_matrix_rotate_axis_angle_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(x) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
let Some(y) = geometry_number_arg(scope, &args, 1, 0.0, "DOMMatrix") else {
return;
};
let Some(z) = geometry_number_arg(scope, &args, 2, 0.0, "DOMMatrix") else {
return;
};
let Some(degrees) = geometry_number_arg(scope, &args, 3, 0.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_rotate_axis_angle(scope, args.this(), x, y, z, degrees);
rv.set(args.this().into());
}
fn dom_matrix_skew_x_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(degrees) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_skew_x(scope, matrix, degrees);
rv.set(matrix.into());
}
fn dom_matrix_skew_x_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(degrees) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_skew_x(scope, args.this(), degrees);
rv.set(args.this().into());
}
fn dom_matrix_skew_y_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(degrees) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_skew_y(scope, matrix, degrees);
rv.set(matrix.into());
}
fn dom_matrix_skew_y_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(degrees) = geometry_number_arg(scope, &args, 0, 0.0, "DOMMatrix") else {
return;
};
apply_dom_matrix_skew_y(scope, args.this(), degrees);
rv.set(args.this().into());
}
fn dom_matrix_multiply_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let Some(other) = dom_matrix_argument_components(scope, &args, 0) else {
return;
};
apply_dom_matrix_multiply(scope, matrix, other);
rv.set(matrix.into());
}
fn dom_matrix_multiply_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(other) = dom_matrix_argument_components(scope, &args, 0) else {
return;
};
apply_dom_matrix_multiply(scope, args.this(), other);
rv.set(args.this().into());
}
fn dom_matrix_pre_multiply_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(other) = dom_matrix_argument_components(scope, &args, 0) else {
return;
};
let current = dom_matrix_components(scope, args.this());
set_dom_matrix_components(scope, args.this(), other.multiply(current));
rv.set(args.this().into());
}
fn dom_matrix_flip_x_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
apply_dom_matrix_scale_2d(scope, matrix, -1.0, 1.0);
rv.set(matrix.into());
}
fn dom_matrix_flip_y_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
apply_dom_matrix_scale_2d(scope, matrix, 1.0, -1.0);
rv.set(matrix.into());
}
fn dom_matrix_inverse_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let matrix = copied_dom_matrix(scope, args.this());
let inverted = dom_matrix_components(scope, matrix).inverse();
set_dom_matrix_components(scope, matrix, inverted);
rv.set(matrix.into());
}
fn dom_matrix_invert_self_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let inverted = dom_matrix_components(scope, args.this()).inverse();
set_dom_matrix_components(scope, args.this(), inverted);
rv.set(args.this().into());
}
fn dom_matrix_set_matrix_value_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_mutable_receiver(scope, args.this()) {
return;
}
let Some(text) = webidl::required_argument::<webidl::DomString>(
scope,
&args,
0,
webidl::Context::argument("DOMMatrix.setMatrixValue", 1),
"Failed to execute 'setMatrixValue' on 'DOMMatrix': 1 argument required.",
) else {
return;
};
let text = String::from(text);
if !apply_dom_matrix_transform_list_string(scope, args.this(), &text) {
return;
}
rv.set(args.this().into());
}
fn dom_matrix_transform_point_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
if !dom_matrix_require_readonly_receiver(scope, args.this()) {
return;
}
let Some(init) = optional_dom_point_init_arg(scope, &args, 0, "DOMMatrix.transformPoint")
else {
return;
};
let components = dom_matrix_components(scope, args.this());
let point = build_dom_point_object(
scope,
components.m11 * init.x
+ components.m21 * init.y
+ components.m31 * init.z
+ components.m41 * init.w,
components.m12 * init.x
+ components.m22 * init.y
+ components.m32 * init.z
+ components.m42 * init.w,
components.m13 * init.x
+ components.m23 * init.y
+ components.m33 * init.z
+ components.m43 * init.w,
components.m14 * init.x
+ components.m24 * init.y
+ components.m34 * init.z
+ components.m44 * init.w,
);
rv.set(point.into());
}
fn copied_dom_matrix<'s>(
scope: &mut v8::PinScope<'s, '_>,
source: v8::Local<'s, v8::Object>,
) -> v8::Local<'s, v8::Object> {
let matrix = build_dom_matrix_identity_object(scope);
let components = dom_matrix_components(scope, source);
set_dom_matrix_components(scope, matrix, components);
matrix
}
fn dom_matrix_argument_components<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
index: i32,
) -> Option<DomMatrixComponents> {
if index >= args.length() || args.get(index).is_undefined() {
return Some(DomMatrixComponents::identity());
}
let matrix = build_dom_matrix_identity_object(scope);
if !apply_dom_matrix_init(scope, matrix, args.get(index)) {
return None;
}
Some(dom_matrix_components(scope, matrix))
}
fn dom_matrix_translate_args<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<(f64, f64, f64)> {
Some((
geometry_number_arg(scope, args, 0, 0.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 1, 0.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 2, 0.0, "DOMMatrix")?,
))
}
fn dom_matrix_scale_args<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<(f64, f64, f64, f64, f64, f64)> {
let scale_x = geometry_number_arg(scope, args, 0, 1.0, "DOMMatrix")?;
let scale_y = geometry_number_arg(scope, args, 1, scale_x, "DOMMatrix")?;
let scale_z = geometry_number_arg(scope, args, 2, 1.0, "DOMMatrix")?;
let origin_x = geometry_number_arg(scope, args, 3, 0.0, "DOMMatrix")?;
let origin_y = geometry_number_arg(scope, args, 4, 0.0, "DOMMatrix")?;
let origin_z = geometry_number_arg(scope, args, 5, 0.0, "DOMMatrix")?;
Some((scale_x, scale_y, scale_z, origin_x, origin_y, origin_z))
}
fn dom_matrix_scale_3d_args<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<(f64, f64, f64, f64)> {
Some((
geometry_number_arg(scope, args, 0, 1.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 1, 0.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 2, 0.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 3, 0.0, "DOMMatrix")?,
))
}
fn dom_matrix_rotation_args<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<(f64, f64, f64)> {
if args.length() == 1 || args.get(1).is_undefined() {
return Some((
0.0,
0.0,
geometry_number_arg(scope, args, 0, 0.0, "DOMMatrix")?,
));
}
Some((
geometry_number_arg(scope, args, 0, 0.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 1, 0.0, "DOMMatrix")?,
geometry_number_arg(scope, args, 2, 0.0, "DOMMatrix")?,
))
}
fn apply_dom_matrix_translate<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
(tx, ty, tz): (f64, f64, f64),
) {
let components = dom_matrix_components(scope, matrix).translated(tx, ty, tz);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_scale<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
(scale_x, scale_y, scale_z, origin_x, origin_y, origin_z): (f64, f64, f64, f64, f64, f64),
) {
let components = dom_matrix_components(scope, matrix)
.scaled_with_origin(scale_x, scale_y, scale_z, origin_x, origin_y, origin_z);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_scale_2d<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
scale_x: f64,
scale_y: f64,
) {
let components = dom_matrix_components(scope, matrix).scaled_2d(scale_x, scale_y);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_rotate<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
(rot_x, rot_y, rot_z): (f64, f64, f64),
) {
let components = dom_matrix_components(scope, matrix).rotated(rot_x, rot_y, rot_z);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_rotate_z<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
degrees: f64,
) {
let components = dom_matrix_components(scope, matrix).rotated_z(degrees);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_rotate_axis_angle<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
x: f64,
y: f64,
z: f64,
degrees: f64,
) {
let components = dom_matrix_components(scope, matrix).rotated_axis_angle(x, y, z, degrees);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_skew_x<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
degrees: f64,
) {
let components = dom_matrix_components(scope, matrix).skewed_x(degrees);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_skew_y<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
degrees: f64,
) {
let components = dom_matrix_components(scope, matrix).skewed_y(degrees);
set_dom_matrix_components(scope, matrix, components);
}
fn apply_dom_matrix_multiply<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
other: DomMatrixComponents,
) {
let current = dom_matrix_components(scope, matrix);
set_dom_matrix_components(scope, matrix, current.multiply(other));
}
#[derive(Clone, Copy)]
enum DomMatrixTypedArrayKind {
Float32,
Float64,
}
fn dom_matrix_components_from_typed_array<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
kind: DomMatrixTypedArrayKind,
) -> Option<DomMatrixComponents> {
let expected = match kind {
DomMatrixTypedArrayKind::Float32 => v8::Local::<v8::Float32Array>::try_from(value).is_ok(),
DomMatrixTypedArrayKind::Float64 => v8::Local::<v8::Float64Array>::try_from(value).is_ok(),
};
if !expected {
throw_type_error(
scope,
"DOMMatrix typed array input must match the requested array type.",
);
return None;
}
let object = v8::Local::<v8::Object>::try_from(value).ok()?;
let Some(length) = object
.get(scope, v8str(scope, "length").into())
.and_then(|value| value.number_value(scope))
.map(|value| value as usize)
else {
throw_type_error(scope, "DOMMatrix typed array input is missing length.");
return None;
};
if length != 6 && length != DOM_MATRIX_TYPED_ARRAY_LENGTH {
throw_type_error(scope, "DOMMatrix typed array length must be 6 or 16.");
return None;
}
let mut values = Vec::with_capacity(length);
for index in 0..length {
let Some(value) = object
.get_index(scope, index as u32)
.and_then(|value| value.number_value(scope))
else {
throw_type_error(
scope,
"DOMMatrix typed array input contains a non-number value.",
);
return None;
};
values.push(value);
}
dom_matrix_components_from_values(&values)
}
fn dom_matrix_components_from_sequence_array<'s>(
scope: &mut v8::PinScope<'s, '_>,
array: v8::Local<'s, v8::Array>,
) -> Option<DomMatrixComponents> {
let length = array.length();
if length != 6 && length != DOM_MATRIX_TYPED_ARRAY_LENGTH as u32 {
throw_type_error(scope, "DOMMatrix sequence length must be 6 or 16.");
return None;
}
let mut values = Vec::with_capacity(length as usize);
for index in 0..length {
let value = array
.get_index(scope, index)
.unwrap_or_else(|| v8::undefined(scope).into());
let value =
geometry_number_value(scope, value, webidl::Context::member("DOMMatrix", "init"))?;
values.push(value);
}
dom_matrix_components_from_values(&values)
}
fn dom_matrix_components<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> DomMatrixComponents {
DomMatrixComponents {
m11: dom_matrix_slot(scope, object, DOM_MATRIX_M11_SLOT, 1.0),
m12: dom_matrix_slot(scope, object, DOM_MATRIX_M12_SLOT, 0.0),
m13: dom_matrix_slot(scope, object, DOM_MATRIX_M13_SLOT, 0.0),
m14: dom_matrix_slot(scope, object, DOM_MATRIX_M14_SLOT, 0.0),
m21: dom_matrix_slot(scope, object, DOM_MATRIX_M21_SLOT, 0.0),
m22: dom_matrix_slot(scope, object, DOM_MATRIX_M22_SLOT, 1.0),
m23: dom_matrix_slot(scope, object, DOM_MATRIX_M23_SLOT, 0.0),
m24: dom_matrix_slot(scope, object, DOM_MATRIX_M24_SLOT, 0.0),
m31: dom_matrix_slot(scope, object, DOM_MATRIX_M31_SLOT, 0.0),
m32: dom_matrix_slot(scope, object, DOM_MATRIX_M32_SLOT, 0.0),
m33: dom_matrix_slot(scope, object, DOM_MATRIX_M33_SLOT, 1.0),
m34: dom_matrix_slot(scope, object, DOM_MATRIX_M34_SLOT, 0.0),
m41: dom_matrix_slot(scope, object, DOM_MATRIX_M41_SLOT, 0.0),
m42: dom_matrix_slot(scope, object, DOM_MATRIX_M42_SLOT, 0.0),
m43: dom_matrix_slot(scope, object, DOM_MATRIX_M43_SLOT, 0.0),
m44: dom_matrix_slot(scope, object, DOM_MATRIX_M44_SLOT, 1.0),
}
}
fn dom_matrix_slot<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
slot: &'static str,
default: f64,
) -> f64 {
get_private_value(scope, object, slot)
.and_then(|value| value.number_value(scope))
.unwrap_or(default)
}
fn set_dom_matrix_components<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
components: DomMatrixComponents,
) {
for (slot, value) in [
(DOM_MATRIX_M11_SLOT, components.m11),
(DOM_MATRIX_M12_SLOT, components.m12),
(DOM_MATRIX_M13_SLOT, components.m13),
(DOM_MATRIX_M14_SLOT, components.m14),
(DOM_MATRIX_M21_SLOT, components.m21),
(DOM_MATRIX_M22_SLOT, components.m22),
(DOM_MATRIX_M23_SLOT, components.m23),
(DOM_MATRIX_M24_SLOT, components.m24),
(DOM_MATRIX_M31_SLOT, components.m31),
(DOM_MATRIX_M32_SLOT, components.m32),
(DOM_MATRIX_M33_SLOT, components.m33),
(DOM_MATRIX_M34_SLOT, components.m34),
(DOM_MATRIX_M41_SLOT, components.m41),
(DOM_MATRIX_M42_SLOT, components.m42),
(DOM_MATRIX_M43_SLOT, components.m43),
(DOM_MATRIX_M44_SLOT, components.m44),
] {
set_dom_matrix_slot(scope, object, slot, value);
}
}
fn set_dom_matrix_slot<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
slot: &'static str,
value: f64,
) {
set_private_value(scope, object, slot, v8::Number::new(scope, value).into());
}
fn dom_matrix_array_values(
components: DomMatrixComponents,
) -> [f64; DOM_MATRIX_TYPED_ARRAY_LENGTH] {
[
components.m11,
components.m12,
components.m13,
components.m14,
components.m21,
components.m22,
components.m23,
components.m24,
components.m31,
components.m32,
components.m33,
components.m34,
components.m41,
components.m42,
components.m43,
components.m44,
]
}
fn build_dom_matrix_float32_array<'s>(
scope: &mut v8::PinScope<'s, '_>,
components: DomMatrixComponents,
) -> v8::Local<'s, v8::Value> {
let mut bytes = Vec::with_capacity(DOM_MATRIX_TYPED_ARRAY_LENGTH * std::mem::size_of::<f32>());
for value in dom_matrix_array_values(components) {
bytes.extend_from_slice(&(value as f32).to_ne_bytes());
}
let backing_store = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing_store);
v8::Float32Array::new(scope, buffer, 0, DOM_MATRIX_TYPED_ARRAY_LENGTH)
.expect("Float32Array construction should succeed")
.into()
}
fn build_dom_matrix_float64_array<'s>(
scope: &mut v8::PinScope<'s, '_>,
components: DomMatrixComponents,
) -> v8::Local<'s, v8::Value> {
let mut bytes = Vec::with_capacity(DOM_MATRIX_TYPED_ARRAY_LENGTH * std::mem::size_of::<f64>());
for value in dom_matrix_array_values(components) {
bytes.extend_from_slice(&value.to_ne_bytes());
}
let backing_store = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing_store);
v8::Float64Array::new(scope, buffer, 0, DOM_MATRIX_TYPED_ARRAY_LENGTH)
.expect("Float64Array construction should succeed")
.into()
}
fn apply_dom_matrix_init<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
init: v8::Local<'s, v8::Value>,
) -> bool {
if init.is_string() {
let Some(text) = init.to_string(scope) else {
return false;
};
return apply_dom_matrix_transform_list_string(
scope,
matrix,
&text.to_rust_string_lossy(scope),
);
}
if v8::Local::<v8::Float32Array>::try_from(init).is_ok() {
if let Some(components) =
dom_matrix_components_from_typed_array(scope, init, DomMatrixTypedArrayKind::Float32)
{
set_dom_matrix_components(scope, matrix, components);
}
return true;
}
if v8::Local::<v8::Float64Array>::try_from(init).is_ok() {
if let Some(components) =
dom_matrix_components_from_typed_array(scope, init, DomMatrixTypedArrayKind::Float64)
{
set_dom_matrix_components(scope, matrix, components);
}
return true;
}
if let Ok(array) = v8::Local::<v8::Array>::try_from(init) {
let Some(components) = dom_matrix_components_from_sequence_array(scope, array) else {
return false;
};
set_dom_matrix_components(scope, matrix, components);
return true;
}
if let Ok(object) = v8::Local::<v8::Object>::try_from(init) {
for attribute in DOM_MATRIX_MUTABLE_ATTRIBUTES {
if let DomMatrixAttributeKind::Number(slot) = attribute.kind {
match property_number(scope, object, attribute.name, "DOMMatrixInit") {
Some(Some(value)) => {
set_dom_matrix_slot(scope, matrix, slot, value);
}
Some(None) => {}
None => return false,
}
}
}
return true;
}
match webidl::convert::<webidl::DomString>(
scope,
init,
webidl::Context::argument("DOMMatrix", 1),
) {
Ok(text) => {
let text = String::from(text);
apply_dom_matrix_transform_list_string(scope, matrix, &text)
}
Err(error) => {
webidl::throw_error(scope, &error);
false
}
}
}
fn apply_dom_matrix_transform_list_string<'s>(
scope: &mut v8::PinScope<'s, '_>,
matrix: v8::Local<'s, v8::Object>,
text: &str,
) -> bool {
let Some(components) = parse_dom_matrix_value(text) else {
throw_dom_exception(
scope,
"SyntaxError",
12,
"Failed to parse DOMMatrix transform list.",
);
return false;
};
set_dom_matrix_components(scope, matrix, components);
true
}
fn initialize_dom_matrix_identity_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) {
DomMatrixObjectDeclaration::from_components(DomMatrixComponents::identity())
.initialize(scope, object)
.expect("DOMMatrix declaration should initialize object");
}
fn dom_matrix_is_2d<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> bool {
dom_matrix_components(scope, object).is_2d()
}
fn dom_matrix_is_identity<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> bool {
dom_matrix_components(scope, object).is_identity()
}
fn dom_matrix_css_text<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> Option<String> {
let Some(css_text) = dom_matrix_components(scope, object).dom_matrix_text() else {
throw_dom_exception(
scope,
"InvalidStateError",
11,
"DOMMatrix contains non-finite values.",
);
return None;
};
Some(css_text)
}
fn geometry_number_arg<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
index: i32,
default: f64,
prefix: &'static str,
) -> Option<f64> {
if index >= args.length() || args.get(index).is_undefined() {
return Some(default);
}
geometry_number_value(
scope,
args.get(index),
webidl::Context::argument(prefix, (index + 1) as usize),
)
}
pub(super) fn optional_dom_point_init_arg<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
index: i32,
prefix: &'static str,
) -> Option<DomPointInit> {
if args.length() <= index || args.get(index).is_undefined() {
return Some(DomPointInit::default());
}
dom_point_init_value(
scope,
args.get(index),
webidl::Context::argument(prefix, (index + 1) as usize),
)
}
pub(super) fn dom_point_init_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
context: webidl::Context,
) -> Option<DomPointInit> {
match webidl::parse_dictionary::<DomPointInit>(scope, value, context) {
Ok(Some(init)) => Some(init),
Ok(None) => Some(DomPointInit::default()),
Err(error) => {
webidl::throw_error(scope, &error);
None
}
}
}
fn property_number<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
name: &'static str,
prefix: &'static str,
) -> Option<Option<f64>> {
let key = v8_string(scope, name)?;
let value = object.get(scope, key.into())?;
if value.is_undefined() {
return Some(None);
}
geometry_number_value(scope, value, webidl::Context::member(prefix, name)).map(Some)
}
fn geometry_number_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
context: webidl::Context,
) -> Option<f64> {
match webidl::convert::<webidl::UnrestrictedDouble>(scope, value, context) {
Ok(value) => Some(value.0),
Err(error) => {
webidl::throw_error(scope, &error);
None
}
}
}
#[derive(Clone, Copy)]
enum DomMatrixAttributeKind {
Number(&'static str),
Is2D,
IsIdentity,
}
#[derive(Clone, Copy)]
struct DomMatrixAttribute {
name: &'static str,
kind: DomMatrixAttributeKind,
default: f64,
}
const DOM_POINT_ATTRIBUTE_SLOTS: &[&str] = &[
DOM_POINT_X_SLOT,
DOM_POINT_Y_SLOT,
DOM_POINT_Z_SLOT,
DOM_POINT_W_SLOT,
];
const DOM_MATRIX_MUTABLE_ATTRIBUTES: &[DomMatrixAttribute] = &[
DomMatrixAttribute {
name: "a",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M11_SLOT),
default: 1.0,
},
DomMatrixAttribute {
name: "b",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M12_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "c",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M21_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "d",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M22_SLOT),
default: 1.0,
},
DomMatrixAttribute {
name: "e",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M41_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "f",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M42_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m11",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M11_SLOT),
default: 1.0,
},
DomMatrixAttribute {
name: "m12",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M12_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m13",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M13_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m14",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M14_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m21",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M21_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m22",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M22_SLOT),
default: 1.0,
},
DomMatrixAttribute {
name: "m23",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M23_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m24",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M24_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m31",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M31_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m32",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M32_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m33",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M33_SLOT),
default: 1.0,
},
DomMatrixAttribute {
name: "m34",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M34_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m41",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M41_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m42",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M42_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m43",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M43_SLOT),
default: 0.0,
},
DomMatrixAttribute {
name: "m44",
kind: DomMatrixAttributeKind::Number(DOM_MATRIX_M44_SLOT),
default: 1.0,
},
];
const DOM_MATRIX_READONLY_ATTRIBUTES: &[DomMatrixAttribute] = &[
DomMatrixAttribute {
name: "is2D",
kind: DomMatrixAttributeKind::Is2D,
default: 0.0,
},
DomMatrixAttribute {
name: "isIdentity",
kind: DomMatrixAttributeKind::IsIdentity,
default: 0.0,
},
];
const DOM_MATRIX_ATTRIBUTES: &[DomMatrixAttribute] = &[
DOM_MATRIX_MUTABLE_ATTRIBUTES[0],
DOM_MATRIX_MUTABLE_ATTRIBUTES[1],
DOM_MATRIX_MUTABLE_ATTRIBUTES[2],
DOM_MATRIX_MUTABLE_ATTRIBUTES[3],
DOM_MATRIX_MUTABLE_ATTRIBUTES[4],
DOM_MATRIX_MUTABLE_ATTRIBUTES[5],
DOM_MATRIX_MUTABLE_ATTRIBUTES[6],
DOM_MATRIX_MUTABLE_ATTRIBUTES[7],
DOM_MATRIX_MUTABLE_ATTRIBUTES[8],
DOM_MATRIX_MUTABLE_ATTRIBUTES[9],
DOM_MATRIX_MUTABLE_ATTRIBUTES[10],
DOM_MATRIX_MUTABLE_ATTRIBUTES[11],
DOM_MATRIX_MUTABLE_ATTRIBUTES[12],
DOM_MATRIX_MUTABLE_ATTRIBUTES[13],
DOM_MATRIX_MUTABLE_ATTRIBUTES[14],
DOM_MATRIX_MUTABLE_ATTRIBUTES[15],
DOM_MATRIX_MUTABLE_ATTRIBUTES[16],
DOM_MATRIX_MUTABLE_ATTRIBUTES[17],
DOM_MATRIX_MUTABLE_ATTRIBUTES[18],
DOM_MATRIX_MUTABLE_ATTRIBUTES[19],
DOM_MATRIX_MUTABLE_ATTRIBUTES[20],
DOM_MATRIX_MUTABLE_ATTRIBUTES[21],
DOM_MATRIX_READONLY_ATTRIBUTES[0],
DOM_MATRIX_READONLY_ATTRIBUTES[1],
];
#[derive(Default, webidl::WebIdlDictionary)]
#[webidl(prefix = "DOMMatrix2DInit")]
struct DomMatrix2DInit {
a: Option<f64>,
b: Option<f64>,
c: Option<f64>,
d: Option<f64>,
e: Option<f64>,
f: Option<f64>,
m11: Option<f64>,
m12: Option<f64>,
m21: Option<f64>,
m22: Option<f64>,
m41: Option<f64>,
m42: Option<f64>,
}
pub(in crate::context_bootstrap) fn dom_matrix_2d_init_arg<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
index: i32,
prefix: &'static str,
) -> Option<[f64; 6]> {
if index >= args.length() || args.get(index).is_undefined() {
return Some([1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
}
let init = match webidl::parse_dictionary::<DomMatrix2DInit>(
scope,
args.get(index),
webidl::Context::argument(prefix, (index + 1) as usize),
) {
Ok(Some(init)) => init,
Ok(None) => DomMatrix2DInit::default(),
Err(error) => {
webidl::throw_error(scope, &error);
return None;
}
};
Some([
validated_dom_matrix_2d_alias(scope, "DOMMatrix2DInit", "a", init.a, "m11", init.m11, 1.0)?,
validated_dom_matrix_2d_alias(scope, "DOMMatrix2DInit", "b", init.b, "m12", init.m12, 0.0)?,
validated_dom_matrix_2d_alias(scope, "DOMMatrix2DInit", "c", init.c, "m21", init.m21, 0.0)?,
validated_dom_matrix_2d_alias(scope, "DOMMatrix2DInit", "d", init.d, "m22", init.m22, 1.0)?,
validated_dom_matrix_2d_alias(scope, "DOMMatrix2DInit", "e", init.e, "m41", init.m41, 0.0)?,
validated_dom_matrix_2d_alias(scope, "DOMMatrix2DInit", "f", init.f, "m42", init.m42, 0.0)?,
])
}
fn validated_dom_matrix_2d_alias(
scope: &mut v8::PinScope<'_, '_>,
dictionary_name: &'static str,
alias_name: &'static str,
alias: Option<f64>,
matrix_name: &'static str,
matrix: Option<f64>,
default: f64,
) -> Option<f64> {
if let (Some(alias), Some(matrix)) = (alias, matrix)
&& !same_dom_matrix_2d_number(alias, matrix)
{
throw_type_error(
scope,
&format!("{dictionary_name} {alias_name} and {matrix_name} values differ."),
);
return None;
}
Some(matrix.or(alias).unwrap_or(default))
}
fn same_dom_matrix_2d_number(lhs: f64, rhs: f64) -> bool {
lhs == rhs || (lhs.is_nan() && rhs.is_nan())
}