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