Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / invalidation / has_mutation_invalidator.lucb

#==============================================================================================
#
#   has_mutation_invalidator - :has() invalidation: scheduling the ancestors of a mutation
#                              and, before the next style update, invalidating the elements
#                              whose :has() match the pending mutations can change
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp (lines 1-483): which
#       mutation reasons can affect :has(), the per-scope scheduling of child-list mutations,
#       the filter that compares a :has() rule's argument features with the mutation's, and the
#       upward walk over :has()-scoped ancestors (and their siblings for sibling-combinator
#       arguments).
#
#       Copyright (c) 2026-present, the Ladybird developers
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Scheduling helpers ======================================================================

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:16 Web::CSS::Invalidation::reason_may_affect_has_selectors.
func css_invalidation_reason_may_affect_has_selectors(reason: DomStyleInvalidationReason) -> bool:
    # :has() selectors match based on DOM state only (structure, attributes, pseudo-classes). Reasons that don't change
    # any DOM state can't affect :has() matching, so we can skip scheduling :has() ancestor invalidation.
    match reason:
        .base_url_changed, .css_font_loaded, .htmli_frame_element_geometry_change, .html_object_element_update_layout_and_child_objects, .navigable_set_viewport_size, .settings_change:
            return false
        _:
            return true

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:33 Web::CSS::Invalidation::invalidate_children_affected_by_has_sibling_combinators.
func css_invalidation_invalidate_children_affected_by_has_sibling_combinators(parent: DomNode*):
    # parent.for_each_child_of_type<DOM::Element>(...)
    for child in dom_node_children(parent):
        let element = as_if_dom_element(child) else continue
        if dom_element_affected_by_has_pseudo_class_with_relative_selector_that_has_sibling_combinator(element):
            css_invalidation_invalidate_element_if_affected_by_has(element)

## pending_has_invalidation_covers_all_child_list_mutation_features' `contains_all_keys` lambda.
func css_invalidation_contains_all_keys(existing_features: const ak.HashTable[ak.FlyString, ak.FlyStringTraits]*, used_features: const ak.HashMap[ak.FlyString, ak.Vector[CssHasInvalidationMetadata], ak.FlyStringTraits]*) -> bool:
    for entry in ak.hash_map_begin_const(used_features):
        if not ak.hash_table_contains_t(existing_features, entry.key):
            return false
    return true

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:42 Web::CSS::Invalidation::pending_has_invalidation_covers_all_child_list_mutation_features.
func css_invalidation_pending_has_invalidation_covers_all_child_list_mutation_features(scope: CssStyleScope*, parent: DomNode*) -> bool:
    let mutation_features = ak.ordered_hash_map_get_k(&scope.m_pending_has_invalidations, parent) else return false

    if mutation_features.is_conservative:
        return true

    let rule_cache = scope.m_rule_cache else return false
    let data = &rule_cache.style_invalidation_data

    if not mutation_features.may_affect_sibling_relationships:
        return false

    if not css_invalidation_contains_all_keys(&mutation_features.tag_names, &data.tag_names_used_in_has_selectors):
        return false
    if not css_invalidation_contains_all_keys(&mutation_features.ids, &data.ids_used_in_has_selectors):
        return false
    if not css_invalidation_contains_all_keys(&mutation_features.class_names, &data.class_names_used_in_has_selectors):
        return false
    if not css_invalidation_contains_all_keys(&mutation_features.attribute_names, &data.attribute_names_used_in_has_selectors):
        return false
    if not ak.hash_map_is_empty(&data.pseudo_classes_used_in_has_selectors) and not mutation_features.may_affect_pseudo_classes:
        return false

    return true

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:81 Web::CSS::Invalidation::scope_has_featureless_sensitive_has_selectors.
func css_invalidation_scope_has_featureless_sensitive_has_selectors(scope: const CssStyleScope*) -> bool:
    let rule_cache = scope.m_rule_cache else return false
    return rule_cache.style_invalidation_data.has_selectors_sensitive_to_featureless_subtree_changes

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:87 Web::CSS::Invalidation::invalidate_element_if_affected_by_has.
pub func css_invalidation_invalidate_element_if_affected_by_has(element: DomElement*):
    if dom_element_affected_by_has_pseudo_class_in_subject_position(element):
        dom_node_set_needs_style_update(element.dom_node(), true)
    if dom_element_affected_by_has_pseudo_class_in_non_subject_position(element):
        var properties: ak.Vector[CssInvalidationSetProperty]
        ak.vector_append_t(&properties, CssInvalidationSetProperty(type_ = CssInvalidationSetPropertyType.pseudo_class, value = FlyStringOrPseudoClassOrEmpty.pseudo_class(css_data.PseudoClass.has)))
        dom_node_invalidate_style_vector(element.dom_node(), DomStyleInvalidationReason.other, properties, DomStyleInvalidationOptions())

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:95 Web::CSS::Invalidation::is_in_has_scope.
func css_invalidation_is_in_has_scope(element: DomElement*) -> bool:
    return dom_element_in_has_scope(element) or dom_element_affected_by_has_pseudo_class_in_subject_position(element) or dom_element_affected_by_has_pseudo_class_in_non_subject_position(element)

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:102 Web::CSS::Invalidation::is_in_subtree_of_has_relative_selector_with_sibling_combinator.
func css_invalidation_is_in_subtree_of_has_relative_selector_with_sibling_combinator(element: DomElement*) -> bool:
    return dom_element_in_subtree_of_has_pseudo_class_relative_selector_with_sibling_combinator(element) or dom_element_affected_by_has_pseudo_class_with_relative_selector_that_has_sibling_combinator(element)

