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): validate traversal receivers with native brands
ldm06bbc66799468
diff --git a/moli-renderer-v8/src/native_bridge/traversal/identity.rs b/moli-renderer-v8/src/native_bridge/traversal/identity.rsindex dca19e296..bb86a134e 100644--- a/moli-renderer-v8/src/native_bridge/traversal/identity.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/identity.rs@@ -7,9 +7,9 @@ pub(super) struct TraversalSnapshot<S> {pub(super) state: S,}-pub(super) fn node_iterator_snapshot_from_object(- scope: &mut v8::PinScope<'_, '_>,- object: v8::Local<'_, v8::Object>,+pub(super) fn node_iterator_snapshot_from_object<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,) -> Option<TraversalSnapshot<NodeIteratorSnapshot>> {let (runtime_ptr, id) = traversal_identity(scope, object)?;let state = unsafe { &mut *runtime_ptr }@@ -22,9 +22,9 @@ pub(super) fn node_iterator_snapshot_from_object(})}-pub(super) fn tree_walker_snapshot_from_object(- scope: &mut v8::PinScope<'_, '_>,- object: v8::Local<'_, v8::Object>,+pub(super) fn tree_walker_snapshot_from_object<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,) -> Option<TraversalSnapshot<TreeWalkerSnapshot>> {let (runtime_ptr, id) = traversal_identity(scope, object)?;let state = unsafe { &mut *runtime_ptr }@@ -37,10 +37,11 @@ pub(super) fn tree_walker_snapshot_from_object(})}-pub(super) fn traversal_identity(- scope: &mut v8::PinScope<'_, '_>,- object: v8::Local<'_, v8::Object>,+pub(super) fn traversal_identity<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,) -> Option<(*mut JsContextHost, u32)> {+ let object = moli_webapi_declare::web_api_object_target(scope, object)?;let runtime_ptr = runtime_ptr_from_object(scope, object).ok()?;let value = object.get_internal_field(scope, 1)?;let value = v8::Local::<v8::Value>::try_from(value).ok()?;diff --git a/moli-renderer-v8/src/native_bridge/traversal/node_iterator.rs b/moli-renderer-v8/src/native_bridge/traversal/node_iterator.rsindex 12ed12d50..36b43740c 100644--- a/moli-renderer-v8/src/native_bridge/traversal/node_iterator.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/node_iterator.rs@@ -5,9 +5,9 @@ use super::{};use crate::native_bridge::bridge::throw_dom_exception;-pub(super) fn node_iterator_root_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_root_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -24,9 +24,9 @@ pub(super) fn node_iterator_root_getter();}-pub(super) fn node_iterator_what_to_show_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_what_to_show_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -37,9 +37,9 @@ pub(super) fn node_iterator_what_to_show_getter(rv.set(v8::Number::new(scope, snapshot.state.what_to_show as f64).into());}-pub(super) fn node_iterator_filter_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_filter_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -54,9 +54,9 @@ pub(super) fn node_iterator_filter_getter(rv.set(filter.value(scope));}-pub(super) fn node_iterator_reference_node_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_reference_node_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -73,9 +73,9 @@ pub(super) fn node_iterator_reference_node_getter();}-pub(super) fn node_iterator_pointer_before_reference_node_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_pointer_before_reference_node_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -86,9 +86,9 @@ pub(super) fn node_iterator_pointer_before_reference_node_getter(rv.set_bool(snapshot.state.pointer_before_reference_node);}-pub(super) fn node_iterator_next_node_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_next_node_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -128,9 +128,9 @@ pub(super) fn node_iterator_next_node_callback();}-pub(super) fn node_iterator_previous_node_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn node_iterator_previous_node_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();diff --git a/moli-renderer-v8/src/native_bridge/traversal/tree_walker.rs b/moli-renderer-v8/src/native_bridge/traversal/tree_walker.rsindex 5f0213824..453311ba2 100644--- a/moli-renderer-v8/src/native_bridge/traversal/tree_walker.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/tree_walker.rs@@ -39,9 +39,9 @@ fn tree_walker_end(snapshot: &TraversalSnapshot<TreeWalkerSnapshot>) {.tree_walker_end(snapshot.id);}-pub(super) fn tree_walker_root_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_root_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -58,9 +58,9 @@ pub(super) fn tree_walker_root_getter();}-pub(super) fn tree_walker_what_to_show_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_what_to_show_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -71,9 +71,9 @@ pub(super) fn tree_walker_what_to_show_getter(rv.set(v8::Number::new(scope, snapshot.state.what_to_show as f64).into());}-pub(super) fn tree_walker_filter_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_filter_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -88,9 +88,9 @@ pub(super) fn tree_walker_filter_getter(rv.set(filter.value(scope));}-pub(super) fn tree_walker_current_node_getter(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_current_node_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -131,9 +131,9 @@ pub(super) fn tree_walker_current_node_setter<'s>(.set_tree_walker_current_node(traversal_id, handle);}-pub(super) fn tree_walker_parent_node_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_parent_node_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -163,9 +163,9 @@ pub(super) fn tree_walker_parent_node_callback();}-pub(super) fn tree_walker_first_child_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_first_child_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -201,9 +201,9 @@ pub(super) fn tree_walker_first_child_callback();}-pub(super) fn tree_walker_last_child_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_last_child_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -239,9 +239,9 @@ pub(super) fn tree_walker_last_child_callback();}-pub(super) fn tree_walker_next_sibling_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_next_sibling_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -271,9 +271,9 @@ pub(super) fn tree_walker_next_sibling_callback();}-pub(super) fn tree_walker_previous_sibling_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_previous_sibling_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -304,9 +304,9 @@ pub(super) fn tree_walker_previous_sibling_callback();}-pub(super) fn tree_walker_next_node_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_next_node_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();@@ -336,9 +336,9 @@ pub(super) fn tree_walker_next_node_callback();}-pub(super) fn tree_walker_previous_node_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,+pub(super) fn tree_walker_previous_node_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {let holder = args.this();diff --git a/moli-renderer-v8/src/native_bridge/traversal/wrappers.rs b/moli-renderer-v8/src/native_bridge/traversal/wrappers.rsindex 9b9b34223..90d5a231e 100644--- a/moli-renderer-v8/src/native_bridge/traversal/wrappers.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/wrappers.rs@@ -23,7 +23,7 @@ use crate::native_bridge::bindings::set_named_constructor_prototype;use crate::webidl::WebIdlCallbackInterface;#[derive(WebApiFunctionTemplate)]-#[webapi(interface = web_api_interfaces::NodeIterator, enumerable)]+#[webapi(interface = web_api_interfaces::NodeIterator, enumerable, receiver)]struct NodeIteratorPrototypeDeclaration {#[webapi(accessor_property, getter = node_iterator_root_getter)]root: (),@@ -44,7 +44,7 @@ struct NodeIteratorPrototypeDeclaration {}#[derive(WebApiFunctionTemplate)]-#[webapi(interface = web_api_interfaces::TreeWalker, enumerable)]+#[webapi(interface = web_api_interfaces::TreeWalker, enumerable, receiver)]struct TreeWalkerPrototypeDeclaration {#[webapi(accessor_property, getter = tree_walker_root_getter)]root: (),@@ -130,6 +130,9 @@ pub(in crate::native_bridge) fn build_node_iterator_wrapper<'s>(wrapper.set_internal_field(1, v8::Number::new(scope, id as f64).into()),"NodeIterator wrapper must expose its state id field");+ web_api_interfaces::NodeIterator::DESCRIPTOR+ .initialize(scope, wrapper)+ .expect("NodeIterator wrapper must have native identity");set_named_constructor_prototype(scope, wrapper, "NodeIterator");wrapper}@@ -157,6 +160,9 @@ pub(in crate::native_bridge) fn build_tree_walker_wrapper<'s>(wrapper.set_internal_field(1, v8::Number::new(scope, id as f64).into()),"TreeWalker wrapper must expose its state id field");+ web_api_interfaces::TreeWalker::DESCRIPTOR+ .initialize(scope, wrapper)+ .expect("TreeWalker wrapper must have native identity");set_named_constructor_prototype(scope, wrapper, "TreeWalker");wrapper}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 d2fea50bb..e76f62d70 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@@ -62,6 +62,7 @@ mod structured_clone;mod transferable_streams;mod traversal;mod traversal_coordinator;+mod traversal_receivers;mod trusted_types;mod value_events;mod web_audio;diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/traversal_receivers.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/traversal_receivers.rsnew file mode 100644index 000000000..87a42c116--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/traversal_receivers.rs@@ -0,0 +1,135 @@+use super::*;++#[test]+fn traversal_receivers_preserve_native_state_across_realms_and_document_types() {+ let mut vm = new_parsed_test_vm(+ "https://traversal-receivers.test/",+ "<!doctype html><iframe id=child></iframe>",+ );+ let result = vm+ .eval(include_str!(+ "../../../../tests/fixtures/traversal-receivers.js"+ ))+ .expect("traversal receiver matrix should complete");+ assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "1102");+ assert_eq!(+ result,+ "true",+ "{}",+ vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))")+ .unwrap(),+ );+}++#[test]+fn traversal_receivers_accept_registered_native_proxies_without_author_traps() {+ let mut vm = new_parsed_test_vm(+ "https://traversal-native-proxies.test/",+ "<!doctype html><iframe id=child></iframe>",+ );+ vm.eval(+ r#"+ globalThis.nativeTraversalRecords = [];+ globalThis.nativeTraversalTraps = 0;+ const other = document.querySelector('#child').contentWindow;+ for (const owner of [globalThis, other]) {+ for (const kind of ['NodeIterator', 'TreeWalker']) {+ const root = owner.document.createElement('root');+ const a = root.appendChild(owner.document.createElement('a'));+ const b = root.appendChild(owner.document.createElement('b'));+ const target = owner.document['create' + kind](root, 1);+ const {proxy, revoke} = Proxy.revocable(target, {+ get() {nativeTraversalTraps++; throw new Error('get trap');},+ getPrototypeOf() {nativeTraversalTraps++; throw new Error('prototype trap');}+ });+ nativeTraversalRecords.push({kind, root, a, b, target, proxy, revoke,+ callee: owner === globalThis ? other : globalThis});+ }+ }+ 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, "nativeTraversalRecords").unwrap();+ let value = global.get(scope, key.into()).unwrap();+ let records = v8::Local::<v8::Array>::try_from(value).unwrap();+ assert_eq!(records.length(), 4);+ for index in 0..records.length() {+ let value = records.get_index(scope, index).unwrap();+ let record = v8::Local::<v8::Object>::try_from(value).unwrap();+ let key = v8::String::new(scope, "proxy").unwrap();+ let value = record.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_eq!(+ crate::web_api_interfaces::NodeIterator::is_instance(scope, proxy.into()),+ index % 2 == 0,+ );+ assert_eq!(+ crate::web_api_interfaces::TreeWalker::is_instance(scope, proxy.into()),+ index % 2 == 1,+ );+ }+ Ok(())+ })+ .unwrap();+ assert_eq!(+ vm.eval(+ r#"(() => {+ for (const record of nativeTraversalRecords) {+ const {kind, root, a, b, proxy, revoke, callee} = record;+ const prototype = callee[kind].prototype;+ const get = name => Object.getOwnPropertyDescriptor(prototype, name).get.call(proxy);+ const invoke = name => prototype[name].call(proxy);+ const fails = body => {+ try { body(); return false; }+ catch (error) { return Object.getPrototypeOf(error) === callee.TypeError.prototype; }+ };+ if (get('root') !== root || get('whatToShow') !== 1 || get('filter') !== null) return false;+ let members;+ if (kind === 'NodeIterator') {+ if (get('referenceNode') !== root || !get('pointerBeforeReferenceNode')) return false;+ if (invoke('nextNode') !== root || invoke('previousNode') !== root) return false;+ if (invoke('nextNode') !== root || invoke('nextNode') !== a) return false;+ if (invoke('detach') !== undefined || invoke('nextNode') !== b) return false;+ members = ['root', 'whatToShow', 'filter', 'referenceNode', 'pointerBeforeReferenceNode'];+ } else {+ const set = Object.getOwnPropertyDescriptor(prototype, 'currentNode').set;+ if (get('currentNode') !== root || invoke('firstChild') !== a) return false;+ if (invoke('nextSibling') !== b || invoke('previousSibling') !== a) return false;+ if (invoke('parentNode') !== root || invoke('lastChild') !== b) return false;+ if (invoke('previousNode') !== a || invoke('nextNode') !== b) return false;+ if (set.call(proxy, a) !== undefined || get('currentNode') !== a) return false;+ if (!fails(() => set.call(new Proxy(proxy, {}), root))) return false;+ members = ['root', 'whatToShow', 'filter', 'currentNode'];+ }+ for (const name of members) {+ const getter = Object.getOwnPropertyDescriptor(prototype, name).get;+ if (!fails(() => getter.call(new Proxy(proxy, {})))) return false;+ }+ for (const name of Object.getOwnPropertyNames(prototype)) {+ if (name === 'constructor' || members.includes(name)) continue;+ if (!fails(() => prototype[name].call(new Proxy(proxy, {})))) return false;+ }+ const opposite = callee[kind === 'NodeIterator' ? 'TreeWalker' : 'NodeIterator'].prototype;+ for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(opposite))) {+ if (name === 'constructor') continue;+ for (const receiver of [record.target, proxy]) {+ if (descriptor.get && !fails(() => descriptor.get.call(receiver))) return false;+ if (descriptor.set && !fails(() => descriptor.set.call(receiver, root))) return false;+ if (typeof descriptor.value === 'function' && !fails(() => descriptor.value.call(receiver))) return false;+ }+ }+ const rootGetter = Object.getOwnPropertyDescriptor(prototype, 'root').get;+ revoke();+ if (!fails(() => rootGetter.call(proxy))) return false;+ }+ return nativeTraversalTraps === 0;+ })()"#,+ )+ .unwrap(),+ "true",+ );+}diff --git a/moli-renderer-v8/tests/fixtures/traversal-receivers.js b/moli-renderer-v8/tests/fixtures/traversal-receivers.jsnew file mode 100644index 000000000..5a22078bf--- /dev/null+++ b/moli-renderer-v8/tests/fixtures/traversal-receivers.js@@ -0,0 +1,143 @@+(() => {+ const rows = [];+ const check = (name, body) => {+ try { rows.push({name, passed: body() === true}); }+ catch (error) { rows.push({name, passed: false, error: String(error)}); }+ };+ const typeError = (body, realm) => {+ try { body(); return false; }+ catch (error) { return Object.getPrototypeOf(error) === realm.TypeError.prototype; }+ };+ const realms = [['top', globalThis], ['child', document.querySelector('#child').contentWindow]];+ const attributes = {+ NodeIterator: ['root', 'whatToShow', 'filter', 'referenceNode', 'pointerBeforeReferenceNode'],+ TreeWalker: ['root', 'whatToShow', 'filter', 'currentNode']+ };+ const operations = {+ NodeIterator: ['nextNode', 'previousNode', 'detach'],+ TreeWalker: ['parentNode', 'firstChild', 'lastChild', 'previousSibling', 'nextSibling', 'previousNode', 'nextNode']+ };+ const setup = (owner, kind, flavor = 'live', filter = null) => {+ const doc = flavor === 'live' ? owner.document :+ flavor === 'html' ? owner.document.implementation.createHTMLDocument('traversal') :+ flavor === 'xml' ? owner.document.implementation.createDocument(null, 'root') :+ new owner.DOMParser().parseFromString('<root/>', 'application/xml');+ const root = flavor === 'xml' || flavor === 'parsed' ? doc.documentElement : doc.createElement('root');+ const a = root.appendChild(doc.createElement('a'));+ const leaf = a.appendChild(doc.createElement('leaf'));+ const b = root.appendChild(doc.createElement('b'));+ const traversal = doc['create' + kind](root, 1, filter);+ return {doc, root, a, leaf, b, traversal};+ };+ for (const [calleeName, callee] of realms) {+ for (const kind of ['NodeIterator', 'TreeWalker']) {+ const C = callee[kind], prototype = C.prototype;+ const prefix = `${calleeName} ${kind}`;+ const getters = Object.fromEntries(attributes[kind].map(name =>+ [name, Object.getOwnPropertyDescriptor(prototype, name).get]));+ const methods = Object.fromEntries(operations[kind].map(name => [name, prototype[name]]));+ const setter = kind === 'TreeWalker' ? Object.getOwnPropertyDescriptor(prototype, 'currentNode').set : null;+ for (const name of attributes[kind]) {+ check(`${prefix} ${name} prototype descriptor`, () => {+ const d = Object.getOwnPropertyDescriptor(prototype, name);+ return d.enumerable && d.configurable && d.get.name === 'get ' + name && d.get.length === 0 &&+ Object.getPrototypeOf(d.get) === callee.Function.prototype &&+ (name === 'currentNode' ? d.set.name === 'set currentNode' && d.set.length === 1 : d.set === undefined);+ });+ }+ for (const name of operations[kind]) {+ check(`${prefix} ${name} prototype descriptor`, () => {+ const d = Object.getOwnPropertyDescriptor(prototype, name);+ return d.enumerable && d.configurable && d.writable && d.value.name === name &&+ d.value.length === 0 && Object.getPrototypeOf(d.value) === callee.Function.prototype;+ });+ }+ for (const [ownerName, owner] of realms) {+ for (const flavor of ['live', 'html', 'xml', 'parsed']) {+ const label = `${prefix} borrows ${ownerName} ${flavor}`;+ const filter = {acceptNode() { return 1; }};+ const {root, a, leaf, b, traversal} = setup(owner, kind, flavor, filter);+ check(`${label} factory realm and interface identity`, () =>+ Object.getPrototypeOf(traversal) === owner[kind].prototype && traversal instanceof owner[kind]);+ check(`${label} root mask and filter preserve identity`, () =>+ getters.root.call(traversal) === root && getters.whatToShow.call(traversal) === 1 &&+ getters.filter.call(traversal) === filter &&+ Object.getPrototypeOf(root) === (flavor === 'live' || flavor === 'html' ? owner.HTMLUnknownElement.prototype : owner.Element.prototype));+ check(`${label} traversal state and detach remain functional`, () => {+ if (kind === 'NodeIterator') {+ if (getters.referenceNode.call(traversal) !== root || !getters.pointerBeforeReferenceNode.call(traversal)) return false;+ if (methods.nextNode.call(traversal) !== root || getters.pointerBeforeReferenceNode.call(traversal)) return false;+ if (methods.nextNode.call(traversal) !== a || methods.previousNode.call(traversal) !== a) return false;+ return methods.detach.call(traversal) === undefined && methods.nextNode.call(traversal) === a;+ }+ if (getters.currentNode.call(traversal) !== root || methods.firstChild.call(traversal) !== a) return false;+ if (methods.firstChild.call(traversal) !== leaf || methods.parentNode.call(traversal) !== a) return false;+ if (methods.nextSibling.call(traversal) !== b || methods.previousSibling.call(traversal) !== a) return false;+ if (setter.call(traversal, root) !== undefined || methods.lastChild.call(traversal) !== b) return false;+ if (methods.previousNode.call(traversal) !== leaf || methods.nextNode.call(traversal) !== b) return false;+ return getters.currentNode.call(traversal) === b;+ });+ check(`${label} frozen receiver keeps private native state`, () => {+ const sample = setup(owner, kind, flavor);+ Object.freeze(sample.traversal);+ return methods.nextNode.call(sample.traversal) === (kind === 'NodeIterator' ? sample.root : sample.a) &&+ getters.root.call(sample.traversal) === sample.root && Reflect.ownKeys(sample.traversal).length === 0;+ });+ check(`${label} prototype removal preserves native identity`, () => {+ const sample = setup(owner, kind, flavor);+ Object.setPrototypeOf(sample.traversal, null);+ return getters.root.call(sample.traversal) === sample.root &&+ methods.nextNode.call(sample.traversal) === (kind === 'NodeIterator' ? sample.root : sample.a);+ });+ }+ const valid = setup(owner, kind);+ const opposite = kind === 'NodeIterator' ? 'TreeWalker' : 'NodeIterator';+ const other = setup(owner, opposite);+ let traps = 0;+ const handler = {get() {traps++; throw 1;}, getPrototypeOf() {traps++; throw 1;}, has() {traps++; throw 1;}};+ const author = new Proxy(valid.traversal, handler);+ const revoked = Proxy.revocable(valid.traversal, handler); revoked.revoke();+ const invalid = [['null', null], ['undefined', undefined], ['plain', {}], ['number', 1],+ ['prototype', owner[kind].prototype], ['forged', Object.create(owner[kind].prototype)],+ ['inherited instance', Object.create(valid.traversal)], ['author Proxy', author],+ ['revoked Proxy', revoked.proxy], ['opposite traversal', other.traversal], ['Node', valid.root]];+ for (const [receiverName, receiver] of invalid) {+ for (const name of attributes[kind]) {+ check(`${prefix} ${name} rejects ${ownerName} ${receiverName} in callee realm`, () =>+ typeError(() => getters[name].call(receiver), callee));+ }+ for (const name of operations[kind]) {+ check(`${prefix} ${name} rejects ${ownerName} ${receiverName} in callee realm`, () =>+ typeError(() => methods[name].call(receiver), callee));+ }+ if (setter) {+ check(`${prefix} currentNode setter rejects ${ownerName} ${receiverName} before argument access`, () =>+ typeError(() => setter.call(receiver, new Proxy(valid.root, handler)), callee));+ }+ }+ check(`${prefix} ${ownerName} invalid receivers execute no author traps`, () => traps === 0);+ check(`${prefix} ${ownerName} opposite traversal state remains unchanged`, () =>+ other.traversal.root === other.root && (opposite === 'TreeWalker' ?+ other.traversal.currentNode === other.root : other.traversal.referenceNode === other.root && other.traversal.pointerBeforeReferenceNode));+ if (setter) {+ check(`${prefix} currentNode setter rejects ${ownerName} author Node Proxy without traps`, () =>+ typeError(() => setter.call(valid.traversal, new Proxy(valid.a, handler)), callee) &&+ getters.currentNode.call(valid.traversal) === valid.root && traps === 0);+ }+ }+ check(`${prefix} factory ignores replaced author constructor`, () => {+ const saved = Object.getOwnPropertyDescriptor(callee, kind);+ try {+ Object.defineProperty(callee, kind, {...saved, value: function FakeTraversal() { throw 1; }});+ const sample = setup(callee, kind);+ return Object.getPrototypeOf(sample.traversal) === prototype &&+ getters.root.call(sample.traversal) === sample.root &&+ methods.nextNode.call(sample.traversal) === (kind === 'NodeIterator' ? sample.root : sample.a);+ } finally { Object.defineProperty(callee, kind, saved); }+ });+ }+ }+ globalThis.__uiEventResults = {complete: true, total: rows.length,+ passed: rows.filter(row => row.passed).length, rows};+ return rows.every(row => row.passed);+})()