Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / layout / tree_builder_1.lucb

#==============================================================================================
#
#   tree_builder_1 - Layout::TreeBuilder: insertion into the tree and pseudo-elements
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/TreeBuilder.cpp (lines 1-429) and TreeBuilder.h: the constructor
#       and the ancestor stack, the insertion parents that keep a block's in-flow children all
#       block-level or all inline-level (creating anonymous wrappers), the insertion of a node
#       into its nearest inline or block ancestor, the GeneratedContentImageProvider of
#       `content: url(...)` images, and the boxes of ::before, ::after, ::marker and ::backdrop.
#
#       Copyright (c) 2018-2025, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2022-2023, Sam Atkins <atkinssj@serenityos.org>
#       Copyright (c) 2022, MacDue <macdue@dueutil.tech>
#       Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
#       Copyright (c) 2025, Aziz B. Yesilyurt <abyesilyurt@gmail.com>
#       Copyright (c) 2025, Manuel Zahariev <manuel@duck.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Construction and the ancestor stack =====================================================

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:45 Web::Layout::TreeBuilder::TreeBuilder.
pub func layout_tree_builder_construct(this: LayoutTreeBuilder*):
    this.m_layout_root = none
    this.m_ancestor_stack = ak.Vector[LayoutNodeWithStyle*]()
    this.m_quote_nesting_level = 0

## Ported from Libraries/LibWeb/Layout/TreeBuilder.h:40 Web::Layout::TreeBuilder::push_parent.
func layout_tree_builder_push_parent(this: LayoutTreeBuilder*, node: LayoutNodeWithStyle*):
    ak.vector_append_t(&this.m_ancestor_stack, node)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.h:41 Web::Layout::TreeBuilder::pop_parent.
func layout_tree_builder_pop_parent(this: LayoutTreeBuilder*):
    _ = ak.vector_take_last(&this.m_ancestor_stack)

# mark: Insertion parents =======================================================================

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:47 Web::Layout::has_inline_or_in_flow_block_children.
func layout_has_inline_or_in_flow_block_children(layout_node: LayoutNode*) -> bool:
    for child in layout_node_children(layout_node):
        if layout_node_is_inline(child) or layout_node_is_in_flow(child):
            return true
    return false

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:56 Web::Layout::has_in_flow_block_children.
func layout_has_in_flow_block_children(layout_node: LayoutNode*) -> bool:
    if layout_node_children_are_inline(layout_node):
        return false
    for child in layout_node_children(layout_node):
        if layout_node_is_inline(child):
            continue
        if layout_node_is_in_flow(child):
            return true
    return false

# The insertion_parent_for_*() functions maintain the invariant that the in-flow children of
# block-level boxes must be either all block-level or all inline-level.

## `last_child_creating_anonymous_wrapper_if_needed`: the lambda of insertion_parent_for_inline_node.
func layout_last_child_creating_anonymous_wrapper_if_needed(layout_parent: LayoutNodeWithStyle*) -> LayoutNode*:
    let parent = layout_parent.layout_node()
    var needs_wrapper = true
    if let last_child = tree_node_last_child(parent):
        needs_wrapper = not layout_node_is_anonymous(last_child) or not layout_node_children_are_inline(last_child) or layout_node_is_generated_for_pseudo_element(last_child)
    if needs_wrapper:
        tree_node_append_child(parent, layout_node_with_style_create_anonymous_wrapper(layout_parent).layout_node())
    return tree_node_last_child(parent) else trap("unreachable: the parent has a last child")

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:72 Web::Layout::insertion_parent_for_inline_node.
func layout_insertion_parent_for_inline_node(layout_parent: LayoutNodeWithStyle*) -> LayoutNode*:
    if is_layout_field_set_box(layout_parent):
        return layout_last_child_creating_anonymous_wrapper_if_needed(layout_parent)

    if layout_node_is_svg_foreign_object_box(layout_parent.layout_node()):
        return layout_last_child_creating_anonymous_wrapper_if_needed(layout_parent)

    let display = layout_node_display(layout_parent.layout_node())
    if css_display_is_inline_outside(&display) and css_display_is_flow_inside(&display):
        return layout_parent.layout_node()

    if css_display_is_flex_inside(&display) or css_display_is_grid_inside(&display):
        return layout_last_child_creating_anonymous_wrapper_if_needed(layout_parent)

    if not layout_has_in_flow_block_children(layout_parent.layout_node()) or layout_node_children_are_inline(layout_parent.layout_node()):
        return layout_parent.layout_node()

    # Parent has block-level children, insert into an anonymous wrapper block (and create it first if needed)
    return layout_last_child_creating_anonymous_wrapper_if_needed(layout_parent)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:103 Web::Layout::insertion_parent_for_block_node.
