Skip to content

armgit / moli

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.js
new file mode 100644
index 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);
+})()