Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(events): retain creation state in legacy initializers

ldm098edb0848b04
diff --git a/moli-renderer-v8/src/context_bootstrap/event_legacy.rs b/moli-renderer-v8/src/context_bootstrap/event_legacy.rs
index da60b46b7..624d6f7a5 100644
--- a/moli-renderer-v8/src/context_bootstrap/event_legacy.rs
+++ b/moli-renderer-v8/src/context_bootstrap/event_legacy.rs
@@ -1,4 +1,4 @@
-use super::events::{event_is_dispatching, initialize_event_object};
+use super::events::reinitialize_event_object;
use super::*;
use crate::util::{context_host_ptr_from_window_object, throw_type_error};
use crate::webidl;
@@ -9,9 +9,10 @@ use moli_webapi_declare::WebApiObject;
struct InitEventArgs {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -23,9 +24,10 @@ struct InitEventArgs {
struct InitCustomEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initCustomEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -39,9 +41,10 @@ struct InitCustomEventArgs<'s> {
struct InitStorageEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initStorageEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -63,9 +66,10 @@ struct InitStorageEventArgs<'s> {
struct InitUiEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initUIEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -81,9 +85,10 @@ struct InitUiEventArgs<'s> {
struct InitMouseEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initMouseEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -119,9 +124,10 @@ struct InitMouseEventArgs<'s> {
struct InitKeyboardEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initKeyboardEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -145,9 +151,10 @@ struct InitKeyboardEventArgs<'s> {
struct InitTextEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initTextEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -163,9 +170,10 @@ struct InitTextEventArgs<'s> {
struct InitCompositionEventArgs<'s> {
#[webidl(
required,
+ converter = "raw",
missing_message = "Failed to execute 'initCompositionEvent': 1 argument required."
)]
- event_type: String,
+ event_type: webidl::DomString16,
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
@@ -296,16 +304,13 @@ pub(super) fn event_init_event_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitEventArgs>(scope, &args) else {
return;
};
- initialize_event_object(
+ reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
);
@@ -317,20 +322,19 @@ pub(super) fn ui_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitUiEventArgs>(scope, &args) else {
return;
};
let view = legacy_event_view_or_global(scope, parsed.view);
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
LegacyUiEventInitDeclaration::new(view, parsed.detail)
.initialize(scope, event)
.expect("legacy UIEvent init declaration should initialize");
@@ -342,22 +346,21 @@ pub(super) fn text_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitTextEventArgs>(scope, &args) else {
return;
};
let Some(view) = legacy_text_event_view_or_null(scope, parsed.view) else {
return;
};
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
let data = v8_string(scope, &parsed.data).expect("text event data");
LegacyTextEventInitDeclaration::new(view, 0.0, data)
.initialize(scope, event)
@@ -370,9 +373,6 @@ pub(super) fn mouse_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitMouseEventArgs>(scope, &args) else {
return;
};
@@ -381,13 +381,15 @@ pub(super) fn mouse_event_init_callback<'s>(
.related_target
.filter(|value| !value.is_null_or_undefined())
.unwrap_or_else(|| v8::null(scope).into());
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
LegacyMouseEventBaseInitDeclaration::new(
view,
parsed.detail,
@@ -416,20 +418,19 @@ pub(super) fn keyboard_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitKeyboardEventArgs>(scope, &args) else {
return;
};
let view = legacy_event_view_or_global(scope, parsed.view);
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
let key = v8_string(scope, &parsed.key).unwrap_or_else(|| v8str(scope, ""));
let code = v8str(scope, "");
LegacyKeyboardEventInitDeclaration::new(view, key, code, parsed.location, parsed.repeat)
@@ -443,20 +444,19 @@ pub(super) fn composition_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitCompositionEventArgs>(scope, &args) else {
return;
};
let view = legacy_event_view_or_global(scope, parsed.view);
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
let data = v8_string(scope, &parsed.data).expect("composition event data");
LegacyTextEventInitDeclaration::new(view, 0.0, data)
.initialize(scope, event)
@@ -469,19 +469,18 @@ pub(super) fn custom_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitCustomEventArgs>(scope, &args) else {
return;
};
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
let detail = parsed.detail.unwrap_or_else(|| v8::null(scope).into());
LegacyCustomEventInitDeclaration::new(detail)
.initialize(scope, event)
@@ -494,19 +493,18 @@ pub(super) fn storage_event_init_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = super::events::event_backing(scope, args.this());
- if event_is_dispatching(scope, event) {
- return;
- }
let Some(parsed) = webidl::parse_args::<InitStorageEventArgs>(scope, &args) else {
return;
};
- initialize_event_object(
+ if !reinitialize_event_object(
scope,
event,
- &parsed.event_type,
+ &parsed.event_type.0,
parsed.bubbles,
parsed.cancelable,
- );
+ ) {
+ return;
+ }
super::events::define_storage_event_properties(
scope,
event,
diff --git a/moli-renderer-v8/src/context_bootstrap/event_template.rs b/moli-renderer-v8/src/context_bootstrap/event_template.rs
index 5557a7c12..15c9eac06 100644
--- a/moli-renderer-v8/src/context_bootstrap/event_template.rs
+++ b/moli-renderer-v8/src/context_bootstrap/event_template.rs
@@ -167,7 +167,7 @@ struct FormDataEventTemplateAccessorsDeclaration {
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::UIEvent, enumerable, receiver)]
struct UiEventTemplateMethodsDeclaration {
- #[webapi(method = "initUIEvent", length = 0, callback = ui_event_init_callback)]
+ #[webapi(method = "initUIEvent", length = 1, callback = ui_event_init_callback)]
init_ui_event: (),
#[webapi(
@@ -226,7 +226,7 @@ struct StorageEventTemplateMethodsDeclaration {
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::KeyboardEvent, enumerable, receiver)]
struct KeyboardEventTemplateMethodsDeclaration {
- #[webapi(method = "initKeyboardEvent", length = 7, callback = keyboard_event_init_callback)]
+ #[webapi(method = "initKeyboardEvent", length = 1, callback = keyboard_event_init_callback)]
init_keyboard_event: (),
#[webapi(
@@ -252,7 +252,7 @@ struct MouseEventTemplateMethodsDeclaration {
#[webapi(accessor_property = "offsetY", getter = window_host::mouse_event_offset_y_getter)]
offset_y: (),
- #[webapi(method = "initMouseEvent", length = 15, callback = mouse_event_init_callback)]
+ #[webapi(method = "initMouseEvent", length = 1, callback = mouse_event_init_callback)]
init_mouse_event: (),
}
diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rs
index e0991322e..f2deefd48 100644
--- a/moli-renderer-v8/src/context_bootstrap/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events.rs
@@ -253,8 +253,8 @@ pub(crate) use base::{
EVENT_DISPATCHING_SLOT, EVENT_PASSIVE_SLOT, EVENT_STOP_IMMEDIATE_PROPAGATION_SLOT,
EVENT_STOP_PROPAGATION_SLOT, clear_event_composed_path, define_event_property, event_backing,
event_initialized, event_internal_bool_flag, event_is_dispatching, initialize_event_object,
- initialize_event_object_with_type, mark_event_trusted, set_event_composed_path,
- set_event_internal_flag, set_event_trusted,
+ initialize_event_object_with_type, mark_event_trusted, reinitialize_event_object,
+ set_event_composed_path, set_event_internal_flag, set_event_trusted,
};
fn event_subclass_kind<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/events/base.rs b/moli-renderer-v8/src/context_bootstrap/events/base.rs
index 58602b41e..7c72a08fa 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/base.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/base.rs
@@ -329,27 +329,48 @@ pub(crate) fn initialize_event_object_with_type<'s>(
cancelable: bool,
) {
let event = event_backing(scope, event);
- InitializedEventHeaderDeclaration::new(event_type)
+ initialize_event_attributes(scope, event, event_type, bubbles, cancelable);
+ if !event_has_own_property(scope, event, "isTrusted") {
+ define_event_is_trusted_accessor(scope, event);
+ }
+ initialized_event_tail_declaration(scope)
.initialize(scope, event)
- .expect("initialized event header declaration should initialize");
- initialize_event_after_header(scope, event, bubbles, cancelable);
+ .expect("initialized event tail declaration should initialize");
}
-fn initialize_event_after_header<'s>(
+pub(crate) fn reinitialize_event_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
+ event_type: &[u16],
+ bubbles: bool,
+ cancelable: bool,
+) -> bool {
+ let event = event_backing(scope, event);
+ // WebIDL arguments have already been converted before this method step.
+ if event_is_dispatching(scope, event) {
+ return false;
+ }
+ let Some(event_type) = v8_string_from_utf16_units(scope, event_type) else {
+ return false;
+ };
+ // Creation-only state (including composed and timeStamp) is retained.
+ initialize_event_attributes(scope, event, event_type, bubbles, cancelable);
+ true
+}
+
+fn initialize_event_attributes<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ event: v8::Local<'s, v8::Object>,
+ event_type: v8::Local<'s, v8::String>,
bubbles: bool,
cancelable: bool,
) {
+ InitializedEventHeaderDeclaration::new(event_type)
+ .initialize(scope, event)
+ .expect("initialized event header declaration should initialize");
InitializedEventStateDeclaration::new(bubbles, cancelable)
.initialize(scope, event)
.expect("initialized event state declaration should initialize");
- if !event_has_own_property(scope, event, "isTrusted") {
- define_event_is_trusted_accessor(scope, event);
- }
- initialized_event_tail_declaration(scope)
- .initialize(scope, event)
- .expect("initialized event tail declaration should initialize");
}
pub(super) fn define_event_is_trusted_accessor<'s>(
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs
index eadf76009..79eb757f3 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs
@@ -829,7 +829,7 @@ fn event_subclass_constructors_expose_legacy_keyboard_codes_and_validate_view()
assert_eq!(
result,
- r#"{"defaults":[0,0,0],"nonDefaults":[7,8,9],"viewIsWindow":true,"wrongViewName":"TypeError","lengths":[7,15]}"#
+ r#"{"defaults":[0,0,0],"nonDefaults":[7,8,9],"viewIsWindow":true,"wrongViewName":"TypeError","lengths":[1,1]}"#
);
}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/legacy_event_init.js b/moli-renderer-v8/src/script_vm/tests/browser_api/legacy_event_init.js
new file mode 100644
index 000000000..e53749fb4
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/legacy_event_init.js
@@ -0,0 +1,168 @@
+(() => {
+ const rows = [];
+ const check = (name, passed) => rows.push({name, passed: !!passed});
+ const throws = (fn, Expected = TypeError) => {
+ try { fn(); return false; } catch (error) { return error instanceof Expected; }
+ };
+ const throwsExactly = (fn, expected) => {
+ try { fn(); return false; } catch (error) { return error === expected; }
+ };
+ const raw = 'new\ud800\0\udc00';
+ const flags = {bubbles: false, cancelable: true, composed: true};
+ const detail = {payload: 'detail'};
+ const cases = [
+ {name: 'Event', method: 'initEvent', make: w => new w.Event('before', flags), tail: () => []},
+ {name: 'CustomEvent', method: 'initCustomEvent',
+ make: w => new w.CustomEvent('before', {...flags, detail: 'old'}), tail: () => [detail]},
+ {name: 'UIEvent', method: 'initUIEvent',
+ make: w => new w.UIEvent('before', flags), tail: w => [w, 7]},
+ {name: 'MouseEvent', method: 'initMouseEvent',
+ make: w => new w.MouseEvent('before', flags),
+ tail: w => [w, 7, 1, 2, 3, 4, true, false, true, false, 1, null]},
+ {name: 'KeyboardEvent', method: 'initKeyboardEvent',
+ make: w => new w.KeyboardEvent('before', flags), tail: w => [w]},
+ {name: 'CompositionEvent', method: 'initCompositionEvent',
+ make: w => new w.CompositionEvent('before', flags), tail: w => [w, 'data']},
+ {name: 'StorageEvent', method: 'initStorageEvent',
+ make: w => new w.StorageEvent('before', flags), tail: () => ['key', 'old', 'new', 'https://event.test/', null]},
+ {name: 'TextEvent', method: 'initTextEvent', make: w => {
+ const event = w.document.createEvent('TextEvent');
+ event.initEvent('before', false, true);
+ return event;
+ }, tail: w => [w, 'data']}
+ ];
+ for (const entry of cases) {
+ const event = entry.make(window);
+ const method = event[entry.method];
+ const initialize = (receiver, type, bubbles = true, cancelable = false) =>
+ method.call(receiver, type, bubbles, cancelable, ...entry.tail(window));
+ const stamp = event.timeStamp;
+ const composed = event.composed;
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ const started = Date.now();
+ while (Date.now() - started < 3) {}
+ check(entry.name + ' method metadata', method.name === entry.method && method.length === 1);
+ check(entry.name + ' returns undefined', initialize(event, raw) === undefined);
+ check(entry.name + ' preserves DOMString units', event.type === raw);
+ check(entry.name + ' preserves composed', event.composed === composed);
+ check(entry.name + ' preserves timestamp', event.timeStamp === stamp);
+ check(entry.name + ' reinitializes flags', event.bubbles && !event.cancelable &&
+ !event.defaultPrevented && event.returnValue && !event.cancelBubble && !event.isTrusted);
+ let called = 0;
+ const target = new EventTarget();
+ target.addEventListener(raw, received => { if (received === event) called++; });
+ check(entry.name + ' propagation flags cleared', target.dispatchEvent(event) && called === 1);
+ check(entry.name + ' dispatched target', event.target === target && event.srcElement === target);
+ initialize(event, raw);
+ check(entry.name + ' target cleared', event.target === null && event.srcElement === null &&
+ event.currentTarget === null && event.eventPhase === Event.NONE && event.composedPath().length === 0);
+ check(entry.name + ' repeated timestamp', event.timeStamp === stamp);
+ check(entry.name + ' repeated composed', event.composed === composed);
+ check(entry.name + ' Symbol rejects', throws(() => initialize(event, Symbol())) && event.type === raw);
+ check(entry.name + ' missing type rejects', throws(() => method.call(event)) && event.type === raw);
+ let conversions = 0;
+ const boolean = {valueOf() { throw new Error('boolean conversion must not coerce'); }};
+ check(entry.name + ' conversion order', initialize(event, {toString() {
+ conversions++; return raw;
+ }}, boolean, boolean) === undefined && conversions === 1 && event.type === raw &&
+ event.bubbles && event.cancelable);
+ event.preventDefault();
+ const sentinel = new RangeError('type conversion');
+ check(entry.name + ' conversion failure preserves state', throwsExactly(() => initialize(event, {
+ toString() { throw sentinel; }
+ }), sentinel) && event.defaultPrevented && event.type === raw && event.timeStamp === stamp);
+ let traps = 0;
+ const proxy = new Proxy(event, {get() { traps++; throw sentinel; }, getPrototypeOf() { traps++; throw sentinel; }});
+ const revoked = Proxy.revocable(event, {});
+ revoked.revoke();
+ for (const receiver of [null, undefined, {}, Object.getPrototypeOf(event), Object.create(event), proxy, revoked.proxy]) {
+ conversions = 0;
+ check(entry.name + ' invalid receiver', throws(() => initialize(receiver, {toString() {
+ conversions++; return raw;
+ }})) && conversions === 0);
+ }
+ check(entry.name + ' author Proxy traps skipped', traps === 0);
+ const dispatched = entry.make(window);
+ const beforeStamp = dispatched.timeStamp;
+ const beforeComposed = dispatched.composed;
+ const dispatchTarget = new EventTarget();
+ let dispatchConversions = 0;
+ let dispatchChecks = false;
+ dispatchTarget.addEventListener('before', current => {
+ current.preventDefault();
+ const type = {toString() { dispatchConversions++; return raw; }};
+ initialize(current, type);
+ const failure = throwsExactly(() => initialize(current, {toString() { throw sentinel; }}), sentinel);
+ const missing = throws(() => method.call(current));
+ const symbol = throws(() => initialize(current, Symbol()));
+ dispatchChecks = failure && missing && symbol && current.type === 'before' &&
+ !current.bubbles && current.cancelable && current.defaultPrevented &&
+ current.target === dispatchTarget && current.currentTarget === dispatchTarget &&
+ current.eventPhase === Event.AT_TARGET && current.composed === beforeComposed &&
+ current.timeStamp === beforeStamp;
+ });
+ check(entry.name + ' dispatch remains canceled', dispatchTarget.dispatchEvent(dispatched) === false);
+ check(entry.name + ' converts during dispatch', dispatchConversions === 1);
+ check(entry.name + ' dispatch guard follows conversion', dispatchChecks);
+ initialize(dispatched, raw);
+ check(entry.name + ' reusable after dispatch', dispatched.type === raw && !dispatched.defaultPrevented &&
+ dispatched.target === null && dispatched.timeStamp === beforeStamp && dispatched.composed === beforeComposed);
+ }
+ const payloadCases = [
+ ['CustomEvent', () => new CustomEvent('before', {...flags, detail}), e => e.detail],
+ ['UIEvent', () => new UIEvent('before', {...flags, detail: 9, view: window}), e => e.detail],
+ ['MouseEvent', () => new MouseEvent('before', {...flags, clientX: 9}), e => e.clientX],
+ ['KeyboardEvent', () => new KeyboardEvent('before', {...flags, key: 'key'}), e => e.key],
+ ['CompositionEvent', () => new CompositionEvent('before', {...flags, data: 'data'}), e => e.data],
+ ['StorageEvent', () => new StorageEvent('before', {...flags, key: 'key'}), e => e.key],
+ ['AnimationEvent', () => new AnimationEvent('before', {...flags, animationName: 'animation'}), e => e.animationName],
+ ['TransitionEvent', () => new TransitionEvent('before', {...flags, propertyName: 'color'}), e => e.propertyName]
+ ];
+ for (const [name, make, payload] of payloadCases) {
+ const event = make();
+ const value = payload(event);
+ const stamp = event.timeStamp;
+ Event.prototype.initEvent.call(event, raw);
+ check(name + ' base initializer DOMString', event.type === raw);
+ check(name + ' base initializer retains payload', payload(event) === value);
+ check(name + ' base initializer retains composed', event.composed);
+ check(name + ' base initializer retains timestamp', event.timeStamp === stamp);
+ }
+ const custom = new CustomEvent('before', {...flags, detail});
+ const customStamp = custom.timeStamp;
+ custom.initCustomEvent(raw);
+ check('CustomEvent default detail', custom.detail === null && custom.composed && custom.timeStamp === customStamp);
+ custom.initCustomEvent(raw, false, false, undefined);
+ check('CustomEvent explicit undefined detail', custom.detail === null);
+ custom.initCustomEvent(raw, false, false, detail);
+ check('CustomEvent detail identity', custom.detail === detail);
+ for (const value of [undefined, null, 7, 1n]) {
+ const event = new Event('before');
+ event.initEvent(value);
+ check('Event DOMString ' + String(value), event.type === String(value));
+ }
+ const child = document.querySelector('#child').contentWindow;
+ for (const entry of cases) {
+ const event = entry.make(child);
+ const method = event[entry.method];
+ const stamp = event.timeStamp;
+ const composed = event.composed;
+ const local = entry.make(window);
+ local[entry.method].call(event, raw, true, false, ...entry.tail(window));
+ check(entry.name + ' cross realm receiver', event.type === raw && event.timeStamp === stamp &&
+ event.composed === composed && event instanceof child.Event);
+ let conversions = 0;
+ check(entry.name + ' callee realm receiver error', throws(() => method.call({}, {toString() {
+ conversions++; return raw;
+ }}), child.TypeError) && conversions === 0);
+ check(entry.name + ' callee realm conversion error', throws(() => method.call(event, Symbol()), child.TypeError));
+ }
+ const frozen = Object.freeze(new CustomEvent('before', {...flags, detail}));
+ const frozenStamp = frozen.timeStamp;
+ frozen.initCustomEvent(raw, true, false, 17);
+ check('frozen wrapper reinitialization', frozen.type === raw && frozen.detail === 17 &&
+ frozen.composed && frozen.timeStamp === frozenStamp);
+ globalThis.__legacyEventInitResults = {rows, passed: rows.filter(row => row.passed).length, total: rows.length};
+ return rows.every(row => row.passed) || JSON.stringify(rows.filter(row => !row.passed));
+})()
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/legacy_event_init.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/legacy_event_init.rs
new file mode 100644
index 000000000..a32894d9d
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/legacy_event_init.rs
@@ -0,0 +1,13 @@
+use super::*;
+
+#[test]
+fn legacy_event_initializers_preserve_creation_state_and_convert_before_dispatch_guard() {
+ let mut vm = new_parsed_test_vm(
+ "https://legacy-event-init.test/",
+ "<!doctype html><iframe id=child></iframe>",
+ );
+ let result = vm.eval(include_str!("legacy_event_init.js")).expect(
+ "legacy event initializers should preserve native Event state and WebIDL conversion",
+ );
+ assert_eq!(result, "true");
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
index 62ac1ff68..54094e49d 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
@@ -27,6 +27,7 @@ mod ice_candidate;
mod idle_callbacks;
mod idle_detection;
mod images;
+mod legacy_event_init;
mod media;
mod media_devices;
mod media_query_list_events;