func layout_insertion_parent_for_block_node(layout_parent: LayoutNodeWithStyle*, layout_node: LayoutNode*) -> LayoutNode*:
    # Inline is fine for in-flow block children; we'll maintain the (non-)inline invariant after insertion.
    let parent_display = layout_node_display(layout_parent.layout_node())
    if not layout_node_is_anonymous(layout_node) and layout_node_is_inline(layout_parent.layout_node()) and css_display_is_flow_inside(&parent_display) and not layout_node_is_out_of_flow(layout_node):
        return layout_parent.layout_node()

    # Make sure we're not inserting into an inline node, since those do not support block nodes.
    var new_parent = layout_parent
    while is_layout_inline_node(new_parent):
        new_parent = layout_node_parent(new_parent.layout_node()) else trap("an inline node has a parent")

    # If the parent block has no children, insert this block into parent.
    if not layout_has_inline_or_in_flow_block_children(new_parent.layout_node()):
        return new_parent.layout_node()

    # If the block is out-of-flow and is not a pseudo element,
    if layout_node_is_out_of_flow(layout_node) and not layout_node_is_generated_for_pseudo_element(layout_node):
        # And the parent's last child is an anonymous block, join that anonymous block.
        let new_parent_display = layout_node_display(new_parent.layout_node())
        let last_child = tree_node_last_child(new_parent.layout_node()) else trap("the parent has children")
        if not css_display_is_flex_inside(&new_parent_display) and not css_display_is_grid_inside(&new_parent_display) and not layout_node_is_generated_for_pseudo_element(last_child) and layout_node_is_anonymous(last_child) and layout_node_children_are_inline(last_child):
            return last_child

        # Otherwise, insert this block into parent.
        return new_parent.layout_node()

    # If the parent block has block-level children, insert this block into parent.
    if not layout_node_children_are_inline(new_parent.layout_node()):
        return new_parent.layout_node()

    # Parent block has inline-level children (our siblings); wrap these siblings into an anonymous wrapper block.
    let wrapper = layout_node_with_style_create_anonymous_wrapper(new_parent)
    layout_node_set_children_are_inline(wrapper.layout_node(), true)

    var child = tree_node_first_child(new_parent.layout_node())
    while let current = child:
        let next_child = tree_node_next_sibling(current)
        tree_node_remove_child(new_parent.layout_node(), current)
        tree_node_append_child(wrapper.layout_node(), current)
        child = next_child

    layout_node_set_children_are_inline(new_parent.layout_node(), false)
    tree_node_append_child(new_parent.layout_node(), wrapper.layout_node())

    # Then it's safe to insert this block into parent.
    return new_parent.layout_node()

## `nearest_insertion_ancestor`: the lambda of insert_node_into_inline_or_block_ancestor.
func layout_tree_builder_nearest_insertion_ancestor(this: LayoutTreeBuilder*, node: LayoutNode*) -> LayoutNodeWithStyle*:
    var index = ak.vector_size(&this.m_ancestor_stack)
    while index > 0:
        index -= 1
        let ancestor = *ak.vector_at(&this.m_ancestor_stack, index)
        if layout_node_is_svg_foreign_object_box(ancestor.layout_node()):
            return ancestor

        let ancestor_display = layout_node_display(ancestor.layout_node())

        # Out-of-flow nodes cannot be hosted in inline flow nodes.
        if layout_node_is_out_of_flow(node) and css_display_is_inline_outside(&ancestor_display) and css_display_is_flow_inside(&ancestor_display):
            continue

        if not css_display_is_contents(&ancestor_display):
            return ancestor
    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:155 Web::Layout::TreeBuilder::insert_node_into_inline_or_block_ancestor.
