Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(media): expose native time range snapshots
ldm079e383340aa1
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rsindex 0d5e163d5..2fd695ee3 100644--- a/moli-renderer-v8/src/context_bootstrap.rs+++ b/moli-renderer-v8/src/context_bootstrap.rs@@ -27,6 +27,7 @@ mod form_data_runtime;mod geometry_runtime;mod history_mutation;mod history_runtime;+mod time_ranges;pub(crate) mod web_mcp;pub(crate) use history_runtime::state::bind_isolated_window_history_owner;mod idle_detection;@@ -449,6 +450,7 @@ pub(crate) use self::streams::{prepare_readable_stream_transfer, prepare_transform_stream_transfer,prepare_writable_stream_transfer,};+pub(crate) use self::time_ranges::new_time_ranges_value;#[cfg(test)]pub(crate) use self::trusted_types::trusted_types_lazy_state_materialized;pub(crate) use self::trusted_types::{diff --git a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rsindex af68cc657..13d15b5f7 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs@@ -50,6 +50,7 @@ use super::super::{streams::install_stream_template_bindings,style_font_template::install_style_font_template_bindings,svg_runtime::install_svg_template_bindings,+ time_ranges::install_time_ranges_template_bindings,touch_runtime::install_touch_template_bindings,view_transition_runtime::install_view_transition_template_bindings,web_audio_runtime::{@@ -409,6 +410,7 @@ pub(super) fn install_constructor_template_bindings<'s>(install_abort_template_bindings(scope, template, spec.interface.name());install_attr_template_bindings(scope, template, spec.interface.name());install_dom_rect_template_bindings(scope, template, spec.interface.name());+ install_time_ranges_template_bindings(scope, template, spec.interface.name());install_dom_exception_template_bindings(scope, template, spec.interface.name());install_dom_implementation_template_bindings(scope, template, spec.interface.name());install_custom_element_registry_template_bindings(scope, template, spec.interface.name());diff --git a/moli-renderer-v8/src/context_bootstrap/time_ranges.rs b/moli-renderer-v8/src/context_bootstrap/time_ranges.rsnew file mode 100644index 000000000..830110d9f--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/time_ranges.rs@@ -0,0 +1,140 @@+//! Immutable time-range snapshots, independent of a media decoder.++use crate::{util::get_private_value, web_api_interfaces, webidl};+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};++const RANGES_SLOT: &str = "__moliTimeRanges";++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::TimeRanges, require_prototype)]+struct TimeRangesObjectDeclaration<'scope> {+ #[webapi(slot = RANGES_SLOT)]+ ranges: v8::Local<'scope, v8::Array>,+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::TimeRanges, enumerable, receiver)]+struct TimeRangesPrototypeDeclaration {+ #[webapi(accessor_property, getter = length_getter)]+ length: (),+ #[webapi(method, length = 1, callback = start_callback)]+ start: (),+ #[webapi(method, length = 1, callback = end_callback)]+ end: (),+}++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "TimeRanges.start")]+struct StartArgs {+ #[webidl(required)]+ index: u32,+}++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "TimeRanges.end")]+struct EndArgs {+ #[webidl(required)]+ index: u32,+}++/// Copies native, normalized intervals into a new snapshot in the current realm.+/// Adjacent/overlapping intervals must be merged by the producing media backend.+pub(crate) fn new_time_ranges_value<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ ranges: &[(f64, f64)],+) -> v8::Local<'s, v8::Object> {+ debug_assert!(ranges.iter().all(|(start, end)| start <= end));+ debug_assert!(ranges.windows(2).all(|pair| pair[0].1 < pair[1].0));+ let values: Vec<v8::Local<'s, v8::Value>> = ranges+ .iter()+ .flat_map(|&(start, end)| {+ [+ v8::Number::new(scope, start).into(),+ v8::Number::new(scope, end).into(),+ ]+ })+ .collect();+ let values = v8::Array::new_with_elements(scope, &values);+ TimeRangesObjectDeclaration::new(values)+ .bind(scope)+ .expect("TimeRanges snapshot binds")+}++pub(in crate::context_bootstrap) fn install_time_ranges_template_bindings<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ template: v8::Local<'s, v8::FunctionTemplate>,+ interface_name: &str,+) {+ if interface_name == "TimeRanges" {+ TimeRangesPrototypeDeclaration::initialize_prototype_template(+ scope,+ template.prototype_template(scope),+ );+ }+}++fn native_ranges<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+) -> v8::Local<'s, v8::Array> {+ let target = moli_webapi_declare::web_api_object_target(scope, receiver)+ .expect("validated TimeRanges receiver");+ v8::Local::<v8::Array>::try_from(+ get_private_value(scope, target, RANGES_SLOT).expect("TimeRanges snapshot slot"),+ )+ .expect("TimeRanges native interval array")+}++fn length_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set_uint32(native_ranges(scope, args.this()).length() / 2);+}++fn start_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(parsed) = webidl::parse_args::<StartArgs>(scope, &args) else {+ return;+ };+ endpoint(scope, args.this(), parsed.index, 0, rv);+}++fn end_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(parsed) = webidl::parse_args::<EndArgs>(scope, &args) else {+ return;+ };+ endpoint(scope, args.this(), parsed.index, 1, rv);+}++fn endpoint<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+ index: u32,+ offset: u32,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let ranges = native_ranges(scope, receiver);+ if index >= ranges.length() / 2 {+ super::constructors::throw_dom_exception_value(+ scope,+ "The index is outside the time ranges.",+ "IndexSizeError",+ );+ return;+ }+ // Check the native size before multiplying, including for wrapped uint32 indices.+ rv.set(+ ranges+ .get_index(scope, index * 2 + offset)+ .expect("native endpoint"),+ );+}diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rsindex 29effdfae..c1957e8b3 100644--- a/moli-renderer-v8/src/native_bridge/element.rs+++ b/moli-renderer-v8/src/native_bridge/element.rs@@ -547,8 +547,8 @@ pub(crate) use media::{};pub(super) use media::{apply_default_text_track_modes_for_media, media_add_text_track_callback,- media_autoplay_getter_function, media_autoplay_setter_function, media_can_play_type_callback,- media_controls_getter_function, media_controls_setter_function,+ media_autoplay_getter_function, media_autoplay_setter_function, media_buffered_getter_function,+ media_can_play_type_callback, media_controls_getter_function, media_controls_setter_function,media_cross_origin_getter_function, media_cross_origin_setter_function,media_current_time_getter_function, media_current_time_setter_function,media_default_muted_getter_function, media_default_muted_setter_function,@@ -558,9 +558,10 @@ pub(super) use media::{media_loop_setter_function, media_muted_getter_function, media_muted_setter_function,media_network_state_getter_function, media_pause_callback, media_paused_getter_function,media_play_callback, media_playback_rate_getter_function, media_playback_rate_setter_function,- media_plays_inline_getter_function, media_plays_inline_setter_function,- media_poster_getter_function, media_poster_setter_function, media_preload_getter_function,- media_preload_setter_function, media_ready_state_getter_function,+ media_played_getter_function, media_plays_inline_getter_function,+ media_plays_inline_setter_function, media_poster_getter_function, media_poster_setter_function,+ media_preload_getter_function, media_preload_setter_function,+ media_ready_state_getter_function, media_seekable_getter_function,media_seeking_getter_function, media_src_getter_function, media_src_setter_function,media_text_tracks_getter_function, media_video_height_getter_function,media_video_width_getter_function, media_volume_getter_function, media_volume_setter_function,diff --git a/moli-renderer-v8/src/native_bridge/element/media.rs b/moli-renderer-v8/src/native_bridge/element/media.rsindex b1b6aa1eb..7938443b2 100644--- a/moli-renderer-v8/src/native_bridge/element/media.rs+++ b/moli-renderer-v8/src/native_bridge/element/media.rs@@ -2,6 +2,7 @@ mod attributes;mod methods;mod state;mod text_tracks;+mod time_ranges;mod video;pub(crate) use attributes::{@@ -44,6 +45,9 @@ pub(in crate::native_bridge) use text_tracks::{refresh_media_active_text_track_cues, track_ready_state_for_handle,track_text_track_getter_function,};+pub(in crate::native_bridge) use time_ranges::{+ media_buffered_getter_function, media_played_getter_function, media_seekable_getter_function,+};pub(in crate::native_bridge) use video::{media_height_getter_function, media_height_setter_function, media_poster_getter_function,media_poster_setter_function, media_video_height_getter_function,diff --git a/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs b/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rsnew file mode 100644index 000000000..a375cb868--- /dev/null+++ b/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs@@ -0,0 +1,40 @@+use super::super::html_media_element_getter_receiver;++pub(in crate::native_bridge) fn media_buffered_getter_function<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'_, v8::Value>,+) {+ media_ranges_getter(scope, args.this(), "buffered", rv);+}++pub(in crate::native_bridge) fn media_played_getter_function<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'_, v8::Value>,+) {+ media_ranges_getter(scope, args.this(), "played", rv);+}++pub(in crate::native_bridge) fn media_seekable_getter_function<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'_, v8::Value>,+) {+ media_ranges_getter(scope, args.this(), "seekable", rv);+}++fn media_ranges_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+ member: &'static str,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ if html_media_element_getter_receiver(scope, receiver, member).is_none() {+ return;+ }+ // The current media backend does not decode/buffer media or advance a+ // playback timeline. Do not invent loaded or played ranges from currentTime.+ // Each read still returns an independent native snapshot.+ rv.set(crate::context_bootstrap::new_time_ranges_value(scope, &[]).into());+}diff --git a/moli-renderer-v8/src/native_bridge/element/media_elements.rs b/moli-renderer-v8/src/native_bridge/element/media_elements.rsindex 8eb0b4b0d..268bbffbd 100644--- a/moli-renderer-v8/src/native_bridge/element/media_elements.rs+++ b/moli-renderer-v8/src/native_bridge/element/media_elements.rs@@ -13,8 +13,14 @@ pub(super) struct HtmlHtmlElementPrototypeDeclaration {}#[derive(WebApiFunctionTemplate)]-#[webapi(interface = web_api_interfaces::HTMLMediaElement, enumerable)]+#[webapi(interface = web_api_interfaces::HTMLMediaElement, enumerable, receiver)]pub(super) struct HtmlMediaElementPrototypeDeclaration {+ #[webapi(accessor_property, getter = media_buffered_getter_function)]+ buffered: (),+ #[webapi(accessor_property, getter = media_played_getter_function)]+ played: (),+ #[webapi(accessor_property, getter = media_seekable_getter_function)]+ seekable: (),#[webapi(accessor_property, getter = media_error_getter_function)]error: (),#[webapi(diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rsindex a4d677c23..47566f449 100644--- a/moli-renderer-v8/src/script_vm/tests/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs@@ -2171,6 +2171,7 @@ mod svg_filter_interfaces;mod svg_number_validation;mod svg_root_factory_receivers;mod svg_switch_mpath_interfaces;+mod time_ranges;mod url_components;mod webgl_interfaces;mod webidl_collections;diff --git a/moli-renderer-v8/src/script_vm/tests/time_ranges.js b/moli-renderer-v8/src/script_vm/tests/time_ranges.jsnew file mode 100644index 000000000..f55d47bab--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/time_ranges.js@@ -0,0 +1,139 @@+(() => {+ const checks = [];+ const equal = (actual, expected) => {+ if (!Object.is(actual, expected)) throw Error(`expected ${String(expected)}, got ${String(actual)}`);+ };+ const throws = (realm, name, run) => {+ let error;+ try { run(); } catch (caught) { error = caught; }+ const C = name === 'TypeError' ? realm.TypeError : realm.DOMException;+ if (!error || error.name !== name || !(error instanceof C)) throw Error(`expected ${name} in callee realm, got ${error}`);+ return error;+ };+ const realms = [globalThis, document.getElementById('child').contentWindow];+ for (const [index, realm] of realms.entries()) {+ const C = realm.TimeRanges, prototype = C.prototype;+ const getLength = Object.getOwnPropertyDescriptor(prototype, 'length')?.get;+ const test = (name, run) => {+ try { run(); checks.push({realm: index, name, passed: true}); }+ catch (error) { checks.push({realm: index, name, passed: false, error: String(error), stack: error.stack}); }+ };+ test('interface metadata and illegal constructor', () => {+ equal(C.name, 'TimeRanges'); equal(C.length, 0); equal(prototype.constructor, C);+ equal(Object.getPrototypeOf(C), realm.Function.prototype);+ equal(Object.getPrototypeOf(prototype), realm.Object.prototype);+ const tag = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag);+ equal(tag.value, 'TimeRanges'); equal(tag.writable, false); equal(tag.enumerable, false); equal(tag.configurable, true);+ for (const run of [() => C(), () => new C(), () => Reflect.construct(C, [], function Other() {})]) throws(realm, 'TypeError', run);+ });+ test('length descriptor', () => {+ const d = Object.getOwnPropertyDescriptor(prototype, 'length');+ equal(d.enumerable, true); equal(d.configurable, true); equal(d.set, undefined);+ equal(d.get.name, 'get length'); equal(d.get.length, 0); equal(Object.getPrototypeOf(d.get), realm.Function.prototype);+ });+ for (const name of ['start', 'end']) test(`${name} descriptor`, () => {+ const d = Object.getOwnPropertyDescriptor(prototype, name);+ equal(d.enumerable, true); equal(d.configurable, true); equal(d.writable, true);+ equal(d.value.name, name); equal(d.value.length, 1); equal(Object.getPrototypeOf(d.value), realm.Function.prototype);+ });+ const factories = [+ ['video', () => realm.document.createElement('video')],+ ['audio', () => realm.document.createElement('audio')],+ ['Audio', () => new realm.Audio()],+ ['windowless video', () => realm.document.implementation.createHTMLDocument('').createElement('video')],+ ];+ for (const property of ['buffered', 'played', 'seekable']) {+ const get = Object.getOwnPropertyDescriptor(realm.HTMLMediaElement.prototype, property)?.get;+ test(`${property} descriptor`, () => {+ const d = Object.getOwnPropertyDescriptor(realm.HTMLMediaElement.prototype, property);+ equal(d.enumerable, true); equal(d.configurable, true); equal(d.set, undefined);+ equal(get.name, `get ${property}`); equal(get.length, 0); equal(Object.getPrototypeOf(get), realm.Function.prototype);+ });+ for (const [label, factory] of factories) test(`${property} fresh empty snapshots from ${label}`, () => {+ const media = factory(), a = get.call(media), b = get.call(media);+ equal(a === b, false); equal(a.length, 0); equal(b.length, 0);+ equal(Object.getPrototypeOf(a), prototype); equal(Object.prototype.toString.call(a), '[object TimeRanges]');+ equal(a.constructor, C); equal(Object.keys(a).length, 0); equal(Array.isArray(a), false);+ equal(0 in a, false); equal(a[Symbol.iterator], undefined); equal(Reflect.set(a, 'length', 9), false);+ a.extra = 'author'; equal(b.extra, undefined); equal(getLength.call(a), 0);+ });+ test(`${property} accepts foreign native media in callee realm`, () => {+ const foreign = realms[1 - index].document.createElement('video'), ranges = get.call(foreign);+ equal(Object.getPrototypeOf(ranges), prototype); equal(getLength.call(ranges), 0);+ });+ test(`${property} rejects forged and proxy media without author traps`, () => {+ let traps = 0;+ const media = realm.document.createElement('video');+ const revoked = Proxy.revocable(media, {}); revoked.revoke();+ const receivers = [{}, Object.create(realm.HTMLMediaElement.prototype), Object.create(media),+ realm.document.createElement('div'), new Proxy(media, {get() {traps++;}, getPrototypeOf() {traps++;}}), revoked.proxy];+ for (const receiver of receivers) throws(realm, 'TypeError', () => get.call(receiver));+ equal(traps, 0);+ });+ }+ for (const name of ['start', 'end']) {+ const method = prototype[name];+ const values = [['undefined', undefined], ['null', null], ['false', false], ['true', true], ['zero', 0],+ ['negative zero', -0], ['one', 1], ['fraction', 0.9], ['negative fraction', -0.9], ['negative', -1],+ ['nan', NaN], ['positive infinity', Infinity], ['negative infinity', -Infinity],+ ['uint32 wrap', 2 ** 32], ['wrapped negative', -(2 ** 32)], ['maximum', 2 ** 32 - 1], ['numeric string', '0']];+ for (const [label, value] of values) test(`${name} empty index ${label}`, () => {+ const ranges = realm.document.createElement('video').buffered;+ const error = throws(realm, 'IndexSizeError', () => method.call(ranges, value)); equal(error.code, 1);+ });+ test(`${name} requires an argument before bounds`, () => throws(realm, 'TypeError', () => method.call(realm.document.createElement('video').buffered)));+ for (const [label, value] of [['symbol', Symbol()], ['bigint', 0n]]) test(`${name} rejects ${label} indices`, () =>+ throws(realm, 'TypeError', () => method.call(realm.document.createElement('video').buffered, value)));+ test(`${name} converts exactly once and propagates author exceptions`, () => {+ let conversions = 0; const ranges = realm.document.createElement('video').buffered;+ throws(realm, 'IndexSizeError', () => method.call(ranges, {[Symbol.toPrimitive](hint) {equal(hint, 'number'); conversions++; return 0;}}));+ equal(conversions, 1);+ const marker = {}; let caught;+ try { method.call(ranges, {valueOf() {throw marker;}}); } catch (error) {caught = error;}+ equal(caught, marker);+ });+ test(`${name} receiver validation precedes conversion and proxy traps`, () => {+ let calls = 0; const ranges = realm.document.createElement('video').buffered;+ const input = {valueOf() {calls++; return 0;}};+ const revoked = Proxy.revocable({}, {}); revoked.revoke();+ for (const receiver of [{}, Object.create(prototype), Object.create(ranges), new Proxy(ranges, {get() {calls++;}}), revoked.proxy])+ throws(realm, 'TypeError', () => method.call(receiver, input));+ equal(calls, 0);+ });+ test(`${name} accepts foreign snapshots and throws callee DOMException`, () => {+ const ranges = realms[1 - index].document.createElement('audio').seekable;+ throws(realm, 'IndexSizeError', () => method.call(ranges, 0));+ });+ }+ test('length receiver checks reject author proxies and forged prototypes', () => {+ const ranges = realm.document.createElement('video').buffered; let traps = 0;+ const revoked = Proxy.revocable(ranges, {}); revoked.revoke();+ for (const receiver of [{}, Object.create(prototype), Object.create(ranges), new Proxy(ranges, {get() {traps++;}}), revoked.proxy])+ throws(realm, 'TypeError', () => getLength.call(receiver));+ equal(traps, 0);+ });+ test('public properties do not change native length or bounds', () => {+ const ranges = realm.document.createElement('video').played;+ Object.defineProperty(ranges, 'length', {get() {throw Error('author length');}});+ ranges.__moliTimeRanges = [1, 2]; ranges[0] = 10;+ equal(getLength.call(ranges), 0); throws(realm, 'IndexSizeError', () => prototype.start.call(ranges, 0));+ Object.setPrototypeOf(ranges, null); equal(getLength.call(ranges), 0);+ Object.freeze(ranges); throws(realm, 'IndexSizeError', () => prototype.end.call(ranges, 0));+ });+ test('cloning rejects nested TimeRanges without public getter evaluation', () => {+ const ranges = realm.document.createElement('video').buffered; let gets = 0;+ Object.defineProperty(ranges, 'extra', {enumerable: true, get() {gets++; throw Error('author getter');}});+ throws(realm, 'DataCloneError', () => realm.structuredClone({ranges})); equal(gets, 0);+ });+ test('fresh media snapshots survive global constructor overrides', () => {+ const descriptor = Object.getOwnPropertyDescriptor(realm, 'TimeRanges');+ try {+ Object.defineProperty(realm, 'TimeRanges', {value: function() {throw Error('author constructor');}, configurable: true});+ const ranges = realm.document.createElement('video').buffered;+ equal(Object.getPrototypeOf(ranges), prototype); equal(getLength.call(ranges), 0);+ } finally {Object.defineProperty(realm, 'TimeRanges', descriptor);}+ });+ }+ globalThis.__uiEventResults = {complete: true, checks};+ return true;+})()diff --git a/moli-renderer-v8/src/script_vm/tests/time_ranges.rs b/moli-renderer-v8/src/script_vm/tests/time_ranges.rsnew file mode 100644index 000000000..c0952254c--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/time_ranges.rs@@ -0,0 +1,75 @@+use super::*;++#[test]+fn time_ranges_snapshots_preserve_native_brands_conversion_and_realms() {+ let mut vm = new_storage_page_task_executor_test_vm("https://time-ranges.test/");+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")+ .unwrap();+ vm.eval(include_str!("time_ranges.js")).unwrap();+ assert_eq!(vm.eval("__uiEventResults.complete").unwrap(), "true");+ assert_eq!(+ vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))")+ .unwrap(),+ "[]"+ );+}++#[test]+fn time_ranges_nonempty_native_snapshots_preserve_endpoints_and_uint32_conversion() {+ let mut vm = new_storage_page_task_executor_test_vm("https://time-ranges-native.test/");+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")+ .unwrap();+ let context_ptr = &vm.page_default_context as *const _;+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {+ let intervals = [(-3.5, -1.0), (0.0, 0.0), (0.25, 1.75), (4.0, f64::INFINITY)];+ let ranges = crate::context_bootstrap::new_time_ranges_value(scope, &intervals);+ let global = scope.get_current_context().global(scope);+ let key = crate::util::v8str(scope, "nativeRanges");+ assert_eq!(+ global.create_data_property(scope, key.into(), ranges.into()),+ Some(true)+ );+ // The endpoint backing array is inaccessible to author code. Register a+ // native Proxy to exercise the shared identity path independently.+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, ranges, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ let key = crate::util::v8str(scope, "nativeRangesProxy");+ assert_eq!(+ global.create_data_property(scope, key.into(), proxy.into()),+ Some(true)+ );+ Ok(())+ })+ .unwrap();+ assert_eq!(vm.eval(r#"(() => {+ const snapshots = [nativeRanges, nativeRangesProxy];+ const realms = [globalThis, document.getElementById('child').contentWindow];+ const starts = [-3.5, 0, 0.25, 4], ends = [-1, 0, 1.75, Infinity];+ const equal = (a, b) => {if (!Object.is(a, b)) throw Error(`expected ${b}, got ${a}`);};+ const error = (realm, name, run) => {+ let caught; try {run();} catch(e) {caught = e;}+ if (!caught || caught.name !== name || !(caught instanceof (name === 'TypeError' ? realm.TypeError : realm.DOMException))) throw Error('wrong exception');+ };+ for (const realm of realms) for (const ranges of snapshots) {+ const p = realm.TimeRanges.prototype;+ equal(Object.getOwnPropertyDescriptor(p, 'length').get.call(ranges), 4);+ for (let i = 0; i < 4; i++) {equal(p.start.call(ranges, i), starts[i]); equal(p.end.call(ranges, i), ends[i]);}+ for (const [input, index] of [[NaN, 0], [Infinity, 0], [-Infinity, 0], [2**32, 0], [-(2**32), 0],+ [null, 0], [undefined, 0], ['2', 2], [1.9, 1], [-0.9, 0], [true, 1], [2**32 + 2, 2]]) {+ equal(p.start.call(ranges, input), starts[index]); equal(p.end.call(ranges, input), ends[index]);+ }+ for (const input of [-1, 4, 2**32 - 1]) for (const name of ['start', 'end']) error(realm, 'IndexSizeError', () => p[name].call(ranges, input));+ for (const input of [Symbol(), 0n]) for (const name of ['start', 'end']) error(realm, 'TypeError', () => p[name].call(ranges, input));+ let reads = 0;+ equal(p.start.call(ranges, {valueOf() {reads++; return 2;}}), 0.25); equal(reads, 1);+ const authorProxy = new Proxy(ranges, {get() {reads++;}});+ error(realm, 'TypeError', () => p.start.call(authorProxy, {valueOf() {reads++; return 0;}})); equal(reads, 1);+ }+ Object.defineProperty(nativeRanges, 'length', {value: 900}); nativeRanges.__moliTimeRanges = [100, 200];+ Object.setPrototypeOf(nativeRanges, null); Object.freeze(nativeRanges);+ equal(TimeRanges.prototype.start.call(nativeRanges, 2), 0.25);+ equal(TimeRanges.prototype.end.call(nativeRanges, 3), Infinity);+ return true;+ })()"#).unwrap(), "true");+}