# mark: The :has() feature filter ===============================================================

## selector_may_match_mutation_features' `visit_selector` lambda (recursive through `visit_selector_list`).
func css_invalidation_visit_selector_for_mutation_features(selector: const CssSelector*, mutation_features: const CssPendingHasInvalidationMutationFeatures*) -> bool:
    var saw_concrete_feature = false
    var concrete_feature_found_in_mutation_subtree = false
    var must_be_conservative = false

    for compound_selector in &ak.vector_span_const(&selector.m_compound_selectors):
        if (compound_selector.combinator == CssSelectorCombinator.next_sibling or compound_selector.combinator == CssSelectorCombinator.subsequent_sibling) and mutation_features.may_affect_sibling_relationships:
            must_be_conservative = true
        if ak.vector_is_empty(&compound_selector.simple_selectors):
            must_be_conservative = true
            continue
        for simple_selector in &ak.vector_span_const(&compound_selector.simple_selectors):
            match simple_selector.type_:
                .universal, .nesting, .invalid, .pseudo_element:
                    must_be_conservative = true
                .tag_name:
                    saw_concrete_feature = true
                    concrete_feature_found_in_mutation_subtree = concrete_feature_found_in_mutation_subtree or ak.hash_table_contains_t(&mutation_features.tag_names, css_selector_simple_selector_qualified_name(simple_selector).name.lowercase_name)
                .id:
                    saw_concrete_feature = true
                    concrete_feature_found_in_mutation_subtree = concrete_feature_found_in_mutation_subtree or ak.hash_table_contains_t(&mutation_features.ids, css_selector_simple_selector_name(simple_selector))
                .class_:
                    saw_concrete_feature = true
                    concrete_feature_found_in_mutation_subtree = concrete_feature_found_in_mutation_subtree or ak.hash_table_contains_t(&mutation_features.class_names, css_selector_simple_selector_name(simple_selector))
                .attribute:
                    saw_concrete_feature = true
                    concrete_feature_found_in_mutation_subtree = concrete_feature_found_in_mutation_subtree or ak.hash_table_contains_t(&mutation_features.attribute_names, css_selector_simple_selector_attribute(simple_selector).qualified_name.name.lowercase_name)
                .pseudo_class:
                    let pseudo_class = css_selector_simple_selector_pseudo_class(simple_selector)
                    match pseudo_class.type_:
                        .is, .where:
                            saw_concrete_feature = true
                            # visit_selector_list(pseudo_class.argument_selector_list)
                            var found_in_list = false
                            for argument_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                                if css_invalidation_visit_selector_for_mutation_features(argument_selector, mutation_features):
                                    found_in_list = true
                                    break
                            concrete_feature_found_in_mutation_subtree = concrete_feature_found_in_mutation_subtree or found_in_list
                        .enabled, .defined, .disabled, .empty, .placeholder_shown, .checked, .dir, .lang, .link, .any_link, .local_link, .required, .optional:
                            saw_concrete_feature = true
                            concrete_feature_found_in_mutation_subtree = concrete_feature_found_in_mutation_subtree or mutation_features.may_affect_pseudo_classes or ak.hash_table_contains_t(&mutation_features.pseudo_classes, pseudo_class.type_)
                        _:
                            # Hover, Focus, FocusVisible, FocusWithin, Active, Not, Has and the rest.
                            must_be_conservative = true
                _:
                    trap("VERIFY_NOT_REACHED")

    if must_be_conservative:
        return true
    return not saw_concrete_feature or concrete_feature_found_in_mutation_subtree

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:108 Web::CSS::Invalidation::selector_may_match_mutation_features.
func css_invalidation_selector_may_match_mutation_features(selector: const CssSelector*, mutation_features: const CssPendingHasInvalidationMutationFeatures*) -> bool:
    if mutation_features.is_conservative:
        return true
    return css_invalidation_visit_selector_for_mutation_features(selector, mutation_features)

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:208 Web::CSS::Invalidation::compound_may_match_anchor_ignoring_has.
func css_invalidation_compound_may_match_anchor_ignoring_has(compound_selector: const CssSelectorCompoundSelector*, anchor: DomElement*) -> bool:
    for simple_selector in &ak.vector_span_const(&compound_selector.simple_selectors):
        match simple_selector.type_:
            .universal:
                continue
            .nesting, .invalid, .pseudo_element:
                return true
            .tag_name:
                let local_name = dom_element_local_name(anchor)
                let name = css_selector_simple_selector_qualified_name(simple_selector).name.lowercase_name
                if not ak.fly_string_eq_fly_string(&local_name, &name):
                    return false
            .id:
                let id = dom_element_id(anchor) else return false
                let name = css_selector_simple_selector_name(simple_selector)
                if not ak.fly_string_eq_fly_string(&id, &name):
                    return false
            .class_:
                let class_names = dom_element_class_names(anchor)
                let name = css_selector_simple_selector_name(simple_selector)
                var contains = false
                for class_name in ak.vector_span_const(&class_names):
                    if ak.fly_string_eq_fly_string(&class_name, &name):
                        contains = true
                        break
                if not contains:
                    return false
            .attribute:
                let attribute_name = css_selector_simple_selector_attribute(simple_selector).qualified_name.name.lowercase_name
                var has_attribute = false
                # anchor.for_each_attribute([&](FlyString const& name, String const&) { ... })
                if let attributes = anchor.m_attributes:
                    for i in 0..<dom_named_node_map_length(attributes):
                        let attribute = dom_named_node_map_item(attributes, (u32)i) else trap("NamedNodeMap::item in range")
                        let name = dom_attr_name(attribute)
                        if ak.fly_string_eq_fly_string(&name, &attribute_name):
                            has_attribute = true
                if not has_attribute:
                    return false
            .pseudo_class:
                match css_selector_simple_selector_pseudo_class(simple_selector).type_:
                    .has:
                        continue
                    .root:
                        if dom_document_document_element(dom_node_document(anchor.dom_node())) != anchor:
                            return false
                    _:
                        return true
            _:
                trap("VERIFY_NOT_REACHED")
    return true

