LibWeb: Alphabetically sort StyleValues

The random order keeps confuzing me!

Userland/Libraries/LibWeb/CSS/StyleValue.h

@@ -228,60 +228,60 @@ public:
     virtual ~StyleValue();
 
     enum class Type {
-        Invalid,
-        Inherit,
-        Initial,
-        Unset,
-        String,
-        Length,
-        Color,
-        Identifier,
-        Image,
-        CustomProperty,
-        Numeric,
-        ValueList,
-        Calculated,
         Background,
         BackgroundRepeat,
         Border,
         BorderRadius,
-        CombinedBorderRadius,
         BoxShadow,
+        Calculated,
+        Color,
+        CombinedBorderRadius,
+        CustomProperty,
         Flex,
         FlexFlow,
         Font,
+        Identifier,
+        Image,
+        Inherit,
+        Initial,
+        Invalid,
+        Length,
         ListStyle,
+        Numeric,
         Overflow,
+        String,
         TextDecoration,
         Transformation,
+        Unset,
+        ValueList,
     };
 
     Type type() const { return m_type; }
 
-    bool is_inherit() const { return type() == Type::Inherit; }
-    bool is_initial() const { return type() == Type::Initial; }
-    bool is_unset() const { return type() == Type::Unset; }
-    bool is_color() const;
-    bool is_identifier() const { return type() == Type::Identifier || is_auto(); }
-    bool is_image() const { return type() == Type::Image; }
-    bool is_string() const { return type() == Type::String; }
-    virtual bool is_length() const { return type() == Type::Length; }
-    bool is_custom_property() const { return type() == Type::CustomProperty; }
-    bool is_numeric() const { return type() == Type::Numeric; }
-    bool is_value_list() const { return type() == Type::ValueList; }
-    bool is_calculated() const { return type() == Type::Calculated; }
     bool is_background() const { return type() == Type::Background; }
     bool is_background_repeat() const { return type() == Type::BackgroundRepeat; }
     bool is_border() const { return type() == Type::Border; }
     bool is_border_radius() const { return type() == Type::BorderRadius; }
     bool is_box_shadow() const { return type() == Type::BoxShadow; }
+    bool is_calculated() const { return type() == Type::Calculated; }
+    bool is_color() const { return type() == Type::Color; }
+    bool is_custom_property() const { return type() == Type::CustomProperty; }
     bool is_flex() const { return type() == Type::Flex; }
     bool is_flex_flow() const { return type() == Type::FlexFlow; }
     bool is_font() const { return type() == Type::Font; }
+    bool is_identifier() const { return type() == Type::Identifier || is_auto(); }
+    bool is_image() const { return type() == Type::Image; }
+    bool is_inherit() const { return type() == Type::Inherit; }
+    bool is_initial() const { return type() == Type::Initial; }
+    virtual bool is_length() const { return type() == Type::Length; }
     bool is_list_style() const { return type() == Type::ListStyle; }
+    bool is_numeric() const { return type() == Type::Numeric; }
     bool is_overflow() const { return type() == Type::Overflow; }
+    bool is_string() const { return type() == Type::String; }
     bool is_text_decoration() const { return type() == Type::TextDecoration; }
     bool is_transformation() const { return type() == Type::Transformation; }
+    bool is_unset() const { return type() == Type::Unset; }
+    bool is_value_list() const { return type() == Type::ValueList; }
 
     bool is_builtin() const { return is_inherit() || is_initial() || is_unset(); }
 
@@ -318,74 +318,159 @@ private:
     Type m_type { Type::Invalid };
 };
 
