diff --git a/Documentation/CSSGeneratedFiles.md b/Documentation/CSSGeneratedFiles.md
index 2d43ce20564..f6cfa808ab3 100644
--- a/Documentation/CSSGeneratedFiles.md
+++ b/Documentation/CSSGeneratedFiles.md
@@ -25,7 +25,7 @@ Each property will have some set of these fields on it:
 | `affects-stacking-context` | No       | `false` | Boolean. Whether this property can cause a new stacking context for the element.                                                          | `bool property_affects_stacking_context(PropertyID)`                        |
 | `animation-type`           | Yes      |         | String. How the property should be animated. Defined by the spec. See below.                                                              | `AnimationType animation_type_from_longhand_property(PropertyID)`           |
 | `inherited`                | Yes      |         | Boolean. Whether the property is inherited by its child elements.                                                                         | `bool is_inherited_property(PropertyID)`                                    |
-| `initial`                  | Yes      |         | String. The property's initial value if it is not specified.                                                                              | `NonnullRefPtr<CSSStyleValue> property_initial_value(PropertyID)`           |
+| `initial`                  | Yes      |         | String. The property's initial value if it is not specified.                                                                              | `NonnullRefPtr<CSSStyleValue const> property_initial_value(PropertyID)`           |
 | `legacy-alias-for`         | No       | Nothing | String. The name of a property this is an alias for. See below.                                                                           |                                                                             |
 | `logical-alias-for`        | No       | Nothing | Array of strings. The name of a property this is an alias for. See below.                                                                 |                                                                             |
 | `longhands`                | No       | `[]`    | Array of strings. If this is a shorthand, these are the property names that it expands out into.                                          | `Vector<PropertyID> longhands_for_shorthand(PropertyID)`                    |
@@ -89,7 +89,7 @@ The generated code provides:
   it exists in that at-rule.
 - `FlyString to_string(DescriptorID)` for serializing descriptor names.
 - `bool at_rule_supports_descriptor(AtRuleID, DescriptorID)` to query if the given at-rule allows the descriptor.
-- `RefPtr<CSSStyleValue> descriptor_initial_value(AtRuleID, DescriptorID)` for getting a descriptor's initial value.
+- `RefPtr<CSSStyleValue const> descriptor_initial_value(AtRuleID, DescriptorID)` for getting a descriptor's initial value.
 - `DescriptorMetadata get_descriptor_metadata(AtRuleID, DescriptorID)` returns data used for parsing the descriptor.
 
 ### At-rule fields
diff --git a/Libraries/LibWeb/CSS/Angle.cpp b/Libraries/LibWeb/CSS/Angle.cpp
index 44fa016ba03..68eb0023201 100644
--- a/Libraries/LibWeb/CSS/Angle.cpp
+++ b/Libraries/LibWeb/CSS/Angle.cpp
@@ -84,7 +84,7 @@ Optional<Angle::Type> Angle::unit_from_name(StringView name)
     return {};
 }
 
-Angle Angle::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Angle const& reference_value)
+Angle Angle::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Angle const& reference_value)
 {
     return calculated->resolve_angle(
                          {
diff --git a/Libraries/LibWeb/CSS/Angle.h b/Libraries/LibWeb/CSS/Angle.h
index 533de18f08e..5972b2d6935 100644
--- a/Libraries/LibWeb/CSS/Angle.h
+++ b/Libraries/LibWeb/CSS/Angle.h
@@ -52,7 +52,7 @@ public:
         return 0;
     }
 
-    static Angle resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Angle const& reference_value);
+    static Angle resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, Layout::Node const&, Angle const& reference_value);
 
 private:
     Type m_type;
diff --git a/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp
index 3e9ec1982bc..55df18b5f55 100644
--- a/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp
+++ b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp
@@ -100,7 +100,7 @@ WebIDL::ExceptionOr<void> CSSFontFaceDescriptors::set_property(StringView proper
         return {};
 
     // 5. Let component value list be the result of parsing value for property property.
-    RefPtr<CSSStyleValue> component_value_list = parse_css_descriptor(Parser::ParsingParams {}, AtRuleID::FontFace, *descriptor_id, value);
+    RefPtr<CSSStyleValue const> component_value_list = parse_css_descriptor(Parser::ParsingParams {}, AtRuleID::FontFace, *descriptor_id, value);
 
     // 6. If component value list is null, then return.
     if (!component_value_list)
diff --git a/Libraries/LibWeb/CSS/CSSPropertyRule.cpp b/Libraries/LibWeb/CSS/CSSPropertyRule.cpp
index e6443cb0c79..47b12afffa9 100644
--- a/Libraries/LibWeb/CSS/CSSPropertyRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSPropertyRule.cpp
@@ -13,12 +13,12 @@ namespace Web::CSS {
 
 GC_DEFINE_ALLOCATOR(CSSPropertyRule);
 
-GC::Ref<CSSPropertyRule> CSSPropertyRule::create(JS::Realm& realm, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue> initial_value)
+GC::Ref<CSSPropertyRule> CSSPropertyRule::create(JS::Realm& realm, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue const> initial_value)
 {
     return realm.create<CSSPropertyRule>(realm, move(name), move(syntax), inherits, move(initial_value));
 }
 
-CSSPropertyRule::CSSPropertyRule(JS::Realm& realm, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue> initial_value)
+CSSPropertyRule::CSSPropertyRule(JS::Realm& realm, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue const> initial_value)
     : CSSRule(realm, Type::Property)
     , m_name(move(name))
     , m_syntax(move(syntax))
diff --git a/Libraries/LibWeb/CSS/CSSPropertyRule.h b/Libraries/LibWeb/CSS/CSSPropertyRule.h
index 159361fc92a..49745ea0aed 100644
--- a/Libraries/LibWeb/CSS/CSSPropertyRule.h
+++ b/Libraries/LibWeb/CSS/CSSPropertyRule.h
@@ -21,7 +21,7 @@ class CSSPropertyRule final : public CSSRule {
     GC_DECLARE_ALLOCATOR(CSSPropertyRule);
 
 public:
-    static GC::Ref<CSSPropertyRule> create(JS::Realm&, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue> initial_value);
+    static GC::Ref<CSSPropertyRule> create(JS::Realm&, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue const> initial_value);
 
     virtual ~CSSPropertyRule() = default;
 
@@ -31,7 +31,7 @@ public:
     Optional<String> initial_value() const;
 
 private:
-    CSSPropertyRule(JS::Realm&, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue> initial_value);
+    CSSPropertyRule(JS::Realm&, FlyString name, FlyString syntax, bool inherits, RefPtr<CSSStyleValue const> initial_value);
 
     virtual void initialize(JS::Realm&) override;
     virtual String serialized() const override;
@@ -39,7 +39,7 @@ private:
     FlyString m_name;
     FlyString m_syntax;
     bool m_inherits;
-    RefPtr<CSSStyleValue> m_initial_value;
+    RefPtr<CSSStyleValue const> m_initial_value;
 };
 
 template<>
diff --git a/Libraries/LibWeb/CSS/CSSStyleProperties.cpp b/Libraries/LibWeb/CSS/CSSStyleProperties.cpp
index 3af27b22b93..eaab16c50b4 100644
--- a/Libraries/LibWeb/CSS/CSSStyleProperties.cpp
+++ b/Libraries/LibWeb/CSS/CSSStyleProperties.cpp
@@ -428,10 +428,10 @@ static Optional<StyleProperty> style_property_for_sided_shorthand(PropertyID pro
     if (top->important != right->important || top->important != bottom->important || top->important != left->important)
         return {};
 
-    ValueComparingNonnullRefPtr<CSSStyleValue> const top_value { top->value };
-    ValueComparingNonnullRefPtr<CSSStyleValue> const right_value { right->value };
-    ValueComparingNonnullRefPtr<CSSStyleValue> const bottom_value { bottom->value };
-    ValueComparingNonnullRefPtr<CSSStyleValue> const left_value { left->value };
+    ValueComparingNonnullRefPtr<CSSStyleValue const> const top_value { top->value };
+    ValueComparingNonnullRefPtr<CSSStyleValue const> const right_value { right->value };
+    ValueComparingNonnullRefPtr<CSSStyleValue const> const bottom_value { bottom->value };
+    ValueComparingNonnullRefPtr<CSSStyleValue const> const left_value { left->value };
 
     bool const top_and_bottom_same = top_value == bottom_value;
     bool const left_and_right_same = left_value == right_value;
diff --git a/Libraries/LibWeb/CSS/CalculatedOr.cpp b/Libraries/LibWeb/CSS/CalculatedOr.cpp
index 470d5996df7..ec21a2bb467 100644
--- a/Libraries/LibWeb/CSS/CalculatedOr.cpp
+++ b/Libraries/LibWeb/CSS/CalculatedOr.cpp
@@ -17,92 +17,92 @@
 
 namespace Web::CSS {
 
-Optional<Angle> AngleOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Angle> AngleOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_angle(context);
 }
 
-NonnullRefPtr<CSSStyleValue> AngleOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> AngleOrCalculated::create_style_value() const
 {
     return AngleStyleValue::create(value());
 }
 
-Optional<Flex> FlexOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Flex> FlexOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_flex(context);
 }
 
-NonnullRefPtr<CSSStyleValue> FlexOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> FlexOrCalculated::create_style_value() const
 {
     return FlexStyleValue::create(value());
 }
 
-Optional<Frequency> FrequencyOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Frequency> FrequencyOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_frequency(context);
 }
 
-NonnullRefPtr<CSSStyleValue> FrequencyOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> FrequencyOrCalculated::create_style_value() const
 {
     return FrequencyStyleValue::create(value());
 }
 
-Optional<i64> IntegerOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<i64> IntegerOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_integer(context);
 }
 
-NonnullRefPtr<CSSStyleValue> IntegerOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> IntegerOrCalculated::create_style_value() const
 {
     return IntegerStyleValue::create(value());
 }
 
-Optional<Length> LengthOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Length> LengthOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_length(context);
 }
 
-NonnullRefPtr<CSSStyleValue> LengthOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> LengthOrCalculated::create_style_value() const
 {
     return LengthStyleValue::create(value());
 }
 
-Optional<double> NumberOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<double> NumberOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_number(context);
 }
 
-NonnullRefPtr<CSSStyleValue> NumberOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> NumberOrCalculated::create_style_value() const
 {
     return NumberStyleValue::create(value());
 }
 
-Optional<Percentage> PercentageOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Percentage> PercentageOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_percentage(context);
 }
 
-NonnullRefPtr<CSSStyleValue> PercentageOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> PercentageOrCalculated::create_style_value() const
 {
     return PercentageStyleValue::create(value());
 }
 
-Optional<Resolution> ResolutionOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Resolution> ResolutionOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_resolution(context);
 }
 
-NonnullRefPtr<CSSStyleValue> ResolutionOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> ResolutionOrCalculated::create_style_value() const
 {
     return ResolutionStyleValue::create(value());
 }
 
-Optional<Time> TimeOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+Optional<Time> TimeOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
     return calculated->resolve_time(context);
 }
 
-NonnullRefPtr<CSSStyleValue> TimeOrCalculated::create_style_value() const
+NonnullRefPtr<CSSStyleValue const> TimeOrCalculated::create_style_value() const
 {
     return TimeStyleValue::create(value());
 }
diff --git a/Libraries/LibWeb/CSS/CalculatedOr.h b/Libraries/LibWeb/CSS/CalculatedOr.h
index 1d2f340e8d4..c9872dda092 100644
--- a/Libraries/LibWeb/CSS/CalculatedOr.h
+++ b/Libraries/LibWeb/CSS/CalculatedOr.h
@@ -26,12 +26,12 @@ public:
     {
     }
 
-    CalculatedOr(NonnullRefPtr<CalculatedStyleValue> calculated)
+    CalculatedOr(NonnullRefPtr<CalculatedStyleValue const> calculated)
         : m_value(move(calculated))
     {
     }
 
-    bool is_calculated() const { return m_value.template has<NonnullRefPtr<CalculatedStyleValue>>(); }
+    bool is_calculated() const { return m_value.template has<NonnullRefPtr<CalculatedStyleValue const>>(); }
 
     T const& value() const
     {
@@ -39,17 +39,17 @@ public:
         return m_value.template get<T>();
     }
 
-    NonnullRefPtr<CSSStyleValue> as_style_value() const
+    NonnullRefPtr<CSSStyleValue const> as_style_value() const
     {
         if (is_calculated())
             return calculated();
         return create_style_value();
     }
 
-    NonnullRefPtr<CalculatedStyleValue> const& calculated() const
+    NonnullRefPtr<CalculatedStyleValue const> const& calculated() const
     {
         VERIFY(is_calculated());
-        return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>();
+        return m_value.template get<NonnullRefPtr<CalculatedStyleValue const>>();
     }
 
     Optional<T> resolved(CalculationResolutionContext const& context) const
@@ -58,7 +58,7 @@ public:
             [&](T const& t) -> Optional<T> {
                 return t;
             },
-            [&](NonnullRefPtr<CalculatedStyleValue> const& calculated) {
+            [&](NonnullRefPtr<CalculatedStyleValue const> const& calculated) {
                 return resolve_calculated(calculated, context);
             });
     }
@@ -73,7 +73,7 @@ public:
                     return t.to_string();
                 }
             },
-            [](NonnullRefPtr<CalculatedStyleValue> const& calculated) {
+            [](NonnullRefPtr<CalculatedStyleValue const> const& calculated) {
                 return calculated->to_string(CSSStyleValue::SerializationMode::Normal);
             });
     }
@@ -86,89 +86,89 @@ public:
     }
 
 protected:
-    Optional<T> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, CalculationResolutionContext const& context) const
+    Optional<T> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
     {
         return static_cast<Self const*>(this)->resolve_calculated(calculated, context);
     }
-    NonnullRefPtr<CSSStyleValue> create_style_value() const
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const
     {
         return static_cast<Self const*>(this)->create_style_value();
     }
 
 private:
-    Variant<T, NonnullRefPtr<CalculatedStyleValue>> m_value;
+    Variant<T, NonnullRefPtr<CalculatedStyleValue const>> m_value;
 };
 
 class AngleOrCalculated : public CalculatedOr<AngleOrCalculated, Angle> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Angle> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Angle> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class FlexOrCalculated : public CalculatedOr<FlexOrCalculated, Flex> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Flex> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Flex> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class FrequencyOrCalculated : public CalculatedOr<FrequencyOrCalculated, Frequency> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Frequency> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Frequency> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class IntegerOrCalculated : public CalculatedOr<IntegerOrCalculated, i64> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<i64> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<i64> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class LengthOrCalculated : public CalculatedOr<LengthOrCalculated, Length> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Length> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Length> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class NumberOrCalculated : public CalculatedOr<NumberOrCalculated, double> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<double> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<double> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class PercentageOrCalculated : public CalculatedOr<PercentageOrCalculated, Percentage> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Percentage> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Percentage> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class ResolutionOrCalculated : public CalculatedOr<ResolutionOrCalculated, Resolution> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Resolution> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Resolution> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 class TimeOrCalculated : public CalculatedOr<TimeOrCalculated, Time> {
 public:
     using CalculatedOr::CalculatedOr;
 
-    Optional<Time> resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, CalculationResolutionContext const&) const;
-    NonnullRefPtr<CSSStyleValue> create_style_value() const;
+    Optional<Time> resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, CalculationResolutionContext const&) const;
+    NonnullRefPtr<CSSStyleValue const> create_style_value() const;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/ComputedValues.h b/Libraries/LibWeb/CSS/ComputedValues.h
index 115fabef478..d5e5fa0ca6f 100644
--- a/Libraries/LibWeb/CSS/ComputedValues.h
+++ b/Libraries/LibWeb/CSS/ComputedValues.h
@@ -80,7 +80,7 @@ struct Containment {
     bool is_empty() const { return !(size_containment || inline_size_containment || layout_containment || style_containment || paint_containment); }
 };
 
-using CursorData = Variant<NonnullRefPtr<CursorStyleValue>, Cursor>;
+using CursorData = Variant<NonnullRefPtr<CursorStyleValue const>, Cursor>;
 
 using ListStyleType = Variant<CounterStyleNameKeyword, String>;
 
@@ -720,7 +720,7 @@ protected:
         Optional<MaskReference> mask;
         CSS::MaskType mask_type { InitialValues::mask_type() };
         Optional<ClipPathReference> clip_path;
-        RefPtr<CSS::AbstractImageStyleValue> mask_image;
+        RefPtr<CSS::AbstractImageStyleValue const> mask_image;
 
         LengthPercentage cx { InitialValues::cx() };
         LengthPercentage cy { InitialValues::cy() };
diff --git a/Libraries/LibWeb/CSS/FontFace.cpp b/Libraries/LibWeb/CSS/FontFace.cpp
index 86d186ea819..4ad0188b709 100644
--- a/Libraries/LibWeb/CSS/FontFace.cpp
+++ b/Libraries/LibWeb/CSS/FontFace.cpp
@@ -96,7 +96,7 @@ GC::Ref<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, Font
     font_face->m_ascent_override = try_parse_descriptor(DescriptorID::AscentOverride, descriptors.ascent_override);
     font_face->m_descent_override = try_parse_descriptor(DescriptorID::DescentOverride, descriptors.descent_override);
     font_face->m_line_gap_override = try_parse_descriptor(DescriptorID::LineGapOverride, descriptors.line_gap_override);
-    RefPtr<CSSStyleValue> parsed_source;
+    RefPtr<CSSStyleValue const> parsed_source;
     if (auto* source_string = source.get_pointer<String>()) {
         parsed_source = parse_css_descriptor(parsing_params, AtRuleID::FontFace, DescriptorID::Src, *source_string);
         if (!parsed_source) {
diff --git a/Libraries/LibWeb/CSS/Frequency.cpp b/Libraries/LibWeb/CSS/Frequency.cpp
index cb295c70732..6996a6d3317 100644
--- a/Libraries/LibWeb/CSS/Frequency.cpp
+++ b/Libraries/LibWeb/CSS/Frequency.cpp
@@ -63,7 +63,7 @@ Optional<Frequency::Type> Frequency::unit_from_name(StringView name)
     return {};
 }
 
-Frequency Frequency::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Frequency const& reference_value)
+Frequency Frequency::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Frequency const& reference_value)
 {
     return calculated->resolve_frequency(
                          {
diff --git a/Libraries/LibWeb/CSS/Frequency.h b/Libraries/LibWeb/CSS/Frequency.h
index d8bdcec61d6..95b6cadefec 100644
--- a/Libraries/LibWeb/CSS/Frequency.h
+++ b/Libraries/LibWeb/CSS/Frequency.h
@@ -47,7 +47,7 @@ public:
         return 0;
     }
 
-    static Frequency resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Frequency const& reference_value);
+    static Frequency resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, Layout::Node const&, Frequency const& reference_value);
 
 private:
     Type m_type;
diff --git a/Libraries/LibWeb/CSS/Interpolation.cpp b/Libraries/LibWeb/CSS/Interpolation.cpp
index c87cb4f3853..042e0461b90 100644
--- a/Libraries/LibWeb/CSS/Interpolation.cpp
+++ b/Libraries/LibWeb/CSS/Interpolation.cpp
@@ -508,7 +508,7 @@ NonnullRefPtr<CSSStyleValue const> interpolate_value(DOM::Element& element, Calc
 
         struct NumericBaseTypeAndDefault {
             CSSNumericType::BaseType base_type;
-            ValueComparingNonnullRefPtr<CSSStyleValue> default_value;
+            ValueComparingNonnullRefPtr<CSSStyleValue const> default_value;
         };
         static constexpr auto numeric_base_type_and_default = [](CSSStyleValue const& value) -> Optional<NumericBaseTypeAndDefault> {
             switch (value.type()) {
diff --git a/Libraries/LibWeb/CSS/Length.cpp b/Libraries/LibWeb/CSS/Length.cpp
index 088ee1d130c..e5de0cff40a 100644
--- a/Libraries/LibWeb/CSS/Length.cpp
+++ b/Libraries/LibWeb/CSS/Length.cpp
@@ -410,7 +410,7 @@ Length Length::absolutized(CSSPixelRect const& viewport_rect, FontMetrics const&
     return absolutize(viewport_rect, font_metrics, root_font_metrics).value_or(*this);
 }
 
-Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Length const& reference_value)
+Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Length const& reference_value)
 {
     return calculated->resolve_length(
                          {
@@ -420,7 +420,7 @@ Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& cal
         .value();
 }
 
-Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, CSSPixels reference_value)
+Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, CSSPixels reference_value)
 {
     return calculated->resolve_length(
                          {
diff --git a/Libraries/LibWeb/CSS/Length.h b/Libraries/LibWeb/CSS/Length.h
index 991ff9acda4..686561e4ba2 100644
--- a/Libraries/LibWeb/CSS/Length.h
+++ b/Libraries/LibWeb/CSS/Length.h
@@ -232,8 +232,8 @@ public:
     Optional<Length> absolutize(CSSPixelRect const& viewport_rect, FontMetrics const& font_metrics, FontMetrics const& root_font_metrics) const;
     Length absolutized(CSSPixelRect const& viewport_rect, FontMetrics const& font_metrics, FontMetrics const& root_font_metrics) const;
 
-    static Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Length const& reference_value);
-    static Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, CSSPixels reference_value);
+    static Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, Layout::Node const&, Length const& reference_value);
+    static Length resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, Layout::Node const&, CSSPixels reference_value);
 
 private:
     [[nodiscard]] CSSPixels to_px_slow_case(Layout::Node const&) const;
diff --git a/Libraries/LibWeb/CSS/LengthBox.h b/Libraries/LibWeb/CSS/LengthBox.h
index a46e8c5e975..6ca53ffc5ff 100644
--- a/Libraries/LibWeb/CSS/LengthBox.h
+++ b/Libraries/LibWeb/CSS/LengthBox.h
@@ -16,7 +16,7 @@ public:
     LengthBox(LengthPercentage top, LengthPercentage right, LengthPercentage bottom, LengthPercentage left);
     ~LengthBox();
 
-    // Length (and thus LengthPercentage) includes a RefPtr<CalculatedStyleValue> member, but we can't include the header CSSStyleValue.h as it includes
+    // Length (and thus LengthPercentage) includes a RefPtr<CalculatedStyleValue const> member, but we can't include the header CSSStyleValue.h as it includes
     // this file already. To break the cyclic dependency, we must initialize these members in the constructor.
     LengthPercentage& top() { return m_top; }
     LengthPercentage& right() { return m_right; }