## The captures of has_rule_that_may_be_affected_by_mutation's lambdas.
struct CssInvalidationHasRuleCheck:
    var anchor: DomElement*
    var mutation_features: const CssPendingHasInvalidationMutationFeatures*
    var found_has_rule: bool
    var may_be_affected: bool

## has_rule_that_may_be_affected_by_mutation's `visit_selector` lambda (recursive).
func css_invalidation_has_rule_visit_selector(check: CssInvalidationHasRuleCheck*, selector: const CssSelector*):
    if check.may_be_affected:
        return
    for compound_selector in &ak.vector_span_const(&selector.m_compound_selectors):
        for simple_selector in &ak.vector_span_const(&compound_selector.simple_selectors):
            if simple_selector.type_ != CssSelectorSimpleSelectorType.pseudo_class:
                continue
            let pseudo_class = css_selector_simple_selector_pseudo_class(simple_selector)
            if pseudo_class.type_ == css_data.PseudoClass.has:
                if not css_invalidation_compound_may_match_anchor_ignoring_has(compound_selector, check.anchor):
                    continue
                check.found_has_rule = true
                for argument_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                    if css_invalidation_selector_may_match_mutation_features(argument_selector, check.mutation_features):
                        check.may_be_affected = true
                        return
            for argument_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                css_invalidation_has_rule_visit_selector(check, argument_selector)

