Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(dom): inherit EventTarget operations from its prototype
ldm04bce04758537
diff --git a/moli-renderer-v8/src/context_bootstrap/constructors/core.rs b/moli-renderer-v8/src/context_bootstrap/constructors/core.rsindex 3131f0fdc..f1e06ff12 100644--- a/moli-renderer-v8/src/context_bootstrap/constructors/core.rs+++ b/moli-renderer-v8/src/context_bootstrap/constructors/core.rs@@ -1,4 +1,4 @@-use super::super::media_queries::install_simple_event_target_methods;+use super::super::media_queries::initialize_simple_event_target;use super::*;pub(in crate::context_bootstrap) fn event_target_constructor_callback<'s>(@@ -14,7 +14,7 @@ pub(in crate::context_bootstrap) fn event_target_constructor_callback<'s>(return;}let target = args.this();- install_simple_event_target_methods(scope, target);+ initialize_simple_event_target(scope, target);rv.set(target.into());}diff --git a/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs b/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rsindex 328dd95c4..19181224a 100644--- a/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs+++ b/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs@@ -162,6 +162,9 @@ pub(in crate::context_bootstrap::file_api::file_reader) fn initialize_file_readeFileReaderObjectDeclaration::default().initialize(scope, reader).expect("FileReader declaration should initialize");+ crate::context_bootstrap::media_queries::bind_simple_event_target_dispatch_identity(+ scope, reader, reader,+ );}pub(in crate::context_bootstrap::file_api::file_reader) fn file_reader_ready_state<'s>(diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries.rs b/moli-renderer-v8/src/context_bootstrap/media_queries.rsindex 73ac3159f..46822e9ae 100644--- a/moli-renderer-v8/src/context_bootstrap/media_queries.rs+++ b/moli-renderer-v8/src/context_bootstrap/media_queries.rs@@ -11,9 +11,10 @@ pub(super) use self::evaluation::{pub(in crate::context_bootstrap) use self::events::dispatch_media_query_list_event;pub(crate) use self::events::{SimpleObjectEventListenerInspectorSnapshot, SimpleObjectEventListenerSnapshot,- dispatch_simple_event_target_event, dispatch_simple_event_target_event_collecting_errors,- initialize_simple_event_target, install_simple_event_target_handlers,- install_simple_event_target_methods, invoke_simple_event_listener, is_simple_event_target,+ bind_simple_event_target_dispatch_identity, dispatch_simple_event_target_event,+ dispatch_simple_event_target_event_collecting_errors, initialize_simple_event_target,+ install_simple_event_target_handlers, install_simple_event_target_methods,+ invoke_simple_event_listener, is_simple_event_target,simple_event_target_add_event_listener_callback, simple_event_target_dispatch_event_callback,simple_event_target_handler_getter_callback, simple_event_target_handler_setter_callback,simple_event_target_inspector_listener_snapshots,diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events.rsindex d128e1130..b5e4bcda1 100644--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs@@ -13,9 +13,10 @@ pub(in crate::context_bootstrap) use media_query_list::{};pub(crate) use simple_event_target::{SimpleObjectEventListenerInspectorSnapshot, SimpleObjectEventListenerSnapshot,- dispatch_simple_event_target_event, dispatch_simple_event_target_event_collecting_errors,- initialize_simple_event_target, install_simple_event_target_handlers,- install_simple_event_target_methods, invoke_simple_event_listener, is_simple_event_target,+ bind_simple_event_target_dispatch_identity, dispatch_simple_event_target_event,+ dispatch_simple_event_target_event_collecting_errors, initialize_simple_event_target,+ install_simple_event_target_handlers, install_simple_event_target_methods,+ invoke_simple_event_listener, is_simple_event_target,simple_event_target_add_event_listener_callback, simple_event_target_dispatch_event_callback,simple_event_target_handler_getter_callback, simple_event_target_handler_setter_callback,simple_event_target_inspector_listener_snapshots,diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rsindex cd26f66db..a4743c728 100644--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs@@ -33,5 +33,8 @@ pub(crate) use listeners::{simple_object_event_target_remove_listener,simple_object_event_target_remove_listener_for_target,};-pub(crate) use state::{initialize_simple_event_target, is_simple_event_target};+pub(crate) use state::{+ bind_simple_event_target_dispatch_identity, initialize_simple_event_target,+ is_simple_event_target,+};use state::{simple_event_target_receiver, simple_object_event_listener_registry};diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rsindex bea948728..0ddaaf281 100644--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs@@ -2,6 +2,17 @@ use super::*;use crate::context_bootstrap::shared_event_targets::shared_target_owner;use crate::util::{get_private_object, new_null_prototype_object, set_private_value};+const DISPATCH_IDENTITY_SLOT: &str = "__moliSimpleEventTargetDispatchIdentity";++pub(crate) fn bind_simple_event_target_dispatch_identity<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+ identity: v8::Local<'s, v8::Object>,+) {+ let target = moli_webapi_declare::web_api_object_target(scope, target).unwrap_or(target);+ set_private_value(scope, target, DISPATCH_IDENTITY_SLOT, identity.into());+}+pub(crate) fn initialize_simple_event_target<'s>(scope: &mut v8::PinScope<'s, '_>,target: v8::Local<'s, v8::Object>,@@ -31,12 +42,15 @@ pub(super) fn simple_event_target_receiver<'s>() -> Option<v8::Local<'s, v8::Object>> {// Resolve registered native Proxies only for the simple-target branch.// DOM and Window targets keep their existing receiver resolution.- let target = if target.is_proxy() {+ let native_target = if target.is_proxy() {moli_webapi_declare::web_api_object_target(scope, target)?} else {target};- simple_object_event_listener_registry(scope, target).map(|_| target)+ simple_object_event_listener_registry(scope, native_target)?;+ // Native producers can retain a fixed public identity independently of+ // listener storage. Other native aliases dispatch on their own wrapper.+ Some(get_private_object(scope, native_target, DISPATCH_IDENTITY_SLOT).unwrap_or(target))}pub(super) fn simple_object_event_listener_registry<'s>(diff --git a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rsindex cc605b1ec..4b93b1169 100644--- a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs+++ b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs@@ -27,6 +27,9 @@ pub(super) fn shared_target_owner<'s>(scope: &mut v8::PinScope<'s, '_>,target: v8::Local<'s, v8::Object>,) -> v8::Local<'s, v8::Object> {+ // Native aliases share the backing registry while dispatch keeps the+ // original wrapper for callback this and Event.target.+ let target = moli_webapi_declare::web_api_object_target(scope, target).unwrap_or(target);get_private_object(scope, target, OWNER).unwrap_or(target)}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rsnew file mode 100644index 000000000..6720e8925--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs@@ -0,0 +1,77 @@+use super::*;++#[test]+fn event_target_prototype_methods_preserve_native_state_and_realm_semantics() {+ let mut vm = new_parsed_test_vm(+ "https://event-target-prototype.test/",+ "<!doctype html><iframe id=child></iframe>",+ );+ let result = vm+ .eval(include_str!(+ "../../../../tests/fixtures/event-target-prototype.js"+ ))+ .expect("EventTarget prototype matrix should complete");+ assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "158");+ assert_eq!(+ result,+ "true",+ "{}",+ vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))")+ .unwrap(),+ );+}++#[test]+fn event_target_prototype_methods_accept_registered_native_proxies() {+ let mut vm = new_storage_html_test_vm("https://event-target-native-proxy.test/");+ vm.eval(+ r#"+ globalThis.nativeTarget = new EventTarget();+ globalThis.nativeTargetTraps = 0;+ globalThis.nativeTargetProxy = new Proxy(nativeTarget, {+ get() {nativeTargetTraps++; throw new Error('get trap');},+ getPrototypeOf() {nativeTargetTraps++; throw new Error('prototype trap');}+ });+ true;+ "#,+ )+ .unwrap();+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _host_ptr| {+ let global = scope.get_current_context().global(scope);+ let key = v8::String::new(scope, "nativeTargetProxy").unwrap();+ let value = global.get(scope, key.into()).unwrap();+ let proxy = v8::Local::<v8::Proxy>::try_from(value).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ assert!(crate::web_api_interfaces::EventTarget::is_instance(+ scope,+ proxy.into()+ ));+ Ok(())+ })+ .unwrap();+ assert_eq!(+ vm.eval(+ r#"(() => {+ const {addEventListener: add, removeEventListener: remove, dispatchEvent: dispatch} = EventTarget.prototype;+ let calls = 0;+ function listener(event) {+ if (this === nativeTargetProxy && event.target === nativeTargetProxy && event.currentTarget === nativeTargetProxy) calls++;+ }+ add.call(nativeTargetProxy, 'x', listener);+ if (!dispatch.call(nativeTargetProxy, new Event('x')) || calls !== 1) return false;+ remove.call(nativeTargetProxy, 'x', listener);+ dispatch.call(nativeTargetProxy, new Event('x'));+ if (calls !== 1 || nativeTargetTraps !== 0) return false;+ const author = new Proxy(nativeTargetProxy, {});+ let conversions = 0;+ const type = {toString() {conversions++; return 'x';}};+ for (const call of [() => add.call(author, type, null), () => remove.call(author, type, null), () => dispatch.call(author, new Event('x'))]) {+ try { call(); return false; } catch (error) { if (!(error instanceof TypeError)) return false; }+ }+ return conversions === 0 && nativeTargetTraps === 0;+ })()"#,+ )+ .unwrap(),+ "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.rsindex ae5fdfaf6..679f7204c 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@@ -85,4 +85,5 @@ mod video_codec_support;mod event_prototype_attributes;+mod event_target_prototype;mod named_node_map_receivers;diff --git a/moli-renderer-v8/src/worker/thread/tests/event_target_prototype.rs b/moli-renderer-v8/src/worker/thread/tests/event_target_prototype.rsnew file mode 100644index 000000000..0c0ff090e--- /dev/null+++ b/moli-renderer-v8/src/worker/thread/tests/event_target_prototype.rs@@ -0,0 +1,16 @@+use super::*;++#[tokio::test]+async fn worker_event_target_prototype_methods_preserve_native_state() {+ ensure_v8();+ let probe = include_str!("../../../../tests/fixtures/event-target-prototype.js");+ let mut handle = spawn_worker(+ format!("{probe}\npostMessage(__uiEventResults); close();"),+ "https://event-target-prototype.test/worker.js".into(),+ );+ let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();+ let result: serde_json::Value = serde_json::from_str(&expect_post_json(message)).unwrap();+ assert_eq!(result["complete"], true, "{result}");+ assert_eq!(result["total"], 56, "{result}");+ assert_eq!(result["passed"], result["total"], "{result}");+}diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rsindex 8de684e76..23219eb47 100644--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs@@ -1,6 +1,7 @@mod abort_signal_events;mod callback_execution;mod error_reporting_guard;+mod event_target_prototype;mod text_codecs;use std::pin::pin;use std::sync::Arc;diff --git a/moli-renderer-v8/tests/fixtures/event-target-prototype.js b/moli-renderer-v8/tests/fixtures/event-target-prototype.jsnew file mode 100644index 000000000..e4cc364f1--- /dev/null+++ b/moli-renderer-v8/tests/fixtures/event-target-prototype.js@@ -0,0 +1,217 @@+(() => {+ const own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);+ const typeError = (body, realm) => {+ try { body(); return false; } catch (error) { return error instanceof realm.TypeError; }+ };+ globalThis.eventTargetPrototypeProbe = (realm = globalThis, peers = [['self', realm]]) => {+ const rows = [], observations = {};+ const check = (name, body) => {+ try { rows.push({name, passed: body() === true}); }+ catch (error) { rows.push({name, passed: false, error: String(error)}); }+ };+ const C = realm.EventTarget, prototype = C.prototype;+ const names = ['addEventListener', 'removeEventListener', 'dispatchEvent'];+ const descriptors = Object.fromEntries(names.map(name => [name, Object.getOwnPropertyDescriptor(prototype, name)]));+ const add = prototype.addEventListener, remove = prototype.removeEventListener, dispatch = prototype.dispatchEvent;+ const event = type => new realm.Event(type, {cancelable: true});+ const make = () => new C();+ for (const [name, length] of [['addEventListener', 2], ['removeEventListener', 2], ['dispatchEvent', 1]]) {+ check(`${name} prototype descriptor`, () => {+ const d = descriptors[name];+ return d.writable && d.enumerable && d.configurable && d.value.name === name &&+ d.value.length === length && Object.getPrototypeOf(d.value) === realm.Function.prototype;+ });+ check(`${name} is inherited with canonical identity`, () => {+ const a = make(), b = make();+ return !own(a, name) && !own(b, name) && a[name] === descriptors[name].value && a[name] === b[name];+ });+ check(`${name} follows author prototype replacement`, () => {+ const before = make(), replacement = () => 'author';+ try {+ Object.defineProperty(prototype, name, {...descriptors[name], value: replacement});+ const after = make();+ return before[name] === replacement && after[name] === replacement && !own(after, name);+ } finally { Object.defineProperty(prototype, name, descriptors[name]); }+ });+ check(`${name} deletion does not materialize own methods`, () => {+ try {+ delete prototype[name];+ const target = make();+ let calls = 0; const callback = () => {calls++;};+ add.call(target, 'x', callback); dispatch.call(target, event('x')); remove.call(target, 'x', callback);+ return !(name in target) && !own(target, name) && calls === 1;+ } finally { Object.defineProperty(prototype, name, descriptors[name]); }+ });+ }+ check('constructor requirements and ignored arguments', () => {+ let conversions = 0;+ const ignored = {toString() {conversions++; throw 1;}};+ return C.length === 0 && typeError(() => C(), realm) &&+ new C(ignored) instanceof C && conversions === 0;+ });+ check('native state is private and per-instance', () => {+ const a = make(), b = make(); let calls = 0;+ add.call(a, 'x', () => {calls++;});+ dispatch.call(b, event('x')); dispatch.call(a, event('x'));+ return Reflect.ownKeys(a).length === 0 && Reflect.ownKeys(b).length === 0 && calls === 1;+ });+ check('listener call has target identity and native event state', () => {+ const target = make(), e = event('x'); let observed = false;+ add.call(target, 'x', function(received) {+ observed = received === e && this === target && e.target === target &&+ e.currentTarget === target && e.eventPhase === 2 && e.composedPath().length === 1 &&+ e.composedPath()[0] === target && !e.isTrusted;+ });+ const result = dispatch.call(target, e);+ return observed && result && e.target === target && e.currentTarget === null &&+ e.eventPhase === 0 && e.composedPath().length === 0;+ });+ check('frozen target retains mutable native listener state', () => {+ const target = Object.freeze(make()); let calls = 0;+ const callback = () => {calls++;};+ add.call(target, 'x', callback); dispatch.call(target, event('x'));+ remove.call(target, 'x', callback); dispatch.call(target, event('x'));+ return calls === 1 && Reflect.ownKeys(target).length === 0;+ });+ check('prototype removal preserves native receiver and state', () => {+ const target = make(); Object.setPrototypeOf(target, null); let calls = 0;+ add.call(target, 'x', function(e) {if (e.target === target && this === target) calls++;});+ return dispatch.call(target, event('x')) && calls === 1;+ });+ check('subclass overrides are not shadowed by native own methods', () => {+ let registrations = 0, calls = 0;+ class Derived extends C {+ addEventListener(...args) {registrations++; return add.apply(this, args);}+ }+ const target = new Derived();+ target.addEventListener('x', () => {calls++;});+ return target instanceof Derived && !own(target, 'addEventListener') &&+ target.dispatchEvent(event('x')) && registrations === 1 && calls === 1;+ });+ check('custom newTarget prototype preserves branding and listener state', () => {+ function NewTarget() {}+ const custom = {marker: 1}; NewTarget.prototype = custom;+ const target = Reflect.construct(C, [], NewTarget); let calls = 0;+ add.call(target, 'x', function(e) {if (this === target && e.target === target) calls++;});+ dispatch.call(target, event('x'));+ return Object.getPrototypeOf(target) === custom && target.marker === 1 &&+ names.every(name => !own(target, name)) && calls === 1;+ });+ check('constructor does not consult prototype method getters', () => {+ let reads = 0;+ try {+ for (const name of names) Object.defineProperty(prototype, name, {configurable: true, get() {reads++; throw 1;}});+ const target = make(); let calls = 0;+ add.call(target, 'x', () => {calls++;}); dispatch.call(target, event('x'));+ return reads === 0 && calls === 1 && names.every(name => !own(target, name));+ } finally { for (const name of names) Object.defineProperty(prototype, name, descriptors[name]); }+ });+ check('once and duplicate identity are preserved', () => {+ const target = make(); let calls = 0; const callback = () => {calls++;};+ add.call(target, 'x', callback, {once: true}); add.call(target, 'x', callback, {once: false});+ dispatch.call(target, event('x')); dispatch.call(target, event('x'));+ return calls === 1;+ });+ check('capture order and matching removal are preserved', () => {+ const target = make(), trace = [], capture = () => trace.push('capture');+ add.call(target, 'x', () => trace.push('bubble')); add.call(target, 'x', capture, true);+ dispatch.call(target, event('x')); remove.call(target, 'x', capture, true);+ dispatch.call(target, event('x'));+ observations.captureOrder = trace.join(',');+ return observations.captureOrder === 'capture,bubble,bubble';+ });+ check('cancellation and passive listeners are preserved', () => {+ const a = make(), b = make(), ea = event('x'), eb = event('x');+ add.call(a, 'x', e => e.preventDefault());+ add.call(b, 'x', e => e.preventDefault(), {passive: true});+ return dispatch.call(a, ea) === false && ea.defaultPrevented &&+ dispatch.call(b, eb) === true && !eb.defaultPrevented;+ });+ check('AbortSignal removes listeners from native state', () => {+ const target = make(), controller = new realm.AbortController(); let calls = 0;+ add.call(target, 'x', () => {calls++;}, {signal: controller.signal});+ dispatch.call(target, event('x')); controller.abort(); dispatch.call(target, event('x'));+ return calls === 1;+ });+ check('callback interface lookup remains dynamic', () => {+ const target = make(), trace = [], listener = {handleEvent() {if (this === listener) trace.push('first');}};+ add.call(target, 'x', listener); dispatch.call(target, event('x'));+ listener.handleEvent = function() {if (this === listener) trace.push('second');};+ dispatch.call(target, event('x')); remove.call(target, 'x', listener); dispatch.call(target, event('x'));+ return trace.join(',') === 'first,second';+ });+ check('listener Proxy is callable without making a Proxy receiver valid', () => {+ const target = make(); let calls = 0;+ const callback = new Proxy(() => {}, {apply(_fn, receiver, args) {+ if (receiver === target && args[0].target === target) calls++;+ }});+ add.call(target, 'x', callback); dispatch.call(target, event('x'));+ return calls === 1;+ });+ check('stopImmediatePropagation stops later target listeners', () => {+ const target = make(), trace = [];+ add.call(target, 'x', e => {trace.push('first'); e.stopImmediatePropagation();});+ add.call(target, 'x', () => trace.push('second')); dispatch.call(target, event('x'));+ return trace.join(',') === 'first';+ });+ check('listener removal during dispatch preserves live registration state', () => {+ const target = make(), trace = [], later = () => trace.push('later');+ add.call(target, 'x', () => {trace.push('first'); remove.call(target, 'x', later);});+ add.call(target, 'x', later); dispatch.call(target, event('x'));+ return trace.join(',') === 'first';+ });+ for (const name of names) {+ check(`${name} enforces required argument count in callee realm`, () =>+ typeError(() => descriptors[name].value.call(make()), realm));+ }+ for (const [label, receiver] of [['null', null], ['undefined', undefined]]) {+ check(`${label} receiver maps to the callee global EventTarget`, () => {+ const type = 'event-target-global-' + label;+ let calls = 0;+ const callback = function(e) {if (this === realm && e.target === realm) calls++;};+ try {+ add.call(receiver, type, callback);+ const result = dispatch.call(receiver, new realm.Event(type));+ remove.call(receiver, type, callback);+ dispatch.call(receiver, new realm.Event(type));+ return result === true && calls === 1;+ } finally { remove.call(realm, type, callback); }+ });+ }+ for (const [ownerName, owner] of peers) {+ const target = new owner.EventTarget(); let traps = 0;+ const proxy = new Proxy(target, {get() {traps++;}, getPrototypeOf() {traps++;}, has() {traps++;}});+ const revoked = Proxy.revocable(target, {}); revoked.revoke();+ const invalid = [['plain', {}], ['prototype', owner.EventTarget.prototype],+ ['forged', Object.create(owner.EventTarget.prototype)], ['inherited instance', Object.create(target)],+ ['author Proxy', proxy], ['revoked Proxy', revoked.proxy], ['number', 1]];+ for (const [label, receiver] of invalid) {+ for (const name of names) {+ check(`${ownerName} ${name} rejects ${label} before conversion in callee realm`, () => {+ let conversions = 0;+ const type = {toString() {conversions++; return 'x';}};+ const args = name === 'dispatchEvent' ? [event('x')] : [type, null];+ return typeError(() => descriptors[name].value.call(receiver, ...args), realm) && conversions === 0;+ });+ }+ }+ check(`${ownerName} receiver brand check does not execute traps`, () => traps === 0);+ check(`${ownerName} borrowed methods preserve target identity and dispatch`, () => {+ const e = new owner.Event('borrowed', {cancelable: true}); let calls = 0;+ function listener(received) {if (this === target && received === e && e.target === target) calls++;}+ add.call(target, 'borrowed', listener); const result = dispatch.call(target, e);+ remove.call(target, 'borrowed', listener); dispatch.call(target, new owner.Event('borrowed'));+ return result && calls === 1;+ });+ }+ return {complete: true, total: rows.length, passed: rows.filter(row => row.passed).length, rows, observations};+ };+ const realms = typeof document === 'undefined' ? [['worker', globalThis]] :+ [['top', globalThis], ['child', document.querySelector('#child').contentWindow]];+ const probes = realms.map(([name, realm]) => [name, eventTargetPrototypeProbe(realm, realms)]);+ const rows = probes.flatMap(([name, probe]) => probe.rows.map(row => ({...row, name: `${name}: ${row.name}`})));+ const observations = Object.fromEntries(probes.map(([name, probe]) => [name, probe.observations]));+ globalThis.__uiEventResults = {complete: true, total: rows.length,+ passed: rows.filter(row => row.passed).length, rows, observations};+ return rows.every(row => row.passed);+})()