-// FIXME: Allow for fallback
-class CustomStyleValue : public StyleValue {
+class BackgroundStyleValue final : public StyleValue {
 public:
-    static NonnullRefPtr<CustomStyleValue> create(const String& custom_property_name)
+    static NonnullRefPtr<BackgroundStyleValue> create(
+        NonnullRefPtr<StyleValue> color,
+        NonnullRefPtr<StyleValue> image,
+        NonnullRefPtr<StyleValue> repeat_x,
+        NonnullRefPtr<StyleValue> repeat_y)
     {
-        return adopt_ref(*new CustomStyleValue(custom_property_name));
+        return adopt_ref(*new BackgroundStyleValue(color, image, repeat_x, repeat_y));
     }
-    String custom_property_name() const { return m_custom_property_name; }
-    String to_string() const override { return m_custom_property_name; }
+    virtual ~BackgroundStyleValue() override { }
 
-private:
-    explicit CustomStyleValue(const String& custom_property_name)
-        : StyleValue(Type::CustomProperty)
-        , m_custom_property_name(custom_property_name)
+    NonnullRefPtr<StyleValue> color() const { return m_color; }
+    NonnullRefPtr<StyleValue> image() const { return m_image; }
+    NonnullRefPtr<StyleValue> repeat_x() const { return m_repeat_x; }
+    NonnullRefPtr<StyleValue> repeat_y() const { return m_repeat_y; }
+
+    virtual String to_string() const override
     {
+        return String::formatted("{} {} {} {}", m_color->to_string(), m_image->to_string(), m_repeat_x->to_string(), m_repeat_y->to_string());
     }
 
-    String m_custom_property_name {};
+private:
+    BackgroundStyleValue(
+        NonnullRefPtr<StyleValue> color,
+        NonnullRefPtr<StyleValue> image,
+        NonnullRefPtr<StyleValue> repeat_x,
+        NonnullRefPtr<StyleValue> repeat_y)
+        : StyleValue(Type::Background)
+        , m_color(color)
+        , m_image(image)
+        , m_repeat_x(repeat_x)
+        , m_repeat_y(repeat_y)
+    {
+    }
+    NonnullRefPtr<StyleValue> m_color;
+    NonnullRefPtr<StyleValue> m_image;
+    // FIXME: background-position
+    // FIXME: background-size
+    NonnullRefPtr<StyleValue> m_repeat_x;
+    NonnullRefPtr<StyleValue> m_repeat_y;
+    // FIXME: background-attachment
+    // FIXME: background-clip
+    // FIXME: background-origin
 };
 
-class NumericStyleValue : public StyleValue {
+class BackgroundRepeatStyleValue final : public StyleValue {
 public:
-    static NonnullRefPtr<NumericStyleValue> create(float value)
+    static NonnullRefPtr<BackgroundRepeatStyleValue> create(NonnullRefPtr<StyleValue> repeat_x, NonnullRefPtr<StyleValue> repeat_y)
     {
-        return adopt_ref(*new NumericStyleValue(value));
+        return adopt_ref(*new BackgroundRepeatStyleValue(repeat_x, repeat_y));
     }
+    virtual ~BackgroundRepeatStyleValue() override { }
 
-    virtual bool is_length() const override { return m_value == 0; }
-    virtual Length to_length() const override { return Length(0, Length::Type::Px); }
+    NonnullRefPtr<StyleValue> repeat_x() const { return m_repeat_x; }
+    NonnullRefPtr<StyleValue> repeat_y() const { return m_repeat_y; }
 
-    float value() const { return m_value; }
-    String to_string() const override { return String::formatted("{}", m_value); }
+    virtual String to_string() const override
+    {
+        return String::formatted("{} {}", m_repeat_x->to_string(), m_repeat_y->to_string());
+    }
 
-    virtual bool equals(StyleValue const& other) const override
+private:
+    BackgroundRepeatStyleValue(NonnullRefPtr<StyleValue> repeat_x, NonnullRefPtr<StyleValue> repeat_y)
+        : StyleValue(Type::BackgroundRepeat)
+        , m_repeat_x(repeat_x)
+        , m_repeat_y(repeat_y)
     {
-        if (type() != other.type())
-            return false;
-        return m_value == static_cast<NumericStyleValue const&>(other).m_value;
+    }
+
+    NonnullRefPtr<StyleValue> m_repeat_x;
+    NonnullRefPtr<StyleValue> m_repeat_y;
+};
+
+class BorderStyleValue final : public StyleValue {
+public:
+    static NonnullRefPtr<BorderStyleValue> create(
+        NonnullRefPtr<StyleValue> border_width,
+        NonnullRefPtr<StyleValue> border_style,
+        NonnullRefPtr<StyleValue> border_color)
+    {
+        return adopt_ref(*new BorderStyleValue(border_width, border_style, border_color));
+    }
+    virtual ~BorderStyleValue() override { }
+
+    NonnullRefPtr<StyleValue> border_width() const { return m_border_width; }
+    NonnullRefPtr<StyleValue> border_style() const { return m_border_style; }
+    NonnullRefPtr<StyleValue> border_color() const { return m_border_color; }
+
+    virtual String to_string() const override
+    {
+        return String::formatted("Border border_width: {}, border_style: {}, border_color: {}", m_border_width->to_string(), m_border_style->to_string(), m_border_color->to_string());
     }
 
 private:
-    explicit NumericStyleValue(float value)
-        : StyleValue(Type::Numeric)
-        , m_value(value)
+    BorderStyleValue(
+        NonnullRefPtr<StyleValue> border_width,
+        NonnullRefPtr<StyleValue> border_style,
+        NonnullRefPtr<StyleValue> border_color)
+        : StyleValue(Type::Border)
+        , m_border_width(border_width)
+        , m_border_style(border_style)
+        , m_border_color(border_color)
     {
     }
 
-    float m_value { 0 };
+    NonnullRefPtr<StyleValue> m_border_width;
+    NonnullRefPtr<StyleValue> m_border_style;
+    NonnullRefPtr<StyleValue> m_border_color;
 };
 
-class StringStyleValue : public StyleValue {
+class BorderRadiusStyleValue final : public StyleValue {
 public:
-    static NonnullRefPtr<StringStyleValue> create(const String& string)
+    static NonnullRefPtr<BorderRadiusStyleValue> create(Length const& horizontal_radius, Length const& vertical_radius)
     {
-        return adopt_ref(*new StringStyleValue(string));
+        return adopt_ref(*new BorderRadiusStyleValue(horizontal_radius, vertical_radius));
     }
-    virtual ~StringStyleValue() override { }
+    virtual ~BorderRadiusStyleValue() override { }
 
-    String to_string() const override { return m_string; }
+    Length const& horizontal_radius() const { return m_horizontal_radius; }
+    Length const& vertical_radius() const { return m_vertical_radius; }
+    bool is_elliptical() const { return m_is_elliptical; }
+
+    // FIXME: Remove this once we support elliptical border-radius in Layout/Node.
+    virtual Length to_length() const override { return horizontal_radius(); }
+
+    virtual String to_string() const override
+    {
+        return String::formatted("{} / {}", m_horizontal_radius.to_string(), m_vertical_radius.to_string());
+    }
+
+    virtual bool equals(StyleValue const& other) const override
+    {
+        if (type() != other.type())
+            return false;
+        auto& other_value = static_cast<BorderRadiusStyleValue const&>(other);
+        return m_is_elliptical == other_value.m_is_elliptical
+            && m_horizontal_radius == other_value.m_horizontal_radius
+            && m_vertical_radius == other_value.m_vertical_radius;
+    }
 
 private:
-    explicit StringStyleValue(const String& string)
-        : StyleValue(Type::String)
-        , m_string(string)
+    BorderRadiusStyleValue(Length const& horizontal_radius, Length const& vertical_radius)
+        : StyleValue(Type::BorderRadius)
+        , m_horizontal_radius(horizontal_radius)
+        , m_vertical_radius(vertical_radius)
     {
+        m_is_elliptical = (m_horizontal_radius != m_vertical_radius);
     }
 
-    String m_string;
+    bool m_is_elliptical;
+    Length m_horizontal_radius;
+    Length m_vertical_radius;
 };
 
 class BoxShadowStyleValue : public StyleValue {
@@ -420,38 +505,6 @@ private:
     Color m_color;
 };
 
-class LengthStyleValue : public StyleValue {
-public:
-    static NonnullRefPtr<LengthStyleValue> create(const Length& length)
-    {
-        return adopt_ref(*new LengthStyleValue(length));
-    }
-    virtual ~LengthStyleValue() override { }
-
-    virtual String to_string() const override { return m_length.to_string(); }
-    virtual Length to_length() const override { return m_length; }
-
-    const Length& length() const { return m_length; }
-
-    virtual bool is_auto() const override { return m_length.is_auto(); }
-
-    virtual bool equals(const StyleValue& other) const override
-    {
-        if (type() != other.type())
-            return false;
-        return m_length == static_cast<const LengthStyleValue&>(other).m_length;
-    }
-
-private:
-    explicit LengthStyleValue(const Length& length)
-        : StyleValue(Type::Length)
-        , m_length(length)
-    {
-    }
-
-    Length m_length;
-};
-
 class CalculatedStyleValue : public StyleValue {
 public:
     struct CalcSum;
@@ -550,303 +603,42 @@ public:
 private:
     explicit CalculatedStyleValue(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
         : StyleValue(Type::Calculated)
-        , m_expression_string(expression_string)
-        , m_expression(move(calc_sum))
-    {
-    }
-
-    String m_expression_string;
-    NonnullOwnPtr<CalcSum> m_expression;
-};
-
-class InitialStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<InitialStyleValue> the()
-    {
-        static NonnullRefPtr<InitialStyleValue> instance = adopt_ref(*new InitialStyleValue);
-        return instance;
-    }
-    virtual ~InitialStyleValue() override { }
-
-    String to_string() const override { return "initial"; }
-
-private:
-    InitialStyleValue()
-        : StyleValue(Type::Initial)
-    {
-    }
-};
-
-class InheritStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<InheritStyleValue> the()
-    {
-        static NonnullRefPtr<InheritStyleValue> instance = adopt_ref(*new InheritStyleValue);
-        return instance;
-    }
-    virtual ~InheritStyleValue() override { }
-
-    String to_string() const override { return "inherit"; }
-
-private:
-    InheritStyleValue()
-        : StyleValue(Type::Inherit)
-    {
-    }
-};
-
-class UnsetStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<UnsetStyleValue> the()
-    {
-        static NonnullRefPtr<UnsetStyleValue> instance = adopt_ref(*new UnsetStyleValue);
-        return instance;
-    }
-    virtual ~UnsetStyleValue() override { }
-
-    String to_string() const override { return "unset"; }
-
-private:
-    UnsetStyleValue()
-        : StyleValue(Type::Unset)
-    {
-    }
-};
-
-class ColorStyleValue : public StyleValue {
-public:
-    static NonnullRefPtr<ColorStyleValue> create(Color color)
-    {
-        return adopt_ref(*new ColorStyleValue(color));
-    }
-    virtual ~ColorStyleValue() override { }
-
-    Color color() const { return m_color; }
-    String to_string() const override { return m_color.to_string(); }
-    Color to_color(Layout::NodeWithStyle const&) const override { return m_color; }
-
-    virtual bool equals(const StyleValue& other) const override
-    {
-        if (type() != other.type())
-            return false;
-        return m_color == static_cast<const ColorStyleValue&>(other).m_color;
-    }
-
-private:
-    explicit ColorStyleValue(Color color)
-        : StyleValue(Type::Color)
-        , m_color(color)
-    {
-    }
-
-    Color m_color;
-};
-
-class IdentifierStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<IdentifierStyleValue> create(CSS::ValueID id)
-    {
-        return adopt_ref(*new IdentifierStyleValue(id));
-    }
-    virtual ~IdentifierStyleValue() override { }
-
-    CSS::ValueID id() const { return m_id; }
-
-    virtual String to_string() const override;
-    virtual Color to_color(Layout::NodeWithStyle const& node) const override;
-
-    virtual bool equals(const StyleValue& other) const override
-    {
-        if (type() != other.type())
-            return false;
-        return m_id == static_cast<const IdentifierStyleValue&>(other).m_id;
-    }
-
-private:
-    explicit IdentifierStyleValue(CSS::ValueID id)
-        : StyleValue(Type::Identifier)
-        , m_id(id)
-    {
-    }
-
-    CSS::ValueID m_id { CSS::ValueID::Invalid };
-};
-
-class ImageStyleValue final
-    : public StyleValue
-    , public ImageResourceClient {
-public:
-    static NonnullRefPtr<ImageStyleValue> create(const AK::URL& url, DOM::Document& document) { return adopt_ref(*new ImageStyleValue(url, document)); }
-    virtual ~ImageStyleValue() override { }
-
-    String to_string() const override { return String::formatted("Image({})", m_url.to_string()); }
-
-    const Gfx::Bitmap* bitmap() const { return m_bitmap; }
-
-private:
-    ImageStyleValue(const AK::URL&, DOM::Document&);
-
-    // ^ResourceClient
-    virtual void resource_did_load() override;
-
-    AK::URL m_url;
-    WeakPtr<DOM::Document> m_document;
-    RefPtr<Gfx::Bitmap> m_bitmap;
-};
-
-class BackgroundStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<BackgroundStyleValue> create(
-        NonnullRefPtr<StyleValue> color,
-        NonnullRefPtr<StyleValue> image,
-        NonnullRefPtr<StyleValue> repeat_x,
-        NonnullRefPtr<StyleValue> repeat_y)
-    {
-        return adopt_ref(*new BackgroundStyleValue(color, image, repeat_x, repeat_y));
-    }
-    virtual ~BackgroundStyleValue() override { }
-
-    NonnullRefPtr<StyleValue> color() const { return m_color; }
-    NonnullRefPtr<StyleValue> image() const { return m_image; }
-    NonnullRefPtr<StyleValue> repeat_x() const { return m_repeat_x; }
-    NonnullRefPtr<StyleValue> repeat_y() const { return m_repeat_y; }
-
-    virtual String to_string() const override
-    {
-        return String::formatted("{} {} {} {}", m_color->to_string(), m_image->to_string(), m_repeat_x->to_string(), m_repeat_y->to_string());
-    }
-
-private:
-    BackgroundStyleValue(
-        NonnullRefPtr<StyleValue> color,
-        NonnullRefPtr<StyleValue> image,
-        NonnullRefPtr<StyleValue> repeat_x,
-        NonnullRefPtr<StyleValue> repeat_y)
-        : StyleValue(Type::Background)
-        , m_color(color)
-        , m_image(image)
-        , m_repeat_x(repeat_x)
-        , m_repeat_y(repeat_y)
-    {
-    }
-    NonnullRefPtr<StyleValue> m_color;
-    NonnullRefPtr<StyleValue> m_image;
-    // FIXME: background-position
-    // FIXME: background-size
-    NonnullRefPtr<StyleValue> m_repeat_x;
-    NonnullRefPtr<StyleValue> m_repeat_y;
-    // FIXME: background-attachment
-    // FIXME: background-clip
-    // FIXME: background-origin
-};
-
-class BackgroundRepeatStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<BackgroundRepeatStyleValue> create(NonnullRefPtr<StyleValue> repeat_x, NonnullRefPtr<StyleValue> repeat_y)
-    {
-        return adopt_ref(*new BackgroundRepeatStyleValue(repeat_x, repeat_y));
-    }
-    virtual ~BackgroundRepeatStyleValue() override { }
-
-    NonnullRefPtr<StyleValue> repeat_x() const { return m_repeat_x; }
-    NonnullRefPtr<StyleValue> repeat_y() const { return m_repeat_y; }
-
-    virtual String to_string() const override
-    {
-        return String::formatted("{} {}", m_repeat_x->to_string(), m_repeat_y->to_string());
-    }
-
-private:
-    BackgroundRepeatStyleValue(NonnullRefPtr<StyleValue> repeat_x, NonnullRefPtr<StyleValue> repeat_y)
-        : StyleValue(Type::BackgroundRepeat)
-        , m_repeat_x(repeat_x)
-        , m_repeat_y(repeat_y)
-    {
-    }
-
-    NonnullRefPtr<StyleValue> m_repeat_x;
-    NonnullRefPtr<StyleValue> m_repeat_y;
-};
-
-class BorderStyleValue final : public StyleValue {
-public:
-    static NonnullRefPtr<BorderStyleValue> create(
-        NonnullRefPtr<StyleValue> border_width,
-        NonnullRefPtr<StyleValue> border_style,
-        NonnullRefPtr<StyleValue> border_color)
-    {
-        return adopt_ref(*new BorderStyleValue(border_width, border_style, border_color));
-    }
-    virtual ~BorderStyleValue() override { }
-
-    NonnullRefPtr<StyleValue> border_width() const { return m_border_width; }
-    NonnullRefPtr<StyleValue> border_style() const { return m_border_style; }
-    NonnullRefPtr<StyleValue> border_color() const { return m_border_color; }
-
-    virtual String to_string() const override
-    {
-        return String::formatted("Border border_width: {}, border_style: {}, border_color: {}", m_border_width->to_string(), m_border_style->to_string(), m_border_color->to_string());
-    }
-
-private:
-    BorderStyleValue(
-        NonnullRefPtr<StyleValue> border_width,
-        NonnullRefPtr<StyleValue> border_style,
-        NonnullRefPtr<StyleValue> border_color)
-        : StyleValue(Type::Border)
-        , m_border_width(border_width)
-        , m_border_style(border_style)
-        , m_border_color(border_color)
+        , m_expression_string(expression_string)
+        , m_expression(move(calc_sum))
     {
     }
 
-    NonnullRefPtr<StyleValue> m_border_width;
-    NonnullRefPtr<StyleValue> m_border_style;
-    NonnullRefPtr<StyleValue> m_border_color;
+    String m_expression_string;
+    NonnullOwnPtr<CalcSum> m_expression;
 };
 
