Skip to content

armgit / moli

Public Imported from GitHub
0

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

41.6 KB
Raw Blame
//! CSSOM box, range, element-metric, and source-provenance projections.

use std::{collections::HashMap, fmt::Debug, hash::Hash, ops::Range};

use crate::LayoutPosition;

use super::{
    model::{
        LayoutBoxModel, LayoutCoordinateSpaceId, LayoutFragmentBoxModel, LayoutFragmentKind,
        LayoutOutputBoxId, LayoutPoint, LayoutQuad, LayoutRect, LayoutResolvedGridTracks,
        LayoutSize, LayoutTransform2D, LayoutUsedSize,
    },
    query::{
        LayoutElementMetrics, LayoutNodeOutput, LayoutResizeObserverMetrics,
        LayoutResizeObserverSize,
    },
    tree::{CssSizingBox, FrozenLayoutBox, FrozenLayoutTree},
};

#[cfg(test)]
thread_local! {
    static SOURCE_OUTPUT_BOX_VISITS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}

#[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>
where
    N: Copy + Debug + Eq + Hash,
{
    /// Derives the source view from canonical box provenance.
    ///
    /// No source hash table survives the pass. The returned IDs are copied
    /// into one short-lived query value.
    pub fn source_output(&self, source: N) -> Option<LayoutNodeOutput> {
        let mut found = false;
        let mut output = LayoutNodeOutput::default();
        for layout_box in &self.boxes {
            #[cfg(test)]
            SOURCE_OUTPUT_BOX_VISITS.with(|count| count.set(count.get() + 1));
            if layout_box.principal_source == Some(source) {
                output.principal_box = Some(layout_box.id);
                found = true;
            }
            if layout_box.geometry_source == Some(source) {
                output
                    .fragments
                    .extend(layout_box.fragments.iter().copied().filter(|id| {
                        self.fragment(*id).is_some_and(|fragment| {
                            !matches!(fragment.kind, LayoutFragmentKind::Line { .. })
                        })
                    }));
                found = true;
            }
        }
        for (proxy_source, box_id) in &self.scroll_proxy_links {
            if *proxy_source == source {
                output.scroll_proxy_boxes.push(*box_id);
                found = true;
            }
        }
        found.then_some(output)
    }

    /// Builds provenance only for this operation's requested sources. Absent
    /// sources remain explicit None entries; fragment and proxy order follow
    /// the canonical vectors exactly as in the direct source query.
    pub(super) fn source_outputs(&self, outputs: &mut HashMap<N, Option<LayoutNodeOutput>>) {
        for layout_box in &self.boxes {
            #[cfg(test)]
            SOURCE_OUTPUT_BOX_VISITS.with(|count| count.set(count.get() + 1));
            if let Some(output) = layout_box
                .principal_source
                .and_then(|source| outputs.get_mut(&source))
            {
                output.get_or_insert_default().principal_box = Some(layout_box.id);
            }
            if let Some(output) = layout_box
                .geometry_source
                .and_then(|source| outputs.get_mut(&source))
            {
                output.get_or_insert_default().fragments.extend(
                    layout_box.fragments.iter().copied().filter(|id| {
                        self.fragment(*id).is_some_and(|fragment| {
                            !matches!(fragment.kind, LayoutFragmentKind::Line { .. })
                        })
                    }),
                );
            }
        }
        for (source, box_id) in &self.scroll_proxy_links {
            if let Some(output) = outputs.get_mut(source) {
                output
                    .get_or_insert_default()
                    .scroll_proxy_boxes
                    .push(*box_id);
            }
        }
    }

    pub fn element_metrics_for_source(&self, source: N) -> Option<LayoutElementMetrics<N>> {
        self.element_metrics_for_source_with_offset_parent_filter(source, |_| true)
    }

    /// ResizeObserver's CSS-box sizes, interpreted using only metadata and
    /// geometry from this snapshot. Non-replaced inline and suppressed sources
    /// have no applicable CSS sizing box and produce no measurement here.
    pub fn resize_observer_metrics_for_source(
        &self,
        source: N,
    ) -> Option<LayoutResizeObserverMetrics> {
        self.boxes
            .iter()
            .find(|layout_box| layout_box.principal_source == Some(source))?
            .resize_observer_metrics()
    }

    /// Physical and logical CSSOM sizes from this snapshot's sizing box,
    /// without transforms, integer rounding, or absolute CSS zoom. A source
    /// without an applicable principal box keeps its computed value.
    pub fn used_size_for_source(&self, source: N) -> Option<LayoutUsedSize> {
        let layout_box = self
            .boxes
            .iter()
            .find(|layout_box| layout_box.principal_source == Some(source))?;
        layout_box.used_size()
    }

    /// Derives all applicable sizing boxes in one pass. A batch consumer may
    /// collect this into an operation-local lookup; no index is retained by
    /// the frozen tree, and no DOM or style input is consulted.
    pub fn used_sizes(&self) -> impl Iterator<Item = (N, LayoutUsedSize)> + '_ {
        self.boxes
            .iter()
            .filter_map(|layout_box| Some((layout_box.principal_source?, layout_box.used_size()?)))
    }

    /// Returns the exact unprojected content box produced for a source's
    /// principal layout box.
    ///
    /// Embedded browsing contexts use this as their LocalFrameView size. The
    /// value deliberately comes from used layout geometry rather than
    /// authored width/height CSS, and therefore remains correct for
    /// percentages, `calc()`, box sizing, borders, padding, and transforms.
    pub fn local_content_box_for_source(&self, source: N) -> Option<LayoutRect> {
        let box_id = self.source_output(source)?.principal_box?;
        self.box_geometry(box_id)
            .map(|geometry| geometry.content_box)
    }

    /// Resolves CSSOM View element metrics while allowing the renderer to hide
    /// flat-tree ancestors that do not belong to the queried element's
    /// ancestor tree scopes.
    ///
    /// Shadow DOM tree-scope visibility is an HTML/DOM concern, not a CSS box
    /// tree concern. The frozen tree therefore retains the complete box chain
    /// and lets its short-lived consumer supply that one predicate. Geometry
    /// is still derived wholly from this pass; no live layout state is read or
    /// retained here.
    pub fn element_metrics_for_source_with_offset_parent_filter(
        &self,
        source: N,
        mut offset_parent_is_exposed: impl FnMut(N) -> bool,
    ) -> Option<LayoutElementMetrics<N>> {
        let output = self.source_output(source)?;
        let box_id = output.principal_box?;
        let geometry = self.box_geometry(box_id)?;
        let extent = self.scroll_extent(box_id)?;
        let coordinate_space = self.coordinate_space(geometry.coordinate_space)?;
        let is_root = box_id == self.root_box;
        let offset_parent_id = self.offset_parent_box(box_id, &mut offset_parent_is_exposed);
        let offset_parent = offset_parent_id.and_then(|id| {
            self.boxes
                .get(id.index())
                .and_then(|layout_box| layout_box.geometry_source)
        });
        let offset_parent_origin = offset_parent_id
            .and_then(|id| self.box_geometry(id))
            .map(|parent| {
                if parent.is_body_element {
                    if parent.position == LayoutPosition::Static {
                        LayoutPoint::ZERO
                    } else {
                        parent.layout_origin_in_document
                    }
                } else {
                    LayoutPoint::new(
                        parent.layout_origin_in_document.x + parent.padding_box.x,
                        parent.layout_origin_in_document.y + parent.padding_box.y,
                    )
                }
            })
            .unwrap_or(LayoutPoint::ZERO);
        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(|| {
                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 unzoom = CssomAbsoluteZoom::new(geometry.effective_zoom);
        let client_size = if is_root {
            // CSSOM defines root client dimensions from the viewport and only
            // subtracts an actually-present viewport scrollbar. Stable empty
            // gutters still reduce root layout/scrollWidth, but not
            // documentElement.clientWidth/clientHeight.
            LayoutSize::new(
                (self.viewport.css_width as f32
                    - extent
                        .vertical_scrollbar
                        .map_or(0.0, |scrollbar| scrollbar.frame.width))
                .max(0.0),
                (self.viewport.css_height as f32
                    - extent
                        .horizontal_scrollbar
                        .map_or(0.0, |scrollbar| scrollbar.frame.height))
                .max(0.0),
            )
        } else {
            unzoom.size(LayoutSize::new(
                extent.scrollport.width,
                extent.scrollport.height,
            ))
        };
        Some(LayoutElementMetrics {
            offset_parent,
            offset_position: unzoom.point(LayoutPoint::new(
                layout_origin.x - offset_parent_origin.x,
                layout_origin.y - offset_parent_origin.y,
            )),
            border_origin_in_viewport_ignoring_css_transforms,
            offset_size: unzoom.size(offset_size),
            content_size: unzoom.size(LayoutSize::new(
                geometry.content_box.width,
                geometry.content_box.height,
            )),
            client_size,
            client_border: unzoom.point(LayoutPoint::new(
                if is_root {
                    0.0
                } else {
                    extent.scrollport.x - geometry.border_box.x
                },
                if is_root {
                    0.0
                } else {
                    extent.scrollport.y - geometry.border_box.y
                },
            )),
            scroll_size: unzoom.size(extent.scroll_size),
            scroll_offset: unzoom.point(extent.applied_offset),
            minimum_scroll_offset: unzoom.point(extent.minimum_offset),
            maximum_scroll_offset: unzoom.point(extent.maximum_offset),
            scrollport: if is_root {
                LayoutTransform2D::IDENTITY.map_rect(extent.scrollport)
            } else {
                coordinate_space
                    .local_to_viewport
                    .map_rect(extent.scrollport)
            },
            scrollable_overflow: coordinate_space
                .local_to_viewport
                .map_rect(extent.scrollable_overflow),
            is_scroll_container: extent.is_scroll_container,
            allows_user_scroll_x: extent.allows_user_scroll_x,
            allows_user_scroll_y: extent.allows_user_scroll_y,
            clips_overflow: extent.clips_overflow,
            visible: geometry.visible,
            pointer_events: geometry.pointer_events,
        })
    }

    /// Returns used Grid tracks from the same frozen epoch as other CSSOM
    /// geometry, normalized out of the container's effective CSS zoom.
    pub fn used_grid_tracks_for_source(&self, source: N) -> Option<LayoutResolvedGridTracks> {
        let output = self.source_output(source)?;
        let layout_box = self.boxes.get(output.principal_box?.index())?;
        let mut grid = layout_box.resolved_grid_tracks.clone()?;
        let unzoom = CssomAbsoluteZoom::new(layout_box.geometry.effective_zoom);
        for tracks in [&mut grid.rows, &mut grid.columns] {
            for size in &mut tracks.used_track_sizes {
                *size = unzoom.scalar(*size);
            }
        }
        Some(grid)
    }

    /// Resolves a viewport point into the coordinate system Blink uses for
    /// `MouseEvent.offsetX/Y`: a box target's padding edge, or the shared IFC
    /// coordinate space for a flattened inline layout object.
    pub fn event_offset_for_source(
        &self,
        source: N,
        viewport_point: LayoutPoint,
    ) -> Option<LayoutPoint> {
        let output = self.source_output(source)?;
        let box_id = output.principal_box?;
        if let Some(inline_fragment) = output.fragments.iter().find_map(|id| {
            let fragment = self.fragment(*id)?;
            matches!(
                fragment.kind,
                LayoutFragmentKind::InlineBox {
                    box_id: fragment_box,
                    ..
                } if fragment_box == box_id
            )
            .then_some(fragment)
        }) {
            let inverse = self
                .coordinate_space(inline_fragment.coordinate_space)?
                .local_to_viewport
                .inverse()?;
            return Some(inverse.map_point(viewport_point));
        }

        let geometry = self.box_geometry(box_id)?;
        let inverse = self
            .coordinate_space(geometry.coordinate_space)?
            .local_to_viewport
            .inverse()?;
        let mut local = inverse.map_point(viewport_point);
        local.x -= geometry.padding_box.x - geometry.border_box.x;
        local.y -= geometry.padding_box.y - geometry.border_box.y;
        Some(local)
    }

    pub fn box_model_for_source(&self, source: N) -> Option<LayoutBoxModel> {
        self.box_model_for_output(&self.source_output(source)?)
    }

    pub(super) fn box_model_for_output(&self, output: &LayoutNodeOutput) -> Option<LayoutBoxModel> {
        let fragment_models = output
            .fragments
            .iter()
            .filter_map(|id| self.fragment(*id))
            .filter_map(|fragment| {
                fragment
                    .box_model
                    .map(|model| (fragment.coordinate_space, model))
            })
            .collect::<Vec<_>>();
        if !fragment_models.is_empty() {
            return self.project_fragment_box_models(&fragment_models);
        }

        let box_id = output.principal_box?;
        let geometry = self.box_geometry(box_id)?;
        self.project_local_box_model(
            geometry.coordinate_space,
            LayoutFragmentBoxModel {
                content: geometry.content_box,
                padding: geometry.padding_box,
                border: geometry.border_box,
                margin: geometry.margin_box,
            },
        )
    }

    pub fn client_rects_for_source(&self, source: N) -> Vec<LayoutQuad> {
        self.source_output(source)
            .map_or_else(Vec::new, |output| self.client_rects_for_output(&output))
    }

    pub(super) fn client_rects_for_output(&self, output: &LayoutNodeOutput) -> Vec<LayoutQuad> {
        output
            .fragments
            .iter()
            .filter_map(|id| self.fragment(*id))
            .filter(|fragment| {
                matches!(
                    fragment.kind,
                    LayoutFragmentKind::Box { .. } | LayoutFragmentKind::InlineBox { .. }
                )
            })
            .filter_map(|fragment| {
                self.coordinate_space(fragment.coordinate_space)
                    .map(|space| space.local_to_viewport.map_rect(fragment.rect))
            })
            .collect()
    }

    pub fn content_quads_for_source(&self, source: N) -> Vec<LayoutQuad> {
        self.source_output(source)
            .map_or_else(Vec::new, |output| self.content_quads_for_output(&output))
    }

    pub(super) fn content_quads_for_output(&self, output: &LayoutNodeOutput) -> Vec<LayoutQuad> {
        output
            .fragments
            .iter()
            .filter_map(|id| self.fragment(*id))
            .filter(|fragment| {
                matches!(
                    fragment.kind,
                    LayoutFragmentKind::Box { .. }
                        | LayoutFragmentKind::InlineBox { .. }
                        | LayoutFragmentKind::Text { .. }
                )
            })
            .filter_map(|fragment| {
                let rect = fragment
                    .box_model
                    .map(|model| model.content)
                    .unwrap_or(fragment.rect);
                self.coordinate_space(fragment.coordinate_space)
                    .map(|space| space.local_to_viewport.map_rect(rect))
            })
            .collect()
    }

    pub fn text_range_rects(&self, source: N, utf16_range: Range<usize>) -> Vec<LayoutQuad> {
        self.source_output(source).map_or_else(Vec::new, |output| {
            self.text_range_rects_for_output(&output, utf16_range)
        })
    }

    pub(super) fn text_range_rects_for_output(
        &self,
        output: &LayoutNodeOutput,
        utf16_range: Range<usize>,
    ) -> Vec<LayoutQuad> {
        #[derive(Clone, Copy)]
        struct SelectedTextRect {
            box_id: LayoutOutputBoxId,
            line_index: usize,
            rtl: bool,
            coordinate_space: LayoutCoordinateSpaceId,
            rect: LayoutRect,
        }

        let mut selected = output
            .fragments
            .iter()
            .filter_map(|id| self.fragment(*id))
            .filter_map(|fragment| {
                let LayoutFragmentKind::Text {
                    box_id,
                    line_index,
                    source_utf16_range,
                    rtl,
                    ..
                } = &fragment.kind
                else {
                    return None;
                };
                let source_len = source_utf16_range
                    .end
                    .saturating_sub(source_utf16_range.start);
                let (selected_start, selected_end) = if utf16_range.is_empty() {
                    if utf16_range.start < source_utf16_range.start
                        || utf16_range.start > source_utf16_range.end
                    {
                        return None;
                    }
                    let point = utf16_range
                        .start
                        .saturating_sub(source_utf16_range.start)
                        .min(source_len);
                    (point, point)
                } else {
                    let start = source_utf16_range.start.max(utf16_range.start);
                    let end = source_utf16_range.end.min(utf16_range.end);
                    if start >= end {
                        return None;
                    }
                    (
                        start.saturating_sub(source_utf16_range.start),
                        end.saturating_sub(source_utf16_range.start),
                    )
                };
                let denominator = source_len.max(1) as f32;
                let start_ratio = selected_start as f32 / denominator;
                let end_ratio = selected_end as f32 / denominator;
                let visual_start_ratio = if *rtl { 1.0 - end_ratio } else { start_ratio };
                let rect = LayoutRect::new(
                    fragment.rect.x + fragment.rect.width * visual_start_ratio,
                    fragment.rect.y,
                    fragment.rect.width * (end_ratio - start_ratio),
                    fragment.rect.height,
                );
                Some(SelectedTextRect {
                    box_id: *box_id,
                    line_index: *line_index,
                    rtl: *rtl,
                    coordinate_space: fragment.coordinate_space,
                    rect,
                })
            })
            .collect::<Vec<_>>();

        // Parley exposes cluster-level source fragments, while CSSOM View
        // exposes one Range rect per contiguous directional run on a line.
        // Keep opposite bidi runs separate, but merge adjacent clusters from
        // the same source box before mapping through transforms.
        selected.sort_by(|left, right| {
            left.coordinate_space
                .index()
                .cmp(&right.coordinate_space.index())
                .then_with(|| left.box_id.index().cmp(&right.box_id.index()))
                .then_with(|| left.line_index.cmp(&right.line_index))
                .then_with(|| left.rtl.cmp(&right.rtl))
                .then_with(|| left.rect.y.total_cmp(&right.rect.y))
                .then_with(|| left.rect.x.total_cmp(&right.rect.x))
        });
        let mut merged: Vec<SelectedTextRect> = Vec::with_capacity(selected.len());
        for fragment in selected {
            let can_merge = merged.last().is_some_and(|previous| {
                let tolerance = previous
                    .rect
                    .width
                    .abs()
                    .max(fragment.rect.width.abs())
                    .max(1.0)
                    * f32::EPSILON
                    * 16.0;
                previous.box_id == fragment.box_id
                    && previous.line_index == fragment.line_index
                    && previous.rtl == fragment.rtl
                    && previous.coordinate_space == fragment.coordinate_space
                    && (previous.rect.y - fragment.rect.y).abs() <= tolerance
                    && (previous.rect.height - fragment.rect.height).abs() <= tolerance
                    && fragment.rect.x <= previous.rect.right() + tolerance
            });
            if can_merge {
                let previous = merged.last_mut().expect("checked above");
                previous.rect = previous.rect.union(fragment.rect);
            } else {
                merged.push(fragment);
            }
        }

        let mut quads = merged
            .into_iter()
            .filter_map(|fragment| {
                self.coordinate_space(fragment.coordinate_space)
                    .map(|space| space.local_to_viewport.map_rect(fragment.rect))
            })
            .collect::<Vec<_>>();
        quads.sort_by(|left, right| {
            let left = left.bounding_rect();
            let right = right.bounding_rect();
            left.y
                .total_cmp(&right.y)
                .then_with(|| left.x.total_cmp(&right.x))
        });
        quads
    }
}

impl<N> FrozenLayoutBox<N> {
    fn resize_observer_metrics(&self) -> Option<LayoutResizeObserverMetrics> {
        let sizing = self.css_sizing?;
        let unzoom = CssomAbsoluteZoom::new(self.effective_zoom);
        let content_size = unzoom.size(LayoutSize::new(
            self.content_box.width,
            self.content_box.height,
        ));
        let border_size = unzoom.size(LayoutSize::new(
            self.border_box.width,
            self.border_box.height,
        ));
        let logical = |size: LayoutSize| {
            let (inline_size, block_size) = if sizing.horizontal {
                (size.width, size.height)
            } else {
                (size.height, size.width)
            };
            LayoutResizeObserverSize {
                inline_size,
                block_size,
            }
        };
        Some(LayoutResizeObserverMetrics {
            content_size,
            content_box_size: logical(content_size),
            border_box_size: logical(border_size),
        })
    }

    fn used_size(&self) -> Option<LayoutUsedSize> {
        let sizing = self.css_sizing?;
        let rect = match sizing.box_kind {
            CssSizingBox::Content => self.content_box,
            CssSizingBox::Border => self.border_box,
        };
        let size = CssomAbsoluteZoom::new(self.effective_zoom)
            .size(LayoutSize::new(rect.width, rect.height));
        let (inline_size, block_size) = if sizing.horizontal {
            (size.width, size.height)
        } else {
            (size.height, size.width)
        };
        Some(LayoutUsedSize {
            width: size.width,
            height: size.height,
            inline_size,
            block_size,
        })
    }
}

/// Converts effective-zoomed layout scalars to the coordinate space exposed
/// by CSSOM box sizes and scroll metrics. Viewport quads intentionally stay
/// zoomed: their normalized bases map points back into these unzoomed sizes.
#[derive(Clone, Copy)]
struct CssomAbsoluteZoom(f32);

impl CssomAbsoluteZoom {
    fn new(effective_zoom: f32) -> Self {
        debug_assert!(effective_zoom.is_finite() && effective_zoom > 0.0);
        Self(if effective_zoom.is_finite() && effective_zoom > 0.0 {
            effective_zoom
        } else {
            1.0
        })
    }

    fn point(self, point: LayoutPoint) -> LayoutPoint {
        LayoutPoint::new(point.x / self.0, point.y / self.0)
    }

    fn scalar(self, value: f32) -> f32 {
        value / self.0
    }

    fn size(self, size: LayoutSize) -> LayoutSize {
        LayoutSize::new(size.width / self.0, size.height / self.0)
    }
}

impl<N> FrozenLayoutTree<N>
where
    N: 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,
            // which discards only a 0-by-0 fragment. A one-dimensional
            // fragment still contributes its non-zero axis to offset geometry.
            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)],
    ) -> Option<LayoutBoxModel> {
        let first_space = models.first()?.0;
        if models.iter().all(|(space, _)| *space == first_space) {
            let mut combined = models.first()?.1;
            for (_, model) in &models[1..] {
                combined.content = combined.content.union(model.content);
                combined.padding = combined.padding.union(model.padding);
                combined.border = combined.border.union(model.border);
                combined.margin = combined.margin.union(model.margin);
            }
            return self.project_local_box_model(first_space, combined);
        }

        let mut projected = models
            .iter()
            .filter_map(|(space, model)| self.project_local_box_model(*space, *model));
        let first = projected.next()?;
        let combined = projected.fold(first, |mut combined, model| {
            combined.content = axis_aligned_union(combined.content, model.content);
            combined.padding = axis_aligned_union(combined.padding, model.padding);
            combined.border = axis_aligned_union(combined.border, model.border);
            combined.margin = axis_aligned_union(combined.margin, model.margin);
            combined
        });
        Some(combined)
    }

    fn offset_parent_box(
        &self,
        box_id: LayoutOutputBoxId,
        offset_parent_is_exposed: &mut impl FnMut(N) -> bool,
    ) -> Option<LayoutOutputBoxId> {
        let geometry = self.box_geometry(box_id)?;
        if box_id == self.root_box || geometry.is_body_element {
            return None;
        }
        let base_is_positioned = geometry.position != LayoutPosition::Static;
        let base_effective_zoom = geometry.effective_zoom;
        let mut in_fixed_position_chain = geometry.position == LayoutPosition::Fixed;
        let mut candidate = geometry.structural_parent;
        while let Some(id) = candidate {
            let parent = self.box_geometry(id)?;
            let source = self
                .boxes
                .get(id.index())
                .and_then(|layout_box| layout_box.geometry_source);
            let Some(source) = source else {
                candidate = parent.structural_parent;
                continue;
            };

            if !offset_parent_is_exposed(source) {
                if parent.establishes_fixed_containing_block {
                    in_fixed_position_chain = false;
                } else if parent.position == LayoutPosition::Fixed {
                    in_fixed_position_chain = true;
                }
                candidate = parent.structural_parent;
                continue;
            }

            if in_fixed_position_chain {
                if parent.establishes_fixed_containing_block {
                    return Some(id);
                }
            } else if parent.establishes_positioned_containing_block
                || parent.is_body_element
                || (!base_is_positioned && parent.is_table_offset_parent)
            {
                return Some(id);
            }
            // CSSOM View preserves WebKit/Blink's long-standing extension:
            // offsetParent stops at the first exposed layout ancestor whose
            // absolute zoom differs from the target. Resolve ordinary
            // containing-block candidates first, exactly as Blink does, then
            // admit this geometry-coordinate boundary.
            if base_effective_zoom != parent.effective_zoom {
                return Some(id);
            }
            in_fixed_position_chain |= parent.position == LayoutPosition::Fixed;
            candidate = parent.structural_parent;
        }
        None
    }

    fn project_local_box_model(
        &self,
        coordinate_space: LayoutCoordinateSpaceId,
        model: LayoutFragmentBoxModel,
    ) -> Option<LayoutBoxModel> {
        let transform = self.coordinate_space(coordinate_space)?.local_to_viewport;
        Some(LayoutBoxModel {
            content: transform.map_rect(model.content),
            padding: transform.map_rect(model.padding),
            border: transform.map_rect(model.border),
            margin: transform.map_rect(model.margin),
        })
    }
}