diff --git a/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp b/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp
index 935d48b0f15..f66c307771d 100644
--- a/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::CSS::Parser {
 
-Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue>> Parser::parse_descriptor_value(AtRuleID at_rule_id, DescriptorID descriptor_id, TokenStream<ComponentValue>& unprocessed_tokens)
+Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue const>> Parser::parse_descriptor_value(AtRuleID at_rule_id, DescriptorID descriptor_id, TokenStream<ComponentValue>& unprocessed_tokens)
 {
     if (!at_rule_supports_descriptor(at_rule_id, descriptor_id)) {
         dbgln_if(CSS_PARSER_DEBUG, "Unsupported descriptor '{}' in '{}'", to_string(descriptor_id), to_string(at_rule_id));
@@ -45,7 +45,7 @@ Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue>> Parser::parse_descriptor_valu
             [&](Keyword keyword) {
                 return parse_all_as_single_keyword_value(tokens, keyword);
             },
-            [&](PropertyID property_id) -> RefPtr<CSSStyleValue> {
+            [&](PropertyID property_id) -> RefPtr<CSSStyleValue const> {
                 auto value_or_error = parse_css_value(property_id, tokens);
                 if (value_or_error.is_error())
                     return nullptr;
@@ -58,7 +58,7 @@ Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue>> Parser::parse_descriptor_valu
                     return nullptr;
                 return value_for_property;
             },
-            [&](DescriptorMetadata::ValueType value_type) -> RefPtr<CSSStyleValue> {
+            [&](DescriptorMetadata::ValueType value_type) -> RefPtr<CSSStyleValue const> {
                 switch (value_type) {
                 case DescriptorMetadata::ValueType::FamilyName:
                     return parse_family_name_value(tokens);
@@ -107,7 +107,7 @@ Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue>> Parser::parse_descriptor_valu
                 case DescriptorMetadata::ValueType::String:
                     return parse_string_value(tokens);
                 case DescriptorMetadata::ValueType::UnicodeRangeTokens:
-                    return parse_comma_separated_value_list(tokens, [this](auto& tokens) -> RefPtr<CSSStyleValue> {
+                    return parse_comma_separated_value_list(tokens, [this](auto& tokens) -> RefPtr<CSSStyleValue const> {
                         return parse_unicode_range_value(tokens);
                     });
                 }
diff --git a/Libraries/LibWeb/CSS/Parser/GradientParsing.cpp b/Libraries/LibWeb/CSS/Parser/GradientParsing.cpp
index 3b0090abf1e..832372f0f2e 100644
--- a/Libraries/LibWeb/CSS/Parser/GradientParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/GradientParsing.cpp
@@ -32,7 +32,7 @@ Optional<Vector<TElement>> Parser::parse_color_stop_list(TokenStream<ComponentVa
         if (!tokens.has_next_token())
             return ElementType::Garbage;
 
-        RefPtr<CSSStyleValue> color;
+        RefPtr<CSSStyleValue const> color;
         Optional<typename TElement::PositionType> position;
         Optional<typename TElement::PositionType> second_position;
         if (position = parse_position(tokens); position.has_value()) {
@@ -223,7 +223,7 @@ Optional<InterpolationMethod> Parser::parse_interpolation_method(TokenStream<Com
     return interpolation_method;
 }
 
-RefPtr<LinearGradientStyleValue> Parser::parse_linear_gradient_function(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<LinearGradientStyleValue const> Parser::parse_linear_gradient_function(TokenStream<ComponentValue>& outer_tokens)
 {
     using GradientType = LinearGradientStyleValue::GradientType;
 
@@ -370,7 +370,7 @@ RefPtr<LinearGradientStyleValue> Parser::parse_linear_gradient_function(TokenStr
     return LinearGradientStyleValue::create(gradient_direction, move(*color_stops), gradient_type, repeating_gradient, maybe_interpolation_method);
 }
 
-RefPtr<ConicGradientStyleValue> Parser::parse_conic_gradient_function(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<ConicGradientStyleValue const> Parser::parse_conic_gradient_function(TokenStream<ComponentValue>& outer_tokens)
 {
     auto transaction = outer_tokens.begin_transaction();
     auto& component_value = outer_tokens.consume_a_token();
@@ -397,7 +397,7 @@ RefPtr<ConicGradientStyleValue> Parser::parse_conic_gradient_function(TokenStrea
         return nullptr;
 
     Angle from_angle(0, Angle::Type::Deg);
-    RefPtr<PositionStyleValue> at_position;
+    RefPtr<PositionStyleValue const> at_position;
     Optional<InterpolationMethod> maybe_interpolation_method;
 
     // conic-gradient( [ [ [ from [ <angle> | <zero> ] ]? [ at <position> ]? ] || <color-interpolation-method> ]? , <angular-color-stop-list> )
@@ -483,7 +483,7 @@ RefPtr<ConicGradientStyleValue> Parser::parse_conic_gradient_function(TokenStrea
     return ConicGradientStyleValue::create(from_angle, at_position.release_nonnull(), move(*color_stops), repeating_gradient, maybe_interpolation_method);
 }
 
-RefPtr<RadialGradientStyleValue> Parser::parse_radial_gradient_function(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<RadialGradientStyleValue const> Parser::parse_radial_gradient_function(TokenStream<ComponentValue>& outer_tokens)
 {
     using EndingShape = RadialGradientStyleValue::EndingShape;
     using Extent = RadialGradientStyleValue::Extent;
@@ -526,7 +526,7 @@ RefPtr<RadialGradientStyleValue> Parser::parse_radial_gradient_function(TokenStr
 
     Size size = Extent::FarthestCorner;
     EndingShape ending_shape = EndingShape::Circle;
-    RefPtr<PositionStyleValue> at_position;
+    RefPtr<PositionStyleValue const> at_position;
 
     auto parse_ending_shape = [&]() -> Optional<EndingShape> {
         auto transaction = tokens.begin_transaction();
diff --git a/Libraries/LibWeb/CSS/Parser/Helpers.cpp b/Libraries/LibWeb/CSS/Parser/Helpers.cpp
index 1aacfacc679..5cf6e4b5888 100644
--- a/Libraries/LibWeb/CSS/Parser/Helpers.cpp
+++ b/Libraries/LibWeb/CSS/Parser/Helpers.cpp
@@ -71,14 +71,14 @@ Vector<CSS::Descriptor> parse_css_list_of_descriptors(CSS::Parser::ParsingParams
     return CSS::Parser::Parser::create(parsing_params, css).parse_as_list_of_descriptors(at_rule_id);
 }
 
-RefPtr<CSS::CSSStyleValue> parse_css_value(CSS::Parser::ParsingParams const& context, StringView string, CSS::PropertyID property_id)
+RefPtr<CSS::CSSStyleValue const> parse_css_value(CSS::Parser::ParsingParams const& context, StringView string, CSS::PropertyID property_id)
 {
     if (string.is_empty())
         return nullptr;
     return CSS::Parser::Parser::create(context, string).parse_as_css_value(property_id);
 }
 
-RefPtr<CSS::CSSStyleValue> parse_css_descriptor(CSS::Parser::ParsingParams const& parsing_params, CSS::AtRuleID at_rule_id, CSS::DescriptorID descriptor_id, StringView string)
+RefPtr<CSS::CSSStyleValue const> parse_css_descriptor(CSS::Parser::ParsingParams const& parsing_params, CSS::AtRuleID at_rule_id, CSS::DescriptorID descriptor_id, StringView string)
 {
     if (string.is_empty())
         return nullptr;
diff --git a/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Libraries/LibWeb/CSS/Parser/Parser.cpp
index c450f01ecf6..6a20300b3ef 100644
--- a/Libraries/LibWeb/CSS/Parser/Parser.cpp
+++ b/Libraries/LibWeb/CSS/Parser/Parser.cpp
@@ -1622,7 +1622,7 @@ Vector<ComponentValue> Parser::parse_as_list_of_component_values()
     return parse_a_list_of_component_values(m_token_stream);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_as_css_value(PropertyID property_id)
+RefPtr<CSSStyleValue const> Parser::parse_as_css_value(PropertyID property_id)
 {
     auto component_values = parse_a_list_of_component_values(m_token_stream);
     auto tokens = TokenStream(component_values);
@@ -1632,7 +1632,7 @@ RefPtr<CSSStyleValue> Parser::parse_as_css_value(PropertyID property_id)
     return parsed_value.release_value();
 }
 
-RefPtr<CSSStyleValue> Parser::parse_as_descriptor_value(AtRuleID at_rule_id, DescriptorID descriptor_id)
+RefPtr<CSSStyleValue const> Parser::parse_as_descriptor_value(AtRuleID at_rule_id, DescriptorID descriptor_id)
 {
     auto component_values = parse_a_list_of_component_values(m_token_stream);
     auto tokens = TokenStream(component_values);
diff --git a/Libraries/LibWeb/CSS/Parser/Parser.h b/Libraries/LibWeb/CSS/Parser/Parser.h
index 42f0fd74c95..cb2e13badd8 100644
--- a/Libraries/LibWeb/CSS/Parser/Parser.h
+++ b/Libraries/LibWeb/CSS/Parser/Parser.h
@@ -119,14 +119,14 @@ public:
 
     RefPtr<Supports> parse_as_supports();
 
-    RefPtr<CSSStyleValue> parse_as_css_value(PropertyID);
-    RefPtr<CSSStyleValue> parse_as_descriptor_value(AtRuleID, DescriptorID);
+    RefPtr<CSSStyleValue const> parse_as_css_value(PropertyID);
+    RefPtr<CSSStyleValue const> parse_as_descriptor_value(AtRuleID, DescriptorID);
 
     Optional<ComponentValue> parse_as_component_value();
 
     Vector<ComponentValue> parse_as_list_of_component_values();
 
-    static NonnullRefPtr<CSSStyleValue> resolve_unresolved_style_value(ParsingParams const&, DOM::Element&, Optional<PseudoElement>, PropertyID, UnresolvedStyleValue const&);
+    static NonnullRefPtr<CSSStyleValue const> resolve_unresolved_style_value(ParsingParams const&, DOM::Element&, Optional<PseudoElement>, PropertyID, UnresolvedStyleValue const&);
 
     [[nodiscard]] LengthOrCalculated parse_as_sizes_attribute(DOM::Element const& element, HTML::HTMLImageElement const* img = nullptr);
 
@@ -270,7 +270,7 @@ private:
     Optional<Gfx::UnicodeRange> parse_unicode_range(TokenStream<ComponentValue>&);
     Optional<Gfx::UnicodeRange> parse_unicode_range(StringView);
     Vector<Gfx::UnicodeRange> parse_unicode_ranges(TokenStream<ComponentValue>&);
-    RefPtr<UnicodeRangeStyleValue> parse_unicode_range_value(TokenStream<ComponentValue>&);
+    RefPtr<UnicodeRangeStyleValue const> parse_unicode_range_value(TokenStream<ComponentValue>&);
     Optional<GridSize> parse_grid_size(ComponentValue const&);
     Optional<GridFitContent> parse_grid_fit_content(Vector<ComponentValue> const&);
     Optional<GridMinMax> parse_min_max(Vector<ComponentValue> const&);
@@ -278,12 +278,12 @@ private:
     Optional<ExplicitGridTrack> parse_track_sizing_function(ComponentValue const&);
 
     Optional<URL> parse_url_function(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_url_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_url_value(TokenStream<ComponentValue>&);
 
     Optional<ShapeRadius> parse_shape_radius(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_basic_shape_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_basic_shape_value(TokenStream<ComponentValue>&);
 
-    RefPtr<FitContentStyleValue> parse_fit_content_value(TokenStream<ComponentValue>&);
+    RefPtr<FitContentStyleValue const> parse_fit_content_value(TokenStream<ComponentValue>&);
 
     template<typename TElement>
     Optional<Vector<TElement>> parse_color_stop_list(TokenStream<ComponentValue>& tokens, auto parse_position);
@@ -291,144 +291,144 @@ private:
     Optional<Vector<AngularColorStopListElement>> parse_angular_color_stop_list(TokenStream<ComponentValue>&);
     Optional<InterpolationMethod> parse_interpolation_method(TokenStream<ComponentValue>&);
 
-    RefPtr<LinearGradientStyleValue> parse_linear_gradient_function(TokenStream<ComponentValue>&);
-    RefPtr<ConicGradientStyleValue> parse_conic_gradient_function(TokenStream<ComponentValue>&);
-    RefPtr<RadialGradientStyleValue> parse_radial_gradient_function(TokenStream<ComponentValue>&);
+    RefPtr<LinearGradientStyleValue const> parse_linear_gradient_function(TokenStream<ComponentValue>&);
+    RefPtr<ConicGradientStyleValue const> parse_conic_gradient_function(TokenStream<ComponentValue>&);
+    RefPtr<RadialGradientStyleValue const> parse_radial_gradient_function(TokenStream<ComponentValue>&);
 
-    ParseErrorOr<NonnullRefPtr<CSSStyleValue>> parse_css_value(PropertyID, TokenStream<ComponentValue>&, Optional<String> original_source_text = {});
-    ParseErrorOr<NonnullRefPtr<CSSStyleValue>> parse_descriptor_value(AtRuleID, DescriptorID, TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_css_value_for_property(PropertyID, TokenStream<ComponentValue>&);
+    ParseErrorOr<NonnullRefPtr<CSSStyleValue const>> parse_css_value(PropertyID, TokenStream<ComponentValue>&, Optional<String> original_source_text = {});
+    ParseErrorOr<NonnullRefPtr<CSSStyleValue const>> parse_descriptor_value(AtRuleID, DescriptorID, TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_css_value_for_property(PropertyID, TokenStream<ComponentValue>&);
     struct PropertyAndValue {
         PropertyID property;
-        RefPtr<CSSStyleValue> style_value;
+        RefPtr<CSSStyleValue const> style_value;
     };
     Optional<PropertyAndValue> parse_css_value_for_properties(ReadonlySpan<PropertyID>, TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_builtin_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_calculated_value(ComponentValue const&);
+    RefPtr<CSSStyleValue const> parse_builtin_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_calculated_value(ComponentValue const&);
     Optional<FlyString> parse_custom_ident(TokenStream<ComponentValue>&, ReadonlySpan<StringView> blacklist);
-    RefPtr<CustomIdentStyleValue> parse_custom_ident_value(TokenStream<ComponentValue>&, ReadonlySpan<StringView> blacklist);
+    RefPtr<CustomIdentStyleValue const> parse_custom_ident_value(TokenStream<ComponentValue>&, ReadonlySpan<StringView> blacklist);
     // NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp)
     RefPtr<CalculationNode> parse_math_function(Function const&, CalculationContext const&);
     RefPtr<CalculationNode> parse_a_calc_function_node(Function const&, CalculationContext const&);
-    RefPtr<CSSStyleValue> parse_keyword_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_hue_none_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_solidus_and_alpha_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_rgb_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_hsl_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_hwb_color_value(TokenStream<ComponentValue>&);
-    Optional<Array<RefPtr<CSSStyleValue>, 4>> parse_lab_like_color_value(TokenStream<ComponentValue>&, StringView);
-    RefPtr<CSSStyleValue> parse_lab_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_oklab_color_value(TokenStream<ComponentValue>&);
-    Optional<Array<RefPtr<CSSStyleValue>, 4>> parse_lch_like_color_value(TokenStream<ComponentValue>&, StringView);
-    RefPtr<CSSStyleValue> parse_lch_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_oklch_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_color_function(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_light_dark_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_color_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_color_scheme_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_counter_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_keyword_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_hue_none_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_solidus_and_alpha_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_rgb_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_hsl_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_hwb_color_value(TokenStream<ComponentValue>&);
+    Optional<Array<RefPtr<CSSStyleValue const>, 4>> parse_lab_like_color_value(TokenStream<ComponentValue>&, StringView);
+    RefPtr<CSSStyleValue const> parse_lab_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_oklab_color_value(TokenStream<ComponentValue>&);
+    Optional<Array<RefPtr<CSSStyleValue const>, 4>> parse_lch_like_color_value(TokenStream<ComponentValue>&, StringView);
+    RefPtr<CSSStyleValue const> parse_lch_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_oklch_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_color_function(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_light_dark_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_color_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_color_scheme_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_counter_value(TokenStream<ComponentValue>&);
     enum class AllowReversed {
         No,
         Yes,
     };
-    RefPtr<CSSStyleValue> parse_counter_definitions_value(TokenStream<ComponentValue>&, AllowReversed, i32 default_value_if_not_reversed);
-    RefPtr<CSSStyleValue> parse_rect_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_ratio_value(TokenStream<ComponentValue>&);
-    RefPtr<StringStyleValue> parse_string_value(TokenStream<ComponentValue>&);
-    RefPtr<AbstractImageStyleValue> parse_image_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_paint_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_counter_definitions_value(TokenStream<ComponentValue>&, AllowReversed, i32 default_value_if_not_reversed);
+    RefPtr<CSSStyleValue const> parse_rect_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_ratio_value(TokenStream<ComponentValue>&);
+    RefPtr<StringStyleValue const> parse_string_value(TokenStream<ComponentValue>&);
+    RefPtr<AbstractImageStyleValue const> parse_image_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_paint_value(TokenStream<ComponentValue>&);
     enum class PositionParsingMode {
         Normal,
         BackgroundPosition,
     };
-    RefPtr<PositionStyleValue> parse_position_value(TokenStream<ComponentValue>&, PositionParsingMode = PositionParsingMode::Normal);
-    RefPtr<CSSStyleValue> parse_filter_value_list_value(TokenStream<ComponentValue>&);
-    RefPtr<StringStyleValue> parse_opentype_tag_value(TokenStream<ComponentValue>&);
-    RefPtr<FontSourceStyleValue> parse_font_source_value(TokenStream<ComponentValue>&);
+    RefPtr<PositionStyleValue const> parse_position_value(TokenStream<ComponentValue>&, PositionParsingMode = PositionParsingMode::Normal);
+    RefPtr<CSSStyleValue const> parse_filter_value_list_value(TokenStream<ComponentValue>&);
+    RefPtr<StringStyleValue const> parse_opentype_tag_value(TokenStream<ComponentValue>&);
+    RefPtr<FontSourceStyleValue const> parse_font_source_value(TokenStream<ComponentValue>&);
 
-    RefPtr<CSSStyleValue> parse_angle_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_angle_percentage_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_flex_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_frequency_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_frequency_percentage_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_integer_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_length_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_length_percentage_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_number_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_number_percentage_value(TokenStream<ComponentValue>& tokens);
-    RefPtr<CSSStyleValue> parse_number_percentage_none_value(TokenStream<ComponentValue>& tokens);
-    RefPtr<CSSStyleValue> parse_percentage_value(TokenStream<ComponentValue>& tokens);
-    RefPtr<CSSStyleValue> parse_resolution_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_time_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_time_percentage_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_angle_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_angle_percentage_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_flex_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_frequency_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_frequency_percentage_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_integer_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_length_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_length_percentage_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_number_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_number_percentage_value(TokenStream<ComponentValue>& tokens);
+    RefPtr<CSSStyleValue const> parse_number_percentage_none_value(TokenStream<ComponentValue>& tokens);
+    RefPtr<CSSStyleValue const> parse_percentage_value(TokenStream<ComponentValue>& tokens);
+    RefPtr<CSSStyleValue const> parse_resolution_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_time_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_time_percentage_value(TokenStream<ComponentValue>&);
 
-    using ParseFunction = AK::Function<RefPtr<CSSStyleValue>(TokenStream<ComponentValue>&)>;
-    RefPtr<CSSStyleValue> parse_comma_separated_value_list(TokenStream<ComponentValue>&, ParseFunction);
-    RefPtr<CSSStyleValue> parse_simple_comma_separated_value_list(PropertyID, TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_all_as_single_keyword_value(TokenStream<ComponentValue>&, Keyword);
+    using ParseFunction = AK::Function<RefPtr<CSSStyleValue const>(TokenStream<ComponentValue>&)>;
+    RefPtr<CSSStyleValue const> parse_comma_separated_value_list(TokenStream<ComponentValue>&, ParseFunction);
+    RefPtr<CSSStyleValue const> parse_simple_comma_separated_value_list(PropertyID, TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_all_as_single_keyword_value(TokenStream<ComponentValue>&, Keyword);
 
-    RefPtr<CSSStyleValue> parse_aspect_ratio_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_background_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_single_background_position_x_or_y_value(TokenStream<ComponentValue>&, PropertyID);
-    RefPtr<CSSStyleValue> parse_single_background_repeat_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_single_background_size_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_border_value(PropertyID, TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_border_radius_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_border_radius_shorthand_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_columns_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_content_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_counter_increment_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_counter_reset_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_counter_set_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_cursor_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_display_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_flex_shorthand_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_flex_flow_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_family_name_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_family_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_language_override_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_feature_settings_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variation_settings_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variant(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variant_alternates_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variant_east_asian_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variant_emoji(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variant_ligatures_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_font_variant_numeric_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_list_style_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_math_depth_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_overflow_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_place_content_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_place_items_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_place_self_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_quotes_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_scrollbar_gutter_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_aspect_ratio_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_background_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_single_background_position_x_or_y_value(TokenStream<ComponentValue>&, PropertyID);
+    RefPtr<CSSStyleValue const> parse_single_background_repeat_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_single_background_size_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_border_value(PropertyID, TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_border_radius_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_border_radius_shorthand_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_columns_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_content_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_counter_increment_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_counter_reset_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_counter_set_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_cursor_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_display_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_flex_shorthand_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_flex_flow_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_family_name_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_family_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_language_override_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_feature_settings_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variation_settings_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variant(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variant_alternates_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variant_east_asian_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variant_emoji(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variant_ligatures_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_font_variant_numeric_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_list_style_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_math_depth_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_overflow_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_place_content_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_place_items_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_place_self_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_quotes_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_scrollbar_gutter_value(TokenStream<ComponentValue>&);
     enum class AllowInsetKeyword {
         No,
         Yes,
     };
-    RefPtr<CSSStyleValue> parse_shadow_value(TokenStream<ComponentValue>&, AllowInsetKeyword);
-    RefPtr<CSSStyleValue> parse_single_shadow_value(TokenStream<ComponentValue>&, AllowInsetKeyword);
-    RefPtr<CSSStyleValue> parse_text_decoration_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_text_decoration_line_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_rotate_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_stroke_dasharray_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_easing_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_transform_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_transform_origin_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_transition_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_translate_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_scale_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_grid_track_size_list(TokenStream<ComponentValue>&, bool allow_separate_line_name_blocks = false);
-    RefPtr<CSSStyleValue> parse_grid_auto_track_sizes(TokenStream<ComponentValue>&);
-    RefPtr<GridAutoFlowStyleValue> parse_grid_auto_flow_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_grid_track_size_list_shorthand_value(PropertyID, TokenStream<ComponentValue>&);
-    RefPtr<GridTrackPlacementStyleValue> parse_grid_track_placement(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_grid_track_placement_shorthand_value(PropertyID, TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_grid_template_areas_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_grid_area_shorthand_value(TokenStream<ComponentValue>&);
-    RefPtr<CSSStyleValue> parse_grid_shorthand_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_shadow_value(TokenStream<ComponentValue>&, AllowInsetKeyword);
+    RefPtr<CSSStyleValue const> parse_single_shadow_value(TokenStream<ComponentValue>&, AllowInsetKeyword);
+    RefPtr<CSSStyleValue const> parse_text_decoration_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_text_decoration_line_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_rotate_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_stroke_dasharray_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_easing_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_transform_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_transform_origin_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_transition_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_translate_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_scale_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_grid_track_size_list(TokenStream<ComponentValue>&, bool allow_separate_line_name_blocks = false);
+    RefPtr<CSSStyleValue const> parse_grid_auto_track_sizes(TokenStream<ComponentValue>&);
+    RefPtr<GridAutoFlowStyleValue const> parse_grid_auto_flow_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_grid_track_size_list_shorthand_value(PropertyID, TokenStream<ComponentValue>&);
+    RefPtr<GridTrackPlacementStyleValue const> parse_grid_track_placement(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_grid_track_placement_shorthand_value(PropertyID, TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_grid_template_areas_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_grid_area_shorthand_value(TokenStream<ComponentValue>&);
+    RefPtr<CSSStyleValue const> parse_grid_shorthand_value(TokenStream<ComponentValue>&);
 
     RefPtr<CalculationNode> convert_to_calculation_node(CalcParsing::Node const&, CalculationContext const&);
     RefPtr<CalculationNode> parse_a_calculation(Vector<ComponentValue> const&, CalculationContext const&);
@@ -457,7 +457,7 @@ private:
 
     OwnPtr<BooleanExpression> parse_supports_feature(TokenStream<ComponentValue>&);
 
-    NonnullRefPtr<CSSStyleValue> resolve_unresolved_style_value(DOM::Element&, Optional<PseudoElement>, PropertyID, UnresolvedStyleValue const&);
+    NonnullRefPtr<CSSStyleValue const> resolve_unresolved_style_value(DOM::Element&, Optional<PseudoElement>, PropertyID, UnresolvedStyleValue const&);
     bool expand_variables(DOM::Element&, Optional<PseudoElement>, FlyString const& property_name, HashMap<FlyString, NonnullRefPtr<PropertyDependencyNode>>& dependencies, TokenStream<ComponentValue>& source, Vector<ComponentValue>& dest);
     bool expand_unresolved_values(DOM::Element&, FlyString const& property_name, TokenStream<ComponentValue>& source, Vector<ComponentValue>& dest);
     bool substitute_attr_function(DOM::Element& element, FlyString const& property_name, Function const& attr_function, Vector<ComponentValue>& dest);
@@ -523,8 +523,8 @@ namespace Web {
 GC::Ref<CSS::CSSStyleSheet> parse_css_stylesheet(CSS::Parser::ParsingParams const&, StringView, Optional<::URL::URL> location = {}, Vector<NonnullRefPtr<CSS::MediaQuery>> = {});
 CSS::Parser::Parser::PropertiesAndCustomProperties parse_css_style_attribute(CSS::Parser::ParsingParams const&, StringView);
 Vector<CSS::Descriptor> parse_css_list_of_descriptors(CSS::Parser::ParsingParams const&, CSS::AtRuleID, StringView);
-RefPtr<CSS::CSSStyleValue> parse_css_value(CSS::Parser::ParsingParams const&, StringView, CSS::PropertyID property_id = CSS::PropertyID::Invalid);
-RefPtr<CSS::CSSStyleValue> parse_css_descriptor(CSS::Parser::ParsingParams const&, CSS::AtRuleID, CSS::DescriptorID, StringView);
+RefPtr<CSS::CSSStyleValue const> parse_css_value(CSS::Parser::ParsingParams const&, StringView, CSS::PropertyID property_id = CSS::PropertyID::Invalid);
+RefPtr<CSS::CSSStyleValue const> parse_css_descriptor(CSS::Parser::ParsingParams const&, CSS::AtRuleID, CSS::DescriptorID, StringView);
 Optional<CSS::SelectorList> parse_selector(CSS::Parser::ParsingParams const&, StringView);
 Optional<CSS::SelectorList> parse_selector_for_nested_style_rule(CSS::Parser::ParsingParams const&, StringView);
 Optional<CSS::Selector::PseudoElementSelector> parse_pseudo_element_selector(CSS::Parser::ParsingParams const&, StringView);
diff --git a/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp b/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp
index 100d24d378b..26e0af0c1e1 100644
--- a/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp
@@ -66,7 +66,7 @@ static void remove_property(Vector<PropertyID>& properties, PropertyID property_
     properties.remove_first_matching([&](auto it) { return it == property_to_remove; });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_all_as_single_keyword_value(TokenStream<ComponentValue>& tokens, Keyword keyword)
+RefPtr<CSSStyleValue const> Parser::parse_all_as_single_keyword_value(TokenStream<ComponentValue>& tokens, Keyword keyword)
 {
     auto transaction = tokens.begin_transaction();
     tokens.discard_whitespace();
@@ -80,9 +80,9 @@ RefPtr<CSSStyleValue> Parser::parse_all_as_single_keyword_value(TokenStream<Comp
     return keyword_value;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_simple_comma_separated_value_list(PropertyID property_id, TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_simple_comma_separated_value_list(PropertyID property_id, TokenStream<ComponentValue>& tokens)
 {
-    return parse_comma_separated_value_list(tokens, [this, property_id](auto& tokens) -> RefPtr<CSSStyleValue> {
+    return parse_comma_separated_value_list(tokens, [this, property_id](auto& tokens) -> RefPtr<CSSStyleValue const> {
         if (auto value = parse_css_value_for_property(property_id, tokens))
             return value;
         tokens.reconsume_current_input_token();
@@ -90,7 +90,7 @@ RefPtr<CSSStyleValue> Parser::parse_simple_comma_separated_value_list(PropertyID
     });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_css_value_for_property(PropertyID property_id, TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_css_value_for_property(PropertyID property_id, TokenStream<ComponentValue>& tokens)
 {
     return parse_css_value_for_properties({ &property_id, 1 }, tokens)
         .map([](auto& it) { return it.style_value; })
@@ -355,7 +355,7 @@ Optional<Parser::PropertyAndValue> Parser::parse_css_value_for_properties(Readon
     return OptionalNone {};
 }
 
-Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue>> Parser::parse_css_value(PropertyID property_id, TokenStream<ComponentValue>& unprocessed_tokens, Optional<String> original_source_text)
+Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue const>> Parser::parse_css_value(PropertyID property_id, TokenStream<ComponentValue>& unprocessed_tokens, Optional<String> original_source_text)
 {
     auto context_guard = push_temporary_value_parsing_context(property_id);
 
@@ -763,7 +763,7 @@ Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue>> Parser::parse_css_value(Prope
     return { ShorthandStyleValue::create(property_id, move(longhand_properties), move(longhand_values)) };
 }
 
-RefPtr<CSSStyleValue> Parser::parse_color_scheme_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_color_scheme_value(TokenStream<ComponentValue>& tokens)
 {
     // normal | [ light | dark | <custom-ident> ]+ && only?
 
@@ -828,7 +828,7 @@ RefPtr<CSSStyleValue> Parser::parse_color_scheme_value(TokenStream<ComponentValu
     return ColorSchemeStyleValue::create(schemes, only);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_counter_definitions_value(TokenStream<ComponentValue>& tokens, AllowReversed allow_reversed, i32 default_value_if_not_reversed)
+RefPtr<CSSStyleValue const> Parser::parse_counter_definitions_value(TokenStream<ComponentValue>& tokens, AllowReversed allow_reversed, i32 default_value_if_not_reversed)
 {
     // If AllowReversed is Yes, parses:
     //   [ <counter-name> <integer>? | <reversed-counter-name> <integer>? ]+
@@ -889,7 +889,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_definitions_value(TokenStream<Compon
 }
 
 // https://drafts.csswg.org/css-lists-3/#propdef-counter-increment
-RefPtr<CSSStyleValue> Parser::parse_counter_increment_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_counter_increment_value(TokenStream<ComponentValue>& tokens)
 {
     // [ <counter-name> <integer>? ]+ | none
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
@@ -899,7 +899,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_increment_value(TokenStream<Componen
 }
 
 // https://drafts.csswg.org/css-lists-3/#propdef-counter-reset
-RefPtr<CSSStyleValue> Parser::parse_counter_reset_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_counter_reset_value(TokenStream<ComponentValue>& tokens)
 {
     // [ <counter-name> <integer>? | <reversed-counter-name> <integer>? ]+ | none
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
@@ -909,7 +909,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_reset_value(TokenStream<ComponentVal
 }
 
 // https://drafts.csswg.org/css-lists-3/#propdef-counter-set
-RefPtr<CSSStyleValue> Parser::parse_counter_set_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_counter_set_value(TokenStream<ComponentValue>& tokens)
 {
     // [ <counter-name> <integer>? ]+ | none
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
@@ -919,7 +919,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_set_value(TokenStream<ComponentValue
 }
 
 // https://drafts.csswg.org/css-ui-3/#cursor
-RefPtr<CSSStyleValue> Parser::parse_cursor_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_cursor_value(TokenStream<ComponentValue>& tokens)
 {
     // [ [<url> [<x> <y>]?,]* <built-in-cursor> ]
     // So, any number of custom cursor definitions, and then a mandatory cursor name keyword, all comma-separated.
@@ -985,11 +985,11 @@ RefPtr<CSSStyleValue> Parser::parse_cursor_value(TokenStream<ComponentValue>& to
 }
 
 // https://www.w3.org/TR/css-sizing-4/#aspect-ratio
-RefPtr<CSSStyleValue> Parser::parse_aspect_ratio_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_aspect_ratio_value(TokenStream<ComponentValue>& tokens)
 {
     // `auto || <ratio>`
-    RefPtr<CSSStyleValue> auto_value;
-    RefPtr<CSSStyleValue> ratio_value;
+    RefPtr<CSSStyleValue const> auto_value;
+    RefPtr<CSSStyleValue const> ratio_value;
 
     auto transaction = tokens.begin_transaction();
     while (tokens.has_next_token()) {
@@ -1034,7 +1034,7 @@ RefPtr<CSSStyleValue> Parser::parse_aspect_ratio_value(TokenStream<ComponentValu
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_background_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_background_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
 
@@ -1052,7 +1052,7 @@ RefPtr<CSSStyleValue> Parser::parse_background_value(TokenStream<ComponentValue>
     StyleValueVector background_attachments;
     StyleValueVector background_clips;
     StyleValueVector background_origins;
-    RefPtr<CSSStyleValue> background_color;
+    RefPtr<CSSStyleValue const> background_color;
 
     auto initial_background_image = property_initial_value(PropertyID::BackgroundImage);
     auto initial_background_position_x = property_initial_value(PropertyID::BackgroundPositionX);
@@ -1065,14 +1065,14 @@ RefPtr<CSSStyleValue> Parser::parse_background_value(TokenStream<ComponentValue>
     auto initial_background_color = property_initial_value(PropertyID::BackgroundColor);
 
     // Per-layer values
-    RefPtr<CSSStyleValue> background_image;
-    RefPtr<CSSStyleValue> background_position_x;
-    RefPtr<CSSStyleValue> background_position_y;
-    RefPtr<CSSStyleValue> background_size;
-    RefPtr<CSSStyleValue> background_repeat;
-    RefPtr<CSSStyleValue> background_attachment;
-    RefPtr<CSSStyleValue> background_clip;
-    RefPtr<CSSStyleValue> background_origin;
+    RefPtr<CSSStyleValue const> background_image;
+    RefPtr<CSSStyleValue const> background_position_x;
+    RefPtr<CSSStyleValue const> background_position_y;
+    RefPtr<CSSStyleValue const> background_size;
+    RefPtr<CSSStyleValue const> background_repeat;
+    RefPtr<CSSStyleValue const> background_attachment;
+    RefPtr<CSSStyleValue const> background_clip;
+    RefPtr<CSSStyleValue const> background_origin;
 
     bool has_multiple_layers = false;
     // BackgroundSize is always parsed as part of BackgroundPosition, so we don't include it here.
@@ -1286,7 +1286,7 @@ static Optional<LengthPercentage> style_value_to_length_percentage(auto value)
     return {};
 }
 
-RefPtr<CSSStyleValue> Parser::parse_single_background_position_x_or_y_value(TokenStream<ComponentValue>& tokens, PropertyID property)
+RefPtr<CSSStyleValue const> Parser::parse_single_background_position_x_or_y_value(TokenStream<ComponentValue>& tokens, PropertyID property)
 {
     Optional<PositionEdge> relative_edge {};
 
@@ -1343,7 +1343,7 @@ RefPtr<CSSStyleValue> Parser::parse_single_background_position_x_or_y_value(Toke
     return EdgeStyleValue::create(relative_edge, {});
 }
 
-RefPtr<CSSStyleValue> Parser::parse_single_background_repeat_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_single_background_repeat_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
 
@@ -1403,11 +1403,11 @@ RefPtr<CSSStyleValue> Parser::parse_single_background_repeat_value(TokenStream<C
     return BackgroundRepeatStyleValue::create(x_repeat.value(), y_repeat.value());
 }
 
-RefPtr<CSSStyleValue> Parser::parse_single_background_size_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_single_background_size_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
 
-    auto get_length_percentage = [](CSSStyleValue& style_value) -> Optional<LengthPercentage> {
+    auto get_length_percentage = [](CSSStyleValue const& style_value) -> Optional<LengthPercentage> {
         if (style_value.has_auto())
             return LengthPercentage { Length::make_auto() };
         if (style_value.is_percentage())
@@ -1451,11 +1451,11 @@ RefPtr<CSSStyleValue> Parser::parse_single_background_size_value(TokenStream<Com
     return BackgroundSizeStyleValue::create(x_size.release_value(), y_size.release_value());
 }
 
-RefPtr<CSSStyleValue> Parser::parse_border_value(PropertyID property_id, TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_border_value(PropertyID property_id, TokenStream<ComponentValue>& tokens)
 {
-    RefPtr<CSSStyleValue> border_width;
-    RefPtr<CSSStyleValue> border_color;
-    RefPtr<CSSStyleValue> border_style;
+    RefPtr<CSSStyleValue const> border_width;
+    RefPtr<CSSStyleValue const> border_color;
+    RefPtr<CSSStyleValue const> border_style;
 
     auto color_property = PropertyID::Invalid;
     auto style_property = PropertyID::Invalid;
@@ -1528,7 +1528,7 @@ RefPtr<CSSStyleValue> Parser::parse_border_value(PropertyID property_id, TokenSt
         { border_width.release_nonnull(), border_style.release_nonnull(), border_color.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_border_radius_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_border_radius_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.remaining_token_count() == 2) {
         auto transaction = tokens.begin_transaction();
@@ -1552,7 +1552,7 @@ RefPtr<CSSStyleValue> Parser::parse_border_radius_value(TokenStream<ComponentVal
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_border_radius_shorthand_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_border_radius_shorthand_value(TokenStream<ComponentValue>& tokens)
 {
     auto top_left = [&](Vector<LengthPercentage>& radii) { return radii[0]; };
     auto top_right = [&](Vector<LengthPercentage>& radii) {
@@ -1642,13 +1642,13 @@ RefPtr<CSSStyleValue> Parser::parse_border_radius_shorthand_value(TokenStream<Co
         { move(top_left_radius), move(top_right_radius), move(bottom_right_radius), move(bottom_left_radius) });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_columns_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_columns_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.remaining_token_count() > 2)
         return nullptr;
 
-    RefPtr<CSSStyleValue> column_count;
-    RefPtr<CSSStyleValue> column_width;
+    RefPtr<CSSStyleValue const> column_count;
+    RefPtr<CSSStyleValue const> column_width;
 
     Vector<PropertyID> remaining_longhands { PropertyID::ColumnCount, PropertyID::ColumnWidth };
     int found_autos = 0;
@@ -1710,7 +1710,7 @@ RefPtr<CSSStyleValue> Parser::parse_columns_value(TokenStream<ComponentValue>& t
         { column_count.release_nonnull(), column_width.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_shadow_value(TokenStream<ComponentValue>& tokens, AllowInsetKeyword allow_inset_keyword)
+RefPtr<CSSStyleValue const> Parser::parse_shadow_value(TokenStream<ComponentValue>& tokens, AllowInsetKeyword allow_inset_keyword)
 {
     // "none"
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
@@ -1721,18 +1721,18 @@ RefPtr<CSSStyleValue> Parser::parse_shadow_value(TokenStream<ComponentValue>& to
     });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_single_shadow_value(TokenStream<ComponentValue>& tokens, AllowInsetKeyword allow_inset_keyword)
+RefPtr<CSSStyleValue const> Parser::parse_single_shadow_value(TokenStream<ComponentValue>& tokens, AllowInsetKeyword allow_inset_keyword)
 {
     auto transaction = tokens.begin_transaction();
 
-    RefPtr<CSSStyleValue> color;
-    RefPtr<CSSStyleValue> offset_x;
-    RefPtr<CSSStyleValue> offset_y;
-    RefPtr<CSSStyleValue> blur_radius;
-    RefPtr<CSSStyleValue> spread_distance;
+    RefPtr<CSSStyleValue const> color;
+    RefPtr<CSSStyleValue const> offset_x;
+    RefPtr<CSSStyleValue const> offset_y;
+    RefPtr<CSSStyleValue const> blur_radius;
+    RefPtr<CSSStyleValue const> spread_distance;
     Optional<ShadowPlacement> placement;
 
-    auto possibly_dynamic_length = [&](ComponentValue const& token) -> RefPtr<CSSStyleValue> {
+    auto possibly_dynamic_length = [&](ComponentValue const& token) -> RefPtr<CSSStyleValue const> {
         auto tokens = TokenStream<ComponentValue>::of_single_token(token);
         auto maybe_length = parse_length(tokens);
         if (!maybe_length.has_value())
@@ -1826,7 +1826,7 @@ RefPtr<CSSStyleValue> Parser::parse_single_shadow_value(TokenStream<ComponentVal
     return ShadowStyleValue::create(color.release_nonnull(), offset_x.release_nonnull(), offset_y.release_nonnull(), blur_radius.release_nonnull(), spread_distance.release_nonnull(), placement.release_value());
 }
 
-RefPtr<CSSStyleValue> Parser::parse_rotate_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_rotate_value(TokenStream<ComponentValue>& tokens)
 {
     // Value:	none | <angle> | [ x | y | z | <number>{3} ] && <angle>
 
@@ -1915,7 +1915,7 @@ RefPtr<CSSStyleValue> Parser::parse_rotate_value(TokenStream<ComponentValue>& to
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_stroke_dasharray_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_stroke_dasharray_value(TokenStream<ComponentValue>& tokens)
 {
     // https://svgwg.org/svg2-draft/painting.html#StrokeDashing
     // Value: none | <dasharray>
@@ -1947,7 +1947,7 @@ RefPtr<CSSStyleValue> Parser::parse_stroke_dasharray_value(TokenStream<Component
     return StyleValueList::create(move(dashes), StyleValueList::Separator::Comma);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_content_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_content_value(TokenStream<ComponentValue>& tokens)
 {
     // FIXME: `content` accepts several kinds of function() type, which we don't handle in property_accepts_value() yet.
 
@@ -2016,7 +2016,7 @@ RefPtr<CSSStyleValue> Parser::parse_content_value(TokenStream<ComponentValue>& t
 }
 
 // https://www.w3.org/TR/css-display-3/#the-display-properties
-RefPtr<CSSStyleValue> Parser::parse_display_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_display_value(TokenStream<ComponentValue>& tokens)
 {
     auto parse_single_component_display = [this](TokenStream<ComponentValue>& tokens) -> Optional<Display> {
         auto transaction = tokens.begin_transaction();
@@ -2146,11 +2146,11 @@ RefPtr<CSSStyleValue> Parser::parse_display_value(TokenStream<ComponentValue>& t
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_flex_shorthand_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_flex_shorthand_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
 
-    auto make_flex_shorthand = [&](NonnullRefPtr<CSSStyleValue> flex_grow, NonnullRefPtr<CSSStyleValue> flex_shrink, NonnullRefPtr<CSSStyleValue> flex_basis) {
+    auto make_flex_shorthand = [&](NonnullRefPtr<CSSStyleValue const> flex_grow, NonnullRefPtr<CSSStyleValue const> flex_shrink, NonnullRefPtr<CSSStyleValue const> flex_basis) {
         transaction.commit();
         return ShorthandStyleValue::create(PropertyID::Flex,
             { PropertyID::FlexGrow, PropertyID::FlexShrink, PropertyID::FlexBasis },
@@ -2191,9 +2191,9 @@ RefPtr<CSSStyleValue> Parser::parse_flex_shorthand_value(TokenStream<ComponentVa
         return nullptr;
     }
 
-    RefPtr<CSSStyleValue> flex_grow;
-    RefPtr<CSSStyleValue> flex_shrink;
-    RefPtr<CSSStyleValue> flex_basis;
+    RefPtr<CSSStyleValue const> flex_grow;
+    RefPtr<CSSStyleValue const> flex_shrink;
+    RefPtr<CSSStyleValue const> flex_basis;
 
     // NOTE: FlexGrow has to be before FlexBasis. `0` is a valid FlexBasis, but only
     //       if FlexGrow (along with optional FlexShrink) have already been specified.
@@ -2240,10 +2240,10 @@ RefPtr<CSSStyleValue> Parser::parse_flex_shorthand_value(TokenStream<ComponentVa
     return make_flex_shorthand(flex_grow.release_nonnull(), flex_shrink.release_nonnull(), flex_basis.release_nonnull());
 }
 
-RefPtr<CSSStyleValue> Parser::parse_flex_flow_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_flex_flow_value(TokenStream<ComponentValue>& tokens)
 {
-    RefPtr<CSSStyleValue> flex_direction;
-    RefPtr<CSSStyleValue> flex_wrap;
+    RefPtr<CSSStyleValue const> flex_direction;
+    RefPtr<CSSStyleValue const> flex_wrap;
 
     auto remaining_longhands = Vector { PropertyID::FlexDirection, PropertyID::FlexWrap };
     auto transaction = tokens.begin_transaction();
@@ -2280,15 +2280,15 @@ RefPtr<CSSStyleValue> Parser::parse_flex_flow_value(TokenStream<ComponentValue>&
         { flex_direction.release_nonnull(), flex_wrap.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_value(TokenStream<ComponentValue>& tokens)
 {
-    RefPtr<CSSStyleValue> font_width;
-    RefPtr<CSSStyleValue> font_style;
-    RefPtr<CSSStyleValue> font_weight;
-    RefPtr<CSSStyleValue> font_size;
-    RefPtr<CSSStyleValue> line_height;
-    RefPtr<CSSStyleValue> font_families;
-    RefPtr<CSSStyleValue> font_variant;
+    RefPtr<CSSStyleValue const> font_width;
+    RefPtr<CSSStyleValue const> font_style;
+    RefPtr<CSSStyleValue const> font_weight;
+    RefPtr<CSSStyleValue const> font_size;
+    RefPtr<CSSStyleValue const> line_height;
+    RefPtr<CSSStyleValue const> font_families;
+    RefPtr<CSSStyleValue const> font_variant;
 
     // FIXME: Handle system fonts. (caption, icon, menu, message-box, small-caption, status-bar)
 
@@ -2443,12 +2443,12 @@ RefPtr<CSSStyleValue> Parser::parse_font_value(TokenStream<ComponentValue>& toke
 }
 
 // https://drafts.csswg.org/css-fonts-4/#font-family-prop
-RefPtr<CSSStyleValue> Parser::parse_font_family_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_family_value(TokenStream<ComponentValue>& tokens)
 {
     // [ <family-name> | <generic-family> ]#
     // FIXME: We currently require font-family to always be a list, even with one item.
     //        Maybe change that?
-    auto result = parse_comma_separated_value_list(tokens, [this](auto& inner_tokens) -> RefPtr<CSSStyleValue> {
+    auto result = parse_comma_separated_value_list(tokens, [this](auto& inner_tokens) -> RefPtr<CSSStyleValue const> {
         inner_tokens.discard_whitespace();
 
         // <generic-family>
@@ -2475,7 +2475,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_family_value(TokenStream<ComponentValue
     return StyleValueList::create(StyleValueVector { result.release_nonnull() }, StyleValueList::Separator::Comma);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_language_override_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_language_override_value(TokenStream<ComponentValue>& tokens)
 {
     // https://drafts.csswg.org/css-fonts/#propdef-font-language-override
     // This is `normal | <string>` but with the constraint that the string has to be 4 characters long:
@@ -2507,7 +2507,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_language_override_value(TokenStream<Com
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_feature_settings_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_feature_settings_value(TokenStream<ComponentValue>& tokens)
 {
     // https://drafts.csswg.org/css-fonts/#propdef-font-feature-settings
     // normal | <feature-tag-value>#
@@ -2525,14 +2525,14 @@ RefPtr<CSSStyleValue> Parser::parse_font_feature_settings_value(TokenStream<Comp
     // value for that axis."
     // So, we deduplicate them here using a HashSet.
 
-    OrderedHashMap<FlyString, NonnullRefPtr<OpenTypeTaggedStyleValue>> feature_tags_map;
+    OrderedHashMap<FlyString, NonnullRefPtr<OpenTypeTaggedStyleValue const>> feature_tags_map;
     for (auto const& values : tag_values) {
         // <feature-tag-value> = <opentype-tag> [ <integer [0,∞]> | on | off ]?
         TokenStream tag_tokens { values };
         tag_tokens.discard_whitespace();
         auto opentype_tag = parse_opentype_tag_value(tag_tokens);
         tag_tokens.discard_whitespace();
-        RefPtr<CSSStyleValue> value;
+        RefPtr<CSSStyleValue const> value;
         if (tag_tokens.has_next_token()) {
             if (auto integer = parse_integer_value(tag_tokens)) {
                 if (integer->is_integer() && integer->as_integer().value() < 0)
@@ -2580,7 +2580,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_feature_settings_value(TokenStream<Comp
     return StyleValueList::create(move(feature_tags), StyleValueList::Separator::Comma);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_variation_settings_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_variation_settings_value(TokenStream<ComponentValue>& tokens)
 {
     // https://drafts.csswg.org/css-fonts/#propdef-font-variation-settings
     // normal | [ <opentype-tag> <number>]#
@@ -2597,7 +2597,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variation_settings_value(TokenStream<Co
     // previous value for that axis. This deduplication is observable by accessing the computed value of this property."
     // So, we deduplicate them here using a HashSet.
 
-    OrderedHashMap<FlyString, NonnullRefPtr<OpenTypeTaggedStyleValue>> axis_tags_map;
+    OrderedHashMap<FlyString, NonnullRefPtr<OpenTypeTaggedStyleValue const>> axis_tags_map;
     for (auto const& values : tag_values) {
         TokenStream tag_tokens { values };
         tag_tokens.discard_whitespace();
@@ -2626,7 +2626,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variation_settings_value(TokenStream<Co
     return StyleValueList::create(move(axis_tags), StyleValueList::Separator::Comma);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_variant(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_variant(TokenStream<ComponentValue>& tokens)
 {
     // 6.11 https://drafts.csswg.org/css-fonts/#propdef-font-variant
     // normal | none |
@@ -2655,10 +2655,10 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant(TokenStream<ComponentValue>& to
     bool has_east_asian_variant = false;
     bool has_east_asian_width = false;
     bool has_east_asian_ruby = false;
-    RefPtr<CSSStyleValue> alternates_value {};
-    RefPtr<CSSStyleValue> caps_value {};
-    RefPtr<CSSStyleValue> emoji_value {};
-    RefPtr<CSSStyleValue> position_value {};
+    RefPtr<CSSStyleValue const> alternates_value {};
+    RefPtr<CSSStyleValue const> caps_value {};
+    RefPtr<CSSStyleValue const> emoji_value {};
+    RefPtr<CSSStyleValue const> position_value {};
     StyleValueVector east_asian_values;
     StyleValueVector ligatures_values;
     StyleValueVector numeric_values;
@@ -2817,7 +2817,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant(TokenStream<ComponentValue>& to
     }
 
     auto normal_value = CSSKeywordValue::create(Keyword::Normal);
-    auto resolve_list = [&normal_value](StyleValueVector values) -> NonnullRefPtr<CSSStyleValue> {
+    auto resolve_list = [&normal_value](StyleValueVector values) -> NonnullRefPtr<CSSStyleValue const> {
         if (values.is_empty())
             return normal_value;
         if (values.size() == 1)
@@ -2862,7 +2862,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant(TokenStream<ComponentValue>& to
         });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_variant_alternates_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_variant_alternates_value(TokenStream<ComponentValue>& tokens)
 {
     // 6.8 https://drafts.csswg.org/css-fonts/#font-variant-alternates-prop
     // normal |
@@ -2887,7 +2887,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_alternates_value(TokenStream<Co
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_variant_east_asian_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_variant_east_asian_value(TokenStream<ComponentValue>& tokens)
 {
     // 6.10 https://drafts.csswg.org/css-fonts/#propdef-font-variant-east-asian
     // normal | [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]
@@ -2899,9 +2899,9 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_east_asian_value(TokenStream<Co
         return normal.release_nonnull();
 
     // [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]
-    RefPtr<CSSStyleValue> ruby_value;
-    RefPtr<CSSStyleValue> variant_value;
-    RefPtr<CSSStyleValue> width_value;
+    RefPtr<CSSStyleValue const> ruby_value;
+    RefPtr<CSSStyleValue const> variant_value;
+    RefPtr<CSSStyleValue const> width_value;
 
     while (tokens.has_next_token()) {
         auto maybe_value = parse_keyword_value(tokens);
@@ -2954,7 +2954,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_east_asian_value(TokenStream<Co
     return StyleValueList::create(move(values), StyleValueList::Separator::Space);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_variant_ligatures_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_variant_ligatures_value(TokenStream<ComponentValue>& tokens)
 {
     // 6.4 https://drafts.csswg.org/css-fonts/#propdef-font-variant-ligatures
     // normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]
@@ -2972,10 +2972,10 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_ligatures_value(TokenStream<Com
         return none.release_nonnull();
 
     // [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]
-    RefPtr<CSSStyleValue> common_ligatures_value;
-    RefPtr<CSSStyleValue> discretionary_ligatures_value;
-    RefPtr<CSSStyleValue> historical_ligatures_value;
-    RefPtr<CSSStyleValue> contextual_value;
+    RefPtr<CSSStyleValue const> common_ligatures_value;
+    RefPtr<CSSStyleValue const> discretionary_ligatures_value;
+    RefPtr<CSSStyleValue const> historical_ligatures_value;
+    RefPtr<CSSStyleValue const> contextual_value;
 
     while (tokens.has_next_token()) {
         auto maybe_value = parse_keyword_value(tokens);
@@ -3038,7 +3038,7 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_ligatures_value(TokenStream<Com
     return StyleValueList::create(move(values), StyleValueList::Separator::Space);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_font_variant_numeric_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_font_variant_numeric_value(TokenStream<ComponentValue>& tokens)
 {
     // 6.7 https://drafts.csswg.org/css-fonts/#propdef-font-variant-numeric
     // normal | [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero]
@@ -3050,11 +3050,11 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_numeric_value(TokenStream<Compo
     if (auto normal = parse_all_as_single_keyword_value(tokens, Keyword::Normal))
         return normal.release_nonnull();
 
-    RefPtr<CSSStyleValue> figures_value;
-    RefPtr<CSSStyleValue> spacing_value;
-    RefPtr<CSSStyleValue> fractions_value;
-    RefPtr<CSSStyleValue> ordinals_value;
-    RefPtr<CSSStyleValue> slashed_zero_value;
+    RefPtr<CSSStyleValue const> figures_value;
+    RefPtr<CSSStyleValue const> spacing_value;
+    RefPtr<CSSStyleValue const> fractions_value;
+    RefPtr<CSSStyleValue const> ordinals_value;
+    RefPtr<CSSStyleValue const> slashed_zero_value;
 
     // [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero]
     while (tokens.has_next_token()) {
@@ -3123,11 +3123,11 @@ RefPtr<CSSStyleValue> Parser::parse_font_variant_numeric_value(TokenStream<Compo
     return StyleValueList::create(move(values), StyleValueList::Separator::Space);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_list_style_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_list_style_value(TokenStream<ComponentValue>& tokens)
 {
-    RefPtr<CSSStyleValue> list_position;
-    RefPtr<CSSStyleValue> list_image;
-    RefPtr<CSSStyleValue> list_type;
+    RefPtr<CSSStyleValue const> list_position;
+    RefPtr<CSSStyleValue const> list_image;
+    RefPtr<CSSStyleValue const> list_type;
     int found_nones = 0;
 
     Vector<PropertyID> remaining_longhands { PropertyID::ListStyleImage, PropertyID::ListStylePosition, PropertyID::ListStyleType };
@@ -3200,7 +3200,7 @@ RefPtr<CSSStyleValue> Parser::parse_list_style_value(TokenStream<ComponentValue>
         { list_position.release_nonnull(), list_image.release_nonnull(), list_type.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_math_depth_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_math_depth_value(TokenStream<ComponentValue>& tokens)
 {
     // https://w3c.github.io/mathml-core/#propdef-math-depth
     // auto-add | add(<integer>) | <integer>
@@ -3240,7 +3240,7 @@ RefPtr<CSSStyleValue> Parser::parse_math_depth_value(TokenStream<ComponentValue>
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_overflow_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_overflow_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto maybe_x_value = parse_css_value_for_property(PropertyID::OverflowX, tokens);
@@ -3258,7 +3258,7 @@ RefPtr<CSSStyleValue> Parser::parse_overflow_value(TokenStream<ComponentValue>&
         { *maybe_x_value, *maybe_x_value });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_place_content_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_place_content_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto maybe_align_content_value = parse_css_value_for_property(PropertyID::AlignContent, tokens);
@@ -3283,7 +3283,7 @@ RefPtr<CSSStyleValue> Parser::parse_place_content_value(TokenStream<ComponentVal
         { maybe_align_content_value.release_nonnull(), maybe_justify_content_value.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_place_items_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_place_items_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto maybe_align_items_value = parse_css_value_for_property(PropertyID::AlignItems, tokens);
@@ -3308,7 +3308,7 @@ RefPtr<CSSStyleValue> Parser::parse_place_items_value(TokenStream<ComponentValue
         { *maybe_align_items_value, *maybe_justify_items_value });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_place_self_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_place_self_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto maybe_align_self_value = parse_css_value_for_property(PropertyID::AlignSelf, tokens);
@@ -3333,7 +3333,7 @@ RefPtr<CSSStyleValue> Parser::parse_place_self_value(TokenStream<ComponentValue>
         { *maybe_align_self_value, *maybe_justify_self_value });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_quotes_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_quotes_value(TokenStream<ComponentValue>& tokens)
 {
     // https://www.w3.org/TR/css-content-3/#quotes-property
     // auto | none | [ <string> <string> ]+
@@ -3365,12 +3365,12 @@ RefPtr<CSSStyleValue> Parser::parse_quotes_value(TokenStream<ComponentValue>& to
     return StyleValueList::create(move(string_values), StyleValueList::Separator::Space);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_text_decoration_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_text_decoration_value(TokenStream<ComponentValue>& tokens)
 {
-    RefPtr<CSSStyleValue> decoration_line;
-    RefPtr<CSSStyleValue> decoration_thickness;
-    RefPtr<CSSStyleValue> decoration_style;
-    RefPtr<CSSStyleValue> decoration_color;
+    RefPtr<CSSStyleValue const> decoration_line;
+    RefPtr<CSSStyleValue const> decoration_thickness;
+    RefPtr<CSSStyleValue const> decoration_style;
+    RefPtr<CSSStyleValue const> decoration_color;
 
     auto remaining_longhands = Vector { PropertyID::TextDecorationColor, PropertyID::TextDecorationLine, PropertyID::TextDecorationStyle, PropertyID::TextDecorationThickness };
 
@@ -3427,7 +3427,7 @@ RefPtr<CSSStyleValue> Parser::parse_text_decoration_value(TokenStream<ComponentV
         { decoration_line.release_nonnull(), decoration_thickness.release_nonnull(), decoration_style.release_nonnull(), decoration_color.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_text_decoration_line_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_text_decoration_line_value(TokenStream<ComponentValue>& tokens)
 {
     StyleValueVector style_values;
 
@@ -3475,7 +3475,7 @@ RefPtr<CSSStyleValue> Parser::parse_text_decoration_line_value(TokenStream<Compo
 }
 
 // https://www.w3.org/TR/css-transforms-1/#transform-property
-RefPtr<CSSStyleValue> Parser::parse_transform_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_transform_value(TokenStream<ComponentValue>& tokens)
 {
     // <transform> = none | <transform-list>
     // <transform-list> = <transform-function>+
@@ -3581,7 +3581,7 @@ RefPtr<CSSStyleValue> Parser::parse_transform_value(TokenStream<ComponentValue>&
 
 // https://www.w3.org/TR/css-transforms-1/#propdef-transform-origin
 // FIXME: This only supports a 2D position
-RefPtr<CSSStyleValue> Parser::parse_transform_origin_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_transform_origin_value(TokenStream<ComponentValue>& tokens)
 {
     enum class Axis {
         None,
@@ -3591,10 +3591,10 @@ RefPtr<CSSStyleValue> Parser::parse_transform_origin_value(TokenStream<Component
 
     struct AxisOffset {
         Axis axis;
-        NonnullRefPtr<CSSStyleValue> offset;
+        NonnullRefPtr<CSSStyleValue const> offset;
     };
 
-    auto to_axis_offset = [](RefPtr<CSSStyleValue> value) -> Optional<AxisOffset> {
+    auto to_axis_offset = [](RefPtr<CSSStyleValue const> value) -> Optional<AxisOffset> {
         if (!value)
             return OptionalNone {};
         if (value->is_percentage())
@@ -3625,7 +3625,7 @@ RefPtr<CSSStyleValue> Parser::parse_transform_origin_value(TokenStream<Component
 
     auto transaction = tokens.begin_transaction();
 
-    auto make_list = [&transaction](NonnullRefPtr<CSSStyleValue> const& x_value, NonnullRefPtr<CSSStyleValue> const& y_value) -> NonnullRefPtr<StyleValueList> {
+    auto make_list = [&transaction](NonnullRefPtr<CSSStyleValue const> const& x_value, NonnullRefPtr<CSSStyleValue const> const& y_value) -> NonnullRefPtr<StyleValueList> {
         transaction.commit();
         return StyleValueList::create(StyleValueVector { x_value, y_value }, StyleValueList::Separator::Space);
     };
@@ -3652,8 +3652,8 @@ RefPtr<CSSStyleValue> Parser::parse_transform_origin_value(TokenStream<Component
         if (!first_value.has_value() || !second_value.has_value())
             return nullptr;
 
-        RefPtr<CSSStyleValue> x_value;
-        RefPtr<CSSStyleValue> y_value;
+        RefPtr<CSSStyleValue const> x_value;
+        RefPtr<CSSStyleValue const> y_value;
 
         if (first_value->axis == Axis::X) {
             x_value = first_value->offset;
@@ -3696,7 +3696,7 @@ RefPtr<CSSStyleValue> Parser::parse_transform_origin_value(TokenStream<Component
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_transition_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_transition_value(TokenStream<ComponentValue>& tokens)
 {
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
         return none;
@@ -3775,7 +3775,7 @@ RefPtr<CSSStyleValue> Parser::parse_transition_value(TokenStream<ComponentValue>
     return TransitionStyleValue::create(move(transitions));
 }
 
-RefPtr<CSSStyleValue> Parser::parse_translate_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_translate_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.remaining_token_count() == 1) {
         // "none"
@@ -3802,7 +3802,7 @@ RefPtr<CSSStyleValue> Parser::parse_translate_value(TokenStream<ComponentValue>&
     return TransformationStyleValue::create(PropertyID::Translate, TransformFunction::Translate, { maybe_x.release_nonnull(), maybe_y.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_scale_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_scale_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.remaining_token_count() == 1) {
         // "none"
@@ -3830,7 +3830,7 @@ RefPtr<CSSStyleValue> Parser::parse_scale_value(TokenStream<ComponentValue>& tok
 }
 
 // https://drafts.csswg.org/css-overflow/#propdef-scrollbar-gutter
-RefPtr<CSSStyleValue> Parser::parse_scrollbar_gutter_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_scrollbar_gutter_value(TokenStream<ComponentValue>& tokens)
 {
     // auto | stable && both-edges?
     if (!tokens.has_next_token())
@@ -3893,7 +3893,7 @@ RefPtr<CSSStyleValue> Parser::parse_scrollbar_gutter_value(TokenStream<Component
     return ScrollbarGutterStyleValue::create(gutter_value);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_grid_track_placement_shorthand_value(PropertyID property_id, TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_grid_track_placement_shorthand_value(PropertyID property_id, TokenStream<ComponentValue>& tokens)
 {
     auto start_property = (property_id == PropertyID::GridColumn) ? PropertyID::GridColumnStart : PropertyID::GridRowStart;
     auto end_property = (property_id == PropertyID::GridColumn) ? PropertyID::GridColumnEnd : PropertyID::GridRowEnd;
@@ -3952,7 +3952,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_track_placement_shorthand_value(Propert
 
 // https://www.w3.org/TR/css-grid-2/#explicit-grid-shorthand
 // 7.4. Explicit Grid Shorthand: the grid-template property
-RefPtr<CSSStyleValue> Parser::parse_grid_track_size_list_shorthand_value(PropertyID property_id, TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_grid_track_size_list_shorthand_value(PropertyID property_id, TokenStream<ComponentValue>& tokens)
 {
     // The grid-template property is a shorthand for setting grid-template-columns, grid-template-rows,
     // and grid-template-areas in a single declaration. It has several distinct syntax forms:
@@ -4010,7 +4010,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_track_size_list_shorthand_value(Propert
         { parsed_template_areas_values.release_nonnull(), parsed_template_rows_values.release_nonnull(), parsed_template_columns_values.release_nonnull() });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_grid_area_shorthand_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_grid_area_shorthand_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
 
@@ -4099,7 +4099,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_area_shorthand_value(TokenStream<Compon
         { GridTrackPlacementStyleValue::create(row_start), GridTrackPlacementStyleValue::create(column_start), GridTrackPlacementStyleValue::create(row_end), GridTrackPlacementStyleValue::create(column_end) });
 }
 
-RefPtr<CSSStyleValue> Parser::parse_grid_shorthand_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_grid_shorthand_value(TokenStream<ComponentValue>& tokens)
 {
     // <'grid-template'> |
     // FIXME: <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? |
@@ -4108,7 +4108,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_shorthand_value(TokenStream<ComponentVa
 }
 
 // https://www.w3.org/TR/css-grid-1/#grid-template-areas-property
-RefPtr<CSSStyleValue> Parser::parse_grid_template_areas_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_grid_template_areas_value(TokenStream<ComponentValue>& tokens)
 {
     // none | <string>+
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
@@ -4169,7 +4169,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_template_areas_value(TokenStream<Compon
     return GridTemplateAreaStyleValue::create(grid_area_rows);
 }
 
-RefPtr<CSSStyleValue> Parser::parse_grid_auto_track_sizes(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_grid_auto_track_sizes(TokenStream<ComponentValue>& tokens)
 {
     // https://www.w3.org/TR/css-grid-2/#auto-tracks
     // <track-size>+
@@ -4191,7 +4191,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_auto_track_sizes(TokenStream<ComponentV
 }
 
 // https://www.w3.org/TR/css-grid-1/#grid-auto-flow-property
-RefPtr<GridAutoFlowStyleValue> Parser::parse_grid_auto_flow_value(TokenStream<ComponentValue>& tokens)
+RefPtr<GridAutoFlowStyleValue const> Parser::parse_grid_auto_flow_value(TokenStream<ComponentValue>& tokens)
 {
     // [ row | column ] || dense
     if (!tokens.has_next_token())
@@ -4243,7 +4243,7 @@ RefPtr<GridAutoFlowStyleValue> Parser::parse_grid_auto_flow_value(TokenStream<Co
     return GridAutoFlowStyleValue::create(axis.value_or(GridAutoFlowStyleValue::Axis::Row), dense.value_or(GridAutoFlowStyleValue::Dense::No));
 }
 
-RefPtr<CSSStyleValue> Parser::parse_grid_track_size_list(TokenStream<ComponentValue>& tokens, bool allow_separate_line_name_blocks)
+RefPtr<CSSStyleValue const> Parser::parse_grid_track_size_list(TokenStream<ComponentValue>& tokens, bool allow_separate_line_name_blocks)
 {
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
         return GridTrackSizeListStyleValue::make_none();
@@ -4290,7 +4290,7 @@ RefPtr<CSSStyleValue> Parser::parse_grid_track_size_list(TokenStream<ComponentVa
     return GridTrackSizeListStyleValue::create(GridTrackSizeList(move(track_list)));
 }
 
-RefPtr<CSSStyleValue> Parser::parse_filter_value_list_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_filter_value_list_value(TokenStream<ComponentValue>& tokens)
 {
     if (auto none = parse_all_as_single_keyword_value(tokens, Keyword::None))
         return none;
diff --git a/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp b/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp
index de02d4ba10f..060523104be 100644
--- a/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp
@@ -538,7 +538,7 @@ GC::Ptr<CSSPropertyRule> Parser::convert_to_property_rule(AtRule const& rule)
 
     Optional<FlyString> syntax_maybe;
     Optional<bool> inherits_maybe;
-    RefPtr<CSSStyleValue> initial_value_maybe;
+    RefPtr<CSSStyleValue const> initial_value_maybe;
 
     rule.for_each_as_declaration_list([&](auto& declaration) {
         if (auto descriptor = convert_to_descriptor(AtRuleID::Property, declaration); descriptor.has_value()) {
diff --git a/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp b/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
index d8842a75b82..4dcccc53359 100644
--- a/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
@@ -66,7 +66,7 @@
 
 namespace Web::CSS::Parser {
 
-RefPtr<CSSStyleValue> Parser::parse_comma_separated_value_list(TokenStream<ComponentValue>& tokens, ParseFunction parse_one_value)
+RefPtr<CSSStyleValue const> Parser::parse_comma_separated_value_list(TokenStream<ComponentValue>& tokens, ParseFunction parse_one_value)
 {
     auto first = parse_one_value(tokens);
     if (!first || !tokens.has_next_token())
@@ -338,7 +338,7 @@ Optional<Ratio> Parser::parse_ratio(TokenStream<ComponentValue>& tokens)
 }
 
 // https://drafts.csswg.org/css-fonts-4/#family-name-syntax
-RefPtr<CSSStyleValue> Parser::parse_family_name_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_family_name_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     tokens.discard_whitespace();
@@ -647,14 +647,14 @@ Vector<Gfx::UnicodeRange> Parser::parse_unicode_ranges(TokenStream<ComponentValu
     return unicode_ranges;
 }
 
-RefPtr<UnicodeRangeStyleValue> Parser::parse_unicode_range_value(TokenStream<ComponentValue>& tokens)
+RefPtr<UnicodeRangeStyleValue const> Parser::parse_unicode_range_value(TokenStream<ComponentValue>& tokens)
 {
     if (auto range = parse_unicode_range(tokens); range.has_value())
         return UnicodeRangeStyleValue::create(range.release_value());
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_integer_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_integer_value(TokenStream<ComponentValue>& tokens)
 {
     auto const& peek_token = tokens.next_token();
     if (peek_token.is(Token::Type::Number) && peek_token.token().number().is_integer()) {
@@ -671,7 +671,7 @@ RefPtr<CSSStyleValue> Parser::parse_integer_value(TokenStream<ComponentValue>& t
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_number_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_number_value(TokenStream<ComponentValue>& tokens)
 {
     auto const& peek_token = tokens.next_token();
     if (peek_token.is(Token::Type::Number)) {
@@ -688,7 +688,7 @@ RefPtr<CSSStyleValue> Parser::parse_number_value(TokenStream<ComponentValue>& to
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_number_percentage_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_number_percentage_value(TokenStream<ComponentValue>& tokens)
 {
     // Parses [<percentage> | <number>] (which is equivalent to [<alpha-value>])
     if (auto value = parse_number_value(tokens))
@@ -698,7 +698,7 @@ RefPtr<CSSStyleValue> Parser::parse_number_percentage_value(TokenStream<Componen
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_number_percentage_none_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_number_percentage_none_value(TokenStream<ComponentValue>& tokens)
 {
     // Parses [<percentage> | <number> | none] (which is equivalent to [<alpha-value> | none])
     if (auto value = parse_number_value(tokens))
@@ -714,7 +714,7 @@ RefPtr<CSSStyleValue> Parser::parse_number_percentage_none_value(TokenStream<Com
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_percentage_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_percentage_value(TokenStream<ComponentValue>& tokens)
 {
     auto const& peek_token = tokens.next_token();
     if (peek_token.is(Token::Type::Percentage)) {
@@ -731,7 +731,7 @@ RefPtr<CSSStyleValue> Parser::parse_percentage_value(TokenStream<ComponentValue>
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_angle_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_angle_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -762,7 +762,7 @@ RefPtr<CSSStyleValue> Parser::parse_angle_value(TokenStream<ComponentValue>& tok
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_angle_percentage_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_angle_percentage_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -796,7 +796,7 @@ RefPtr<CSSStyleValue> Parser::parse_angle_percentage_value(TokenStream<Component
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_flex_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_flex_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -818,7 +818,7 @@ RefPtr<CSSStyleValue> Parser::parse_flex_value(TokenStream<ComponentValue>& toke
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_frequency_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_frequency_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -840,7 +840,7 @@ RefPtr<CSSStyleValue> Parser::parse_frequency_value(TokenStream<ComponentValue>&
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_frequency_percentage_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_frequency_percentage_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -865,7 +865,7 @@ RefPtr<CSSStyleValue> Parser::parse_frequency_percentage_value(TokenStream<Compo
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_length_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_length_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -909,7 +909,7 @@ RefPtr<CSSStyleValue> Parser::parse_length_value(TokenStream<ComponentValue>& to
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_length_percentage_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_length_percentage_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -956,7 +956,7 @@ RefPtr<CSSStyleValue> Parser::parse_length_percentage_value(TokenStream<Componen
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_resolution_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_resolution_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -978,7 +978,7 @@ RefPtr<CSSStyleValue> Parser::parse_resolution_value(TokenStream<ComponentValue>
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_time_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_time_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -1000,7 +1000,7 @@ RefPtr<CSSStyleValue> Parser::parse_time_value(TokenStream<ComponentValue>& toke
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_time_percentage_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_time_percentage_value(TokenStream<ComponentValue>& tokens)
 {
     if (tokens.next_token().is(Token::Type::Dimension)) {
         auto transaction = tokens.begin_transaction();
@@ -1025,7 +1025,7 @@ RefPtr<CSSStyleValue> Parser::parse_time_percentage_value(TokenStream<ComponentV
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_keyword_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_keyword_value(TokenStream<ComponentValue>& tokens)
 {
     auto const& peek_token = tokens.next_token();
     if (peek_token.is(Token::Type::Ident)) {
@@ -1040,7 +1040,7 @@ RefPtr<CSSStyleValue> Parser::parse_keyword_value(TokenStream<ComponentValue>& t
 }
 
 // https://www.w3.org/TR/CSS2/visufx.html#value-def-shape
-RefPtr<CSSStyleValue> Parser::parse_rect_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_rect_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto const& function_token = tokens.consume_a_token();
@@ -1123,7 +1123,7 @@ RefPtr<CSSStyleValue> Parser::parse_rect_value(TokenStream<ComponentValue>& toke
 }
 
 // https://www.w3.org/TR/css-color-4/#typedef-hue
-RefPtr<CSSStyleValue> Parser::parse_hue_none_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_hue_none_value(TokenStream<ComponentValue>& tokens)
 {
     // Parses [<hue> | none]
     //   <hue> = <number> | <angle>
@@ -1141,7 +1141,7 @@ RefPtr<CSSStyleValue> Parser::parse_hue_none_value(TokenStream<ComponentValue>&
 }
 
 // https://www.w3.org/TR/css-color-4/#typedef-color-alpha-value
-RefPtr<CSSStyleValue> Parser::parse_solidus_and_alpha_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_solidus_and_alpha_value(TokenStream<ComponentValue>& tokens)
 {
     // [ / [<alpha-value> | none] ]?
     // <alpha-value> = <number> | <percentage>
@@ -1162,7 +1162,7 @@ RefPtr<CSSStyleValue> Parser::parse_solidus_and_alpha_value(TokenStream<Componen
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-rgb
-RefPtr<CSSStyleValue> Parser::parse_rgb_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_rgb_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // rgb() = [ <legacy-rgb-syntax> | <modern-rgb-syntax> ]
     // rgba() = [ <legacy-rgba-syntax> | <modern-rgba-syntax> ]
@@ -1186,10 +1186,10 @@ RefPtr<CSSStyleValue> Parser::parse_rgb_color_value(TokenStream<ComponentValue>&
 
     auto context_guard = push_temporary_value_parsing_context(FunctionContext { function_token.function().name });
 
-    RefPtr<CSSStyleValue> red;
-    RefPtr<CSSStyleValue> green;
-    RefPtr<CSSStyleValue> blue;
-    RefPtr<CSSStyleValue> alpha;
+    RefPtr<CSSStyleValue const> red;
+    RefPtr<CSSStyleValue const> green;
+    RefPtr<CSSStyleValue const> blue;
+    RefPtr<CSSStyleValue const> alpha;
 
     auto inner_tokens = TokenStream { function_token.function().value };
     inner_tokens.discard_whitespace();
@@ -1284,7 +1284,7 @@ RefPtr<CSSStyleValue> Parser::parse_rgb_color_value(TokenStream<ComponentValue>&
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-hsl
-RefPtr<CSSStyleValue> Parser::parse_hsl_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_hsl_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // hsl() = [ <legacy-hsl-syntax> | <modern-hsl-syntax> ]
     // hsla() = [ <legacy-hsla-syntax> | <modern-hsla-syntax> ]
@@ -1310,10 +1310,10 @@ RefPtr<CSSStyleValue> Parser::parse_hsl_color_value(TokenStream<ComponentValue>&
 
     auto context_guard = push_temporary_value_parsing_context(FunctionContext { function_token.function().name });
 
-    RefPtr<CSSStyleValue> h;
-    RefPtr<CSSStyleValue> s;
-    RefPtr<CSSStyleValue> l;
-    RefPtr<CSSStyleValue> alpha;
+    RefPtr<CSSStyleValue const> h;
+    RefPtr<CSSStyleValue const> s;
+    RefPtr<CSSStyleValue const> l;
+    RefPtr<CSSStyleValue const> alpha;
 
     auto inner_tokens = TokenStream { function_token.function().value };
     inner_tokens.discard_whitespace();
@@ -1396,7 +1396,7 @@ RefPtr<CSSStyleValue> Parser::parse_hsl_color_value(TokenStream<ComponentValue>&
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-hwb
-RefPtr<CSSStyleValue> Parser::parse_hwb_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_hwb_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // hwb() = hwb(
     //     [<hue> | none]
@@ -1413,10 +1413,10 @@ RefPtr<CSSStyleValue> Parser::parse_hwb_color_value(TokenStream<ComponentValue>&
 
     auto context_guard = push_temporary_value_parsing_context(FunctionContext { function_token.function().name });
 
-    RefPtr<CSSStyleValue> h;
-    RefPtr<CSSStyleValue> w;
-    RefPtr<CSSStyleValue> b;
-    RefPtr<CSSStyleValue> alpha;
+    RefPtr<CSSStyleValue const> h;
+    RefPtr<CSSStyleValue const> w;
+    RefPtr<CSSStyleValue const> b;
+    RefPtr<CSSStyleValue const> alpha;
 
     auto inner_tokens = TokenStream { function_token.function().value };
     inner_tokens.discard_whitespace();
@@ -1449,7 +1449,7 @@ RefPtr<CSSStyleValue> Parser::parse_hwb_color_value(TokenStream<ComponentValue>&
     return CSSHWB::create(h.release_nonnull(), w.release_nonnull(), b.release_nonnull(), alpha.release_nonnull());
 }
 
-Optional<Array<RefPtr<CSSStyleValue>, 4>> Parser::parse_lab_like_color_value(TokenStream<ComponentValue>& outer_tokens, StringView function_name)
+Optional<Array<RefPtr<CSSStyleValue const>, 4>> Parser::parse_lab_like_color_value(TokenStream<ComponentValue>& outer_tokens, StringView function_name)
 {
     // This helper is designed to be compatible with lab and oklab and parses a function with a form like:
     // f() = f( [ <percentage> | <number> | none]
@@ -1464,10 +1464,10 @@ Optional<Array<RefPtr<CSSStyleValue>, 4>> Parser::parse_lab_like_color_value(Tok
     if (!function_token.is_function(function_name))
         return OptionalNone {};
 
-    RefPtr<CSSStyleValue> l;
-    RefPtr<CSSStyleValue> a;
-    RefPtr<CSSStyleValue> b;
-    RefPtr<CSSStyleValue> alpha;
+    RefPtr<CSSStyleValue const> l;
+    RefPtr<CSSStyleValue const> a;
+    RefPtr<CSSStyleValue const> b;
+    RefPtr<CSSStyleValue const> alpha;
 
     auto inner_tokens = TokenStream { function_token.function().value };
     inner_tokens.discard_whitespace();
@@ -1502,7 +1502,7 @@ Optional<Array<RefPtr<CSSStyleValue>, 4>> Parser::parse_lab_like_color_value(Tok
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-lab
-RefPtr<CSSStyleValue> Parser::parse_lab_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_lab_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // lab() = lab( [<percentage> | <number> | none]
     //      [ <percentage> | <number> | none]
@@ -1522,7 +1522,7 @@ RefPtr<CSSStyleValue> Parser::parse_lab_color_value(TokenStream<ComponentValue>&
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-oklab
-RefPtr<CSSStyleValue> Parser::parse_oklab_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_oklab_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // oklab() = oklab( [ <percentage> | <number> | none]
     //     [ <percentage> | <number> | none]
@@ -1541,7 +1541,7 @@ RefPtr<CSSStyleValue> Parser::parse_oklab_color_value(TokenStream<ComponentValue
         color_values[3].release_nonnull());
 }
 
-Optional<Array<RefPtr<CSSStyleValue>, 4>> Parser::parse_lch_like_color_value(TokenStream<ComponentValue>& outer_tokens, StringView function_name)
+Optional<Array<RefPtr<CSSStyleValue const>, 4>> Parser::parse_lch_like_color_value(TokenStream<ComponentValue>& outer_tokens, StringView function_name)
 {
     // This helper is designed to be compatible with lch and oklch and parses a function with a form like:
     // f() = f( [<percentage> | <number> | none]
@@ -1574,7 +1574,7 @@ Optional<Array<RefPtr<CSSStyleValue>, 4>> Parser::parse_lch_like_color_value(Tok
         return OptionalNone {};
     inner_tokens.discard_whitespace();
 
-    RefPtr<CSSStyleValue> alpha;
+    RefPtr<CSSStyleValue const> alpha;
     if (inner_tokens.has_next_token()) {
         alpha = parse_solidus_and_alpha_value(inner_tokens);
         if (!alpha || inner_tokens.has_next_token())
@@ -1590,7 +1590,7 @@ Optional<Array<RefPtr<CSSStyleValue>, 4>> Parser::parse_lch_like_color_value(Tok
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-lch
-RefPtr<CSSStyleValue> Parser::parse_lch_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_lch_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // lch() = lch( [<percentage> | <number> | none]
     //      [ <percentage> | <number> | none]
@@ -1610,7 +1610,7 @@ RefPtr<CSSStyleValue> Parser::parse_lch_color_value(TokenStream<ComponentValue>&
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-oklch
-RefPtr<CSSStyleValue> Parser::parse_oklch_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_oklch_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     // oklch() = oklch( [ <percentage> | <number> | none]
     //     [ <percentage> | <number> | none]
@@ -1630,7 +1630,7 @@ RefPtr<CSSStyleValue> Parser::parse_oklch_color_value(TokenStream<ComponentValue
 }
 
 // https://www.w3.org/TR/css-color-4/#funcdef-color
-RefPtr<CSSStyleValue> Parser::parse_color_function(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_color_function(TokenStream<ComponentValue>& outer_tokens)
 {
     // color() = color( <colorspace-params> [ / [ <alpha-value> | none ] ]? )
     //     <colorspace-params> = [ <predefined-rgb-params> | <xyz-params>]
@@ -1673,7 +1673,7 @@ RefPtr<CSSStyleValue> Parser::parse_color_function(TokenStream<ComponentValue>&
         return {};
     inner_tokens.discard_whitespace();
 
-    RefPtr<CSSStyleValue> alpha;
+    RefPtr<CSSStyleValue const> alpha;
     if (inner_tokens.has_next_token()) {
         alpha = parse_solidus_and_alpha_value(inner_tokens);
         if (!alpha || inner_tokens.has_next_token())
@@ -1692,7 +1692,7 @@ RefPtr<CSSStyleValue> Parser::parse_color_function(TokenStream<ComponentValue>&
 }
 
 // https://drafts.csswg.org/css-color-5/#funcdef-light-dark
-RefPtr<CSSStyleValue> Parser::parse_light_dark_color_value(TokenStream<ComponentValue>& outer_tokens)
+RefPtr<CSSStyleValue const> Parser::parse_light_dark_color_value(TokenStream<ComponentValue>& outer_tokens)
 {
     auto transaction = outer_tokens.begin_transaction();
 
@@ -1726,7 +1726,7 @@ RefPtr<CSSStyleValue> Parser::parse_light_dark_color_value(TokenStream<Component
 }
 
 // https://www.w3.org/TR/css-color-4/#color-syntax
-RefPtr<CSSStyleValue> Parser::parse_color_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_color_value(TokenStream<ComponentValue>& tokens)
 {
 
     // Keywords: <system-color> | <deprecated-color> | currentColor
@@ -1873,7 +1873,7 @@ RefPtr<CSSStyleValue> Parser::parse_color_value(TokenStream<ComponentValue>& tok
 }
 
 // https://drafts.csswg.org/css-lists-3/#counter-functions
-RefPtr<CSSStyleValue> Parser::parse_counter_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_counter_value(TokenStream<ComponentValue>& tokens)
 {
     auto parse_counter_name = [this](TokenStream<ComponentValue>& tokens) -> Optional<FlyString> {
         // https://drafts.csswg.org/css-lists-3/#typedef-counter-name
@@ -1895,7 +1895,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_value(TokenStream<ComponentValue>& t
         return counter_name->custom_ident();
     };
 
-    auto parse_counter_style = [this](TokenStream<ComponentValue>& tokens) -> RefPtr<CSSStyleValue> {
+    auto parse_counter_style = [this](TokenStream<ComponentValue>& tokens) -> RefPtr<CSSStyleValue const> {
         // https://drafts.csswg.org/css-counter-styles-3/#typedef-counter-style
         // <counter-style> = <counter-style-name> | <symbols()>
         // For now we just support <counter-style-name>, found here:
@@ -1933,7 +1933,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_value(TokenStream<ComponentValue>& t
         if (!counter_name.has_value())
             return nullptr;
 
-        RefPtr<CSSStyleValue> counter_style;
+        RefPtr<CSSStyleValue const> counter_style;
         if (function_values.size() > 1) {
             TokenStream counter_style_tokens { function_values[1] };
             counter_style = parse_counter_style(counter_style_tokens);
@@ -1970,7 +1970,7 @@ RefPtr<CSSStyleValue> Parser::parse_counter_value(TokenStream<ComponentValue>& t
         if (!join_string || string_tokens.has_next_token())
             return nullptr;
 
-        RefPtr<CSSStyleValue> counter_style;
+        RefPtr<CSSStyleValue const> counter_style;
         if (function_values.size() > 2) {
             TokenStream counter_style_tokens { function_values[2] };
             counter_style = parse_counter_style(counter_style_tokens);
@@ -1988,14 +1988,14 @@ RefPtr<CSSStyleValue> Parser::parse_counter_value(TokenStream<ComponentValue>& t
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_ratio_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_ratio_value(TokenStream<ComponentValue>& tokens)
 {
     if (auto ratio = parse_ratio(tokens); ratio.has_value())
         return RatioStyleValue::create(ratio.release_value());
     return nullptr;
 }
 
-RefPtr<StringStyleValue> Parser::parse_string_value(TokenStream<ComponentValue>& tokens)
+RefPtr<StringStyleValue const> Parser::parse_string_value(TokenStream<ComponentValue>& tokens)
 {
     auto const& peek = tokens.next_token();
     if (peek.is(Token::Type::String)) {
@@ -2006,7 +2006,7 @@ RefPtr<StringStyleValue> Parser::parse_string_value(TokenStream<ComponentValue>&
     return nullptr;
 }
 
-RefPtr<AbstractImageStyleValue> Parser::parse_image_value(TokenStream<ComponentValue>& tokens)
+RefPtr<AbstractImageStyleValue const> Parser::parse_image_value(TokenStream<ComponentValue>& tokens)
 {
     tokens.mark();
     auto url = parse_url_function(tokens);
@@ -2036,11 +2036,11 @@ RefPtr<AbstractImageStyleValue> Parser::parse_image_value(TokenStream<ComponentV
 }
 
 // https://svgwg.org/svg2-draft/painting.html#SpecifyingPaint
-RefPtr<CSSStyleValue> Parser::parse_paint_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_paint_value(TokenStream<ComponentValue>& tokens)
 {
     // `<paint> = none | <color> | <url> [none | <color>]? | context-fill | context-stroke`
 
-    auto parse_color_or_none = [&]() -> Optional<RefPtr<CSSStyleValue>> {
+    auto parse_color_or_none = [&]() -> Optional<RefPtr<CSSStyleValue const>> {
         if (auto color = parse_color_value(tokens))
             return color;
 
@@ -2080,7 +2080,7 @@ RefPtr<CSSStyleValue> Parser::parse_paint_value(TokenStream<ComponentValue>& tok
 }
 
 // https://www.w3.org/TR/css-values-4/#position
-RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentValue>& tokens, PositionParsingMode position_parsing_mode)
+RefPtr<PositionStyleValue const> Parser::parse_position_value(TokenStream<ComponentValue>& tokens, PositionParsingMode position_parsing_mode)
 {
     auto parse_position_edge = [](TokenStream<ComponentValue>& tokens) -> Optional<PositionEdge> {
         auto transaction = tokens.begin_transaction();
@@ -2131,7 +2131,7 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
     // ]
 
     // [ left | center | right | top | bottom | <length-percentage> ]
-    auto alternative_1 = [&]() -> RefPtr<PositionStyleValue> {
+    auto alternative_1 = [&]() -> RefPtr<PositionStyleValue const> {
         auto transaction = tokens.begin_transaction();
 
         tokens.discard_whitespace();
@@ -2164,7 +2164,7 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
     };
 
     // [ left | center | right ] && [ top | center | bottom ]
-    auto alternative_2 = [&]() -> RefPtr<PositionStyleValue> {
+    auto alternative_2 = [&]() -> RefPtr<PositionStyleValue const> {
         auto transaction = tokens.begin_transaction();
 
         tokens.discard_whitespace();
@@ -2200,10 +2200,10 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
 
     // [ left | center | right | <length-percentage> ]
     // [ top | center | bottom | <length-percentage> ]
-    auto alternative_3 = [&]() -> RefPtr<PositionStyleValue> {
+    auto alternative_3 = [&]() -> RefPtr<PositionStyleValue const> {
         auto transaction = tokens.begin_transaction();
 
-        auto parse_position_or_length = [&](bool as_horizontal) -> RefPtr<EdgeStyleValue> {
+        auto parse_position_or_length = [&](bool as_horizontal) -> RefPtr<EdgeStyleValue const> {
             tokens.discard_whitespace();
 
             if (auto maybe_position = parse_position_edge(tokens); maybe_position.has_value()) {
@@ -2237,7 +2237,7 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
 
     // [ [ left | right ] <length-percentage> ] &&
     // [ [ top | bottom ] <length-percentage> ]
-    auto alternative_4 = [&]() -> RefPtr<PositionStyleValue> {
+    auto alternative_4 = [&]() -> RefPtr<PositionStyleValue const> {
         struct PositionAndLength {
             PositionEdge position;
             LengthPercentage length;
@@ -2293,7 +2293,7 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
     // The extra 3-value syntax that's allowed for background-position:
     // [ center | [ left | right ] <length-percentage>? ] &&
     // [ center | [ top | bottom ] <length-percentage>? ]
-    auto alternative_5_for_background_position = [&]() -> RefPtr<PositionStyleValue> {
+    auto alternative_5_for_background_position = [&]() -> RefPtr<PositionStyleValue const> {
         auto transaction = tokens.begin_transaction();
 
         struct PositionAndMaybeLength {
@@ -2355,7 +2355,7 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
         if (!is_vertical(group2.position, true))
             return nullptr;
 
-        auto to_style_value = [&](PositionAndMaybeLength const& group) -> NonnullRefPtr<EdgeStyleValue> {
+        auto to_style_value = [&](PositionAndMaybeLength const& group) -> NonnullRefPtr<EdgeStyleValue const> {
             if (group.position == PositionEdge::Center)
                 return EdgeStyleValue::create(PositionEdge::Center, {});
 
@@ -2382,7 +2382,7 @@ RefPtr<PositionStyleValue> Parser::parse_position_value(TokenStream<ComponentVal
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_easing_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_easing_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
 
@@ -2392,7 +2392,7 @@ RefPtr<CSSStyleValue> Parser::parse_easing_value(TokenStream<ComponentValue>& to
 
     if (part.is(Token::Type::Ident)) {
         auto name = part.token().ident();
-        auto maybe_simple_easing = [&] -> RefPtr<EasingStyleValue> {
+        auto maybe_simple_easing = [&] -> RefPtr<EasingStyleValue const> {
             if (name.equals_ignoring_ascii_case("linear"sv))
                 return EasingStyleValue::create(EasingStyleValue::Linear::identity());
             if (name.equals_ignoring_ascii_case("ease"sv))
@@ -2590,7 +2590,7 @@ Optional<URL> Parser::parse_url_function(TokenStream<ComponentValue>& tokens)
     return {};
 }
 
-RefPtr<CSSStyleValue> Parser::parse_url_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_url_value(TokenStream<ComponentValue>& tokens)
 {
     auto url = parse_url_function(tokens);
     if (!url.has_value())
@@ -2633,7 +2633,7 @@ Optional<ShapeRadius> Parser::parse_shape_radius(TokenStream<ComponentValue>& to
     return {};
 }
 
-RefPtr<FitContentStyleValue> Parser::parse_fit_content_value(TokenStream<ComponentValue>& tokens)
+RefPtr<FitContentStyleValue const> Parser::parse_fit_content_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto& component_value = tokens.consume_a_token();
@@ -2663,7 +2663,7 @@ RefPtr<FitContentStyleValue> Parser::parse_fit_content_value(TokenStream<Compone
     return FitContentStyleValue::create(maybe_length.release_value());
 }
 
-RefPtr<CSSStyleValue> Parser::parse_basic_shape_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_basic_shape_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto& component_value = tokens.consume_a_token();
@@ -2905,7 +2905,7 @@ RefPtr<CSSStyleValue> Parser::parse_basic_shape_value(TokenStream<ComponentValue
     return nullptr;
 }
 
-RefPtr<CSSStyleValue> Parser::parse_builtin_value(TokenStream<ComponentValue>& tokens)
+RefPtr<CSSStyleValue const> Parser::parse_builtin_value(TokenStream<ComponentValue>& tokens)
 {
     auto transaction = tokens.begin_transaction();
     auto& component_value = tokens.consume_a_token();
@@ -2967,7 +2967,7 @@ Optional<FlyString> Parser::parse_custom_ident(TokenStream<ComponentValue>& toke
     return custom_ident;
 }
 
-RefPtr<CustomIdentStyleValue> Parser::parse_custom_ident_value(TokenStream<ComponentValue>& tokens, ReadonlySpan<StringView> blacklist)
+RefPtr<CustomIdentStyleValue const> Parser::parse_custom_ident_value(TokenStream<ComponentValue>& tokens, ReadonlySpan<StringView> blacklist)
 {
     if (auto custom_ident = parse_custom_ident(tokens, blacklist); custom_ident.has_value())
         return CustomIdentStyleValue::create(custom_ident.release_value());
@@ -3213,7 +3213,7 @@ Optional<CSS::ExplicitGridTrack> Parser::parse_track_sizing_function(ComponentVa
     }
 }
 
-RefPtr<GridTrackPlacementStyleValue> Parser::parse_grid_track_placement(TokenStream<ComponentValue>& tokens)
+RefPtr<GridTrackPlacementStyleValue const> Parser::parse_grid_track_placement(TokenStream<ComponentValue>& tokens)
 {
     // FIXME: This shouldn't be needed. Right now, the below code returns a CSSStyleValue even if no tokens are consumed!
     if (!tokens.has_next_token())
@@ -3319,7 +3319,7 @@ RefPtr<GridTrackPlacementStyleValue> Parser::parse_grid_track_placement(TokenStr
     return GridTrackPlacementStyleValue::create(GridTrackPlacement::make_span(span_or_position_value));
 }
 
-RefPtr<CSSStyleValue> Parser::parse_calculated_value(ComponentValue const& component_value)
+RefPtr<CSSStyleValue const> Parser::parse_calculated_value(ComponentValue const& component_value)
 {
     if (!component_value.is_function())
         return nullptr;
@@ -3633,7 +3633,7 @@ RefPtr<CalculationNode> Parser::parse_a_calculation(Vector<ComponentValue> const
 }
 
 // https://drafts.csswg.org/css-fonts/#typedef-opentype-tag
-RefPtr<StringStyleValue> Parser::parse_opentype_tag_value(TokenStream<ComponentValue>& tokens)
+RefPtr<StringStyleValue const> Parser::parse_opentype_tag_value(TokenStream<ComponentValue>& tokens)
 {
     // <opentype-tag> = <string>
     // The <opentype-tag> is a case-sensitive OpenType feature tag.
@@ -3657,7 +3657,7 @@ RefPtr<StringStyleValue> Parser::parse_opentype_tag_value(TokenStream<ComponentV
     return string_value;
 }
 
-RefPtr<FontSourceStyleValue> Parser::parse_font_source_value(TokenStream<ComponentValue>& tokens)
+RefPtr<FontSourceStyleValue const> Parser::parse_font_source_value(TokenStream<ComponentValue>& tokens)
 {
     // <font-src> = <url> [ format(<font-format>)]? [ tech( <font-tech>#)]? | local(<family-name>)
     auto transaction = tokens.begin_transaction();
@@ -3728,7 +3728,7 @@ RefPtr<FontSourceStyleValue> Parser::parse_font_source_value(TokenStream<Compone
     return FontSourceStyleValue::create(completed_url.release_value(), move(format));
 }
 
-NonnullRefPtr<CSSStyleValue> Parser::resolve_unresolved_style_value(ParsingParams const& context, DOM::Element& element, Optional<PseudoElement> pseudo_element, PropertyID property_id, UnresolvedStyleValue const& unresolved)
+NonnullRefPtr<CSSStyleValue const> Parser::resolve_unresolved_style_value(ParsingParams const& context, DOM::Element& element, Optional<PseudoElement> pseudo_element, PropertyID property_id, UnresolvedStyleValue const& unresolved)
 {
     // Unresolved always contains a var() or attr(), unless it is a custom property's value, in which case we shouldn't be trying
     // to produce a different CSSStyleValue from it.
@@ -3783,7 +3783,7 @@ private:
     bool m_marked { false };
 };
 
-NonnullRefPtr<CSSStyleValue> Parser::resolve_unresolved_style_value(DOM::Element& element, Optional<PseudoElement> pseudo_element, PropertyID property_id, UnresolvedStyleValue const& unresolved)
+NonnullRefPtr<CSSStyleValue const> Parser::resolve_unresolved_style_value(DOM::Element& element, Optional<PseudoElement> pseudo_element, PropertyID property_id, UnresolvedStyleValue const& unresolved)
 {
     TokenStream unresolved_values_without_variables_expanded { unresolved.values() };
     Vector<ComponentValue> values_with_variables_expanded;
diff --git a/Libraries/LibWeb/CSS/PercentageOr.h b/Libraries/LibWeb/CSS/PercentageOr.h
index 2098d60dc8a..52be7b8bef2 100644
--- a/Libraries/LibWeb/CSS/PercentageOr.h
+++ b/Libraries/LibWeb/CSS/PercentageOr.h
@@ -31,7 +31,7 @@ public:
     {
     }
 
-    PercentageOr(NonnullRefPtr<CalculatedStyleValue> calculated)
+    PercentageOr(NonnullRefPtr<CalculatedStyleValue const> calculated)
         : m_value(move(calculated))
     {
     }
@@ -51,7 +51,7 @@ public:
     }
 
     bool is_percentage() const { return m_value.template has<Percentage>(); }
-    bool is_calculated() const { return m_value.template has<NonnullRefPtr<CalculatedStyleValue>>(); }
+    bool is_calculated() const { return m_value.template has<NonnullRefPtr<CalculatedStyleValue const>>(); }
 
     bool contains_percentage() const
     {
@@ -62,7 +62,7 @@ public:
             [&](Percentage const&) {
                 return true;
             },
-            [&](NonnullRefPtr<CalculatedStyleValue> const& calculated) {
+            [&](NonnullRefPtr<CalculatedStyleValue const> const& calculated) {
                 return calculated->contains_percentage();
             });
     }
@@ -73,10 +73,10 @@ public:
         return m_value.template get<Percentage>();
     }
 
-    NonnullRefPtr<CalculatedStyleValue> const& calculated() const
+    NonnullRefPtr<CalculatedStyleValue const> const& calculated() const
     {
         VERIFY(is_calculated());
-        return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>();
+        return m_value.template get<NonnullRefPtr<CalculatedStyleValue const>>();
     }
 
     CSSPixels to_px(Layout::Node const& layout_node, CSSPixels reference_value) const
@@ -100,7 +100,7 @@ public:
             [&](Percentage const& percentage) {
                 return reference_value.percentage_of(percentage);
             },
-            [&](NonnullRefPtr<CalculatedStyleValue> const& calculated) {
+            [&](NonnullRefPtr<CalculatedStyleValue const> const& calculated) {
                 return T::resolve_calculated(calculated, layout_node, reference_value);
             });
     }
@@ -114,7 +114,7 @@ public:
             [&](Percentage const& percentage) {
                 return Length::make_px(CSSPixels(percentage.value() * reference_value) / 100);
             },
-            [&](NonnullRefPtr<CalculatedStyleValue> const& calculated) {
+            [&](NonnullRefPtr<CalculatedStyleValue const> const& calculated) {
                 return T::resolve_calculated(calculated, layout_node, reference_value);
             });
     }
@@ -122,7 +122,7 @@ public:
     String to_string() const
     {
         if (is_calculated())
-            return m_value.template get<NonnullRefPtr<CalculatedStyleValue>>()->to_string(CSSStyleValue::SerializationMode::Normal);
+            return m_value.template get<NonnullRefPtr<CalculatedStyleValue const>>()->to_string(CSSStyleValue::SerializationMode::Normal);
         if (is_percentage())
             return m_value.template get<Percentage>().to_string();
         return m_value.template get<T>().to_string();
@@ -135,7 +135,7 @@ public:
         if (is_percentage() != other.is_percentage())
             return false;
         if (is_calculated())
-            return (*m_value.template get<NonnullRefPtr<CalculatedStyleValue>>() == *other.m_value.template get<NonnullRefPtr<CalculatedStyleValue>>());
+            return (*m_value.template get<NonnullRefPtr<CalculatedStyleValue const>>() == *other.m_value.template get<NonnullRefPtr<CalculatedStyleValue const>>());
         if (is_percentage())
             return (m_value.template get<Percentage>() == other.m_value.template get<Percentage>());
         return (m_value.template get<T>() == other.m_value.template get<T>());
@@ -146,7 +146,7 @@ protected:
     T const& get_t() const { return m_value.template get<T>(); }
 
 private:
-    Variant<T, Percentage, NonnullRefPtr<CalculatedStyleValue>> m_value;
+    Variant<T, Percentage, NonnullRefPtr<CalculatedStyleValue const>> m_value;
 };
 
 template<typename T>
diff --git a/Libraries/LibWeb/CSS/Size.cpp b/Libraries/LibWeb/CSS/Size.cpp
index 0abb75befbe..87e1774554a 100644
--- a/Libraries/LibWeb/CSS/Size.cpp
+++ b/Libraries/LibWeb/CSS/Size.cpp
@@ -39,7 +39,7 @@ Size Size::make_percentage(Percentage percentage)
     return Size { Type::Percentage, move(percentage) };
 }
 
-Size Size::make_calculated(NonnullRefPtr<Web::CSS::CalculatedStyleValue> calculated)
+Size Size::make_calculated(NonnullRefPtr<CalculatedStyleValue const> calculated)
 {
     return Size { Type::Calculated, move(calculated) };
 }
diff --git a/Libraries/LibWeb/CSS/Size.h b/Libraries/LibWeb/CSS/Size.h
index cd9514f88c3..31a56c575a3 100644
--- a/Libraries/LibWeb/CSS/Size.h
+++ b/Libraries/LibWeb/CSS/Size.h
@@ -29,7 +29,7 @@ public:
     static Size make_px(CSSPixels);
     static Size make_length(Length);
     static Size make_percentage(Percentage);
-    static Size make_calculated(NonnullRefPtr<CalculatedStyleValue>);
+    static Size make_calculated(NonnullRefPtr<CalculatedStyleValue const>);
     static Size make_min_content();
     static Size make_max_content();
     static Size make_fit_content(LengthPercentage available_space);
diff --git a/Libraries/LibWeb/CSS/StyleComputer.cpp b/Libraries/LibWeb/CSS/StyleComputer.cpp
index dda533237c6..10dbd5e5e99 100644
--- a/Libraries/LibWeb/CSS/StyleComputer.cpp
+++ b/Libraries/LibWeb/CSS/StyleComputer.cpp
@@ -1006,7 +1006,7 @@ void StyleComputer::set_all_properties(
             continue;
         }
 
-        NonnullRefPtr<CSSStyleValue> property_value = value;
+        NonnullRefPtr<CSSStyleValue const> property_value = value;
         if (property_value->is_unresolved())
             property_value = Parser::Parser::resolve_unresolved_style_value(Parser::ParsingParams { document }, element, pseudo_element, property_id, property_value->as_unresolved());
         if (!property_value->is_unresolved())
@@ -2486,7 +2486,7 @@ static bool is_monospace(CSSStyleValue const& value)
 //       instead of the default font size (16px).
 //       See this blog post for a lot more details about this weirdness:
 //       https://manishearth.github.io/blog/2017/08/10/font-size-an-unexpectedly-complex-css-property/
-RefPtr<CSSStyleValue> StyleComputer::recascade_font_size_if_needed(
+RefPtr<CSSStyleValue const> StyleComputer::recascade_font_size_if_needed(
     DOM::Element& element,
     Optional<CSS::PseudoElement> pseudo_element,
     CascadedProperties& cascaded_properties) const
@@ -2510,7 +2510,7 @@ RefPtr<CSSStyleValue> StyleComputer::recascade_font_size_if_needed(
     for (auto* ancestor = element.parent_element(); ancestor; ancestor = ancestor->parent_element())
         ancestors.append(*ancestor);
 
-    NonnullRefPtr<CSSStyleValue> new_font_size = CSS::LengthStyleValue::create(CSS::Length::make_px(default_monospace_font_size_in_px));
+    NonnullRefPtr<CSSStyleValue const> new_font_size = CSS::LengthStyleValue::create(CSS::Length::make_px(default_monospace_font_size_in_px));
     CSSPixels current_size_in_px = default_monospace_font_size_in_px;
 
     for (auto& ancestor : ancestors.in_reverse()) {
diff --git a/Libraries/LibWeb/CSS/StyleComputer.h b/Libraries/LibWeb/CSS/StyleComputer.h
index 70747b5909a..f64e6f7c866 100644
--- a/Libraries/LibWeb/CSS/StyleComputer.h
+++ b/Libraries/LibWeb/CSS/StyleComputer.h
@@ -183,7 +183,7 @@ public:
     static CSSPixelFraction absolute_size_mapping(Keyword);
     RefPtr<Gfx::FontCascadeList const> compute_font_for_style_values(DOM::Element const* element, Optional<CSS::PseudoElement> pseudo_element, CSSStyleValue const& font_family, CSSStyleValue const& font_size, CSSStyleValue const& font_style, CSSStyleValue const& font_weight, CSSStyleValue const& font_stretch, int math_depth = 0) const;
 
-    [[nodiscard]] RefPtr<CSSStyleValue> recascade_font_size_if_needed(DOM::Element&, Optional<CSS::PseudoElement> pseudo_element, CascadedProperties&) const;
+    [[nodiscard]] RefPtr<CSSStyleValue const> recascade_font_size_if_needed(DOM::Element&, Optional<CSS::PseudoElement> pseudo_element, CascadedProperties&) const;
 
     void set_viewport_rect(Badge<DOM::Document>, CSSPixelRect const& viewport_rect) { m_viewport_rect = viewport_rect; }
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/AbstractImageStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/AbstractImageStyleValue.h
index a530da24e17..6820ee6d337 100644
--- a/Libraries/LibWeb/CSS/StyleValues/AbstractImageStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/AbstractImageStyleValue.h
@@ -165,7 +165,7 @@ struct ColorStopListElement {
 
     Optional<ColorHint> transition_hint;
     struct ColorStop {
-        RefPtr<CSSStyleValue> color;
+        RefPtr<CSSStyleValue const> color;
         Optional<TPosition> position;
         Optional<TPosition> second_position = {};
         inline bool operator==(ColorStop const&) const = default;
diff --git a/Libraries/LibWeb/CSS/StyleValues/AngleStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/AngleStyleValue.h
index fa96e3f88da..5a5a1497e86 100644
--- a/Libraries/LibWeb/CSS/StyleValues/AngleStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/AngleStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class AngleStyleValue : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<AngleStyleValue> create(Angle angle)
+    static ValueComparingNonnullRefPtr<AngleStyleValue const> create(Angle angle)
     {
         return adopt_ref(*new (nothrow) AngleStyleValue(move(angle)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/BackgroundRepeatStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/BackgroundRepeatStyleValue.h
index a6b3387ae0b..4686d862682 100644
--- a/Libraries/LibWeb/CSS/StyleValues/BackgroundRepeatStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/BackgroundRepeatStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class BackgroundRepeatStyleValue final : public StyleValueWithDefaultOperators<BackgroundRepeatStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<BackgroundRepeatStyleValue> create(Repeat repeat_x, Repeat repeat_y)
+    static ValueComparingNonnullRefPtr<BackgroundRepeatStyleValue const> create(Repeat repeat_x, Repeat repeat_y)
     {
         return adopt_ref(*new (nothrow) BackgroundRepeatStyleValue(repeat_x, repeat_y));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h
index e05ec31eaa9..66a2164049f 100644
--- a/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h
@@ -18,7 +18,7 @@ namespace Web::CSS {
 // NOTE: This is not used for identifier sizes, like `cover` and `contain`.
 class BackgroundSizeStyleValue final : public StyleValueWithDefaultOperators<BackgroundSizeStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<BackgroundSizeStyleValue> create(LengthPercentage size_x, LengthPercentage size_y)
+    static ValueComparingNonnullRefPtr<BackgroundSizeStyleValue const> create(LengthPercentage size_x, LengthPercentage size_y)
     {
         return adopt_ref(*new (nothrow) BackgroundSizeStyleValue(size_x, size_y));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/BasicShapeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/BasicShapeStyleValue.h
index e9ec143b8a7..766d6f28375 100644
--- a/Libraries/LibWeb/CSS/StyleValues/BasicShapeStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/BasicShapeStyleValue.h
@@ -59,7 +59,7 @@ struct Circle {
     bool operator==(Circle const&) const = default;
 
     ShapeRadius radius;
-    ValueComparingNonnullRefPtr<PositionStyleValue> position;
+    ValueComparingNonnullRefPtr<PositionStyleValue const> position;
 };
 
 struct Ellipse {
@@ -70,7 +70,7 @@ struct Ellipse {
 
     ShapeRadius radius_x;
     ShapeRadius radius_y;
-    ValueComparingNonnullRefPtr<PositionStyleValue> position;
+    ValueComparingNonnullRefPtr<PositionStyleValue const> position;
 };
 
 struct Polygon {
@@ -94,7 +94,7 @@ using BasicShape = Variant<Inset, Xywh, Rect, Circle, Ellipse, Polygon>;
 
 class BasicShapeStyleValue : public StyleValueWithDefaultOperators<BasicShapeStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<BasicShapeStyleValue> create(BasicShape basic_shape)
+    static ValueComparingNonnullRefPtr<BasicShapeStyleValue const> create(BasicShape basic_shape)
     {
         return adopt_ref(*new (nothrow) BasicShapeStyleValue(move(basic_shape)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h
index de772f9d857..ddb9e30802b 100644
--- a/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h
@@ -17,7 +17,7 @@ namespace Web::CSS {
 
 class BorderRadiusStyleValue final : public StyleValueWithDefaultOperators<BorderRadiusStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<BorderRadiusStyleValue> create(LengthPercentage const& horizontal_radius, LengthPercentage const& vertical_radius)
+    static ValueComparingNonnullRefPtr<BorderRadiusStyleValue const> create(LengthPercentage const& horizontal_radius, LengthPercentage const& vertical_radius)
     {
         return adopt_ref(*new (nothrow) BorderRadiusStyleValue(horizontal_radius, vertical_radius));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
index c6ea9da5cc9..fd39275a2b0 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
@@ -18,7 +18,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<CSSColorValue> CSSColorValue::create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name)
+ValueComparingNonnullRefPtr<CSSColorValue const> CSSColorValue::create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name)
 {
     return CSSRGB::create(
         NumberStyleValue::create(color.red()),
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.h b/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.h
index 38af42e20b4..00c6e1b2d88 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.h
@@ -23,7 +23,7 @@ enum class ColorSyntax : u8 {
 // https://drafts.css-houdini.org/css-typed-om-1/#csscolorvalue
 class CSSColorValue : public CSSStyleValue {
 public:
-    static ValueComparingNonnullRefPtr<CSSColorValue> create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name = {});
+    static ValueComparingNonnullRefPtr<CSSColorValue const> create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name = {});
     virtual ~CSSColorValue() override = default;
 
     virtual bool has_color() const override { return true; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSHSL.h b/Libraries/LibWeb/CSS/StyleValues/CSSHSL.h
index 29de8b36248..0534fe29e7d 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSHSL.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSHSL.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 // https://drafts.css-houdini.org/css-typed-om-1/#csshsl
 class CSSHSL final : public CSSColorValue {
 public:
-    static ValueComparingNonnullRefPtr<CSSHSL> create(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> s, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax)
+    static ValueComparingNonnullRefPtr<CSSHSL const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> s, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax)
     {
         // alpha defaults to 1
         if (!alpha)
@@ -36,17 +36,17 @@ public:
     virtual bool equals(CSSStyleValue const& other) const override;
 
 private:
-    CSSHSL(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> s, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax)
+    CSSHSL(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> s, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax)
         : CSSColorValue(ColorType::HSL, color_syntax)
         , m_properties { .h = move(h), .s = move(s), .l = move(l), .alpha = move(alpha) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<CSSStyleValue> h;
-        ValueComparingNonnullRefPtr<CSSStyleValue> s;
-        ValueComparingNonnullRefPtr<CSSStyleValue> l;
-        ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> h;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> s;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> l;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
         bool operator==(Properties const&) const = default;
     } m_properties;
 };
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSHWB.h b/Libraries/LibWeb/CSS/StyleValues/CSSHWB.h
index fc84ae8bfdf..46fc32ec34c 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSHWB.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSHWB.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 // https://drafts.css-houdini.org/css-typed-om-1/#csshwb
 class CSSHWB final : public CSSColorValue {
 public:
-    static ValueComparingNonnullRefPtr<CSSHWB> create(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> w, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingRefPtr<CSSStyleValue> alpha = {})
+    static ValueComparingNonnullRefPtr<CSSHWB const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> w, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingRefPtr<CSSStyleValue const> alpha = {})
     {
         // alpha defaults to 1
         if (!alpha)
@@ -36,17 +36,17 @@ public:
     virtual bool equals(CSSStyleValue const& other) const override;
 
 private:
-    CSSHWB(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> w, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSHWB(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> w, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSColorValue(ColorType::HWB, ColorSyntax::Modern)
         , m_properties { .h = move(h), .w = move(w), .b = move(b), .alpha = move(alpha) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<CSSStyleValue> h;
-        ValueComparingNonnullRefPtr<CSSStyleValue> w;
-        ValueComparingNonnullRefPtr<CSSStyleValue> b;
-        ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> h;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> w;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> b;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
         bool operator==(Properties const&) const = default;
     } m_properties;
 };
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSKeywordValue.h b/Libraries/LibWeb/CSS/StyleValues/CSSKeywordValue.h
index 874996ffafb..3fc8c4ee685 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSKeywordValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSKeywordValue.h
@@ -17,28 +17,28 @@ namespace Web::CSS {
 // https://drafts.css-houdini.org/css-typed-om-1/#csskeywordvalue
 class CSSKeywordValue : public StyleValueWithDefaultOperators<CSSKeywordValue> {
 public:
-    static ValueComparingNonnullRefPtr<CSSKeywordValue> create(Keyword keyword)
+    static ValueComparingNonnullRefPtr<CSSKeywordValue const> create(Keyword keyword)
     {
         // NOTE: We'll have to be much more careful with caching once we expose CSSKeywordValue to JS, as it's mutable.
         switch (keyword) {
         case Keyword::Inherit: {
-            static ValueComparingNonnullRefPtr<CSSKeywordValue> const inherit_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Inherit));
+            static ValueComparingNonnullRefPtr<CSSKeywordValue const> const inherit_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Inherit));
             return inherit_instance;
         }
         case Keyword::Initial: {
-            static ValueComparingNonnullRefPtr<CSSKeywordValue> const initial_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Initial));
+            static ValueComparingNonnullRefPtr<CSSKeywordValue const> const initial_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Initial));
             return initial_instance;
         }
         case Keyword::Revert: {
-            static ValueComparingNonnullRefPtr<CSSKeywordValue> const revert_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Revert));
+            static ValueComparingNonnullRefPtr<CSSKeywordValue const> const revert_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Revert));
             return revert_instance;
         }
         case Keyword::RevertLayer: {
-            static ValueComparingNonnullRefPtr<CSSKeywordValue> const revert_layer_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::RevertLayer));
+            static ValueComparingNonnullRefPtr<CSSKeywordValue const> const revert_layer_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::RevertLayer));
             return revert_layer_instance;
         }
         case Keyword::Unset: {
-            static ValueComparingNonnullRefPtr<CSSKeywordValue> const unset_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Unset));
+            static ValueComparingNonnullRefPtr<CSSKeywordValue const> const unset_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Unset));
             return unset_instance;
         }
         default:
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSLCHLike.h b/Libraries/LibWeb/CSS/StyleValues/CSSLCHLike.h
index 49cefab4672..9ac0e2de698 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSLCHLike.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSLCHLike.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 class CSSLCHLike : public CSSColorValue {
 public:
     template<DerivedFrom<CSSLCHLike> T>
-    static ValueComparingNonnullRefPtr<T> create(ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingRefPtr<CSSStyleValue> alpha = {})
+    static ValueComparingNonnullRefPtr<T const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingRefPtr<CSSStyleValue const> alpha = {})
     {
         // alpha defaults to 1
         if (!alpha)
@@ -32,17 +32,17 @@ public:
     virtual bool equals(CSSStyleValue const& other) const override;
 
 protected:
-    CSSLCHLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSLCHLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSColorValue(color_type, ColorSyntax::Modern)
         , m_properties { .l = move(l), .c = move(c), .h = move(h), .alpha = move(alpha) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<CSSStyleValue> l;
-        ValueComparingNonnullRefPtr<CSSStyleValue> c;
-        ValueComparingNonnullRefPtr<CSSStyleValue> h;
-        ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> l;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> c;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> h;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
         bool operator==(Properties const&) const = default;
     } m_properties;
 };
@@ -50,7 +50,7 @@ protected:
 // https://drafts.css-houdini.org/css-typed-om-1/#csslch
 class CSSLCH final : public CSSLCHLike {
 public:
-    CSSLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSLCHLike(ColorType::LCH, move(l), move(c), move(h), move(alpha))
     {
     }
@@ -64,7 +64,7 @@ public:
 // https://drafts.css-houdini.org/css-typed-om-1/#cssoklch
 class CSSOKLCH final : public CSSLCHLike {
 public:
-    CSSOKLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSOKLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSLCHLike(ColorType::OKLCH, move(l), move(c), move(h), move(alpha))
     {
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSLabLike.h b/Libraries/LibWeb/CSS/StyleValues/CSSLabLike.h
index 03b85766698..f01dc6452b5 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSLabLike.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSLabLike.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 class CSSLabLike : public CSSColorValue {
 public:
     template<typename T>
-    static ValueComparingNonnullRefPtr<T> create(ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingRefPtr<CSSStyleValue> alpha = {})
+    static ValueComparingNonnullRefPtr<T const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingRefPtr<CSSStyleValue const> alpha = {})
     {
         // alpha defaults to 1
         if (!alpha)
@@ -33,17 +33,17 @@ public:
     virtual bool equals(CSSStyleValue const& other) const override;
 
 protected:
-    CSSLabLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSLabLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSColorValue(color_type, ColorSyntax::Modern)
         , m_properties { .l = move(l), .a = move(a), .b = move(b), .alpha = move(alpha) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<CSSStyleValue> l;
-        ValueComparingNonnullRefPtr<CSSStyleValue> a;
-        ValueComparingNonnullRefPtr<CSSStyleValue> b;
-        ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> l;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> a;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> b;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
         bool operator==(Properties const&) const = default;
     } m_properties;
 };
@@ -54,7 +54,7 @@ public:
     virtual Color to_color(Optional<Layout::NodeWithStyle const&>) const override;
     virtual String to_string(SerializationMode) const override;
 
-    CSSOKLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSOKLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSLabLike(ColorType::OKLab, move(l), move(a), move(b), move(alpha))
     {
     }
@@ -66,7 +66,7 @@ public:
     virtual Color to_color(Optional<Layout::NodeWithStyle const&>) const override;
     virtual String to_string(SerializationMode) const override;
 
-    CSSLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    CSSLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSLabLike(ColorType::Lab, move(l), move(a), move(b), move(alpha))
     {
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSLightDark.h b/Libraries/LibWeb/CSS/StyleValues/CSSLightDark.h
index d4d9bea7299..1c740952549 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSLightDark.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSLightDark.h
@@ -15,7 +15,7 @@ class CSSLightDark final : public CSSColorValue {
 public:
     virtual ~CSSLightDark() override = default;
 
-    static ValueComparingNonnullRefPtr<CSSLightDark> create(ValueComparingNonnullRefPtr<CSSStyleValue> light, ValueComparingNonnullRefPtr<CSSStyleValue> dark)
+    static ValueComparingNonnullRefPtr<CSSLightDark const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> light, ValueComparingNonnullRefPtr<CSSStyleValue const> dark)
     {
         return AK::adopt_ref(*new (nothrow) CSSLightDark(move(light), move(dark)));
     }
@@ -25,15 +25,15 @@ public:
     virtual String to_string(SerializationMode) const override;
 
 private:
-    CSSLightDark(ValueComparingNonnullRefPtr<CSSStyleValue> light, ValueComparingNonnullRefPtr<CSSStyleValue> dark)
+    CSSLightDark(ValueComparingNonnullRefPtr<CSSStyleValue const> light, ValueComparingNonnullRefPtr<CSSStyleValue const> dark)
         : CSSColorValue(CSSColorValue::ColorType::LightDark, ColorSyntax::Modern)
         , m_properties { .light = move(light), .dark = move(dark) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<CSSStyleValue> light;
-        ValueComparingNonnullRefPtr<CSSStyleValue> dark;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> light;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> dark;
         bool operator==(Properties const&) const = default;
     };
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSRGB.h b/Libraries/LibWeb/CSS/StyleValues/CSSRGB.h
index e668ceed75b..db6bef453a5 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSRGB.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSRGB.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 // https://drafts.css-houdini.org/css-typed-om-1/#cssrgb
 class CSSRGB final : public CSSColorValue {
 public:
-    static ValueComparingNonnullRefPtr<CSSRGB> create(ValueComparingNonnullRefPtr<CSSStyleValue> r, ValueComparingNonnullRefPtr<CSSStyleValue> g, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
+    static ValueComparingNonnullRefPtr<CSSRGB const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> r, ValueComparingNonnullRefPtr<CSSStyleValue const> g, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
     {
         // alpha defaults to 1
         if (!alpha)
@@ -36,17 +36,17 @@ public:
     virtual bool equals(CSSStyleValue const& other) const override;
 
 private:
-    CSSRGB(ValueComparingNonnullRefPtr<CSSStyleValue> r, ValueComparingNonnullRefPtr<CSSStyleValue> g, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
+    CSSRGB(ValueComparingNonnullRefPtr<CSSStyleValue const> r, ValueComparingNonnullRefPtr<CSSStyleValue const> g, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
         : CSSColorValue(ColorType::RGB, color_syntax)
         , m_properties { .r = move(r), .g = move(g), .b = move(b), .alpha = move(alpha), .name = name }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<CSSStyleValue> r;
-        ValueComparingNonnullRefPtr<CSSStyleValue> g;
-        ValueComparingNonnullRefPtr<CSSStyleValue> b;
-        ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> r;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> g;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> b;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
         Optional<FlyString> name;
         bool operator==(Properties const&) const = default;
     } m_properties;
diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
index 757559217a4..22777b67d20 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
@@ -664,11 +664,11 @@ CalculatedStyleValue::CalculationResult NumericCalculationNode::resolve(Calculat
     return CalculatedStyleValue::CalculationResult::from_value(m_value, context, numeric_type());
 }
 
-RefPtr<CSSStyleValue> NumericCalculationNode::to_style_value(CalculationContext const& context) const
+RefPtr<CSSStyleValue const> NumericCalculationNode::to_style_value(CalculationContext const& context) const
 {
     // TODO: Clamp values to the range allowed by the context.
     return m_value.visit(
-        [&](Number const& number) -> RefPtr<CSSStyleValue> {
+        [&](Number const& number) -> RefPtr<CSSStyleValue const> {
             // FIXME: Returning infinity or NaN as a NumberStyleValue isn't valid.
             //        This is a temporary fix until value-clamping is implemented here.
             //        In future, we can remove these two lines and return NonnullRefPtr again.
@@ -679,13 +679,13 @@ RefPtr<CSSStyleValue> NumericCalculationNode::to_style_value(CalculationContext
                 return IntegerStyleValue::create(llround(number.value()));
             return NumberStyleValue::create(number.value());
         },
-        [](Angle const& angle) -> RefPtr<CSSStyleValue> { return AngleStyleValue::create(angle); },
-        [](Flex const& flex) -> RefPtr<CSSStyleValue> { return FlexStyleValue::create(flex); },
-        [](Frequency const& frequency) -> RefPtr<CSSStyleValue> { return FrequencyStyleValue::create(frequency); },
-        [](Length const& length) -> RefPtr<CSSStyleValue> { return LengthStyleValue::create(length); },
-        [](Percentage const& percentage) -> RefPtr<CSSStyleValue> { return PercentageStyleValue::create(percentage); },
-        [](Resolution const& resolution) -> RefPtr<CSSStyleValue> { return ResolutionStyleValue::create(resolution); },
-        [](Time const& time) -> RefPtr<CSSStyleValue> { return TimeStyleValue::create(time); });
+        [](Angle const& angle) -> RefPtr<CSSStyleValue const> { return AngleStyleValue::create(angle); },
+        [](Flex const& flex) -> RefPtr<CSSStyleValue const> { return FlexStyleValue::create(flex); },
+        [](Frequency const& frequency) -> RefPtr<CSSStyleValue const> { return FrequencyStyleValue::create(frequency); },
+        [](Length const& length) -> RefPtr<CSSStyleValue const> { return LengthStyleValue::create(length); },
+        [](Percentage const& percentage) -> RefPtr<CSSStyleValue const> { return PercentageStyleValue::create(percentage); },
+        [](Resolution const& resolution) -> RefPtr<CSSStyleValue const> { return ResolutionStyleValue::create(resolution); },
+        [](Time const& time) -> RefPtr<CSSStyleValue const> { return TimeStyleValue::create(time); });
 }
 
 Optional<NonFiniteValue> NumericCalculationNode::infinite_or_nan_value() const
diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
index c08a6dc2d3d..15a2e26d68b 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
@@ -67,7 +67,7 @@ public:
         Optional<CSSNumericType> m_type;
     };
 
-    static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullRefPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context)
+    static ValueComparingNonnullRefPtr<CalculatedStyleValue const> create(NonnullRefPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context)
     {
         return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), move(resolved_type), move(context)));
     }
@@ -262,7 +262,7 @@ public:
     virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
     virtual NonnullRefPtr<CalculationNode> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; }
 
-    RefPtr<CSSStyleValue> to_style_value(CalculationContext const&) const;
+    RefPtr<CSSStyleValue const> to_style_value(CalculationContext const&) const;
 
     virtual Vector<NonnullRefPtr<CalculationNode>> children() const override { return {}; }
     NumericValue const& value() const { return m_value; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp
index 2cdbe28d969..02dbea45a75 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp
@@ -58,7 +58,7 @@ StringView string_view_from_color_type(CSSColorValue::ColorType color_type)
 
 }
 
-ValueComparingNonnullRefPtr<ColorFunctionStyleValue> ColorFunctionStyleValue::create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue> c1, ValueComparingNonnullRefPtr<CSSStyleValue> c2, ValueComparingNonnullRefPtr<CSSStyleValue> c3, ValueComparingRefPtr<CSSStyleValue> alpha)
+ValueComparingNonnullRefPtr<ColorFunctionStyleValue const> ColorFunctionStyleValue::create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue const> c1, ValueComparingNonnullRefPtr<CSSStyleValue const> c2, ValueComparingNonnullRefPtr<CSSStyleValue const> c3, ValueComparingRefPtr<CSSStyleValue const> alpha)
 {
     VERIFY(any_of(s_supported_color_space, [=](auto supported) { return color_space == supported; }));
 
@@ -93,7 +93,7 @@ ColorFunctionStyleValue::Resolved ColorFunctionStyleValue::resolve_properties()
 // https://www.w3.org/TR/css-color-4/#serializing-color-function-values
 String ColorFunctionStyleValue::to_string(SerializationMode mode) const
 {
-    auto convert_percentage = [](ValueComparingNonnullRefPtr<CSSStyleValue> const& value) -> RemoveReference<decltype(value)> {
+    auto convert_percentage = [](ValueComparingNonnullRefPtr<CSSStyleValue const> const& value) -> RemoveReference<decltype(value)> {
         if (value->is_percentage())
             return NumberStyleValue::create(value->as_percentage().value() / 100);
         return value;
diff --git a/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.h
index eb0a3cb6cb2..a96286d6f60 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.h
@@ -15,7 +15,7 @@ class ColorFunctionStyleValue final : public CSSColorValue {
 public:
     virtual ~ColorFunctionStyleValue() override = default;
 
-    static ValueComparingNonnullRefPtr<ColorFunctionStyleValue> create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue> c1, ValueComparingNonnullRefPtr<CSSStyleValue> c2, ValueComparingNonnullRefPtr<CSSStyleValue> c3, ValueComparingRefPtr<CSSStyleValue> alpha = {});
+    static ValueComparingNonnullRefPtr<ColorFunctionStyleValue const> create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue const> c1, ValueComparingNonnullRefPtr<CSSStyleValue const> c2, ValueComparingNonnullRefPtr<CSSStyleValue const> c3, ValueComparingRefPtr<CSSStyleValue const> alpha = {});
 
     virtual bool equals(CSSStyleValue const&) const override;
     virtual Color to_color(Optional<Layout::NodeWithStyle const&>) const override;
@@ -26,15 +26,15 @@ public:
     static constexpr Array s_supported_color_space = { "a98-rgb"sv, "display-p3"sv, "srgb"sv, "srgb-linear"sv, "prophoto-rgb"sv, "rec2020"sv, "xyz"sv, "xyz-d50"sv, "xyz-d65"sv };
 
 private:
-    ColorFunctionStyleValue(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue> c1, ValueComparingNonnullRefPtr<CSSStyleValue> c2, ValueComparingNonnullRefPtr<CSSStyleValue> c3, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
+    ColorFunctionStyleValue(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue const> c1, ValueComparingNonnullRefPtr<CSSStyleValue const> c2, ValueComparingNonnullRefPtr<CSSStyleValue const> c3, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
         : CSSColorValue(color_type, ColorSyntax::Modern)
         , m_properties { .channels = { move(c1), move(c2), move(c3) }, .alpha = move(alpha) }
     {
     }
 
     struct Properties {
-        Array<ValueComparingNonnullRefPtr<CSSStyleValue>, 3> channels;
-        ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
+        Array<ValueComparingNonnullRefPtr<CSSStyleValue const>, 3> channels;
+        ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
         bool operator==(Properties const&) const = default;
     };
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/ColorSchemeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ColorSchemeStyleValue.h
index da304856360..75bedaf4358 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ColorSchemeStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ColorSchemeStyleValue.h
@@ -12,11 +12,11 @@ namespace Web::CSS {
 
 class ColorSchemeStyleValue final : public StyleValueWithDefaultOperators<ColorSchemeStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<ColorSchemeStyleValue> create(Vector<String> schemes, bool only)
+    static ValueComparingNonnullRefPtr<ColorSchemeStyleValue const> create(Vector<String> schemes, bool only)
     {
         return adopt_ref(*new (nothrow) ColorSchemeStyleValue(move(schemes), only));
     }
-    static ValueComparingNonnullRefPtr<ColorSchemeStyleValue> normal()
+    static ValueComparingNonnullRefPtr<ColorSchemeStyleValue const> normal()
     {
         return adopt_ref(*new (nothrow) ColorSchemeStyleValue({}, false));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/ConicGradientStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ConicGradientStyleValue.h
index 1e9ba192e6d..e8955160e70 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ConicGradientStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ConicGradientStyleValue.h
@@ -17,7 +17,7 @@ namespace Web::CSS {
 
 class ConicGradientStyleValue final : public AbstractImageStyleValue {
 public:
-    static ValueComparingNonnullRefPtr<ConicGradientStyleValue> create(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
+    static ValueComparingNonnullRefPtr<ConicGradientStyleValue const> create(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
     {
         VERIFY(!color_stop_list.is_empty());
         bool any_non_legacy = color_stop_list.find_first_index_if([](auto const& stop) { return !stop.color_stop.color->is_keyword() && stop.color_stop.color->as_color().color_syntax() == ColorSyntax::Modern; }).has_value();
@@ -54,7 +54,7 @@ public:
     bool is_repeating() const { return m_properties.repeating == GradientRepeating::Yes; }
 
 private:
-    ConicGradientStyleValue(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
+    ConicGradientStyleValue(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
         : AbstractImageStyleValue(Type::ConicGradient)
         , m_properties { .from_angle = from_angle, .position = move(position), .color_stop_list = move(color_stop_list), .repeating = repeating, .interpolation_method = interpolation_method, .color_syntax = color_syntax }
     {
@@ -62,7 +62,7 @@ private:
 
     struct Properties {
         Angle from_angle;
-        ValueComparingNonnullRefPtr<PositionStyleValue> position;
+        ValueComparingNonnullRefPtr<PositionStyleValue const> position;
         Vector<AngularColorStopListElement> color_stop_list;
         GradientRepeating repeating;
         Optional<InterpolationMethod> interpolation_method;
diff --git a/Libraries/LibWeb/CSS/StyleValues/ContentStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ContentStyleValue.h
index 67476888632..faff2b7b2cc 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ContentStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ContentStyleValue.h
@@ -15,7 +15,7 @@ namespace Web::CSS {
 
 class ContentStyleValue final : public StyleValueWithDefaultOperators<ContentStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<ContentStyleValue> create(ValueComparingNonnullRefPtr<StyleValueList> content, ValueComparingRefPtr<StyleValueList> alt_text)
+    static ValueComparingNonnullRefPtr<ContentStyleValue const> create(ValueComparingNonnullRefPtr<StyleValueList const> content, ValueComparingRefPtr<StyleValueList const> alt_text)
     {
         return adopt_ref(*new (nothrow) ContentStyleValue(move(content), move(alt_text)));
     }
@@ -30,15 +30,15 @@ public:
     bool properties_equal(ContentStyleValue const& other) const { return m_properties == other.m_properties; }
 
 private:
-    ContentStyleValue(ValueComparingNonnullRefPtr<StyleValueList> content, ValueComparingRefPtr<StyleValueList> alt_text)
+    ContentStyleValue(ValueComparingNonnullRefPtr<StyleValueList const> content, ValueComparingRefPtr<StyleValueList const> alt_text)
         : StyleValueWithDefaultOperators(Type::Content)
         , m_properties { .content = move(content), .alt_text = move(alt_text) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<StyleValueList> content;
-        ValueComparingRefPtr<StyleValueList> alt_text;
+        ValueComparingNonnullRefPtr<StyleValueList const> content;
+        ValueComparingRefPtr<StyleValueList const> alt_text;
         bool operator==(Properties const&) const = default;
     } m_properties;
 };
diff --git a/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h
index c4928ca659c..1b9c72a124d 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h
@@ -23,7 +23,7 @@ struct CounterDefinition {
  */
 class CounterDefinitionsStyleValue : public StyleValueWithDefaultOperators<CounterDefinitionsStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<CounterDefinitionsStyleValue> create(Vector<CounterDefinition> counter_definitions)
+    static ValueComparingNonnullRefPtr<CounterDefinitionsStyleValue const> create(Vector<CounterDefinition> counter_definitions)
     {
         return adopt_ref(*new (nothrow) CounterDefinitionsStyleValue(move(counter_definitions)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/CounterStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CounterStyleValue.h
index df7df2fd4ab..d5ae7d510d6 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CounterStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CounterStyleValue.h
@@ -19,11 +19,11 @@ public:
         Counters,
     };
 
-    static ValueComparingNonnullRefPtr<CounterStyleValue> create_counter(FlyString counter_name, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
+    static ValueComparingNonnullRefPtr<CounterStyleValue const> create_counter(FlyString counter_name, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
     {
         return adopt_ref(*new (nothrow) CounterStyleValue(CounterFunction::Counter, move(counter_name), move(counter_style), {}));
     }
-    static ValueComparingNonnullRefPtr<CounterStyleValue> create_counters(FlyString counter_name, FlyString join_string, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
+    static ValueComparingNonnullRefPtr<CounterStyleValue const> create_counters(FlyString counter_name, FlyString join_string, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
     {
         return adopt_ref(*new (nothrow) CounterStyleValue(CounterFunction::Counters, move(counter_name), move(counter_style), move(join_string)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h
index 5754e3d34d5..3b840b0da02 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h
@@ -18,14 +18,14 @@ namespace Web::CSS {
 
 class CursorStyleValue final : public StyleValueWithDefaultOperators<CursorStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<CursorStyleValue> create(ValueComparingNonnullRefPtr<AbstractImageStyleValue> image, Optional<NumberOrCalculated> x, Optional<NumberOrCalculated> y)
+    static ValueComparingNonnullRefPtr<CursorStyleValue const> create(ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image, Optional<NumberOrCalculated> x, Optional<NumberOrCalculated> y)
     {
         VERIFY(x.has_value() == y.has_value());
         return adopt_ref(*new (nothrow) CursorStyleValue(move(image), move(x), move(y)));
     }
     virtual ~CursorStyleValue() override = default;
 
-    ValueComparingNonnullRefPtr<AbstractImageStyleValue> image() const { return m_properties.image; }
+    ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image() const { return m_properties.image; }
     Optional<NumberOrCalculated> const& x() const { return m_properties.x; }
     Optional<NumberOrCalculated> const& y() const { return m_properties.y; }
 
@@ -36,7 +36,7 @@ public:
     bool properties_equal(CursorStyleValue const& other) const { return m_properties == other.m_properties; }
 
 private:
-    CursorStyleValue(ValueComparingNonnullRefPtr<AbstractImageStyleValue> image,
+    CursorStyleValue(ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image,
         Optional<NumberOrCalculated> x,
         Optional<NumberOrCalculated> y)
         : StyleValueWithDefaultOperators(Type::Cursor)
@@ -45,7 +45,7 @@ private:
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<AbstractImageStyleValue> image;
+        ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image;
         Optional<NumberOrCalculated> x;
         Optional<NumberOrCalculated> y;
         bool operator==(Properties const&) const = default;
diff --git a/Libraries/LibWeb/CSS/StyleValues/CustomIdentStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CustomIdentStyleValue.h
index d915bde2d11..d1ec7e32903 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CustomIdentStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CustomIdentStyleValue.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 // https://www.w3.org/TR/css-values-4/#custom-idents
 class CustomIdentStyleValue final : public StyleValueWithDefaultOperators<CustomIdentStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<CustomIdentStyleValue> create(FlyString custom_ident)
+    static ValueComparingNonnullRefPtr<CustomIdentStyleValue const> create(FlyString custom_ident)
     {
         return adopt_ref(*new (nothrow) CustomIdentStyleValue(move(custom_ident)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.cpp
index 3adf2af752d..df2d7847a0c 100644
--- a/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.cpp
@@ -8,7 +8,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<DisplayStyleValue> DisplayStyleValue::create(Display const& display)
+ValueComparingNonnullRefPtr<DisplayStyleValue const> DisplayStyleValue::create(Display const& display)
 {
     return adopt_ref(*new (nothrow) DisplayStyleValue(display));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.h
index cb894fd4560..58203d19dfc 100644
--- a/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/DisplayStyleValue.h
@@ -13,7 +13,7 @@ namespace Web::CSS {
 
 class DisplayStyleValue : public StyleValueWithDefaultOperators<DisplayStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<DisplayStyleValue> create(Display const&);
+    static ValueComparingNonnullRefPtr<DisplayStyleValue const> create(Display const&);
     virtual ~DisplayStyleValue() override = default;
 
     virtual String to_string(SerializationMode) const override { return m_display.to_string(); }
diff --git a/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h
index 8bc90d1ab33..ef373afb187 100644
--- a/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h
@@ -94,7 +94,7 @@ public:
         String to_string() const;
     };
 
-    static ValueComparingNonnullRefPtr<EasingStyleValue> create(Function const& function)
+    static ValueComparingNonnullRefPtr<EasingStyleValue const> create(Function const& function)
     {
         return adopt_ref(*new (nothrow) EasingStyleValue(function));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.h
index fa9bdc3d833..bd354108abb 100644
--- a/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/EdgeStyleValue.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 
 class EdgeStyleValue final : public StyleValueWithDefaultOperators<EdgeStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<EdgeStyleValue> create(Optional<PositionEdge> edge, Optional<LengthPercentage> const& offset)
+    static ValueComparingNonnullRefPtr<EdgeStyleValue const> create(Optional<PositionEdge> edge, Optional<LengthPercentage> const& offset)
     {
         return adopt_ref(*new (nothrow) EdgeStyleValue(edge, offset));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.h
index 43f269c72ea..8985b27d9bb 100644
--- a/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.h
@@ -57,7 +57,7 @@ using FilterFunction = Variant<FilterOperation::Blur, FilterOperation::DropShado
 
 class FilterValueListStyleValue final : public StyleValueWithDefaultOperators<FilterValueListStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<FilterValueListStyleValue> create(
+    static ValueComparingNonnullRefPtr<FilterValueListStyleValue const> create(
         Vector<FilterFunction> filter_value_list)
     {
         VERIFY(filter_value_list.size() >= 1);
diff --git a/Libraries/LibWeb/CSS/StyleValues/FitContentStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/FitContentStyleValue.h
index ce399084fd7..d1750d27e03 100644
--- a/Libraries/LibWeb/CSS/StyleValues/FitContentStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/FitContentStyleValue.h
@@ -13,11 +13,11 @@ namespace Web::CSS {
 
 class FitContentStyleValue final : public CSSStyleValue {
 public:
-    static ValueComparingNonnullRefPtr<FitContentStyleValue> create()
+    static ValueComparingNonnullRefPtr<FitContentStyleValue const> create()
     {
         return adopt_ref(*new (nothrow) FitContentStyleValue(LengthPercentage { Length::make_auto() }));
     }
-    static ValueComparingNonnullRefPtr<FitContentStyleValue> create(LengthPercentage length_percentage)
+    static ValueComparingNonnullRefPtr<FitContentStyleValue const> create(LengthPercentage length_percentage)
     {
         return adopt_ref(*new (nothrow) FitContentStyleValue(move(length_percentage)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/FlexStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/FlexStyleValue.h
index d14685fd545..e671ad8fdff 100644
--- a/Libraries/LibWeb/CSS/StyleValues/FlexStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/FlexStyleValue.h
@@ -13,7 +13,7 @@ namespace Web::CSS {
 
 class FlexStyleValue final : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<FlexStyleValue> create(Flex flex)
+    static ValueComparingNonnullRefPtr<FlexStyleValue const> create(Flex flex)
     {
         return adopt_ref(*new (nothrow) FlexStyleValue(move(flex)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/FontSourceStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/FontSourceStyleValue.h
index f088947afff..4fa02aa9529 100644
--- a/Libraries/LibWeb/CSS/StyleValues/FontSourceStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/FontSourceStyleValue.h
@@ -14,11 +14,11 @@ namespace Web::CSS {
 class FontSourceStyleValue final : public StyleValueWithDefaultOperators<FontSourceStyleValue> {
 public:
     struct Local {
-        NonnullRefPtr<CSSStyleValue> name;
+        NonnullRefPtr<CSSStyleValue const> name;
     };
     using Source = Variant<Local, ::URL::URL>;
 
-    static ValueComparingNonnullRefPtr<FontSourceStyleValue> create(Source source, Optional<FlyString> format)
+    static ValueComparingNonnullRefPtr<FontSourceStyleValue const> create(Source source, Optional<FlyString> format)
     {
         return adopt_ref(*new (nothrow) FontSourceStyleValue(move(source), move(format)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/FrequencyStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/FrequencyStyleValue.h
index a0b09ed0dc8..e54967e3a20 100644
--- a/Libraries/LibWeb/CSS/StyleValues/FrequencyStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/FrequencyStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class FrequencyStyleValue final : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<FrequencyStyleValue> create(Frequency frequency)
+    static ValueComparingNonnullRefPtr<FrequencyStyleValue const> create(Frequency frequency)
     {
         return adopt_ref(*new (nothrow) FrequencyStyleValue(move(frequency)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.cpp
index a51040f90f3..789aa5385bb 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.cpp
@@ -8,7 +8,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<GridAutoFlowStyleValue> GridAutoFlowStyleValue::create(Axis axis, Dense dense)
+ValueComparingNonnullRefPtr<GridAutoFlowStyleValue const> GridAutoFlowStyleValue::create(Axis axis, Dense dense)
 {
     return adopt_ref(*new GridAutoFlowStyleValue(axis, dense));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.h
index aaa23ba0452..311908338a2 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/GridAutoFlowStyleValue.h
@@ -20,7 +20,7 @@ public:
         No,
         Yes,
     };
-    static ValueComparingNonnullRefPtr<GridAutoFlowStyleValue> create(Axis, Dense);
+    static ValueComparingNonnullRefPtr<GridAutoFlowStyleValue const> create(Axis, Dense);
     virtual ~GridAutoFlowStyleValue() override = default;
 
     [[nodiscard]] bool is_row() const { return m_row; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.cpp
index 3046a3e9308..ade8f478422 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue> GridTemplateAreaStyleValue::create(Vector<Vector<String>> grid_template_area)
+ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue const> GridTemplateAreaStyleValue::create(Vector<Vector<String>> grid_template_area)
 {
     return adopt_ref(*new (nothrow) GridTemplateAreaStyleValue(grid_template_area));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.h
index 3b4dc258994..af1be28ed04 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/GridTemplateAreaStyleValue.h
@@ -15,7 +15,7 @@ namespace Web::CSS {
 
 class GridTemplateAreaStyleValue final : public StyleValueWithDefaultOperators<GridTemplateAreaStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue> create(Vector<Vector<String>> grid_template_area);
+    static ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue const> create(Vector<Vector<String>> grid_template_area);
     virtual ~GridTemplateAreaStyleValue() override = default;
 
     Vector<Vector<String>> const& grid_template_area() const { return m_grid_template_area; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.cpp
index 39ddb9ae9dc..4fdd091a5d4 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue> GridTrackPlacementStyleValue::create(CSS::GridTrackPlacement grid_track_placement)
+ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue const> GridTrackPlacementStyleValue::create(CSS::GridTrackPlacement grid_track_placement)
 {
     return adopt_ref(*new (nothrow) GridTrackPlacementStyleValue(grid_track_placement));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h
index 5fabda5624c..e83df35230a 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/GridTrackPlacementStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class GridTrackPlacementStyleValue final : public StyleValueWithDefaultOperators<GridTrackPlacementStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue> create(GridTrackPlacement grid_track_placement);
+    static ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue const> create(GridTrackPlacement grid_track_placement);
     virtual ~GridTrackPlacementStyleValue() override = default;
 
     GridTrackPlacement const& grid_track_placement() const { return m_grid_track_placement; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.cpp
index 60bc7272af0..2ca5df1f698 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.cpp
@@ -16,17 +16,17 @@ String GridTrackSizeListStyleValue::to_string(SerializationMode) const
     return m_grid_track_size_list.to_string();
 }
 
-ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> GridTrackSizeListStyleValue::create(CSS::GridTrackSizeList grid_track_size_list)
+ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> GridTrackSizeListStyleValue::create(CSS::GridTrackSizeList grid_track_size_list)
 {
     return adopt_ref(*new (nothrow) GridTrackSizeListStyleValue(grid_track_size_list));
 }
 
-ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> GridTrackSizeListStyleValue::make_auto()
+ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> GridTrackSizeListStyleValue::make_auto()
 {
     return adopt_ref(*new (nothrow) GridTrackSizeListStyleValue(CSS::GridTrackSizeList()));
 }
 
-ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> GridTrackSizeListStyleValue::make_none()
+ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> GridTrackSizeListStyleValue::make_none()
 {
     return adopt_ref(*new (nothrow) GridTrackSizeListStyleValue(CSS::GridTrackSizeList()));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h
index 6b190444fdf..a6ebd8646bf 100644
--- a/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/GridTrackSizeListStyleValue.h
@@ -16,11 +16,11 @@ namespace Web::CSS {
 
 class GridTrackSizeListStyleValue final : public StyleValueWithDefaultOperators<GridTrackSizeListStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> create(CSS::GridTrackSizeList grid_track_size_list);
+    static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> create(CSS::GridTrackSizeList grid_track_size_list);
     virtual ~GridTrackSizeListStyleValue() override = default;
 
-    static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> make_auto();
-    static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> make_none();
+    static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> make_auto();
+    static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> make_none();
 
     CSS::GridTrackSizeList grid_track_size_list() const { return m_grid_track_size_list; }
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
index 920f97d7967..0ac05c64444 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
@@ -20,12 +20,12 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<ImageStyleValue> ImageStyleValue::create(URL const& url)
+ValueComparingNonnullRefPtr<ImageStyleValue const> ImageStyleValue::create(URL const& url)
 {
     return adopt_ref(*new (nothrow) ImageStyleValue(url));
 }
 
-ValueComparingNonnullRefPtr<ImageStyleValue> ImageStyleValue::create(::URL::URL const& url)
+ValueComparingNonnullRefPtr<ImageStyleValue const> ImageStyleValue::create(::URL::URL const& url)
 {
     return adopt_ref(*new (nothrow) ImageStyleValue(URL { url.to_string() }));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
index b57495f659a..5ae0b6913ad 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
@@ -24,9 +24,8 @@ class ImageStyleValue final
     using Base = AbstractImageStyleValue;
 
 public:
-    static ValueComparingNonnullRefPtr<ImageStyleValue> create(URL const&);
-    static ValueComparingNonnullRefPtr<ImageStyleValue> create(::URL::URL const&);
-
+    static ValueComparingNonnullRefPtr<ImageStyleValue const> create(URL const&);
+    static ValueComparingNonnullRefPtr<ImageStyleValue const> create(::URL::URL const&);
     virtual ~ImageStyleValue() override;
 
     virtual void visit_edges(JS::Cell::Visitor& visitor) const override;
@@ -46,7 +45,7 @@ public:
     virtual Optional<Gfx::Color> color_if_single_pixel_bitmap() const override;
     Gfx::ImmutableBitmap const* current_frame_bitmap(DevicePixelRect const& dest_rect) const;
 
-    Function<void()> on_animate;
+    mutable Function<void()> on_animate;
 
     GC::Ptr<HTML::DecodedImageData> image_data() const;
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/IntegerStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/IntegerStyleValue.h
index 2da33fd8f60..825701743bc 100644
--- a/Libraries/LibWeb/CSS/StyleValues/IntegerStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/IntegerStyleValue.h
@@ -12,7 +12,7 @@ namespace Web::CSS {
 
 class IntegerStyleValue final : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<IntegerStyleValue> create(i64 value)
+    static ValueComparingNonnullRefPtr<IntegerStyleValue const> create(i64 value)
     {
         return adopt_ref(*new (nothrow) IntegerStyleValue(value));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp
index 39b97d60639..796b02e808e 100644
--- a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<LengthStyleValue> LengthStyleValue::create(Length const& length)
+ValueComparingNonnullRefPtr<LengthStyleValue const> LengthStyleValue::create(Length const& length)
 {
     VERIFY(!length.is_auto());
     if (length.is_px()) {
diff --git a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h
index a7fbb86a5e0..43472de8928 100644
--- a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class LengthStyleValue final : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<LengthStyleValue> create(Length const&);
+    static ValueComparingNonnullRefPtr<LengthStyleValue const> create(Length const&);
     virtual ~LengthStyleValue() override = default;
 
     Length const& length() const { return m_length; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.h
index 4dace89136f..fc3b07d8a35 100644
--- a/Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.h
@@ -39,7 +39,7 @@ public:
         WebKit
     };
 
-    static ValueComparingNonnullRefPtr<LinearGradientStyleValue> create(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
+    static ValueComparingNonnullRefPtr<LinearGradientStyleValue const> create(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
     {
         VERIFY(!color_stop_list.is_empty());
         bool any_non_legacy = color_stop_list.find_first_index_if([](auto const& stop) { return !stop.color_stop.color->is_keyword() && stop.color_stop.color->as_color().color_syntax() == ColorSyntax::Modern; }).has_value();
diff --git a/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.cpp
index 0f9e928fab2..f4c0d726e5a 100644
--- a/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.cpp
@@ -8,17 +8,17 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<MathDepthStyleValue> MathDepthStyleValue::create_auto_add()
+ValueComparingNonnullRefPtr<MathDepthStyleValue const> MathDepthStyleValue::create_auto_add()
 {
     return adopt_ref(*new (nothrow) MathDepthStyleValue(MathDepthType::AutoAdd));
 }
 
-ValueComparingNonnullRefPtr<MathDepthStyleValue> MathDepthStyleValue::create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
+ValueComparingNonnullRefPtr<MathDepthStyleValue const> MathDepthStyleValue::create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
 {
     return adopt_ref(*new (nothrow) MathDepthStyleValue(MathDepthType::Add, move(integer_value)));
 }
 
-ValueComparingNonnullRefPtr<MathDepthStyleValue> MathDepthStyleValue::create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
+ValueComparingNonnullRefPtr<MathDepthStyleValue const> MathDepthStyleValue::create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
 {
     return adopt_ref(*new (nothrow) MathDepthStyleValue(MathDepthType::Integer, move(integer_value)));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.h
index 8d0ce62c0b6..ebe29460876 100644
--- a/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/MathDepthStyleValue.h
@@ -12,9 +12,9 @@ namespace Web::CSS {
 
 class MathDepthStyleValue : public StyleValueWithDefaultOperators<MathDepthStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<MathDepthStyleValue> create_auto_add();
-    static ValueComparingNonnullRefPtr<MathDepthStyleValue> create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
-    static ValueComparingNonnullRefPtr<MathDepthStyleValue> create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
+    static ValueComparingNonnullRefPtr<MathDepthStyleValue const> create_auto_add();
+    static ValueComparingNonnullRefPtr<MathDepthStyleValue const> create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
+    static ValueComparingNonnullRefPtr<MathDepthStyleValue const> create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
     virtual ~MathDepthStyleValue() override = default;
 
     bool is_auto_add() const { return m_type == MathDepthType::AutoAdd; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/NumberStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/NumberStyleValue.h
index 1b853d547f3..4ea8000d7f7 100644
--- a/Libraries/LibWeb/CSS/StyleValues/NumberStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/NumberStyleValue.h
@@ -15,7 +15,7 @@ namespace Web::CSS {
 
 class NumberStyleValue final : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<NumberStyleValue> create(double value)
+    static ValueComparingNonnullRefPtr<NumberStyleValue const> create(double value)
     {
         return adopt_ref(*new (nothrow) NumberStyleValue(value));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h
index a328942c8f2..80a5bfe6338 100644
--- a/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h
@@ -20,21 +20,21 @@ public:
         FontFeatureSettings,
         FontVariationSettings,
     };
-    static ValueComparingNonnullRefPtr<OpenTypeTaggedStyleValue> create(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue> value)
+    static ValueComparingNonnullRefPtr<OpenTypeTaggedStyleValue const> create(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue const> value)
     {
         return adopt_ref(*new (nothrow) OpenTypeTaggedStyleValue(mode, move(tag), move(value)));
     }
     virtual ~OpenTypeTaggedStyleValue() override = default;
 
     FlyString const& tag() const { return m_tag; }
-    ValueComparingNonnullRefPtr<CSSStyleValue> const& value() const { return m_value; }
+    ValueComparingNonnullRefPtr<CSSStyleValue const> const& value() const { return m_value; }
 
     virtual String to_string(SerializationMode) const override;
 
     bool properties_equal(OpenTypeTaggedStyleValue const&) const;
 
 private:
-    explicit OpenTypeTaggedStyleValue(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue> value)
+    explicit OpenTypeTaggedStyleValue(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue const> value)
         : StyleValueWithDefaultOperators(Type::OpenTypeTagged)
         , m_mode(mode)
         , m_tag(move(tag))
@@ -44,7 +44,7 @@ private:
 
     Mode m_mode;
     FlyString m_tag;
-    ValueComparingNonnullRefPtr<CSSStyleValue> m_value;
+    ValueComparingNonnullRefPtr<CSSStyleValue const> m_value;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/PercentageStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/PercentageStyleValue.h
index e9f9ba44927..df6f8605968 100644
--- a/Libraries/LibWeb/CSS/StyleValues/PercentageStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/PercentageStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class PercentageStyleValue final : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<PercentageStyleValue> create(Percentage percentage)
+    static ValueComparingNonnullRefPtr<PercentageStyleValue const> create(Percentage percentage)
     {
         return adopt_ref(*new (nothrow) PercentageStyleValue(move(percentage)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/PositionStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/PositionStyleValue.h
index dcd3c10b280..79cae979c53 100644
--- a/Libraries/LibWeb/CSS/StyleValues/PositionStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/PositionStyleValue.h
@@ -18,11 +18,11 @@ namespace Web::CSS {
 
 class PositionStyleValue final : public StyleValueWithDefaultOperators<PositionStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<PositionStyleValue> create(ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y)
+    static ValueComparingNonnullRefPtr<PositionStyleValue const> create(ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y)
     {
         return adopt_ref(*new (nothrow) PositionStyleValue(move(edge_x), move(edge_y)));
     }
-    static ValueComparingNonnullRefPtr<PositionStyleValue> create_center()
+    static ValueComparingNonnullRefPtr<PositionStyleValue const> create_center()
     {
         return adopt_ref(*new (nothrow) PositionStyleValue(
             EdgeStyleValue::create(PositionEdge::Center, {}),
@@ -30,8 +30,8 @@ public:
     }
     virtual ~PositionStyleValue() override = default;
 
-    ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x() const { return m_properties.edge_x; }
-    ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y() const { return m_properties.edge_y; }
+    ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x() const { return m_properties.edge_x; }
+    ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y() const { return m_properties.edge_y; }
     bool is_center() const;
     CSSPixelPoint resolved(Layout::Node const&, CSSPixelRect const&) const;
 
@@ -40,15 +40,15 @@ public:
     bool properties_equal(PositionStyleValue const& other) const { return m_properties == other.m_properties; }
 
 private:
-    PositionStyleValue(ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y)
+    PositionStyleValue(ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y)
         : StyleValueWithDefaultOperators(Type::Position)
-        , m_properties { .edge_x = edge_x, .edge_y = edge_y }
+        , m_properties { .edge_x = move(edge_x), .edge_y = move(edge_y) }
     {
     }
 
     struct Properties {
-        ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x;
-        ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y;
+        ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x;
+        ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y;
         bool operator==(Properties const&) const = default;
     } m_properties;
 };
diff --git a/Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h
index 57a90b5e99a..46c91c58dd0 100644
--- a/Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h
@@ -43,7 +43,7 @@ public:
 
     using Size = Variant<Extent, CircleSize, EllipseSize>;
 
-    static ValueComparingNonnullRefPtr<RadialGradientStyleValue> create(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
+    static ValueComparingNonnullRefPtr<RadialGradientStyleValue const> create(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
     {
         VERIFY(!color_stop_list.is_empty());
         bool any_non_legacy = color_stop_list.find_first_index_if([](auto const& stop) { return !stop.color_stop.color->is_keyword() && stop.color_stop.color->as_color().color_syntax() == ColorSyntax::Modern; }).has_value();
@@ -80,7 +80,7 @@ public:
     virtual ~RadialGradientStyleValue() override = default;
 
 private:
-    RadialGradientStyleValue(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
+    RadialGradientStyleValue(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
         : AbstractImageStyleValue(Type::RadialGradient)
         , m_properties { .ending_shape = ending_shape, .size = size, .position = move(position), .color_stop_list = move(color_stop_list), .repeating = repeating, .interpolation_method = interpolation_method, .color_syntax = color_syntax }
     {
@@ -89,7 +89,7 @@ private:
     struct Properties {
         EndingShape ending_shape;
         Size size;
-        ValueComparingNonnullRefPtr<PositionStyleValue> position;
+        ValueComparingNonnullRefPtr<PositionStyleValue const> position;
         Vector<LinearColorStopListElement> color_stop_list;
         GradientRepeating repeating;
         Optional<InterpolationMethod> interpolation_method;
diff --git a/Libraries/LibWeb/CSS/StyleValues/RatioStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/RatioStyleValue.h
index b925a66d52f..0d5af0c0bef 100644
--- a/Libraries/LibWeb/CSS/StyleValues/RatioStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/RatioStyleValue.h
@@ -13,7 +13,7 @@ namespace Web::CSS {
 
 class RatioStyleValue final : public StyleValueWithDefaultOperators<RatioStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<RatioStyleValue> create(Ratio ratio)
+    static ValueComparingNonnullRefPtr<RatioStyleValue const> create(Ratio ratio)
     {
         return adopt_ref(*new (nothrow) RatioStyleValue(move(ratio)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.cpp
index 865d756e561..5eb07fcd0b2 100644
--- a/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::CSS {
 
-ValueComparingNonnullRefPtr<RectStyleValue> RectStyleValue::create(EdgeRect rect)
+ValueComparingNonnullRefPtr<RectStyleValue const> RectStyleValue::create(EdgeRect rect)
 {
     return adopt_ref(*new (nothrow) RectStyleValue(move(rect)));
 }
diff --git a/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.h
index 44ff665dc19..41d525bd4cc 100644
--- a/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/RectStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class RectStyleValue : public StyleValueWithDefaultOperators<RectStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<RectStyleValue> create(EdgeRect rect);
+    static ValueComparingNonnullRefPtr<RectStyleValue const> create(EdgeRect rect);
     virtual ~RectStyleValue() override = default;
 
     EdgeRect rect() const { return m_rect; }
diff --git a/Libraries/LibWeb/CSS/StyleValues/ResolutionStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ResolutionStyleValue.h
index 66fd6813fbb..bf0b2df1ab0 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ResolutionStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ResolutionStyleValue.h
@@ -13,7 +13,7 @@ namespace Web::CSS {
 
 class ResolutionStyleValue : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<ResolutionStyleValue> create(Resolution resolution)
+    static ValueComparingNonnullRefPtr<ResolutionStyleValue const> create(Resolution resolution)
     {
         return adopt_ref(*new (nothrow) ResolutionStyleValue(move(resolution)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/ScrollbarGutterStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ScrollbarGutterStyleValue.h
index c76d57d83bb..87311338f9a 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ScrollbarGutterStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ScrollbarGutterStyleValue.h
@@ -12,7 +12,7 @@ namespace Web::CSS {
 
 class ScrollbarGutterStyleValue final : public StyleValueWithDefaultOperators<ScrollbarGutterStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<ScrollbarGutterStyleValue> create(ScrollbarGutter value)
+    static ValueComparingNonnullRefPtr<ScrollbarGutterStyleValue const> create(ScrollbarGutter value)
     {
         return adopt_ref(*new (nothrow) ScrollbarGutterStyleValue(value));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h
index ab5c325370c..d057c520d90 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h
@@ -22,7 +22,7 @@ enum class ShadowPlacement {
 
 class ShadowStyleValue final : public StyleValueWithDefaultOperators<ShadowStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<ShadowStyleValue> create(
+    static ValueComparingNonnullRefPtr<ShadowStyleValue const> create(
         ValueComparingNonnullRefPtr<CSSStyleValue const> color,
         ValueComparingNonnullRefPtr<CSSStyleValue const> offset_x,
         ValueComparingNonnullRefPtr<CSSStyleValue const> offset_y,
diff --git a/Libraries/LibWeb/CSS/StyleValues/ShorthandStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ShorthandStyleValue.h
index ac621742242..2d17705ae66 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ShorthandStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ShorthandStyleValue.h
@@ -12,7 +12,7 @@ namespace Web::CSS {
 
 class ShorthandStyleValue final : public StyleValueWithDefaultOperators<ShorthandStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<ShorthandStyleValue> create(PropertyID shorthand, Vector<PropertyID> sub_properties, Vector<ValueComparingNonnullRefPtr<CSSStyleValue const>> values)
+    static ValueComparingNonnullRefPtr<ShorthandStyleValue const> create(PropertyID shorthand, Vector<PropertyID> sub_properties, Vector<ValueComparingNonnullRefPtr<CSSStyleValue const>> values)
     {
         return adopt_ref(*new ShorthandStyleValue(shorthand, move(sub_properties), move(values)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/StringStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/StringStyleValue.h
index 2141717455f..4f779259fb0 100644
--- a/Libraries/LibWeb/CSS/StyleValues/StringStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/StringStyleValue.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 
 class StringStyleValue : public StyleValueWithDefaultOperators<StringStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<StringStyleValue> create(FlyString const& string)
+    static ValueComparingNonnullRefPtr<StringStyleValue const> create(FlyString const& string)
     {
         return adopt_ref(*new (nothrow) StringStyleValue(string));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/TimeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/TimeStyleValue.h
index 2b3e37880fe..0608234b9b4 100644
--- a/Libraries/LibWeb/CSS/StyleValues/TimeStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/TimeStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class TimeStyleValue : public CSSUnitValue {
 public:
-    static ValueComparingNonnullRefPtr<TimeStyleValue> create(Time time)
+    static ValueComparingNonnullRefPtr<TimeStyleValue const> create(Time time)
     {
         return adopt_ref(*new (nothrow) TimeStyleValue(move(time)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h
index 0dfdb199da4..d4ba7682d43 100644
--- a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h
@@ -16,7 +16,7 @@ namespace Web::CSS {
 
 class TransformationStyleValue final : public StyleValueWithDefaultOperators<TransformationStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<TransformationStyleValue> create(PropertyID property, TransformFunction transform_function, StyleValueVector&& values)
+    static ValueComparingNonnullRefPtr<TransformationStyleValue const> create(PropertyID property, TransformFunction transform_function, StyleValueVector&& values)
     {
         return adopt_ref(*new (nothrow) TransformationStyleValue(property, transform_function, move(values)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/TransitionStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/TransitionStyleValue.h
index 2d3931dabdf..abbc7311b78 100644
--- a/Libraries/LibWeb/CSS/StyleValues/TransitionStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/TransitionStyleValue.h
@@ -17,15 +17,15 @@ namespace Web::CSS {
 class TransitionStyleValue final : public StyleValueWithDefaultOperators<TransitionStyleValue> {
 public:
     struct Transition {
-        ValueComparingRefPtr<CustomIdentStyleValue> property_name;
+        ValueComparingRefPtr<CustomIdentStyleValue const> property_name;
         TimeOrCalculated duration { CSS::Time::make_seconds(0.0) };
         TimeOrCalculated delay { CSS::Time::make_seconds(0.0) };
-        ValueComparingRefPtr<EasingStyleValue> easing;
+        ValueComparingRefPtr<EasingStyleValue const> easing;
 
         bool operator==(Transition const&) const = default;
     };
 
-    static ValueComparingNonnullRefPtr<TransitionStyleValue> create(Vector<Transition> transitions)
+    static ValueComparingNonnullRefPtr<TransitionStyleValue const> create(Vector<Transition> transitions)
     {
         return adopt_ref(*new (nothrow) TransitionStyleValue(move(transitions)));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/URLStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/URLStyleValue.h
index 8e4b1f45a3f..e8bbe38639c 100644
--- a/Libraries/LibWeb/CSS/StyleValues/URLStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/URLStyleValue.h
@@ -14,7 +14,7 @@ namespace Web::CSS {
 
 class URLStyleValue final : public StyleValueWithDefaultOperators<URLStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<URLStyleValue> create(::URL::URL const& url)
+    static ValueComparingNonnullRefPtr<URLStyleValue const> create(::URL::URL const& url)
     {
         return adopt_ref(*new (nothrow) URLStyleValue(url));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/UnicodeRangeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/UnicodeRangeStyleValue.h
index ef873e64719..23d636b7f2a 100644
--- a/Libraries/LibWeb/CSS/StyleValues/UnicodeRangeStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/UnicodeRangeStyleValue.h
@@ -13,7 +13,7 @@ namespace Web::CSS {
 
 class UnicodeRangeStyleValue final : public StyleValueWithDefaultOperators<UnicodeRangeStyleValue> {
 public:
-    static ValueComparingNonnullRefPtr<UnicodeRangeStyleValue> create(Gfx::UnicodeRange unicode_range)
+    static ValueComparingNonnullRefPtr<UnicodeRangeStyleValue const> create(Gfx::UnicodeRange unicode_range)
     {
         return adopt_ref(*new (nothrow) UnicodeRangeStyleValue(unicode_range));
     }
diff --git a/Libraries/LibWeb/CSS/StyleValues/UnresolvedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/UnresolvedStyleValue.h
index 6982d668ef1..ab7cd5d49d1 100644
--- a/Libraries/LibWeb/CSS/StyleValues/UnresolvedStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/UnresolvedStyleValue.h
@@ -17,7 +17,7 @@ namespace Web::CSS {
 
 class UnresolvedStyleValue final : public CSSStyleValue {
 public:
-    static ValueComparingNonnullRefPtr<UnresolvedStyleValue> create(Vector<Parser::ComponentValue>&& values, bool contains_var_or_attr, Optional<String> original_source_text)
+    static ValueComparingNonnullRefPtr<UnresolvedStyleValue const> create(Vector<Parser::ComponentValue>&& values, bool contains_var_or_attr, Optional<String> original_source_text)
     {
         return adopt_ref(*new (nothrow) UnresolvedStyleValue(move(values), contains_var_or_attr, move(original_source_text)));
     }
diff --git a/Libraries/LibWeb/CSS/Time.cpp b/Libraries/LibWeb/CSS/Time.cpp
index a9e7c70727b..1fdfcdfbea9 100644
--- a/Libraries/LibWeb/CSS/Time.cpp
+++ b/Libraries/LibWeb/CSS/Time.cpp
@@ -74,7 +74,7 @@ Optional<Time::Type> Time::unit_from_name(StringView name)
     return {};
 }
 
-Time Time::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Time const& reference_value)
+Time Time::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Time const& reference_value)
 {
     return calculated->resolve_time(
                          {
diff --git a/Libraries/LibWeb/CSS/Time.h b/Libraries/LibWeb/CSS/Time.h
index 356e9a778f4..6a82c02a70a 100644
--- a/Libraries/LibWeb/CSS/Time.h
+++ b/Libraries/LibWeb/CSS/Time.h
@@ -49,7 +49,7 @@ public:
         return 0;
     }
 
-    static Time resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const&, Layout::Node const&, Time const& reference_value);
+    static Time resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const&, Layout::Node const&, Time const& reference_value);
 
 private:
     Type m_type;
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasState.h b/Libraries/LibWeb/HTML/Canvas/CanvasState.h
index daf111a41c8..b077bf6252c 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasState.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasState.h
@@ -98,7 +98,7 @@ public:
         Bindings::ImageSmoothingQuality image_smoothing_quality { Bindings::ImageSmoothingQuality::Low };
         float global_alpha = { 1 };
         Gfx::CompositingAndBlendingOperator current_compositing_and_blending_operator = Gfx::CompositingAndBlendingOperator::SourceOver;
-        RefPtr<CSS::CSSStyleValue> font_style_value { nullptr };
+        RefPtr<CSS::CSSStyleValue const> font_style_value { nullptr };
         RefPtr<Gfx::Font const> current_font { nullptr };
         Bindings::CanvasTextAlign text_align { Bindings::CanvasTextAlign::Start };
         Bindings::CanvasTextBaseline text_baseline { Bindings::CanvasTextBaseline::Alphabetic };
diff --git a/Libraries/LibWeb/HTML/HTMLBodyElement.h b/Libraries/LibWeb/HTML/HTMLBodyElement.h
index 24888808c0a..eadc7583be7 100644
--- a/Libraries/LibWeb/HTML/HTMLBodyElement.h
+++ b/Libraries/LibWeb/HTML/HTMLBodyElement.h
@@ -44,7 +44,7 @@ private:
     // ^HTML::WindowEventHandlers
     virtual GC::Ptr<DOM::EventTarget> window_event_handlers_to_event_target() override;
 
-    RefPtr<CSS::ImageStyleValue> m_background_style_value;
+    RefPtr<CSS::ImageStyleValue const> m_background_style_value;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp b/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp
index 009014546b1..b651dc88f0a 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp
+++ b/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp
@@ -4925,7 +4925,7 @@ String HTMLParser::serialize_html_fragment(DOM::Node const& node, SerializableSh
 }
 
 // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#current-dimension-value
-static RefPtr<CSS::CSSStyleValue> parse_current_dimension_value(float value, Utf8View input, Utf8View::Iterator position)
+static RefPtr<CSS::CSSStyleValue const> parse_current_dimension_value(float value, Utf8View input, Utf8View::Iterator position)
 {
     // 1. If position is past the end of input, then return value as a length.
     if (position == input.end())
@@ -4940,7 +4940,7 @@ static RefPtr<CSS::CSSStyleValue> parse_current_dimension_value(float value, Utf
 }
 
 // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-dimension-values
-RefPtr<CSS::CSSStyleValue> parse_dimension_value(StringView string)
+RefPtr<CSS::CSSStyleValue const> parse_dimension_value(StringView string)
 {
     // 1. Let input be the string being parsed.
     auto input = Utf8View(string);
@@ -5014,7 +5014,7 @@ RefPtr<CSS::CSSStyleValue> parse_dimension_value(StringView string)
 }
 
 // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-non-zero-dimension-values
-RefPtr<CSS::CSSStyleValue> parse_nonzero_dimension_value(StringView string)
+RefPtr<CSS::CSSStyleValue const> parse_nonzero_dimension_value(StringView string)
 {
     // 1. Let input be the string being parsed.
     // 2. Let value be the result of parsing input using the rules for parsing dimension values.
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLParser.h b/Libraries/LibWeb/HTML/Parser/HTMLParser.h
index 16902a40c76..cfcd1a70001 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLParser.h
+++ b/Libraries/LibWeb/HTML/Parser/HTMLParser.h
@@ -216,8 +216,8 @@ private:
     StringBuilder m_character_insertion_builder;
 } SWIFT_UNSAFE_REFERENCE;
 
-RefPtr<CSS::CSSStyleValue> parse_dimension_value(StringView);
-RefPtr<CSS::CSSStyleValue> parse_nonzero_dimension_value(StringView);
+RefPtr<CSS::CSSStyleValue const> parse_dimension_value(StringView);
+RefPtr<CSS::CSSStyleValue const> parse_nonzero_dimension_value(StringView);
 Optional<Color> parse_legacy_color_value(StringView);
 
 // Swift interop
diff --git a/Libraries/LibWeb/Layout/LayoutState.h b/Libraries/LibWeb/Layout/LayoutState.h
index a3b9882889a..7c0243a0554 100644
--- a/Libraries/LibWeb/Layout/LayoutState.h
+++ b/Libraries/LibWeb/Layout/LayoutState.h
@@ -148,10 +148,10 @@ struct LayoutState {
         void set_computed_svg_transforms(Painting::SVGGraphicsPaintable::ComputedTransforms const& computed_transforms) { m_computed_svg_transforms = computed_transforms; }
         auto const& computed_svg_transforms() const { return m_computed_svg_transforms; }
 
-        void set_grid_template_columns(RefPtr<CSS::GridTrackSizeListStyleValue> used_values_for_grid_template_columns) { m_grid_template_columns = move(used_values_for_grid_template_columns); }
+        void set_grid_template_columns(RefPtr<CSS::GridTrackSizeListStyleValue const> used_values_for_grid_template_columns) { m_grid_template_columns = move(used_values_for_grid_template_columns); }
         auto const& grid_template_columns() const { return m_grid_template_columns; }
 
-        void set_grid_template_rows(RefPtr<CSS::GridTrackSizeListStyleValue> used_values_for_grid_template_rows) { m_grid_template_rows = move(used_values_for_grid_template_rows); }
+        void set_grid_template_rows(RefPtr<CSS::GridTrackSizeListStyleValue const> used_values_for_grid_template_rows) { m_grid_template_rows = move(used_values_for_grid_template_rows); }
         auto const& grid_template_rows() const { return m_grid_template_rows; }
 
         void set_static_position_rect(StaticPositionRect const& static_position_rect) { m_static_position_rect = static_position_rect; }
@@ -191,8 +191,8 @@ struct LayoutState {
         Optional<Gfx::Path> m_computed_svg_path;
         Optional<Painting::SVGGraphicsPaintable::ComputedTransforms> m_computed_svg_transforms;
 
-        RefPtr<CSS::GridTrackSizeListStyleValue> m_grid_template_columns;
-        RefPtr<CSS::GridTrackSizeListStyleValue> m_grid_template_rows;
+        RefPtr<CSS::GridTrackSizeListStyleValue const> m_grid_template_columns;
+        RefPtr<CSS::GridTrackSizeListStyleValue const> m_grid_template_rows;
 
         Optional<StaticPositionRect> m_static_position_rect;
     };
diff --git a/Libraries/LibWeb/Page/EventHandler.cpp b/Libraries/LibWeb/Page/EventHandler.cpp
index 9a3b2ae2839..7c16a8babb3 100644
--- a/Libraries/LibWeb/Page/EventHandler.cpp
+++ b/Libraries/LibWeb/Page/EventHandler.cpp
@@ -152,7 +152,7 @@ static Gfx::Cursor resolve_cursor(Layout::NodeWithStyle const& layout_node, Vect
                     return Gfx::StandardCursor::None;
                 }
             },
-            [&layout_node](NonnullRefPtr<CSS::CursorStyleValue> const& cursor_style_value) -> Optional<Gfx::Cursor> {
+            [&layout_node](NonnullRefPtr<CSS::CursorStyleValue const> const& cursor_style_value) -> Optional<Gfx::Cursor> {
                 if (auto image_cursor = cursor_style_value->make_image_cursor(layout_node); image_cursor.has_value())
                     return image_cursor.release_value();
                 return {};
diff --git a/Libraries/LibWeb/Painting/PaintableBox.h b/Libraries/LibWeb/Painting/PaintableBox.h
index bd114322301..046d73fba5f 100644
--- a/Libraries/LibWeb/Painting/PaintableBox.h
+++ b/Libraries/LibWeb/Painting/PaintableBox.h
@@ -239,11 +239,11 @@ public:
 
     [[nodiscard]] bool could_be_scrolled_by_wheel_event() const;
 
-    void set_used_values_for_grid_template_columns(RefPtr<CSS::GridTrackSizeListStyleValue> style_value) { m_used_values_for_grid_template_columns = move(style_value); }
-    RefPtr<CSS::GridTrackSizeListStyleValue> const& used_values_for_grid_template_columns() const { return m_used_values_for_grid_template_columns; }
+    void set_used_values_for_grid_template_columns(RefPtr<CSS::GridTrackSizeListStyleValue const> style_value) { m_used_values_for_grid_template_columns = move(style_value); }
+    RefPtr<CSS::GridTrackSizeListStyleValue const> const& used_values_for_grid_template_columns() const { return m_used_values_for_grid_template_columns; }
 
-    void set_used_values_for_grid_template_rows(RefPtr<CSS::GridTrackSizeListStyleValue> style_value) { m_used_values_for_grid_template_rows = move(style_value); }
-    RefPtr<CSS::GridTrackSizeListStyleValue> const& used_values_for_grid_template_rows() const { return m_used_values_for_grid_template_rows; }
+    void set_used_values_for_grid_template_rows(RefPtr<CSS::GridTrackSizeListStyleValue const> style_value) { m_used_values_for_grid_template_rows = move(style_value); }
+    RefPtr<CSS::GridTrackSizeListStyleValue const> const& used_values_for_grid_template_rows() const { return m_used_values_for_grid_template_rows; }
 
 protected:
     explicit PaintableBox(Layout::Box const&);
@@ -309,8 +309,8 @@ private:
 
     OwnPtr<StickyInsets> m_sticky_insets;
 
-    RefPtr<CSS::GridTrackSizeListStyleValue> m_used_values_for_grid_template_columns;
-    RefPtr<CSS::GridTrackSizeListStyleValue> m_used_values_for_grid_template_rows;
+    RefPtr<CSS::GridTrackSizeListStyleValue const> m_used_values_for_grid_template_columns;
+    RefPtr<CSS::GridTrackSizeListStyleValue const> m_used_values_for_grid_template_rows;
 
     BoxModelMetrics m_box_model;
 };
diff --git a/Libraries/LibWeb/SVG/SVGSVGElement.cpp b/Libraries/LibWeb/SVG/SVGSVGElement.cpp
index 894580cc633..cb6e91daea8 100644
--- a/Libraries/LibWeb/SVG/SVGSVGElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGSVGElement.cpp
@@ -47,7 +47,7 @@ GC::Ptr<Layout::Node> SVGSVGElement::create_layout_node(GC::Ref<CSS::ComputedPro
     return heap().allocate<Layout::SVGSVGBox>(document(), *this, move(style));
 }
 
-RefPtr<CSS::CSSStyleValue> SVGSVGElement::width_style_value_from_attribute() const
+RefPtr<CSS::CSSStyleValue const> SVGSVGElement::width_style_value_from_attribute() const
 {
     auto parsing_context = CSS::Parser::ParsingParams { document(), CSS::Parser::ParsingMode::SVGPresentationAttribute };
     auto width_attribute = attribute(SVG::AttributeNames::width);
@@ -63,7 +63,7 @@ RefPtr<CSS::CSSStyleValue> SVGSVGElement::width_style_value_from_attribute() con
     return nullptr;
 }
 
-RefPtr<CSS::CSSStyleValue> SVGSVGElement::height_style_value_from_attribute() const
+RefPtr<CSS::CSSStyleValue const> SVGSVGElement::height_style_value_from_attribute() const
 {
     auto parsing_context = CSS::Parser::ParsingParams { document(), CSS::Parser::ParsingMode::SVGPresentationAttribute };
     auto height_attribute = attribute(SVG::AttributeNames::height);
diff --git a/Libraries/LibWeb/SVG/SVGSVGElement.h b/Libraries/LibWeb/SVG/SVGSVGElement.h
index f5b14ab457b..88ec8eee11b 100644
--- a/Libraries/LibWeb/SVG/SVGSVGElement.h
+++ b/Libraries/LibWeb/SVG/SVGSVGElement.h
@@ -78,8 +78,8 @@ public:
     void unsuspend_redraw_all() const { }
     void force_redraw() const { }
 
-    [[nodiscard]] RefPtr<CSS::CSSStyleValue> width_style_value_from_attribute() const;
-    [[nodiscard]] RefPtr<CSS::CSSStyleValue> height_style_value_from_attribute() const;
+    [[nodiscard]] RefPtr<CSS::CSSStyleValue const> width_style_value_from_attribute() const;
+    [[nodiscard]] RefPtr<CSS::CSSStyleValue const> height_style_value_from_attribute() const;
 
     struct NaturalMetrics {
         Optional<CSSPixels> width;
diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSDescriptors.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSDescriptors.cpp
index ccf15d65842..e528d381456 100644
--- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSDescriptors.cpp
+++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSDescriptors.cpp
@@ -113,7 +113,7 @@ Optional<DescriptorID> descriptor_id_from_string(AtRuleID, StringView);
 FlyString to_string(DescriptorID);
 
 bool at_rule_supports_descriptor(AtRuleID, DescriptorID);
-RefPtr<CSSStyleValue> descriptor_initial_value(AtRuleID, DescriptorID);
+RefPtr<CSSStyleValue const> descriptor_initial_value(AtRuleID, DescriptorID);
 
 struct DescriptorMetadata {
     enum class ValueType {
@@ -273,12 +273,12 @@ bool at_rule_supports_descriptor(AtRuleID at_rule_id, DescriptorID descriptor_id
 }
 
 
-RefPtr<CSSStyleValue> descriptor_initial_value(AtRuleID at_rule_id, DescriptorID descriptor_id)
+RefPtr<CSSStyleValue const> descriptor_initial_value(AtRuleID at_rule_id, DescriptorID descriptor_id)
 {
     if (!at_rule_supports_descriptor(at_rule_id, descriptor_id))
         return nullptr;
 
-    static Array<Array<RefPtr<CSSStyleValue>, @descriptor_count@>, @at_rule_count@> initial_values;
+    static Array<Array<RefPtr<CSSStyleValue const>, @descriptor_count@>, @at_rule_count@> initial_values;
     if (auto initial_value = initial_values[to_underlying(at_rule_id)][to_underlying(descriptor_id)])
         return initial_value.release_nonnull();
 
diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSPropertyID.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSPropertyID.cpp
index 1f81b8bec85..a963bdc2bec 100644
--- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSPropertyID.cpp
+++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSPropertyID.cpp
@@ -220,7 +220,7 @@ Optional<PropertyID> property_id_from_string(StringView);
 [[nodiscard]] FlyString const& string_from_property_id(PropertyID);
 [[nodiscard]] FlyString const& camel_case_string_from_property_id(PropertyID);
 bool is_inherited_property(PropertyID);
-NonnullRefPtr<CSSStyleValue> property_initial_value(PropertyID);
+NonnullRefPtr<CSSStyleValue const> property_initial_value(PropertyID);
 
 enum class ValueType {
     Angle,
@@ -665,9 +665,9 @@ bool property_affects_stacking_context(PropertyID property_id)
     }
 }
 
-NonnullRefPtr<CSSStyleValue> property_initial_value(PropertyID property_id)
+NonnullRefPtr<CSSStyleValue const> property_initial_value(PropertyID property_id)
 {
-    static Array<RefPtr<CSSStyleValue>, to_underlying(last_property_id) + 1> initial_values;
+    static Array<RefPtr<CSSStyleValue const>, to_underlying(last_property_id) + 1> initial_values;
     if (auto initial_value = initial_values[to_underlying(property_id)])
         return initial_value.release_nonnull();