Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
Model inline offset geometry from fragments
ldm0ce0a6157e29c
diff --git a/moli-layout/src/layout_tree/source_query.rs b/moli-layout/src/layout_tree/source_query.rsindex 0c34bad41..d9ade2474 100644--- a/moli-layout/src/layout_tree/source_query.rs+++ b/moli-layout/src/layout_tree/source_query.rs@@ -13,6 +13,13 @@ use super::{tree::FrozenLayoutTree,};+#[derive(Clone, Copy, Debug, PartialEq)]+struct InlineOffsetGeometry {+ layout_origin_in_document: LayoutPoint,+ border_origin_in_viewport_ignoring_css_transforms: LayoutPoint,+ size: LayoutSize,+}+impl<N> FrozenLayoutTree<N>whereN: Copy + Debug + Eq + Hash,@@ -109,44 +116,24 @@ where}}).unwrap_or(LayoutPoint::ZERO);- let fragment_origins = output.fragments.iter().find_map(|id| {- let fragment = self.fragment(*id)?;- let LayoutFragmentKind::InlineBox {- box_id: fragment_box,- ..- } = fragment.kind- else {- return None;- };- if fragment_box != box_id {- return None;- }- let border = fragment.box_model?.border;- let fragment_space = self.coordinate_space(fragment.coordinate_space)?;- let owner = fragment_space.owner?;- let owner_origin = self.box_geometry(owner)?.layout_origin_in_document;- let local_border_origin = LayoutPoint::new(border.x, border.y);- Some((- LayoutPoint::new(- owner_origin.x + local_border_origin.x,- owner_origin.y + local_border_origin.y,- ),- fragment_space- .local_to_viewport_ignoring_css_transforms- .map_point(local_border_origin),- ))- });- let (layout_origin, border_origin_in_viewport_ignoring_css_transforms) = fragment_origins+ let inline_offset_geometry = self.inline_offset_geometry(&output, box_id);+ let layout_origin = inline_offset_geometry+ .map(|geometry| geometry.layout_origin_in_document)+ .unwrap_or(geometry.layout_origin_in_document);+ let offset_size = inline_offset_geometry+ .map(|geometry| geometry.size).unwrap_or_else(|| {- (- geometry.layout_origin_in_document,- coordinate_space- .local_to_viewport_ignoring_css_transforms- .map_point(LayoutPoint::new(- geometry.border_box.x,- geometry.border_box.y,- )),- )+ LayoutSize::new(geometry.border_box.width, geometry.border_box.height)+ });+ let border_origin_in_viewport_ignoring_css_transforms = inline_offset_geometry+ .map(|geometry| geometry.border_origin_in_viewport_ignoring_css_transforms)+ .unwrap_or_else(|| {+ coordinate_space+ .local_to_viewport_ignoring_css_transforms+ .map_point(LayoutPoint::new(+ geometry.border_box.x,+ geometry.border_box.y,+ ))});let client_size = if is_root {// CSSOM defines root client dimensions from the viewport and only@@ -176,7 +163,7 @@ wherelayout_origin.y - offset_parent_origin.y,),border_origin_in_viewport_ignoring_css_transforms,- offset_size: LayoutSize::new(geometry.border_box.width, geometry.border_box.height),+ offset_size,content_size: LayoutSize::new(geometry.content_box.width, geometry.content_box.height),client_size,client_border: LayoutPoint::new(@@ -466,6 +453,86 @@ impl<N> FrozenLayoutTree<N>whereN: Copy + Debug + Eq + Hash,{+ /// Returns the untransformed CSSOM offset geometry for a flattened inline.+ ///+ /// CSSOM View defines `offsetLeft`/`offsetTop` from the first fragment and+ /// `offsetWidth`/`offsetHeight` from the bounding box of all non-empty+ /// border-box fragments. Mapping each fragment through its IFC owner's+ /// document-layout origin keeps that geometry in one physical coordinate+ /// system while intentionally excluding transforms and scrolling.+ fn inline_offset_geometry(+ &self,+ output: &LayoutNodeOutput,+ box_id: LayoutOutputBoxId,+ ) -> Option<InlineOffsetGeometry> {+ let mut first_fragment = None;+ let mut bounds = None::<LayoutRect>;++ for id in &output.fragments {+ let Some(fragment) = self.fragment(*id) else {+ continue;+ };+ let LayoutFragmentKind::InlineBox {+ box_id: fragment_box,+ ..+ } = fragment.kind+ else {+ continue;+ };+ if fragment_box != box_id {+ continue;+ }+ let Some(box_model) = fragment.box_model else {+ continue;+ };+ let Some(fragment_space) = self.coordinate_space(fragment.coordinate_space) else {+ continue;+ };+ let Some(owner) = fragment_space.owner else {+ continue;+ };+ let Some(owner_geometry) = self.box_geometry(owner) else {+ continue;+ };+ let border = box_model.border;+ let owner_origin = owner_geometry.layout_origin_in_document;+ let local_origin = LayoutPoint::new(border.x, border.y);+ let document_border = LayoutRect::new(+ owner_origin.x + border.x,+ owner_origin.y + border.y,+ border.width,+ border.height,+ );+ first_fragment.get_or_insert_with(|| {+ (+ LayoutPoint::new(document_border.x, document_border.y),+ fragment_space+ .local_to_viewport_ignoring_css_transforms+ .map_point(local_origin),+ )+ });++ // Blink's BoundingBoxRelativeToFirstFragment uses UniteIfNonZero:+ // an empty fragment supplies the offset anchor but cannot stretch+ // the size union across lines by its zero-area position alone.+ if document_border.width <= 0.0 || document_border.height <= 0.0 {+ continue;+ }+ bounds = Some(bounds.map_or(document_border, |current| current.union(document_border)));+ }++ let (layout_origin_in_document, border_origin_in_viewport_ignoring_css_transforms) =+ first_fragment?;+ let size = bounds.map_or(LayoutSize::ZERO, |rect| {+ LayoutSize::new(rect.width, rect.height)+ });+ Some(InlineOffsetGeometry {+ layout_origin_in_document,+ border_origin_in_viewport_ignoring_css_transforms,+ size,+ })+ }+fn project_fragment_box_models(&self,models: &[(LayoutCoordinateSpaceId, LayoutFragmentBoxModel)],@@ -563,3 +630,128 @@ wherefn axis_aligned_union(left: LayoutQuad, right: LayoutQuad) -> LayoutQuad {LayoutTransform2D::IDENTITY.map_rect(left.bounding_rect().union(right.bounding_rect()))}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::layout_tree::{+ FrozenCoordinateSpace, FrozenLayoutBox, LayoutBoxGeometry, LayoutFragment,+ LayoutFragmentId, LayoutScrollExtent, LayoutViewport,+ };++ fn identity_space(owner: Option<LayoutOutputBoxId>) -> FrozenCoordinateSpace {+ FrozenCoordinateSpace {+ owner,+ local_to_viewport: LayoutTransform2D::IDENTITY,+ local_to_viewport_ignoring_css_transforms: LayoutTransform2D::IDENTITY,+ }+ }++ #[test]+ fn inline_offset_geometry_skips_an_unprojectable_fragment_before_valid_geometry() {+ let box_id = LayoutOutputBoxId::from_index(0);+ let coordinate_space = LayoutCoordinateSpaceId::from_index(1);+ let skipped_fragment = LayoutFragmentId::from_index(0);+ let valid_fragment = LayoutFragmentId::from_index(1);+ let fragment = |id, box_model| LayoutFragment {+ id,+ kind: LayoutFragmentKind::InlineBox {+ box_id,+ line_index: 0,+ has_start_edge: true,+ has_end_edge: true,+ },+ rect: LayoutRect::ZERO,+ box_model,+ coordinate_space,+ clip_chain: None,+ paint_order: None,+ };+ let valid_box_model = LayoutFragmentBoxModel {+ content: LayoutRect::new(3.0, 4.0, 10.0, 5.0),+ padding: LayoutRect::new(3.0, 4.0, 10.0, 5.0),+ border: LayoutRect::new(3.0, 4.0, 10.0, 5.0),+ margin: LayoutRect::new(3.0, 4.0, 10.0, 5.0),+ };+ let scroll_extent = LayoutScrollExtent {+ scrollport: LayoutRect::ZERO,+ scrollable_overflow: LayoutRect::ZERO,+ scroll_size: LayoutSize::ZERO,+ applied_offset: LayoutPoint::ZERO,+ minimum_offset: LayoutPoint::ZERO,+ maximum_offset: LayoutPoint::ZERO,+ is_scroll_container: false,+ allows_user_scroll_x: false,+ allows_user_scroll_y: false,+ clips_overflow: false,+ horizontal_scrollbar: None,+ vertical_scrollbar: None,+ scrollbar_corner: None,+ scrollbar_colors: None,+ };+ let tree = FrozenLayoutTree::new(+ 0_u8,+ LayoutViewport::new(100, 100, 1.0),+ LayoutPoint::ZERO,+ LayoutSize::new(100.0, 100.0),+ box_id,+ vec![FrozenLayoutBox {+ geometry: LayoutBoxGeometry {+ id: box_id,+ structural_parent: None,+ parent: None,+ layout_parent: None,+ position: LayoutPosition::Static,+ coordinate_space,+ clip_chain: None,+ content_box: LayoutRect::ZERO,+ padding_box: LayoutRect::ZERO,+ border_box: LayoutRect::ZERO,+ margin_box: LayoutRect::ZERO,+ fragments: vec![skipped_fragment, valid_fragment],+ layout_origin_in_document: LayoutPoint::new(100.0, 200.0),+ is_body_element: false,+ is_table_offset_parent: false,+ establishes_positioned_containing_block: false,+ establishes_fixed_containing_block: false,+ visible: true,+ pointer_events: true,+ },+ scroll_extent,+ coordinate_space: identity_space(Some(box_id)),+ geometry_source: Some(1),+ principal_source: Some(1),+ hit_source: Some(1),+ control_paint_order: None,+ }],+ vec![+ fragment(skipped_fragment, None),+ fragment(valid_fragment, Some(valid_box_model)),+ ],+ Vec::new(),+ identity_space(None),+ Vec::new(),+ Vec::new(),+ true,+ );+ let output = LayoutNodeOutput {+ principal_box: Some(box_id),+ fragments: vec![skipped_fragment, valid_fragment],+ scroll_proxy_boxes: Vec::new(),+ };++ let geometry = tree+ .inline_offset_geometry(&output, box_id)+ .expect("the valid fragment after the skipped entry must contribute geometry");++ assert_eq!(+ geometry.layout_origin_in_document,+ LayoutPoint::new(103.0, 204.0)+ );+ assert_eq!(+ geometry.border_origin_in_viewport_ignoring_css_transforms,+ LayoutPoint::new(3.0, 4.0)+ );+ assert_eq!(geometry.size, LayoutSize::new(10.0, 5.0));+ }+}diff --git a/moli-layout/tests/phase5_output_contract.rs b/moli-layout/tests/phase5_output_contract.rsindex 8c71751c6..ec241f85f 100644--- a/moli-layout/tests/phase5_output_contract.rs+++ b/moli-layout/tests/phase5_output_contract.rs@@ -1278,6 +1278,87 @@ fn inline_output_preserves_line_text_and_utf16_source_fragments() {assert_eq!(scroll_geometry.scroll_containers.len(), 1);}+#[test]+fn inline_offset_metrics_use_fragment_bounds_and_keep_empty_sibling_anchors() {+ let source = Source(vec![+ Node::element("root", vec![1, 3]),+ Node::element("reference", vec![2]),+ Node::text("reference-text", "ref"),+ Node::element("empty-target", vec![4]),+ Node::text("collapsed-trailing-space", " "),+ ]);+ let mut styles = Styles::default();+ styles.0.insert(+ 0,+ fixed_size(LayoutDisplay::Block, 80.0, 80.0).with_text_metrics(10.0, 10.0),+ );+ for node in 1..=4 {+ styles.0.insert(+ node,+ resolved(LayoutDisplay::Inline, Style::default()).with_text_metrics(10.0, 10.0),+ );+ }++ let output = build(&source, &mut styles);+ let reference = output+ .element_metrics_for_source(1)+ .expect("reference inline metrics");+ let target = output+ .element_metrics_for_source(3)+ .expect("empty target inline metrics");++ assert!(reference.offset_size.width > 0.0);+ assert_close(+ target.offset_position.x,+ reference.offset_position.x + reference.offset_size.width,+ );+ assert_close(target.offset_position.y, reference.offset_position.y);+}++#[test]+fn multiline_inline_offset_size_is_the_nonempty_fragment_union() {+ let source = Source(vec![+ Node::element("root", vec![1]),+ Node::element("multiline-inline", vec![2]),+ Node::text("wrapped-text", "ref ref ref"),+ ]);+ let mut styles = Styles::default();+ styles.0.insert(+ 0,+ fixed_size(LayoutDisplay::Block, 14.0, 100.0).with_text_metrics(10.0, 10.0),+ );+ for node in 1..=2 {+ styles.0.insert(+ node,+ resolved(LayoutDisplay::Inline, Style::default()).with_text_metrics(10.0, 10.0),+ );+ }++ let output = build(&source, &mut styles);+ let fragments = output+ .client_rects_for_source(1)+ .into_iter()+ .map(|quad| quad.bounding_rect())+ .filter(|rect| rect.width > 0.0 && rect.height > 0.0)+ .collect::<Vec<_>>();+ assert!(+ fragments.len() > 1,+ "the fixture must generate multiple inline fragments: {fragments:?}"+ );+ let union = fragments[1..]+ .iter()+ .copied()+ .fold(fragments[0], LayoutRect::union);+ let metrics = output+ .element_metrics_for_source(1)+ .expect("multiline inline metrics");++ assert_close(metrics.offset_position.x, fragments[0].x);+ assert_close(metrics.offset_position.y, fragments[0].y);+ assert_close(metrics.offset_size.width, union.width);+ assert_close(metrics.offset_size.height, union.height);+}+#[test]fn inline_and_range_rects_use_font_bounds_instead_of_the_css_line_height() {const CJK_TEXT: &str = "台风白海豚在浙江玉环沿海登陆";diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rsindex 5cf2de47b..25659380b 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs@@ -3168,6 +3168,61 @@ const y = rect.top + 1;.expect("negative-margin elementsFromPoint fixture should run");}+#[tokio::test(flavor = "current_thread")]+async fn inline_offset_metrics_keep_empty_trailing_space_anchor_after_bordered_inline() {+ run_page_vm_async_test(async move {+ let loader =+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");+ let mut page_vm = test_page_vm_with_loader_and_document_url(+ &loader,+ Vec::new(),+ Url::parse("https://example.com/inline-offset-fragments.html")?,+ );+ page_vm.vm_mut().eval(+ r#"+document.head.innerHTML = `<style>+html,body { margin:0 }+.container { position:relative; width:80px; height:70px; padding:10px; font:10px/10px sans-serif }+.reference { border:1px solid transparent; padding:0 6px }+</style>`;+document.body.innerHTML = `+<div class=container><br><span class=reference></span><span class=target> </span></div>`;+'installed'+"#,+ )?;+ page_vm+ .vm_mut()+ .prime_document_lifecycle_processing_and_record_stylesheet_network_results();+ page_vm+ .vm_mut()+ .screenshot_layout_snapshot(moli_layout::PaintViewport::new(100, 90, 1.0))?+ .expect("inline offset fixture must retain a layout root");++ let geometry = page_vm.vm_mut().eval(+ r#"(()=>{const target=document.querySelector('.target');const reference=target.previousSibling;return JSON.stringify({reference:[reference.offsetLeft,reference.offsetTop,reference.offsetWidth,reference.offsetHeight],target:[target.offsetLeft,target.offsetTop]})})()"#,+ )?;+ let geometry: serde_json::Value = serde_json::from_str(&geometry)?;+ let reference = geometry["reference"]+ .as_array()+ .unwrap_or_else(|| panic!("missing reference metrics: {geometry}"));+ let target = geometry["target"]+ .as_array()+ .unwrap_or_else(|| panic!("missing target metrics: {geometry}"));+ let number = |values: &[serde_json::Value], axis: usize| {+ values[axis].as_f64().expect("numeric offset geometry")+ };+ assert_eq!(number(reference, 2), 14.0, "reference width: {geometry}");+ assert_eq!(+ number(target, 0),+ number(reference, 0) + number(reference, 2),+ "the empty inline starts after the reference fragment: {geometry}"+ );+ Ok::<_, anyhow::Error>(())+ })+ .await+ .expect("inline offset fragment fixture should run");+}+#[tokio::test(flavor = "current_thread")]async fn stylesheet_lifecycle_registers_only_the_current_documents_data_web_fonts() {run_page_vm_async_test(async move {