Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / 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 memory_tag = memory_tag_enter(MemoryTag.parse)
    defer memory_tag_leave(memory_tag)
    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