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))