LadybirdBrowser · awesomekling · Jul 17, 2026 · Jul 16, 2026 · Jul 16, 2026 · Jul 16, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Libraries/LibWeb/CMakeLists.txt b/Libraries/LibWeb/CMakeLists.txt
@@ -238,7 +238,8 @@ set(SOURCES
     CSS/Screen.cpp
     CSS/ScreenOrientation.cpp
     CSS/Selector.cpp
-    CSS/SelectorEngine.cpp
+    CSS/SelectorRustBridge.cpp
+    CSS/SelectorMatching.cpp
     CSS/Serialize.cpp
     CSS/Size.cpp
     CSS/Sizing.cpp
@@ -1304,7 +1305,11 @@ foreach(angle_target IN LISTS ANGLE_TARGETS)
     target_compile_options(LibWeb PRIVATE $<TARGET_PROPERTY:${angle_target},INTERFACE_COMPILE_OPTIONS>)
 endforeach()
 
-import_rust_crate(MANIFEST_PATH Rust/Cargo.toml CRATE_NAME libweb_rust FFI_HEADER RustFFI.h)
+import_rust_crate(
+    MANIFEST_PATH Rust/Cargo.toml
+    CRATE_NAME libweb_rust
+    FFI_HEADERS RustFFI.h SelectorRustFFI.h HTML/Parser/RustFFI.h
+)
 
 set(content_blocker_rust_features "")
 if (NOT BUILD_SHARED_LIBS)

diff --git a/Libraries/LibWeb/CSS/Selector.cpp b/Libraries/LibWeb/CSS/Selector.cpp
@@ -11,7 +11,9 @@
 #include <LibWeb/CSS/AncestorFilter.h>
 #include <LibWeb/CSS/CSSStyleRule.h>
 #include <LibWeb/CSS/Parser/ErrorReporter.h>
+#include <LibWeb/CSS/SelectorRustBridge.h>
 #include <LibWeb/CSS/Serialize.h>
+#include <LibWeb/SelectorRustFFI.h>
 
 namespace Web::CSS {
 
@@ -29,60 +31,10 @@ static bool component_value_contains_nesting_selector(Parser::ComponentValue con
     return false;
 }
 
-static bool can_selector_use_fast_matches(Selector const& selector)
-{
-    for (auto const& compound_selector : selector.compound_selectors()) {
-        if (!first_is_one_of(compound_selector.combinator,
-                Selector::Combinator::None, Selector::Combinator::Descendant, Selector::Combinator::ImmediateChild)) {
-            return false;
-        }
-
-        for (auto const& simple_selector : compound_selector.simple_selectors) {
-            if (simple_selector.type == Selector::SimpleSelector::Type::PseudoClass) {
-                auto const pseudo_class = simple_selector.pseudo_class().type;
-                if (!first_is_one_of(pseudo_class,
-                        PseudoClass::Active,
-                        PseudoClass::AnyLink,
-                        PseudoClass::Autofill,
-                        PseudoClass::Checked,
-                        PseudoClass::Disabled,
-                        PseudoClass::Empty,
-                        PseudoClass::Enabled,
-                        PseudoClass::FirstChild,
-                        PseudoClass::Focus,
-                        PseudoClass::FocusVisible,
-                        PseudoClass::FocusWithin,
-                        PseudoClass::Hover,
-                        PseudoClass::LastChild,
-                        PseudoClass::Link,
-                        PseudoClass::LocalLink,
-                        PseudoClass::OnlyChild,
-                        PseudoClass::Root,
-                        PseudoClass::State,
-                        PseudoClass::Unchecked,
-                        PseudoClass::Visited))
-                    return false;
-            } else if (!first_is_one_of(simple_selector.type,
-                           Selector::SimpleSelector::Type::TagName,
-                           Selector::SimpleSelector::Type::Universal,
-                           Selector::SimpleSelector::Type::Class,
-                           Selector::SimpleSelector::Type::Id,
-                           Selector::SimpleSelector::Type::Attribute)) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
 Selector::Selector(Vector<CompoundSelector>&& compound_selectors)
     : m_compound_selectors(move(compound_selectors))
 {
     for (auto const& compound_selector : m_compound_selectors) {
-        if (compound_selector.combinator == Combinator::PseudoElement)
-            m_contains_pseudo_element_transition = true;
-
         for (auto const& simple_selector : compound_selector.simple_selectors) {
             if (simple_selector.type != SimpleSelector::Type::PseudoElement)
                 continue;
@@ -94,16 +46,6 @@ Selector::Selector(Vector<CompoundSelector>&& compound_selectors)
         }
     }
 
-    if (!m_compound_selectors.is_empty()) {
-        auto const& rightmost_compound = m_compound_selectors.last();
-        if (!rightmost_compound.simple_selectors.is_empty()
-            && rightmost_compound.simple_selectors.first().type == SimpleSelector::Type::PseudoElement) {
-            auto pseudo_element = rightmost_compound.simple_selectors.first().pseudo_element().type();
-            if (!first_is_one_of(pseudo_element, PseudoElement::Slotted, PseudoElement::Part))
-                m_target_pseudo_element = pseudo_element;
-        }
-    }
-
     // https://drafts.csswg.org/css-nesting-1/#contain-the-nesting-selector
     // "A selector is said to contain the nesting selector if, when it was parsed as any type of selector,
     // a <delim-token> with the value "&" (U+0026 AMPERSAND) was encountered."
@@ -142,7 +84,14 @@ Selector::Selector(Vector<CompoundSelector>&& compound_selectors)
 
     collect_ancestor_hashes();
 
-    m_can_use_fast_matches = can_selector_use_fast_matches(*this);
+    m_rust_selector = compile_selector_for_matching(*this);
+    VERIFY(m_rust_selector);
+    m_target_pseudo_element = pseudo_element_from_ffi(SelectorFFI::rust_selector_target_pseudo_element(m_rust_selector));
+}
+
+Selector::~Selector()
+{
+    SelectorFFI::rust_selector_destroy(m_rust_selector);
 }
 
 static void append_integer(Utf16StringBuilder& builder, i64 value)
@@ -1098,36 +1047,6 @@ Optional<Selector::SimpleSelector> Selector::SimpleSelector::absolutized(Selecto
     VERIFY_NOT_REACHED();
 }
 
-size_t Selector::sibling_invalidation_distance() const
-{
-    if (m_sibling_invalidation_distance.has_value())
-        return *m_sibling_invalidation_distance;
-
-    m_sibling_invalidation_distance = 0;
-    size_t current_distance = 0;
-    for (auto const& compound_selector : compound_selectors()) {
-        if (compound_selector.combinator == Combinator::None || compound_selector.combinator == Combinator::PseudoElement)
-            continue;
-
-        if (compound_selector.combinator == Combinator::SubsequentSibling) {
-            m_sibling_invalidation_distance = NumericLimits<size_t>::max();
-            return *m_sibling_invalidation_distance;
-        }
-
-        if (compound_selector.combinator == Combinator::NextSibling) {
-            current_distance++;
-        } else {
-            m_sibling_invalidation_distance = max(*m_sibling_invalidation_distance, current_distance);
-            current_distance = 0;
-        }
-    }
-
-    if (current_distance > 0) {
-        m_sibling_invalidation_distance = max(*m_sibling_invalidation_distance, current_distance);
-    }
-    return *m_sibling_invalidation_distance;
-}
-
 SelectorList adapt_nested_relative_selector_list(SelectorList const& selectors, StyleNestingParent style_nesting_parent)
 {
     // "Nested style rules differ from non-nested rules in the following ways:
@@ -1243,47 +1162,6 @@ SelectorList absolutize_selectors_relative_to(SelectorList const& selectors, GC:
     return absolutized_selectors;
 }
 
-// https://drafts.csswg.org/css-syntax-3/#anb-microsyntax
-bool Selector::SimpleSelector::ANPlusBPattern::matches(int index) const
-{
-    // "If both a and b are equal to zero, the pseudo-class represents no element in the document tree."
-    if (step_size == 0 && offset == 0)
-        return false;
-
-    // When "step_size == -1", selector represents first "offset" elements in document tree.
-    if (step_size == -1)
-        return !(offset <= 0 || index > offset);
-
-    // When "step_size == 1", selector represents last "offset" elements in document tree.
-    if (step_size == 1)
-        return !(offset < 0 || index < offset);
-
-    // When "step_size == 0", selector picks only the "offset" element.
-    if (step_size == 0)
-        return index == offset;
-
-    // If both are negative, nothing can match.
-    if (step_size < 0 && offset < 0)
-        return false;
-
-    // Like "a % b", but handles negative integers correctly. Done in 64 bits because "index - offset" and "-step_size"
-    // overflow a 32-bit int for an extreme An+B value such as :nth-child(2n-2147483648).
-    auto const canonical_modulo = [](i64 a, i64 b) -> i64 {
-        i64 c = a % b;
-        if ((c < 0 && b > 0) || (c > 0 && b < 0)) {
-            c += b;
-        }
-        return c;
-    };
-
-    // When "step_size < 0", we start at "offset" and count backwards.
-    if (step_size < 0)
-        return index <= offset && canonical_modulo(static_cast<i64>(index) - offset, -static_cast<i64>(step_size)) == 0;
-
-    // Otherwise, we start at "offset" and count forwards.
-    return index >= offset && canonical_modulo(static_cast<i64>(index) - offset, step_size) == 0;
-}
-
 // https://drafts.csswg.org/css-syntax-3/#serializing-anb
 Utf16String Selector::SimpleSelector::ANPlusBPattern::serialize() const
 {

diff --git a/Libraries/LibWeb/CSS/Selector.h b/Libraries/LibWeb/CSS/Selector.h
@@ -23,6 +23,12 @@
 
 namespace Web::CSS {
 
+namespace SelectorFFI {
+
+struct RustSelector;
+
+}
+
 using SelectorList = Vector<NonnullRefPtr<class Selector>>;
 
 // This is a <complex-selector> in the spec. https://www.w3.org/TR/selectors-4/#complex
@@ -94,7 +100,6 @@ class Selector : public RefCounted<Selector> {
             int step_size { 0 }; // "A"
             int offset = { 0 };  // "B"
 
-            bool matches(int index) const;
             Utf16String serialize() const;
             void serialize_to(Utf16StringBuilder&) const;
         };
@@ -243,11 +248,10 @@ class Selector : public RefCounted<Selector> {
         return adopt_ref(*new Selector(move(compound_selectors)));
     }
 
-    ~Selector() = default;
+    ~Selector();
 
     Vector<CompoundSelector> const& compound_selectors() const { return m_compound_selectors; }
     Optional<PseudoElement> target_pseudo_element() const { return m_target_pseudo_element; }
-    bool contains_pseudo_element_transition() const { return m_contains_pseudo_element_transition; }
     NonnullRefPtr<Selector> relative_to(SimpleSelector const&) const;
     bool contains_the_nesting_selector() const { return m_contains_the_nesting_selector; }
     bool contains_pseudo_class(PseudoClass pseudo_class) const { return m_contained_pseudo_classes.get(pseudo_class); }
@@ -259,25 +263,25 @@ class Selector : public RefCounted<Selector> {
 
     auto const& ancestor_hashes() const { return m_ancestor_hashes; }
 
-    bool can_use_fast_matches() const { return m_can_use_fast_matches; }
     bool can_use_ancestor_filter() const { return m_can_use_ancestor_filter; }
 
-    size_t sibling_invalidation_distance() const;
-
     bool is_slotted() const { return m_contains_slotted_pseudo_element; }
     bool has_part_pseudo_element() const { return m_contains_part_pseudo_element; }
 
+    SelectorFFI::RustSelector const& rust_selector() const
+    {
+        VERIFY(m_rust_selector);
+        return *m_rust_selector;
+    }
+
 private:
     explicit Selector(Vector<CompoundSelector>&&);
 
     Vector<CompoundSelector> m_compound_selectors;
     mutable Optional<u32> m_specificity;
     Optional<PseudoElement> m_target_pseudo_element;
-    mutable Optional<size_t> m_sibling_invalidation_distance;
-    bool m_can_use_fast_matches { false };
     bool m_can_use_ancestor_filter { false };
     bool m_contains_the_nesting_selector { false };
-    bool m_contains_pseudo_element_transition { false };
     bool m_contains_slotted_pseudo_element { false };
     bool m_contains_part_pseudo_element { false };
 
@@ -286,6 +290,7 @@ class Selector : public RefCounted<Selector> {
     void collect_ancestor_hashes();
 
     Array<u32, 8> m_ancestor_hashes;
+    SelectorFFI::RustSelector* m_rust_selector { nullptr };
 };
 
 bool is_legacy_single_colon_pseudo_element(PseudoElement);