## has_rule_that_may_be_affected_by_mutation's `check_rule_vector` lambda (with `check_selector` inlined).
func css_invalidation_has_rule_check_rule_vector(check: CssInvalidationHasRuleCheck*, rules: const ak.Vector[CssMatchingRule]*):
    for rule in &ak.vector_span_const(rules):
        css_invalidation_has_rule_visit_selector(check, rule.selector)
        if check.may_be_affected:
            return

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:259 Web::CSS::Invalidation::has_rule_that_may_be_affected_by_mutation.
func css_invalidation_has_rule_that_may_be_affected_by_mutation(style_scope: CssStyleScope*, anchor: DomElement*, mutation_features: const CssPendingHasInvalidationMutationFeatures*) -> bool:
    var check = CssInvalidationHasRuleCheck(anchor = anchor, mutation_features = mutation_features, found_has_rule = false, may_be_affected = false)

    let has_rule_cache = css_style_scope_get_pseudo_class_rule_cache(style_scope, css_data.PseudoClass.has)
    for entry in ak.hash_map_begin_const(&has_rule_cache.rules_by_id):
        css_invalidation_has_rule_check_rule_vector(&check, &entry.value)
    for entry in ak.hash_map_begin_const(&has_rule_cache.rules_by_class):
        css_invalidation_has_rule_check_rule_vector(&check, &entry.value)
    for entry in ak.hash_map_begin_const(&has_rule_cache.rules_by_tag_name):
        css_invalidation_has_rule_check_rule_vector(&check, &entry.value)
    for entry in ak.hash_map_begin_const(&has_rule_cache.rules_by_attribute_name):
        css_invalidation_has_rule_check_rule_vector(&check, &entry.value)
    for rules in &has_rule_cache.rules_by_pseudo_element:
        css_invalidation_has_rule_check_rule_vector(&check, rules)
    css_invalidation_has_rule_check_rule_vector(&check, &has_rule_cache.root_rules)
    css_invalidation_has_rule_check_rule_vector(&check, &has_rule_cache.slotted_rules)
    css_invalidation_has_rule_check_rule_vector(&check, &has_rule_cache.part_rules)
    css_invalidation_has_rule_check_rule_vector(&check, &has_rule_cache.other_rules)

    return not check.found_has_rule or check.may_be_affected

# mark: Invalidating elements affected by pending :has() mutations ==============================

