dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / parser / helpers.lucb
#==============================================================================================
#
# helpers - the CSS parser's entry points for the rest of LibWeb
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/Helpers.cpp (lines 1-245): the internal CSS realm,
# parse_css_stylesheet and the other parse_* helpers that make a Parser for a string,
# "CSS decode bytes" and is_valid_custom_ident.
#
# Copyright (c) 2018-2025, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2020-2023, the SerenityOS developers.
# Copyright (c) 2021-2024, Sam Atkins <atkinssj@serenityos.org>
# Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
# Copyright (c) 2022, MacDue <macdue@dueutil.tech>
# Copyright (c) 2025, Lorenz Ackermann <me@lorenzackermann.xyz>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: The internal CSS realm ==================================================================
## `static GC::Root<JS::Realm> realm` of internal_css_realm().
var internal_css_realm_s_realm: gc.Root[Realm]
## `static GC::Root<HTML::Window> window` of internal_css_realm().
var internal_css_realm_s_window: gc.Root[HtmlWindow]
## `static OwnPtr<JS::ExecutionContext> execution_context` of internal_css_realm().
var internal_css_realm_s_execution_context: JsExecutionContext*?
## The first customization of internal_css_realm's realm: a new Window as the global object.
func internal_css_realm_create_global_object(context: void*?, realm: Realm*) -> JsObject*?:
_ = context
internal_css_realm_s_window = gc.root_create(html_window_create(realm))
return (JsObject*?)gc.root_cell(&internal_css_realm_s_window)
## The second customization: the same Window as the global this value.
func internal_css_realm_create_global_this_value(context: void*?, realm: Realm*) -> JsObject*?:
_ = context
_ = realm
return (JsObject*?)gc.root_cell(&internal_css_realm_s_window)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:24 Web::internal_css_realm.
pub func internal_css_realm() -> Realm*:
if gc.root_is_null(&internal_css_realm_s_realm):
internal_css_realm_s_execution_context = bind_create_a_new_javascript_realm(
bind_main_thread_vm(),
ak.Function1[Realm*, JsObject*?](call = internal_css_realm_create_global_object, context = none),
ak.Function1[Realm*, JsObject*?](call = internal_css_realm_create_global_this_value, context = none),
)
let execution_context = internal_css_realm_s_execution_context else trap("VERIFY: an execution context")
let realm = execution_context.realm else trap("VERIFY: the execution context has a realm")
internal_css_realm_s_realm = gc.root_create(realm)
let intrinsics = realm_create_bind_intrinsics(realm, realm)
let host_defined = bind_host_defined_create(intrinsics)
realm_set_host_defined(realm, host_defined)
return gc.root_cell(&internal_css_realm_s_realm) else trap("VERIFY: the internal CSS realm")
## The internal CSS realm forgotten as its VM is destroyed (vm_destroy): C++'s statics live as
## long as the process's one VM.
func internal_css_realm_forget():
gc.root_release(&internal_css_realm_s_window)
gc.root_release(&internal_css_realm_s_realm)
internal_css_realm_s_execution_context = none
# mark: Parsing entry points ====================================================================
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:48 Web::parse_css_stylesheet.
pub func parse_css_stylesheet(context: CssParsingParams, css: ak.StringView, location: web_url.Url? = none, media_list: CssMediaList*? = none) -> CssCssStyleSheet*:
let realm = context.realm else trap("VERIFY: the parsing params have a realm")
if ak.string_view_is_empty(&css):
let no_rules = ak.Vector[CssRule*]()
let rule_list = css_rule_list_create(realm, ak.vector_span_const(&no_rules))
var media = media_list
if media == none:
media = css_media_list_create(realm, ak.Vector[CssMediaQuery*]())
let style_sheet = css_css_style_sheet_create(realm, rule_list, media else trap("VERIFY: a media list"), location)
css_css_style_sheet_set_source_text(style_sheet, ak.string_new())
return style_sheet
var parser = css_parser_create(context, css)
let style_sheet = css_parser_parse_as_css_stylesheet(&parser, location, media_list)
# FIXME: Avoid this copy
css_css_style_sheet_set_source_text(style_sheet, ak.string_from_utf8(css) else trap("MUST: String::from_utf8"))
return style_sheet
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:64 Web::parse_css_property_declaration_block.
pub func parse_css_property_declaration_block(context: CssParsingParams, css: ak.StringView) -> CssParserPropertiesAndCustomProperties:
if ak.string_view_is_empty(&css):
return CssParserPropertiesAndCustomProperties()
var parser = css_parser_create(context, css)
return css_parser_parse_as_property_declaration_block(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:71 Web::parse_css_descriptor_declaration_block.
pub func parse_css_descriptor_declaration_block(parsing_params: CssParsingParams, at_rule_id: css_data.AtRuleId, css: ak.StringView) -> ak.Vector[CssDescriptor]:
if ak.string_view_is_empty(&css):
return ak.Vector[CssDescriptor]()
var parser = css_parser_create(parsing_params, css)
return css_parser_parse_as_descriptor_declaration_block(&parser, at_rule_id)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:78 Web::parse_css_value.
pub func parse_css_value(context: CssParsingParams, string: ak.StringView, property_id: css_data.PropertyId) -> CssStyleValue*?:
if ak.string_view_is_empty(&string):
return none
var parser = css_parser_create(context, string)
return css_parser_parse_as_css_value(&parser, property_id)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:85 Web::parse_css_type.
pub func parse_css_type(context: CssParsingParams, string: ak.StringView, value_type: CssValueType) -> CssStyleValue*?:
if ak.string_view_is_empty(&string):
return none
var parser = css_parser_create(context, string)
return css_parser_parse_as_type(&parser, value_type)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:92 Web::parse_css_descriptor.
pub func parse_css_descriptor(parsing_params: CssParsingParams, at_rule_id: css_data.AtRuleId, descriptor_name_and_id: CssDescriptorNameAndId, string: ak.StringView) -> CssStyleValue*?:
if ak.string_view_is_empty(&string):
return none
var parser = css_parser_create(parsing_params, string)
return css_parser_parse_as_descriptor_value(&parser, at_rule_id, descriptor_name_and_id)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:99 Web::parse_css_rule.
pub func parse_css_rule(context: CssParsingParams, css_text: ak.StringView) -> CssRule*?:
var parser = css_parser_create(context, css_text)
return css_parser_parse_as_css_rule(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:104 Web::parse_selector.
pub func parse_selector(context: CssParsingParams, selector_text: ak.StringView) -> ak.Vector[CssSelector*]?:
var parser = css_parser_create(context, selector_text)
return css_parser_parse_as_selector(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:109 Web::parse_selector_for_nested_style_rule.
pub func parse_selector_for_nested_style_rule(context: CssParsingParams, selector_text: ak.StringView) -> ak.Vector[CssSelector*]?:
var parser = css_parser_create(context, selector_text)
let maybe_selectors = css_parser_parse_as_relative_selector(&parser, CssParserSelectorParsingMode.standard)
let selectors = maybe_selectors else return none
return css_adapt_nested_relative_selector_list(selectors)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:120 Web::parse_page_selector_list.
pub func parse_page_selector_list(params: CssParsingParams, selector_text: ak.StringView) -> ak.Vector[CssPageSelector]?:
var parser = css_parser_create(params, selector_text)
return css_parser_parse_as_page_selector_list(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:125 Web::parse_pseudo_element_selector.
pub func parse_pseudo_element_selector(context: CssParsingParams, selector_text: ak.StringView) -> CssSelectorPseudoElementSelector?:
var parser = css_parser_create(context, selector_text)
return css_parser_parse_as_pseudo_element_selector(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:130 Web::parse_media_query.
pub func parse_media_query(context: CssParsingParams, string: ak.StringView) -> CssMediaQuery*?:
var parser = css_parser_create(context, string)
return css_parser_parse_as_media_query(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:135 Web::parse_media_query_list.
pub func parse_media_query_list(context: CssParsingParams, string: ak.StringView) -> ak.Vector[CssMediaQuery*]:
var parser = css_parser_create(context, string)
return css_parser_parse_as_media_query_list(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:140 Web::parse_css_supports.
pub func parse_css_supports(context: CssParsingParams, string: ak.StringView) -> CssSupports*?:
if ak.string_view_is_empty(&string):
return none
var parser = css_parser_create(context, string)
return css_parser_parse_as_supports(&parser)
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:147 Web::parse_component_values_list.
pub func parse_component_values_list(parsing_params: CssParsingParams, string: ak.StringView) -> ak.Vector[css_syntax.ComponentValue]:
var parser = css_parser_create(parsing_params, string)
return css_parser_parse_as_list_of_component_values(&parser)
# mark: CSS decode bytes ========================================================================
## The `check_stylesheets_byte_stream` lambda of determine_the_fallback_encoding: 2. of
## https://drafts.csswg.org/css-syntax/#determine-the-fallback-encoding
func css_check_stylesheets_byte_stream(encoded_string: const ak.ByteBuffer*) -> ak.StringView?:
let scan_length = ak.min(ak.byte_buffer_size(encoded_string), 1024)
let pattern_start = ak.sv("@charset \"")
let pattern_end = ak.sv("\";")
if scan_length < ak.string_view_length(&pattern_start):
return none
let buffer_view = ak.string_view_from_bytes(ak.byte_buffer_bytes_const(encoded_string)[0..<scan_length])
if not ak.string_view_starts_with_string_view(&buffer_view, pattern_start):
return none
let encoding_start = ak.string_view_length(&pattern_start)
let end_index = ak.string_view_find_string_view(&buffer_view, pattern_end, encoding_start) else return none
let encoding_length = end_index - encoding_start
let encoding_view = ak.string_view_substring_view_usize(&buffer_view, encoding_start, encoding_length)
for byte in ak.string_view_bytes(&encoding_view):
if (byte < 0x01 or byte > 0x21) and (byte < 0x23 or byte > 0x7F):
return none
return text_codec.get_standardized_encoding(encoding_view)
## The `determine_the_fallback_encoding` lambda of css_decode_bytes.
# https://drafts.csswg.org/css-syntax/#determine-the-fallback-encoding
func css_determine_the_fallback_encoding(environment_encoding: ak.StringView?, mime_type_charset: ak.String?, encoded_string: const ak.ByteBuffer*) -> ak.StringView:
# 1. If HTTP or equivalent protocol provides an encoding label (e.g. via the charset parameter of the Content-Type header) for the stylesheet,
# get an encoding from encoding label. If that does not return failure, return it.
if let charset = mime_type_charset:
if let encoding = text_codec.get_standardized_encoding(ak.string_bytes_as_string_view(&charset)):
return encoding
# 2. Otherwise, check stylesheet’s byte stream. If the first 1024 bytes of the stream begin with the hex sequence
# 40 63 68 61 72 73 65 74 20 22 XX* 22 3B
# where each XX byte is a value between 0x16 and 0x21 inclusive or a value between 0x23 and 0x7F inclusive,
# then get an encoding from a string formed out of the sequence of XX bytes, interpreted as ASCII.
# If the return value was utf-16be or utf-16le, return utf-8; if it was anything else except failure, return it.
if let byte_stream_value = css_check_stylesheets_byte_stream(encoded_string):
if ak.string_view_equals(&byte_stream_value, "UTF-16BE") or ak.string_view_equals(&byte_stream_value, "UTF-16LE"):
return ak.sv("utf-8")
return byte_stream_value
# 3. Otherwise, if an environment encoding is provided by the referring document, return it.
if let encoding = environment_encoding:
return encoding
# 4. Otherwise, return utf-8.
return ak.sv("utf-8")
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:153 Web::css_decode_bytes.
# https://drafts.csswg.org/css-syntax/#css-decode-bytes
pub func css_decode_bytes(environment_encoding: ak.StringView?, mime_type_charset: ak.String?, encoded_string: const ak.ByteBuffer*) -> ak.String!:
# 1. Determine the fallback encoding of stylesheet, and let fallback be the result.
let fallback = css_determine_the_fallback_encoding(environment_encoding, mime_type_charset, encoded_string)
if let decoder = text_codec.decoder_for(fallback):
# 2. Decode stylesheet’s stream of bytes with fallback encoding fallback, and return the result.
return try text_codec.convert_input_to_utf8_using_given_decoder_unless_there_is_a_byte_order_mark(decoder, ak.string_view_from_bytes(ak.byte_buffer_bytes_const(encoded_string)))
# If we don't support the encoding yet, let's error out instead of trying to decode it as something it's most likely not.
ak.dbgln(f"FIXME: Style sheet encoding '{ak.string_view_text(fallback)}' is not supported yet")
error(ak.ak_error, "No Decoder found")
# mark: <custom-ident> ==========================================================================
## Ported from Libraries/LibWeb/CSS/Parser/Helpers.cpp:224 Web::is_valid_custom_ident.
# https://drafts.csswg.org/css-values-4/#identifier-value
pub func is_valid_custom_ident(ident: ak.FlyString, blacklist: const ak.StringView[]) -> bool:
# The CSS-wide keywords are not valid <custom-ident>s.
if css_data.is_css_wide_keyword(ak.fly_string_bytes_as_string_view(&ident)):
return false
# The default keyword is reserved and is also not a valid <custom-ident>.
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("default")):
return false
# Specifications using <custom-ident> must specify clearly what other keywords are excluded from <custom-ident>,
# if any—for example by saying that any pre-defined keywords in that property’s value definition are excluded.
# Excluded keywords are excluded in all ASCII case permutations.
for value in blacklist:
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, value):
return false
return true