-class BorderRadiusStyleValue final : public StyleValue {
+class ColorStyleValue : public StyleValue {
 public:
-    static NonnullRefPtr<BorderRadiusStyleValue> create(Length const& horizontal_radius, Length const& vertical_radius)
+    static NonnullRefPtr<ColorStyleValue> create(Color color)
     {
-        return adopt_ref(*new BorderRadiusStyleValue(horizontal_radius, vertical_radius));
+        return adopt_ref(*new ColorStyleValue(color));
     }
-    virtual ~BorderRadiusStyleValue() override { }
-
-    Length const& horizontal_radius() const { return m_horizontal_radius; }
-    Length const& vertical_radius() const { return m_vertical_radius; }
-    bool is_elliptical() const { return m_is_elliptical; }
-
-    // FIXME: Remove this once we support elliptical border-radius in Layout/Node.
-    virtual Length to_length() const override { return horizontal_radius(); }
+    virtual ~ColorStyleValue() override { }
 
-    virtual String to_string() const override
-    {
-        return String::formatted("{} / {}", m_horizontal_radius.to_string(), m_vertical_radius.to_string());
-    }
+    Color color() const { return m_color; }
+    String to_string() const override { return m_color.to_string(); }
+    Color to_color(Layout::NodeWithStyle const&) const override { return m_color; }
 
-    virtual bool equals(StyleValue const& other) const override
+    virtual bool equals(const StyleValue& other) const override
     {
         if (type() != other.type())
             return false;
-        auto& other_value = static_cast<BorderRadiusStyleValue const&>(other);
-        return m_is_elliptical == other_value.m_is_elliptical
-            && m_horizontal_radius == other_value.m_horizontal_radius
-            && m_vertical_radius == other_value.m_vertical_radius;
+        return m_color == static_cast<const ColorStyleValue&>(other).m_color;
     }
 
 private:
-    BorderRadiusStyleValue(Length const& horizontal_radius, Length const& vertical_radius)
-        : StyleValue(Type::BorderRadius)
-        , m_horizontal_radius(horizontal_radius)
-        , m_vertical_radius(vertical_radius)
+    explicit ColorStyleValue(Color color)
+        : StyleValue(Type::Color)
+        , m_color(color)
     {
-        m_is_elliptical = (m_horizontal_radius != m_vertical_radius);
     }
 
-    bool m_is_elliptical;
-    Length m_horizontal_radius;
-    Length m_vertical_radius;
+    Color m_color;
 };
 
 class CombinedBorderRadiusStyleValue final : public StyleValue {
@@ -883,6 +675,26 @@ private:
     NonnullRefPtr<BorderRadiusStyleValue> m_bottom_left;
 };
 
+// FIXME: Allow for fallback
+class CustomStyleValue : public StyleValue {
+public:
+    static NonnullRefPtr<CustomStyleValue> create(const String& custom_property_name)
+    {
+        return adopt_ref(*new CustomStyleValue(custom_property_name));
+    }
+    String custom_property_name() const { return m_custom_property_name; }
+    String to_string() const override { return m_custom_property_name; }
+
+private:
+    explicit CustomStyleValue(const String& custom_property_name)
+        : StyleValue(Type::CustomProperty)
+        , m_custom_property_name(custom_property_name)
+    {
+    }
+
+    String m_custom_property_name {};
+};
+
 class FlexStyleValue final : public StyleValue {
 public:
     static NonnullRefPtr<FlexStyleValue> create(
@@ -984,6 +796,126 @@ private:
     // FIXME: Implement font-stretch and font-variant.
 };
 
+class IdentifierStyleValue final : public StyleValue {
+public:
+    static NonnullRefPtr<IdentifierStyleValue> create(CSS::ValueID id)
+    {
+        return adopt_ref(*new IdentifierStyleValue(id));
+    }
+    virtual ~IdentifierStyleValue() override { }
+
+    CSS::ValueID id() const { return m_id; }
+
+    virtual String to_string() const override;
+    virtual Color to_color(Layout::NodeWithStyle const& node) const override;
+
+    virtual bool equals(const StyleValue& other) const override
+    {
+        if (type() != other.type())
+            return false;
+        return m_id == static_cast<const IdentifierStyleValue&>(other).m_id;
+    }
+
+private:
+    explicit IdentifierStyleValue(CSS::ValueID id)
+        : StyleValue(Type::Identifier)
+        , m_id(id)
+    {
+    }
+
+    CSS::ValueID m_id { CSS::ValueID::Invalid };
+};
+
+class ImageStyleValue final
+    : public StyleValue
+    , public ImageResourceClient {
+public:
+    static NonnullRefPtr<ImageStyleValue> create(const AK::URL& url, DOM::Document& document) { return adopt_ref(*new ImageStyleValue(url, document)); }
+    virtual ~ImageStyleValue() override { }
+
+    String to_string() const override { return String::formatted("Image({})", m_url.to_string()); }
+
+    const Gfx::Bitmap* bitmap() const { return m_bitmap; }
+
+private:
+    ImageStyleValue(const AK::URL&, DOM::Document&);
+
+    // ^ResourceClient
+    virtual void resource_did_load() override;
+
+    AK::URL m_url;
+    WeakPtr<DOM::Document> m_document;
+    RefPtr<Gfx::Bitmap> m_bitmap;
+};
+
+class InheritStyleValue final : public StyleValue {
+public:
+    static NonnullRefPtr<InheritStyleValue> the()
+    {
+        static NonnullRefPtr<InheritStyleValue> instance = adopt_ref(*new InheritStyleValue);
+        return instance;
+    }
+    virtual ~InheritStyleValue() override { }
+
+    String to_string() const override { return "inherit"; }
+
+private:
+    InheritStyleValue()
+        : StyleValue(Type::Inherit)
+    {
+    }
+};
+
+class InitialStyleValue final : public StyleValue {
+public:
+    static NonnullRefPtr<InitialStyleValue> the()
+    {
+        static NonnullRefPtr<InitialStyleValue> instance = adopt_ref(*new InitialStyleValue);
+        return instance;
+    }
+    virtual ~InitialStyleValue() override { }
+
+    String to_string() const override { return "initial"; }
+
+private:
+    InitialStyleValue()
+        : StyleValue(Type::Initial)
+    {
+    }
+};
+
+class LengthStyleValue : public StyleValue {
+public:
+    static NonnullRefPtr<LengthStyleValue> create(const Length& length)
+    {
+        return adopt_ref(*new LengthStyleValue(length));
+    }
+    virtual ~LengthStyleValue() override { }
+
+    virtual String to_string() const override { return m_length.to_string(); }
+    virtual Length to_length() const override { return m_length; }
+
+    const Length& length() const { return m_length; }
+
+    virtual bool is_auto() const override { return m_length.is_auto(); }
+
+    virtual bool equals(const StyleValue& other) const override
+    {
+        if (type() != other.type())
+            return false;
+        return m_length == static_cast<const LengthStyleValue&>(other).m_length;
+    }
+
+private:
+    explicit LengthStyleValue(const Length& length)
+        : StyleValue(Type::Length)
+        , m_length(length)
+    {
+    }
+
+    Length m_length;
+};
+
 class ListStyleStyleValue final : public StyleValue {
 public:
     static NonnullRefPtr<ListStyleStyleValue> create(
@@ -1021,6 +953,36 @@ private:
     NonnullRefPtr<StyleValue> m_style_type;
 };
 
+class NumericStyleValue : public StyleValue {
+public:
+    static NonnullRefPtr<NumericStyleValue> create(float value)
+    {
+        return adopt_ref(*new NumericStyleValue(value));
+    }
+
+    virtual bool is_length() const override { return m_value == 0; }
+    virtual Length to_length() const override { return Length(0, Length::Type::Px); }
+
+    float value() const { return m_value; }
+    String to_string() const override { return String::formatted("{}", m_value); }
+
+    virtual bool equals(StyleValue const& other) const override
+    {
+        if (type() != other.type())
+            return false;
+        return m_value == static_cast<NumericStyleValue const&>(other).m_value;
+    }
+
+private:
+    explicit NumericStyleValue(float value)
+        : StyleValue(Type::Numeric)
+        , m_value(value)
+    {
+    }
+
+    float m_value { 0 };
+};
+
 class OverflowStyleValue final : public StyleValue {
 public:
     static NonnullRefPtr<OverflowStyleValue> create(NonnullRefPtr<StyleValue> overflow_x, NonnullRefPtr<StyleValue> overflow_y)
@@ -1049,6 +1011,26 @@ private:
     NonnullRefPtr<StyleValue> m_overflow_y;
 };
 
+class StringStyleValue : public StyleValue {
+public:
+    static NonnullRefPtr<StringStyleValue> create(const String& string)
+    {
+        return adopt_ref(*new StringStyleValue(string));
+    }
+    virtual ~StringStyleValue() override { }
+
+    String to_string() const override { return m_string; }
+
+private:
+    explicit StringStyleValue(const String& string)
+        : StyleValue(Type::String)
+        , m_string(string)
+    {
+    }
+
+    String m_string;
+};
+
 class TextDecorationStyleValue final : public StyleValue {
 public:
     static NonnullRefPtr<TextDecorationStyleValue> create(
@@ -1114,6 +1096,24 @@ private:
     NonnullRefPtrVector<StyleValue> m_values;
 };
 
+class UnsetStyleValue final : public StyleValue {
+public:
+    static NonnullRefPtr<UnsetStyleValue> the()
+    {
+        static NonnullRefPtr<UnsetStyleValue> instance = adopt_ref(*new UnsetStyleValue);
+        return instance;
+    }
+    virtual ~UnsetStyleValue() override { }
+
+    String to_string() const override { return "unset"; }
+
+private:
+    UnsetStyleValue()
+        : StyleValue(Type::Unset)
+    {
+    }
+};
+
 class StyleValueList final : public StyleValue {
 public:
     static NonnullRefPtr<StyleValueList> create(NonnullRefPtrVector<StyleValue>&& values) { return adopt_ref(*new StyleValueList(move(values))); }