## A copy of `features` with its own tables (the C++ copy constructor of PendingHasInvalidationMutationFeatures).
func css_invalidation_clone_pending_has_invalidation_mutation_features(features: const CssPendingHasInvalidationMutationFeatures*) -> CssPendingHasInvalidationMutationFeatures:
    return CssPendingHasInvalidationMutationFeatures(is_conservative = features.is_conservative, may_affect_sibling_relationships = features.may_affect_sibling_relationships, may_affect_pseudo_classes = features.may_affect_pseudo_classes, tag_names = ak.hash_table_clone(&features.tag_names), ids = ak.hash_table_clone(&features.ids), class_names = ak.hash_table_clone(&features.class_names), attribute_names = ak.hash_table_clone(&features.attribute_names), pseudo_classes = ak.hash_table_clone(&features.pseudo_classes))

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:319 Web::CSS::Invalidation::invalidate_style_of_elements_affected_by_pending_has_mutations.
func css_invalidation_invalidate_style_of_elements_affected_by_pending_has_mutations(style_scope: CssStyleScope*):
    if ak.ordered_hash_map_is_empty(&style_scope.m_pending_has_invalidations):
        return

    # ScopeGuard clear_pending_nodes_guard
    defer ak.ordered_hash_map_clear(&style_scope.m_pending_has_invalidations)

    # It's ok to call have_has_selectors() instead of may_have_has_selectors() here and force
    # rule cache build, because it's going to be built soon anyway, since we could get here
    # only from update_style().
    if not css_style_scope_have_has_selectors(style_scope):
        return

    let counters = dom_document_style_invalidation_counters(css_style_scope_document(style_scope))
    counters.has_ancestor_walk_invocations += 1

    var elements_already_invalidated_for_has: ak.HashTable[DomElement*, ak.PtrTraits[DomElement]]
    # auto pending_has_invalidations = style_scope.m_pending_has_invalidations; (a copy, in order)
    var pending_has_invalidations: ak.OrderedHashMap[DomNode*, CssPendingHasInvalidationMutationFeatures, ak.PtrTraits[DomNode]]
    for entry in ak.ordered_hash_map_begin(&style_scope.m_pending_has_invalidations):
        _ = ak.ordered_hash_map_set(&pending_has_invalidations, entry.key, css_invalidation_clone_pending_has_invalidation_mutation_features(&entry.value))
    let should_scan_ancestor_siblings = css_style_scope_have_has_selectors_with_relative_selector_that_has_sibling_combinator(style_scope)
    for entry in ak.ordered_hash_map_begin(&pending_has_invalidations):
        let node = entry.key
        let mutation_features = &entry.value
        var elements_skipped_by_has_feature_filter: ak.HashTable[DomElement*, ak.PtrTraits[DomElement]]
        var has_scope_ancestors: ak.Vector[DomElement*]
        var should_delay_ancestor_sibling_scans = false
        var ancestor: DomNode*? = node
        while let current = ancestor:
            ancestor = (DomNode*?)dom_node_parent_or_shadow_host(current)
            let element = as_if_dom_element(current) else continue

            # Terminate the upward walk once we reach an element that no :has()
            # anchor has ever observed. Its style cannot be affected by a mutation
            # further down the tree, so neither can anything above it.
            if not css_invalidation_is_in_has_scope(element):
                break

            ak.vector_append_t(&has_scope_ancestors, element)
            should_delay_ancestor_sibling_scans = should_delay_ancestor_sibling_scans or css_invalidation_is_in_subtree_of_has_relative_selector_with_sibling_combinator(element)

        for element in ak.vector_span(&has_scope_ancestors):
            if ak.hash_table_contains_t(&elements_already_invalidated_for_has, element):
                continue

            counters.has_ancestor_walk_visits += 1
            let can_skip_unchanged_has_fanout = not dom_node_is_shadow_root(tree_node_root(element.dom_node())) and dom_slottable_mixin_assigned_slot_internal(&element.slottable_mixin) == none and not dom_element_is_shadow_host(element)
            var should_invalidate_element = true
            if dom_element_affected_by_has_pseudo_class_in_non_subject_position(element) and can_skip_unchanged_has_fanout:
                should_invalidate_element = css_invalidation_has_rule_that_may_be_affected_by_mutation(style_scope, element, mutation_features)
            if should_invalidate_element:
                _ = ak.hash_table_set(&elements_already_invalidated_for_has, element)
                css_invalidation_invalidate_element_if_affected_by_has(element)
            else:
                _ = ak.hash_table_set(&elements_skipped_by_has_feature_filter, element)

            let parent = dom_node_parent_or_shadow_host(element.dom_node()) else return

            # If any ancestor's sibling was tested against selectors like ".a:has(+ .b)" or ".a:has(~ .b)"
            # its style might be affected by the change in descendant node.
            if not should_scan_ancestor_siblings:
                continue
            if should_delay_ancestor_sibling_scans and not css_invalidation_is_in_subtree_of_has_relative_selector_with_sibling_combinator(element):
                continue
            # parent->for_each_child_of_type<DOM::Element>(...)
            for child in dom_node_children(parent.dom_node()):
                let ancestor_sibling = as_if_dom_element(child) else continue
                counters.has_ancestor_sibling_element_checks += 1
                if dom_element_affected_by_has_pseudo_class_with_relative_selector_that_has_sibling_combinator(ancestor_sibling):
                    if ak.hash_table_contains_t(&elements_skipped_by_has_feature_filter, ancestor_sibling):
                        continue
                    if ak.hash_table_set(&elements_already_invalidated_for_has, ancestor_sibling) != ak.HashSetResult.inserted_new_entry:
                        continue

                    counters.has_ancestor_walk_visits += 1
                    css_invalidation_invalidate_element_if_affected_by_has(ancestor_sibling)

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:403 Web::CSS::Invalidation::invalidate_style_for_pending_has_mutations.
pub func css_invalidation_invalidate_style_for_pending_has_mutations(document: DomDocument*):
    css_invalidation_invalidate_style_of_elements_affected_by_pending_has_mutations(dom_document_style_scope(document))
    # document.for_each_shadow_root([&](auto& shadow_root) { ... })
    for shadow_root in ak.intrusive_list_begin(&document.m_shadow_roots):
        css_invalidation_invalidate_style_of_elements_affected_by_pending_has_mutations(dom_shadow_root_style_scope(shadow_root))