func layout_tree_builder_insert_node_into_inline_or_block_ancestor(this: LayoutTreeBuilder*, node: LayoutNode*, display: CssDisplay, mode: LayoutTreeBuilderAppendOrPrepend):
    let node_display = layout_node_display(node)
    if css_display_is_contents(&node_display):
        return

    # Find the nearest ancestor that can host the node.
    let nearest_insertion_ancestor = layout_tree_builder_nearest_insertion_ancestor(this, node)

    var insertion_point: LayoutNode* = ---
    if css_display_is_inline_outside(&display):
        insertion_point = layout_insertion_parent_for_inline_node(nearest_insertion_ancestor)
    else:
        insertion_point = layout_insertion_parent_for_block_node(nearest_insertion_ancestor, node)

    if mode == LayoutTreeBuilderAppendOrPrepend.prepend:
        tree_node_prepend_child(insertion_point, node)
    else:
        tree_node_append_child(insertion_point, node)

    if css_display_is_inline_outside(&display):
        # After inserting an inline-level box into a parent, mark the parent as having inline children.
        layout_node_set_children_are_inline(insertion_point, true)
    elif layout_node_is_in_flow(node):
        # After inserting an in-flow block-level box into a parent, mark the parent as having non-inline children.
        layout_node_set_children_are_inline(insertion_point, false)

# mark: GeneratedContentImageProvider (TreeBuilder.cpp:195-273) =================================

## The GeneratedContentImageProvider whose ImageProvider mixin is `base` (C++'s pointer adjustment).
func layout_generated_content_image_provider_from_image_provider(base: LayoutImageProvider*) -> LayoutGeneratedContentImageProvider*:
    return (LayoutGeneratedContentImageProvider*)((u8*)base - memory.offset_of(LayoutGeneratedContentImageProvider, image_provider))

## The GeneratedContentImageProvider whose ImageStyleValue::Client mixin is `base`.
func layout_generated_content_image_provider_from_client(base: CssImageStyleValueClient*) -> LayoutGeneratedContentImageProvider*:
    return (LayoutGeneratedContentImageProvider*)((u8*)base - memory.offset_of(LayoutGeneratedContentImageProvider, client))

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:207 Web::Layout::GeneratedContentImageProvider::finalize (override).
pub func layout_generated_content_image_provider_finalize_impl(base: gc.Cell*):
    let this = (LayoutGeneratedContentImageProvider*)base
    gc.cell_finalize_impl(base)
    css_image_style_value_client_image_style_value_finalize(&this.client)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:213 Web::Layout::GeneratedContentImageProvider::is_image_available (override).
