From cb8511772dec30f8041db5a4c9f45d137fcc6bbe Mon Sep 17 00:00:00 2001 From: Sam Atkins Date: Thu, 3 Apr 2025 11:44:06 +0100 Subject: [PATCH] LibWeb/CSS: Add CSSFontFaceDescriptors type This is a CSSOM type that holds the descriptors for a CSSFontFaceRule, but this commit only adds it without using it. --- Libraries/LibWeb/CMakeLists.txt | 1 + .../LibWeb/CSS/CSSFontFaceDescriptors.cpp | 406 ++++++++++++++++++ Libraries/LibWeb/CSS/CSSFontFaceDescriptors.h | 93 ++++ .../LibWeb/CSS/CSSFontFaceDescriptors.idl | 35 ++ Libraries/LibWeb/Forward.h | 1 + Libraries/LibWeb/idl_files.cmake | 1 + .../Text/expected/all-window-properties.txt | 1 + 7 files changed, 538 insertions(+) create mode 100644 Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp create mode 100644 Libraries/LibWeb/CSS/CSSFontFaceDescriptors.h create mode 100644 Libraries/LibWeb/CSS/CSSFontFaceDescriptors.idl diff --git a/Libraries/LibWeb/CMakeLists.txt b/Libraries/LibWeb/CMakeLists.txt index 1d2f4009fae..3516892a5a4 100644 --- a/Libraries/LibWeb/CMakeLists.txt +++ b/Libraries/LibWeb/CMakeLists.txt @@ -70,6 +70,7 @@ set(SOURCES CSS/CSSImportRule.cpp CSS/CSSKeyframeRule.cpp CSS/CSSKeyframesRule.cpp + CSS/CSSFontFaceDescriptors.cpp CSS/CSSFontFaceRule.cpp CSS/CSSLayerBlockRule.cpp CSS/CSSLayerStatementRule.cpp diff --git a/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp new file mode 100644 index 00000000000..86d25094c56 --- /dev/null +++ b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.cpp @@ -0,0 +1,406 @@ +/* + * Copyright (c) 2025, Sam Atkins + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include "Parser/Parser.h" + +#include +#include +#include +#include +#include + +namespace Web::CSS { + +GC_DEFINE_ALLOCATOR(CSSFontFaceDescriptors); + +GC::Ref CSSFontFaceDescriptors::create(JS::Realm& realm, Vector descriptors) +{ + return realm.create(realm, move(descriptors)); +} + +CSSFontFaceDescriptors::CSSFontFaceDescriptors(JS::Realm& realm, Vector descriptors) + : CSSStyleDeclaration(realm, Computed::No, Readonly::No) + , m_descriptors(move(descriptors)) +{ +} + +CSSFontFaceDescriptors::~CSSFontFaceDescriptors() = default; + +void CSSFontFaceDescriptors::initialize(JS::Realm& realm) +{ + Base::initialize(realm); + WEB_SET_PROTOTYPE_FOR_INTERFACE(CSSFontFaceDescriptors); +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-length +size_t CSSFontFaceDescriptors::length() const +{ + // The length attribute must return the number of CSS declarations in the declarations. + return m_descriptors.size(); +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-item +String CSSFontFaceDescriptors::item(size_t index) const +{ + // The item(index) method must return the property name of the CSS declaration at position index. + if (index >= length()) + return {}; + + return to_string(m_descriptors[index].descriptor_id).to_string(); +} + +// https://drafts.csswg.org/cssom/#set-a-css-declaration +bool CSSFontFaceDescriptors::set_a_css_declaration(DescriptorID descriptor_id, NonnullRefPtr value, Important) +{ + VERIFY(!is_computed()); + + for (auto& descriptor : m_descriptors) { + if (descriptor.descriptor_id == descriptor_id) { + if (*descriptor.value == *value) + return false; + descriptor.value = move(value); + return true; + } + } + + m_descriptors.append(Descriptor { + .descriptor_id = descriptor_id, + .value = move(value), + }); + return true; +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-setproperty +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_property(StringView property, StringView value, StringView priority) +{ + // 1. If the readonly flag is set, then throw a NoModificationAllowedError exception. + if (is_readonly()) + return WebIDL::NoModificationAllowedError::create(realm(), "Cannot modify properties of readonly CSSFontFaceDescriptors"_string); + + // 2. If property is not a custom property, follow these substeps: + Optional descriptor_id; + { + // 1. Let property be property converted to ASCII lowercase. + // 2. If property is not a case-sensitive match for a supported CSS property, then return. + descriptor_id = descriptor_id_from_string(AtRuleID::FontFace, property); + if (!descriptor_id.has_value()) + return {}; + } + + // 3. If value is the empty string, invoke removeProperty() with property as argument and return. + if (value.is_empty()) { + MUST(remove_property(property)); + return {}; + } + + // 4. If priority is not the empty string and is not an ASCII case-insensitive match for the string "important", then return. + if (!priority.is_empty() && !Infra::is_ascii_case_insensitive_match(priority, "important"sv)) + return {}; + + // 5. Let component value list be the result of parsing value for property property. + RefPtr 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) + return {}; + + // 7. Let updated be false. + auto updated = false; + + // 8. If property is a shorthand property... + // NB: Descriptors can't be shorthands. + // 9. Otherwise, let updated be the result of set the CSS declaration property with value component value list, + // with the important flag set if priority is not the empty string, and unset otherwise, and with the list of + // declarations being the declarations. + updated = set_a_css_declaration(*descriptor_id, *component_value_list, !priority.is_empty() ? Important::Yes : Important::No); + + // 10. If updated is true, update style attribute for the CSS declaration block. + if (updated) + update_style_attribute(); + + return {}; +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-removeproperty +WebIDL::ExceptionOr CSSFontFaceDescriptors::remove_property(StringView property) +{ + // 1. If the readonly flag is set, then throw a NoModificationAllowedError exception. + if (is_readonly()) + return WebIDL::NoModificationAllowedError::create(realm(), "Cannot modify properties of readonly CSSFontFaceDescriptors"_string); + + // 2. If property is not a custom property, let property be property converted to ASCII lowercase. + // AD-HOC: We compare names case-insensitively instead. + + // 3. Let value be the return value of invoking getPropertyValue() with property as argument. + auto value = get_property_value(property); + + // 4. Let removed be false. + bool removed = false; + + // 5. If property is a shorthand property... + // NB: Descriptors can't be shorthands. + // 6. Otherwise, if property is a case-sensitive match for a property name of a CSS declaration in the + // declarations, remove that CSS declaration and let removed be true. + // auto descriptor_id = descriptor_from_string() + auto descriptor_id = descriptor_id_from_string(AtRuleID::FontFace, property); + if (descriptor_id.has_value()) { + removed = m_descriptors.remove_first_matching([descriptor_id](auto& entry) { return entry.descriptor_id == *descriptor_id; }); + } + + // 7. If removed is true, Update style attribute for the CSS declaration block. + if (removed) + update_style_attribute(); + + // 8. Return value. + return value; +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertyvalue +String CSSFontFaceDescriptors::get_property_value(StringView property) const +{ + // 1. If property is not a custom property, follow these substeps: ... + // NB: These substeps only apply to shorthands, and descriptors cannot be shorthands. + + // 2. If property is a case-sensitive match for a property name of a CSS declaration in the declarations, then + // return the result of invoking serialize a CSS value of that declaration. + auto descriptor_id = descriptor_id_from_string(AtRuleID::FontFace, property); + if (descriptor_id.has_value()) { + auto match = m_descriptors.first_matching([descriptor_id](auto& entry) { return entry.descriptor_id == *descriptor_id; }); + if (match.has_value()) + return match->value->to_string(CSSStyleValue::SerializationMode::Normal); + } + + // 3. Return the empty string. + return {}; +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertypriority +StringView CSSFontFaceDescriptors::get_property_priority(StringView) const +{ + // AD-HOC: It's not valid for descriptors to be !important. + return {}; +} + +// https://drafts.csswg.org/cssom/#serialize-a-css-declaration-block +String CSSFontFaceDescriptors::serialized() const +{ + // 1. Let list be an empty array. + Vector list; + list.ensure_capacity(m_descriptors.size()); + + // 2. Let already serialized be an empty array. + // AD-HOC: Not needed as we don't have shorthands. + + // 3. Declaration loop: For each CSS declaration declaration in declaration block’s declarations, follow these substeps: + for (auto const& descriptor : m_descriptors) { + // 1. Let property be declaration’s property name. + auto property = to_string(descriptor.descriptor_id); + + // 2. If property is in already serialized, continue with the steps labeled declaration loop. + // AD-HOC: Not needed as we don't have shorthands. + + // 3. If property maps to one or more shorthand properties, let shorthands be an array of those shorthand properties, in preferred order. + // 4. Shorthand loop: For each shorthand in shorthands, follow these substeps: ... + // NB: Descriptors can't be shorthands. + + // 5. Let value be the result of invoking serialize a CSS value of declaration. + auto value = descriptor.value->to_string(CSSStyleValue::SerializationMode::Normal); + + // 6. Let serialized declaration be the result of invoking serialize a CSS declaration with property name property, value value, and the important flag set if declaration has its important flag set. + auto serialized_declaration = serialize_a_css_declaration(property, value, Important::No); + + // 7. Append serialized declaration to list. + list.append(serialized_declaration); + + // 8. Append property to already serialized. + // AD-HOC: Not needed as we don't have shorthands. + } + + // 4. Return list joined with " " (U+0020). + return MUST(String::join(' ', list)); +} + +// https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-csstext +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_css_text(StringView value) +{ + // 1. If the readonly flag is set, then throw a NoModificationAllowedError exception. + if (is_readonly()) + return WebIDL::NoModificationAllowedError::create(realm(), "Cannot modify properties of readonly CSSFontFaceDescriptors"_string); + + // 2. Empty the declarations. + m_descriptors.clear(); + + // 3. Parse the given value and, if the return value is not the empty list, insert the items in the list into the + // declarations, in specified order. + auto descriptors = parse_css_list_of_descriptors(Parser::ParsingParams {}, AtRuleID::FontFace, value); + if (!descriptors.is_empty()) + m_descriptors = move(descriptors); + + // 4. Update style attribute for the CSS declaration block. + update_style_attribute(); + + return {}; +} + +void CSSFontFaceDescriptors::visit_edges(Visitor& visitor) +{ + Base::visit_edges(visitor); + for (auto& descriptor : m_descriptors) { + descriptor.value->visit_edges(visitor); + } +} + +RefPtr CSSFontFaceDescriptors::descriptor(DescriptorID descriptor_id) const +{ + auto match = m_descriptors.first_matching([descriptor_id](Descriptor const& descriptor) { + return descriptor.descriptor_id == descriptor_id; + }); + if (match.has_value()) + return match->value; + return nullptr; +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_ascent_override(StringView value) +{ + return set_property("ascent-override"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::ascent_override() const +{ + return get_property_value("ascent-override"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_descent_override(StringView value) +{ + return set_property("descent-override"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::descent_override() const +{ + return get_property_value("descent-override"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_display(StringView value) +{ + return set_property("font-display"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_display() const +{ + return get_property_value("font-display"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_family(StringView value) +{ + return set_property("font-family"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_family() const +{ + return get_property_value("font-family"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_feature_settings(StringView value) +{ + return set_property("font-feature-settings"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_feature_settings() const +{ + return get_property_value("font-feature-settings"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_language_override(StringView value) +{ + return set_property("font-language-override"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_language_override() const +{ + return get_property_value("font-language-override"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_named_instance(StringView value) +{ + return set_property("font-named-instance"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_named_instance() const +{ + return get_property_value("font-named-instance"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_style(StringView value) +{ + return set_property("font-style"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_style() const +{ + return get_property_value("font-style"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_variation_settings(StringView value) +{ + return set_property("font-variation-settings"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_variation_settings() const +{ + return get_property_value("font-variation-settings"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_weight(StringView value) +{ + return set_property("font-weight"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_weight() const +{ + return get_property_value("font-weight"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_font_width(StringView value) +{ + return set_property("font-width"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::font_width() const +{ + return get_property_value("font-width"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_line_gap_override(StringView value) +{ + return set_property("line-gap-override"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::line_gap_override() const +{ + return get_property_value("line-gap-override"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_src(StringView value) +{ + return set_property("src"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::src() const +{ + return get_property_value("src"sv); +} + +WebIDL::ExceptionOr CSSFontFaceDescriptors::set_unicode_range(StringView value) +{ + return set_property("unicode-range"sv, value, ""sv); +} + +String CSSFontFaceDescriptors::unicode_range() const +{ + return get_property_value("unicode-range"sv); +} + +} diff --git a/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.h b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.h new file mode 100644 index 00000000000..214df680de2 --- /dev/null +++ b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2025, Sam Atkins + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include + +namespace Web::CSS { + +// https://drafts.csswg.org/css-fonts-4/#cssfontfacedescriptors +class CSSFontFaceDescriptors final + : public CSSStyleDeclaration { + WEB_PLATFORM_OBJECT(CSSFontFaceDescriptors, CSSStyleDeclaration); + GC_DECLARE_ALLOCATOR(CSSFontFaceDescriptors); + +public: + [[nodiscard]] static GC::Ref create(JS::Realm&, Vector); + + virtual ~CSSFontFaceDescriptors() override; + + virtual void initialize(JS::Realm&) override; + + virtual size_t length() const override; + virtual String item(size_t index) const override; + + virtual WebIDL::ExceptionOr set_property(StringView property, StringView value, StringView priority) override; + virtual WebIDL::ExceptionOr remove_property(StringView property) override; + virtual String get_property_value(StringView property) const override; + virtual StringView get_property_priority(StringView property) const override; + + RefPtr descriptor(DescriptorID) const; + + WebIDL::ExceptionOr set_ascent_override(StringView value); + String ascent_override() const; + + WebIDL::ExceptionOr set_descent_override(StringView value); + String descent_override() const; + + WebIDL::ExceptionOr set_font_display(StringView value); + String font_display() const; + + WebIDL::ExceptionOr set_font_family(StringView value); + String font_family() const; + + WebIDL::ExceptionOr set_font_feature_settings(StringView value); + String font_feature_settings() const; + + WebIDL::ExceptionOr set_font_language_override(StringView value); + String font_language_override() const; + + WebIDL::ExceptionOr set_font_named_instance(StringView value); + String font_named_instance() const; + + WebIDL::ExceptionOr set_font_style(StringView value); + String font_style() const; + + WebIDL::ExceptionOr set_font_variation_settings(StringView value); + String font_variation_settings() const; + + WebIDL::ExceptionOr set_font_weight(StringView value); + String font_weight() const; + + WebIDL::ExceptionOr set_font_width(StringView value); + String font_width() const; + + WebIDL::ExceptionOr set_line_gap_override(StringView value); + String line_gap_override() const; + + WebIDL::ExceptionOr set_src(StringView value); + String src() const; + + WebIDL::ExceptionOr set_unicode_range(StringView value); + String unicode_range() const; + + virtual String serialized() const override; + + virtual WebIDL::ExceptionOr set_css_text(StringView) override; + +private: + CSSFontFaceDescriptors(JS::Realm&, Vector); + + bool set_a_css_declaration(DescriptorID, NonnullRefPtr, Important); + + virtual void visit_edges(Visitor&) override; + + Vector m_descriptors; +}; + +} diff --git a/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.idl b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.idl new file mode 100644 index 00000000000..f98052d12c4 --- /dev/null +++ b/Libraries/LibWeb/CSS/CSSFontFaceDescriptors.idl @@ -0,0 +1,35 @@ +#import + +// https://drafts.csswg.org/css-fonts-4/#cssfontfacedescriptors +[Exposed=Window] +interface CSSFontFaceDescriptors : CSSStyleDeclaration { + [LegacyNullToEmptyString] attribute CSSOMString src; + [LegacyNullToEmptyString, AttributeCallbackName=font_family_regular, ImplementedAs=font_family] attribute CSSOMString fontFamily; + [LegacyNullToEmptyString, AttributeCallbackName=font_family_dashed, ImplementedAs=font_family] attribute CSSOMString font-family; + [LegacyNullToEmptyString, AttributeCallbackName=font_style_regular, ImplementedAs=font_style] attribute CSSOMString fontStyle; + [LegacyNullToEmptyString, AttributeCallbackName=font_style_dashed, ImplementedAs=font_style] attribute CSSOMString font-style; + [LegacyNullToEmptyString, AttributeCallbackName=font_weight_regular, ImplementedAs=font_weight] attribute CSSOMString fontWeight; + [LegacyNullToEmptyString, AttributeCallbackName=font_weight_dashed, ImplementedAs=font_weight] attribute CSSOMString font-weight; + [LegacyNullToEmptyString, AttributeCallbackName=font_stretch_regular, ImplementedAs=font_width] attribute CSSOMString fontStretch; + [LegacyNullToEmptyString, AttributeCallbackName=font_stretch_dashed, ImplementedAs=font_width] attribute CSSOMString font-stretch; + [LegacyNullToEmptyString, AttributeCallbackName=font_width_regular, ImplementedAs=font_width] attribute CSSOMString fontWidth; + [LegacyNullToEmptyString, AttributeCallbackName=font_width_dashed, ImplementedAs=font_width] attribute CSSOMString font-width; + [LegacyNullToEmptyString, AttributeCallbackName=unicode_range_regular, ImplementedAs=unicode_range] attribute CSSOMString unicodeRange; + [LegacyNullToEmptyString, AttributeCallbackName=unicode_range_dashed, ImplementedAs=unicode_range] attribute CSSOMString unicode-range; + [LegacyNullToEmptyString, AttributeCallbackName=font_feature_settings_regular, ImplementedAs=font_feature_settings] attribute CSSOMString fontFeatureSettings; + [LegacyNullToEmptyString, AttributeCallbackName=font_feature_settings_dashed, ImplementedAs=font_feature_settings] attribute CSSOMString font-feature-settings; + [LegacyNullToEmptyString, AttributeCallbackName=font_variation_settings_regular, ImplementedAs=font_variation_settings] attribute CSSOMString fontVariationSettings; + [LegacyNullToEmptyString, AttributeCallbackName=font_variation_settings_dashed, ImplementedAs=font_variation_settings] attribute CSSOMString font-variation-settings; + [LegacyNullToEmptyString, AttributeCallbackName=font_named_instance_regular, ImplementedAs=font_named_instance] attribute CSSOMString fontNamedInstance; + [LegacyNullToEmptyString, AttributeCallbackName=font_named_instance_dashed, ImplementedAs=font_named_instance] attribute CSSOMString font-named-instance; + [LegacyNullToEmptyString, AttributeCallbackName=font_display_regular, ImplementedAs=font_display] attribute CSSOMString fontDisplay; + [LegacyNullToEmptyString, AttributeCallbackName=font_display_dashed, ImplementedAs=font_display] attribute CSSOMString font-display; + [LegacyNullToEmptyString, AttributeCallbackName=font_language_override_regular, ImplementedAs=font_language_override] attribute CSSOMString fontLanguageOverride; + [LegacyNullToEmptyString, AttributeCallbackName=font_language_override_dashed, ImplementedAs=font_language_override] attribute CSSOMString font-language-override; + [LegacyNullToEmptyString, AttributeCallbackName=ascent_override_regular, ImplementedAs=ascent_override] attribute CSSOMString ascentOverride; + [LegacyNullToEmptyString, AttributeCallbackName=ascent_override_dashed, ImplementedAs=ascent_override] attribute CSSOMString ascent-override; + [LegacyNullToEmptyString, AttributeCallbackName=descent_override_regular, ImplementedAs=descent_override] attribute CSSOMString descentOverride; + [LegacyNullToEmptyString, AttributeCallbackName=descent_override_dashed, ImplementedAs=descent_override] attribute CSSOMString descent-override; + [LegacyNullToEmptyString, AttributeCallbackName=line_gap_override_regular, ImplementedAs=line_gap_override] attribute CSSOMString lineGapOverride; + [LegacyNullToEmptyString, AttributeCallbackName=line_gap_override_dashed, ImplementedAs=line_gap_override] attribute CSSOMString line-gap-override; +}; \ No newline at end of file diff --git a/Libraries/LibWeb/Forward.h b/Libraries/LibWeb/Forward.h index 378fc59c2c6..23d621cfdee 100644 --- a/Libraries/LibWeb/Forward.h +++ b/Libraries/LibWeb/Forward.h @@ -159,6 +159,7 @@ class CounterStyleValue; class CSSAnimation; class CSSColorValue; class CSSConditionRule; +class CSSFontFaceDescriptors; class CSSFontFaceRule; class CSSGroupingRule; class CSSHSL; diff --git a/Libraries/LibWeb/idl_files.cmake b/Libraries/LibWeb/idl_files.cmake index 6d6af4e6a62..ee5ba51f249 100644 --- a/Libraries/LibWeb/idl_files.cmake +++ b/Libraries/LibWeb/idl_files.cmake @@ -23,6 +23,7 @@ libweb_js_bindings(Crypto/SubtleCrypto) libweb_js_bindings(CSS/AnimationEvent) libweb_js_bindings(CSS/CSSAnimation) libweb_js_bindings(CSS/CSSConditionRule) +libweb_js_bindings(CSS/CSSFontFaceDescriptors) libweb_js_bindings(CSS/CSSFontFaceRule) libweb_js_bindings(CSS/CSSGroupingRule) libweb_js_bindings(CSS/CSSImportRule) diff --git a/Tests/LibWeb/Text/expected/all-window-properties.txt b/Tests/LibWeb/Text/expected/all-window-properties.txt index 4406c33fe37..8ab200c6e33 100644 --- a/Tests/LibWeb/Text/expected/all-window-properties.txt +++ b/Tests/LibWeb/Text/expected/all-window-properties.txt @@ -38,6 +38,7 @@ ByteLengthQueuingStrategy CDATASection CSSAnimation CSSConditionRule +CSSFontFaceDescriptors CSSFontFaceRule CSSGroupingRule CSSImportRule