fn 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,
        }
    }

    fn inline_fragment_tree() -> FrozenLayoutTree<u8> {
        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, 0.0, 5.0),
            padding: LayoutRect::new(3.0, 4.0, 0.0, 5.0),
            border: LayoutRect::new(3.0, 4.0, 0.0, 5.0),
            margin: LayoutRect::new(3.0, 4.0, 0.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,
        };
        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,
                    effective_zoom: 1.0,
                    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),
                css_sizing: None,
                resolved_grid_tracks: None,
                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(),
        )
    }

    #[test]
    fn inline_offset_geometry_skips_unprojectable_fragments_and_keeps_one_dimensional_bounds() {
        let tree = inline_fragment_tree();
        let box_id = LayoutOutputBoxId::from_index(0);
        let skipped_fragment = LayoutFragmentId::from_index(0);
        let valid_fragment = LayoutFragmentId::from_index(1);
        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(0.0, 5.0));
    }
    #[test]
    fn batch_fragment_queries_scan_boxes_once_and_preserve_missing_sources() {
        use crate::{LayoutFlushReason, LayoutQuery, LayoutQueryBatch};
        let mut tree = inline_fragment_tree();
        for source in 2..=64 {
            let mut layout_box = tree.boxes[0].clone();
            layout_box.geometry.id = LayoutOutputBoxId::from_index(tree.boxes.len());
            layout_box.geometry.fragments.clear();
            layout_box.geometry_source = Some(source);
            layout_box.principal_source = Some(source);
            tree.boxes.push(layout_box);
        }
        // Include proxy-only and missing sources as well as repeated queries.
        tree.scroll_proxy_links.push((100, tree.boxes[0].id));
        let queries = LayoutQueryBatch::new(
            (0..=128)
                .flat_map(|source| {
                    [
                        LayoutQuery::ClientRects { source },
                        LayoutQuery::ContentQuads { source },
                        LayoutQuery::BoxModel { source },
                        LayoutQuery::TextRangeRects {
                            source,
                            utf16_range: 0..4,
                        },
                    ]
                })
                .collect(),
        );
        SOURCE_OUTPUT_BOX_VISITS.with(|count| count.set(0));
        let expected = queries
            .queries
            .iter()
            .map(|query| tree.answer_query(query))
            .collect::<Vec<_>>();
        assert_eq!(
            SOURCE_OUTPUT_BOX_VISITS.with(std::cell::Cell::get),
            tree.boxes.len() * queries.queries.len()
        );
        SOURCE_OUTPUT_BOX_VISITS.with(|count| count.set(0));
        // The metrics are pass diagnostics, copied unchanged by query batches.
        let metrics = crate::LayoutPassMetrics {
            reason: LayoutFlushReason::Test,
            elapsed: std::time::Duration::ZERO,
            box_tree_elapsed: std::time::Duration::ZERO,
            list_marker_elapsed: std::time::Duration::ZERO,
            form_control_elapsed: std::time::Duration::ZERO,
            inline_preparation_elapsed: std::time::Duration::ZERO,
            numeric_layout_elapsed: std::time::Duration::ZERO,
            numeric_first_pass_elapsed: std::time::Duration::ZERO,
            numeric_followup_passes_elapsed: std::time::Duration::ZERO,
            overflow_detection_elapsed: std::time::Duration::ZERO,
            scrollbar_feedback_elapsed: std::time::Duration::ZERO,
            embedded_frame_elapsed: std::time::Duration::ZERO,
            projection_elapsed: std::time::Duration::ZERO,
            numeric_layout_pass_count: 0,
            numeric_feedback_invalidated_node_count: 0,
            numeric_feedback_overflow_recomputed_node_count: 0,
            box_count: 0,
            fragment_count: 0,
            paint_event_count: 0,
            paint_culled_event_count: 0,
            paint_text_line_count: 0,
            paint_culled_text_line_count: 0,
            paint_operation_count: 0,
            fallback_count: 0,
        };
        let answers = tree.answer_queries(&queries, metrics);
        assert_eq!(answers.answers, expected);
        assert_eq!(
            SOURCE_OUTPUT_BOX_VISITS.with(std::cell::Cell::get),
            tree.boxes.len()
        );
        assert_eq!(answers.metrics, metrics);
        SOURCE_OUTPUT_BOX_VISITS.with(|count| count.set(0));
        let one = LayoutQueryBatch::new(vec![LayoutQuery::ClientRects { source: 1 }]);
        tree.answer_queries(&one, metrics);
        assert_eq!(
            SOURCE_OUTPUT_BOX_VISITS.with(std::cell::Cell::get),
            tree.boxes.len()
        );
    }
}