pub func layout_generated_content_image_provider_is_image_available_impl(base: LayoutImageProvider*) -> bool:
    let this = layout_generated_content_image_provider_from_image_provider(base)
    return css_abstract_image_style_value_is_paintable(this.m_image.css_abstract_image_style_value())

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:215 Web::Layout::GeneratedContentImageProvider::intrinsic_width (override).
pub func layout_generated_content_image_provider_intrinsic_width_impl(base: LayoutImageProvider*) -> gfx.CssPixels?:
    let this = layout_generated_content_image_provider_from_image_provider(base)
    return css_abstract_image_style_value_natural_width(this.m_image.css_abstract_image_style_value())

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:216 Web::Layout::GeneratedContentImageProvider::intrinsic_height (override).
pub func layout_generated_content_image_provider_intrinsic_height_impl(base: LayoutImageProvider*) -> gfx.CssPixels?:
    let this = layout_generated_content_image_provider_from_image_provider(base)
    return css_abstract_image_style_value_natural_height(this.m_image.css_abstract_image_style_value())

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:217 Web::Layout::GeneratedContentImageProvider::intrinsic_aspect_ratio (override).
pub func layout_generated_content_image_provider_intrinsic_aspect_ratio_impl(base: LayoutImageProvider*) -> gfx.CssPixelFraction?:
    let this = layout_generated_content_image_provider_from_image_provider(base)
    return css_abstract_image_style_value_natural_aspect_ratio(this.m_image.css_abstract_image_style_value())

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:219 Web::Layout::GeneratedContentImageProvider::current_image_bitmap_sized (override).
pub func layout_generated_content_image_provider_current_image_bitmap_sized_impl(base: LayoutImageProvider*, size: gfx.IntSize) -> gfx.ImmutableBitmap*?:
    let this = layout_generated_content_image_provider_from_image_provider(base)
    var rect: gfx.DevicePixelRect = ---
    gfx.device_pixel_rect_construct_int_point(&rect, gfx.IntPoint(), size)
    return (gfx.ImmutableBitmap*?)css_image_style_value_current_frame_bitmap(this.m_image, rect)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:225 Web::Layout::GeneratedContentImageProvider::set_visible_in_viewport (override).
pub func layout_generated_content_image_provider_set_visible_in_viewport_impl(base: LayoutImageProvider*, arg0: bool):
    _ = base
    _ = arg0

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:227 Web::Layout::GeneratedContentImageProvider::to_html_element (override).
pub func layout_generated_content_image_provider_to_html_element_impl(base: LayoutImageProvider*) -> DomElement*?:
    _ = base
    return none

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:229 Web::Layout::GeneratedContentImageProvider::create.
pub func layout_generated_content_image_provider_create(heap: gc.Heap*, image: CssImageStyleValue*) -> LayoutGeneratedContentImageProvider*:
    let this = (LayoutGeneratedContentImageProvider*)web_heap_allocate_cell(heap, &layout_generated_content_image_provider_class)
    gc.heap_defer_gc(heap)
    layout_generated_content_image_provider_construct(this, image)
    gc.heap_undefer_gc(heap)
    return this

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:234 Web::Layout::GeneratedContentImageProvider::set_layout_node.
pub func layout_generated_content_image_provider_set_layout_node(this: LayoutGeneratedContentImageProvider*, layout_node: LayoutNode*):
    this.m_layout_node = layout_node

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:239 Web::Layout::GeneratedContentImageProvider::current_frame_index (override).
pub func layout_generated_content_image_provider_current_frame_index_impl(base: LayoutImageProvider*) -> usize:
    _ = base
    return 0

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:240 Web::Layout::GeneratedContentImageProvider::decoded_image_data (override).
pub func layout_generated_content_image_provider_decoded_image_data_impl(base: LayoutImageProvider*) -> HtmlDecodedImageData*?:
    let this = layout_generated_content_image_provider_from_image_provider(base)
    return css_image_style_value_image_data(this.m_image)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:246 Web::Layout::GeneratedContentImageProvider::GeneratedContentImageProvider.
pub func layout_generated_content_image_provider_construct(this: LayoutGeneratedContentImageProvider*, image: CssImageStyleValue*):
    # The vptrs of the two mixin bases (ImageProvider, ImageStyleValue::Client).
    this.image_provider.vtable = &layout_generated_content_image_provider_image_provider_vtable
    this.image_provider.class_id = this.cell().class_id
    this.client.vtable = &layout_generated_content_image_provider_client_vtable
    this.client.class_id = this.cell().class_id
    css_image_style_value_client_construct(&this.client, image)
    this.m_image = image

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:252 Web::Layout::GeneratedContentImageProvider::visit_edges (override).
pub func layout_generated_content_image_provider_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (LayoutGeneratedContentImageProvider*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_layout_node)
    css_style_value_visit_edges(this.m_image.css_style_value(), visitor)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:259 Web::Layout::GeneratedContentImageProvider::image_provider_visit_edges (override).