# mark: Scheduling ==============================================================================

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:411 Web::CSS::Invalidation::schedule_has_invalidation_for_child_list_mutation.
func css_invalidation_schedule_has_invalidation_for_child_list_mutation(parent: DomNode*, mutation_root: DomNode*, scope: CssStyleScope*):
    if not css_style_scope_may_have_has_selectors(scope):
        return

    let has_sibling_combinator_has_selectors = css_style_scope_may_have_has_selectors_with_relative_selector_that_has_sibling_combinator(scope)

    if css_invalidation_pending_has_invalidation_covers_all_child_list_mutation_features(scope, parent):
        return

    if css_invalidation_scope_has_featureless_sensitive_has_selectors(scope):
        css_style_scope_record_conservative_pending_has_invalidation(scope, parent, true)
        if has_sibling_combinator_has_selectors:
            css_invalidation_invalidate_children_affected_by_has_sibling_combinators(parent)
        return

    # Sibling-combinator :has() selectors are sensitive to featureless insertions/removals because a plain node can
    # still change adjacency and following-sibling relationships.
    let may_affect_has_match = dom_node_is_character_data(mutation_root) or css_invalidation_subtree_has_feature_used_in_has_selector(mutation_root, scope) or has_sibling_combinator_has_selectors
    if not may_affect_has_match:
        return

    css_style_scope_record_pending_has_invalidation_mutation_features_dom_node(scope, parent, mutation_root, true)
    css_style_scope_schedule_ancestors_style_invalidation_due_to_presence_of_has(scope, parent)

    if has_sibling_combinator_has_selectors:
        css_invalidation_invalidate_children_affected_by_has_sibling_combinators(parent)

## The captures of the for_each_style_scope_which_may_observe_the_node lambdas of schedule_has_invalidation_for_node
## and schedule_has_invalidation_for_same_parent_move.
struct CssInvalidationChildListMutation:
    var parent: DomNode*
    var node: DomNode*

## `[&](StyleScope& scope) { schedule_has_invalidation_for_child_list_mutation(*parent, node, scope); }`.
func css_invalidation_schedule_child_list_mutation_in_scope(context: void*?, scope: CssStyleScope*):
    let captures = (CssInvalidationChildListMutation*)(context else trap("no captures"))
    css_invalidation_schedule_has_invalidation_for_child_list_mutation(captures.parent, captures.node, scope)

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:443 Web::CSS::Invalidation::schedule_has_invalidation_for_node.
pub func css_invalidation_schedule_has_invalidation_for_node(node: DomNode*, reason: DomStyleInvalidationReason):
    let is_child_list_mutation = reason == DomStyleInvalidationReason.node_remove or reason == DomStyleInvalidationReason.node_insert_before

    # On insertion and removal the mutated node itself is uninteresting to the
    # :has() walker (a freshly inserted node has no :has() scope flags yet, and
    # a removed node is about to leave the tree). Start the walk at the parent,
    # which was in scope before and reliably carries the correct flags.
    if is_child_list_mutation:
        let parent = dom_node_parent_or_shadow_host(node) else return

        # Walk every scope that can observe the parent, including enclosing and hosted shadow roots, so :has() in
        # :host(), ::slotted(), and ::part() selectors can react to the mutation.
        var captures = CssInvalidationChildListMutation(parent = parent.dom_node(), node = node)
        dom_node_for_each_style_scope_which_may_observe_the_node(parent.dom_node(), ak.Function1[CssStyleScope*, unit](call = css_invalidation_schedule_child_list_mutation_in_scope, context = &captures))
        return

    let style_scope = dom_node_style_scope(node)
    if not css_style_scope_may_have_has_selectors(style_scope) or not css_invalidation_reason_may_affect_has_selectors(reason):
        return
    css_style_scope_record_pending_has_invalidation_mutation_features_dom_node(style_scope, node, node, false)
    css_style_scope_schedule_ancestors_style_invalidation_due_to_presence_of_has(style_scope, node)

## Ported from Libraries/LibWeb/CSS/Invalidation/HasMutationInvalidator.cpp:472 Web::CSS::Invalidation::schedule_has_invalidation_for_same_parent_move.
pub func css_invalidation_schedule_has_invalidation_for_same_parent_move(node: DomNode*):
    let parent = dom_node_parent_or_shadow_host(node) else return

    var captures = CssInvalidationChildListMutation(parent = parent.dom_node(), node = node)
    dom_node_for_each_style_scope_which_may_observe_the_node(parent.dom_node(), ak.Function1[CssStyleScope*, unit](call = css_invalidation_schedule_child_list_mutation_in_scope, context = &captures))