pub func layout_generated_content_image_provider_image_provider_visit_edges_impl(base: LayoutImageProvider*, visitor: gc.CellVisitor*):
    let this = layout_generated_content_image_provider_from_image_provider(base)
    layout_image_provider_image_provider_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t_2(visitor, this)

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:265 Web::Layout::GeneratedContentImageProvider::image_style_value_did_update (override).
pub func layout_generated_content_image_provider_image_style_value_did_update_impl(base: CssImageStyleValueClient*, arg0: CssImageStyleValue*):
    _ = arg0
    let this = layout_generated_content_image_provider_from_client(base)
    let layout_node = this.m_layout_node else trap("GeneratedContentImageProvider: no layout node")
    layout_node_set_needs_layout_update(layout_node, DomSetNeedsLayoutReason.generated_content_image_finished_loading)

# mark: Pseudo-elements =========================================================================

## Ported from Libraries/LibWeb/Layout/TreeBuilder.cpp:276 Web::Layout::TreeBuilder::create_pseudo_element_if_needed.
func layout_tree_builder_create_pseudo_element_if_needed(this: LayoutTreeBuilder*, element: DomElement*, pseudo_element: css_data.PseudoElement, insertion_mode: LayoutTreeBuilderAppendOrPrepend?) -> LayoutNodeWithStyle*?:
    let document = dom_node_document(element.dom_node())
    let realm = layout_document_realm(document)

    let pseudo_element_style = dom_element_computed_properties(element, pseudo_element) else return none

    let initial_quote_nesting_level = this.m_quote_nesting_level
    var element_reference = dom_element_abstract_element(element, pseudo_element)
    let content_and_level = css_computed_properties_content(pseudo_element_style, &element_reference, initial_quote_nesting_level)
    let pseudo_element_content = content_and_level.content_data
    this.m_quote_nesting_level = content_and_level.final_quote_nesting_level
    let pseudo_element_display = css_computed_properties_display(pseudo_element_style)

    # ::before and ::after only exist if they have content. `content: normal` computes to `none` for them.
    # We also don't create them if they are `display: none`.
    if (pseudo_element == css_data.PseudoElement.before or pseudo_element == css_data.PseudoElement.after) and (css_display_is_none(&pseudo_element_display) or pseudo_element_content.type_ == CssContentDataType.normal or pseudo_element_content.type_ == CssContentDataType.none_):
        return none

    # For ::marker with content or display 'none' -- do nothing.
    if pseudo_element == css_data.PseudoElement.marker and (css_display_is_none(&pseudo_element_display) or pseudo_element_content.type_ == CssContentDataType.none_):
        return none

    # For ::marker with content 'normal', create the marker pseudo-element from a ListItemMarkerBox
    # FIXME: This + ListItemBox + ListItemMarkerBox will disappear once ::marker pseudo-elements with 'normal' content
    #        are rendered using the special list-item counter.
    #        See: https://github.com/LadybirdBrowser/ladybird/issues/4782
    # NB: Called during layout tree construction.
    if pseudo_element == css_data.PseudoElement.marker and pseudo_element_content.type_ == CssContentDataType.normal:
        let element_layout_node = dom_element_unsafe_layout_node(element) else trap("the element has a layout node")
        if let list_box = as_if_layout_list_item_box(element_layout_node):
            # https://www.w3.org/TR/css-lists-3/#content-property
            # "::marker does not generate a box" when list-style-type is 'none' and there's no marker image. Custom
            # ::marker content is already excluded by the outer condition checking for Type::Normal.
            let list_box_values = &layout_node_computed_values(list_box.layout_node()).computed_values
            let list_style_type = css_computed_values_list_style_type(list_box_values)
            let list_style_type_is_empty = match list_style_type:
                .empty => true
                _ => false
            if list_style_type_is_empty and layout_node_with_style_list_style_image(list_box.layout_node_with_style()) == none:
                return none

            let list_item_marker = realm_create_layout_list_item_marker_box(realm, document, list_style_type, css_computed_values_list_style_position(list_box_values), element, pseudo_element_style)
            layout_list_item_box_set_marker(list_box, list_item_marker)
            dom_element_set_computed_properties(element, css_data.PseudoElement.marker, pseudo_element_style)
            dom_element_set_pseudo_element_node(element, css_data.PseudoElement.marker, list_item_marker.layout_node_with_style())
            tree_node_prepend_child(list_box.layout_node(), list_item_marker.layout_node())
            return list_item_marker.layout_node_with_style()

    let pseudo_element_node = dom_element_create_layout_node_for_display_type(document, pseudo_element_display, pseudo_element_style, none) else return none

    # FIXME: This code actually computes style for element::marker, and shouldn't for element::pseudo::marker
    if is_layout_list_item_box(pseudo_element_node):
        let style_computer = dom_document_style_computer(document)

        let marker_style = css_style_computer_compute_style(style_computer, dom_element_abstract_element(element, css_data.PseudoElement.marker))
        let pseudo_element_values = &layout_node_computed_values(pseudo_element_node.layout_node()).computed_values
        let list_item_marker = realm_create_layout_list_item_marker_box(realm, document, css_computed_values_list_style_type(pseudo_element_values), css_computed_values_list_style_position(pseudo_element_values), element, marker_style)
        layout_list_item_box_set_marker((LayoutListItemBox*)pseudo_element_node, list_item_marker)
        dom_element_set_pseudo_element_node(element, css_data.PseudoElement.marker, list_item_marker.layout_node_with_style())
        tree_node_prepend_child(pseudo_element_node.layout_node(), list_item_marker.layout_node())

        # FIXME: Support counters on element::pseudo::marker

    layout_node_set_generated_for(pseudo_element_node.layout_node(), pseudo_element, element)
    layout_node_set_initial_quote_nesting_level(pseudo_element_node.layout_node(), initial_quote_nesting_level)

    dom_element_set_pseudo_element_node(element, pseudo_element, pseudo_element_node)
    if let mode = insertion_mode:
        layout_tree_builder_insert_node_into_inline_or_block_ancestor(this, pseudo_element_node.layout_node(), pseudo_element_display, mode)
    css_mutable_computed_values_set_content(layout_node_with_style_mutable_computed_values(pseudo_element_node), pseudo_element_content)

    css_resolve_counters(&element_reference)
    # Now that we have counters, we can compute the content for real. Which is silly.
    if pseudo_element_content.type_ == CssContentDataType.list:
        let new_content = css_computed_properties_content(pseudo_element_style, &element_reference, initial_quote_nesting_level).content_data
        css_mutable_computed_values_set_content(layout_node_with_style_mutable_computed_values(pseudo_element_node), new_content)

        # FIXME: Handle images, and multiple values
        if new_content.type_ == CssContentDataType.list:
            layout_tree_builder_push_parent(this, pseudo_element_node)
            for item in ak.vector_span_const(&new_content.data):
                var layout_node: LayoutNode* = ---
                match item:
                    .string(string):
                        let text = realm_create_dom_text_utf16_string(realm, document, ak.utf16_string_from_utf8_string(&string))
                        layout_node = realm_create_layout_text_node(realm, document, text).layout_node()
                    .css_image_style_value(image):
                        css_abstract_image_style_value_load_any_resources_dom_document(image.css_abstract_image_style_value(), document)
                        let image_provider = layout_generated_content_image_provider_create(gc.cell_heap(element.cell()), image)
                        layout_node = realm_create_layout_image_box(realm, document, none, pseudo_element_style, &image_provider.image_provider).layout_node()
                        layout_generated_content_image_provider_set_layout_node(image_provider, layout_node)
                layout_node_set_generated_for(layout_node, pseudo_element, element)
                layout_tree_builder_insert_node_into_inline_or_block_ancestor(this, layout_node, layout_node_display(layout_node), LayoutTreeBuilderAppendOrPrepend.append)
            layout_tree_builder_pop_parent(this)
        else:
            trap("TODO")

    return pseudo_element_node