Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / parser / value_parsing_8.lucb

#==============================================================================================
#
#   value_parsing_8 - parsing CSS values: font-style and the font-variant-* values
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/ValueParsing.cpp (lines 3601-3940): <'font-style'>,
#       <'font-variant-alternates'> (its feature-value functions), and the keyword tuples of
#       <'font-variant-east-asian'>, <'font-variant-numeric'> and <'font-variant-ligatures'>.
#
#       Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       (the full list of ValueParsing.cpp's copyright holders is in value_parsing_1)
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: font-style ==============================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3601 Web::CSS::Parser::Parser::parse_font_style_value.
pub func css_parser_parse_font_style_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # https://drafts.csswg.org/css-fonts/#font-style-prop
    # normal | italic | left | right | oblique <angle [-90deg,90deg]>?
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    let keyword_value = css_parser_parse_keyword_value(this, tokens) else return none

    if css_data.keyword_to_font_style_keyword(css_style_value_to_keyword(keyword_value)) == none:
        return none

    let font_style = css_data.keyword_to_font_style_keyword(css_style_value_to_keyword(keyword_value)) else return none

    if css_syntax.token_stream_has_next_token(tokens) and css_style_value_to_keyword(keyword_value) == css_data.Keyword.oblique:
        if let angle_value = css_parser_parse_angle_value(this, tokens, CssNumericRange(min = -90.0, max = 90.0)):
            css_syntax.state_transaction_commit(&transaction)
            return css_font_style_style_value_create(font_style, angle_value).css_style_value()

    css_syntax.state_transaction_commit(&transaction)
    return css_font_style_style_value_create(font_style).css_style_value()

# mark: font-variant-alternates =================================================================

## `FunctionStyleValue::create(name, StyleValueList::create(move(feature_value_names), StyleValueList::Separator::Comma))`.
func css_feature_value_function(name: str, feature_value_names: ak.Vector[CssStyleValue*]) -> CssStyleValue*:
    return css_function_style_value_create(ak.fly_string_from_str(name), css_style_value_list_create(feature_value_names, CssStyleValueListSeparator.comma).css_style_value()).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3627 Web::CSS::Parser::Parser::parse_font_variant_alternates_value.
pub func css_parser_parse_font_variant_alternates_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # 6.8 https://drafts.csswg.org/css-fonts/#font-variant-alternates-prop
    # [ stylistic(<feature-value-name>) || historical-forms || styleset(<feature-value-name>#) || character-variant(<feature-value-name>#) || swash(<feature-value-name>) || ornaments(<feature-value-name>) || annotation(<feature-value-name>) ]
    # <feature-value-name> = <ident>
    var stylistic: CssStyleValue*? = none
    var historical_forms: CssStyleValue*? = none
    var styleset: CssStyleValue*? = none
    var character_variant: CssStyleValue*? = none
    var swash: CssStyleValue*? = none
    var ornaments: CssStyleValue*? = none
    var annotation: CssStyleValue*? = none

    while css_syntax.token_stream_has_next_token(tokens):
        css_syntax.token_stream_discard_whitespace(tokens)

        # historical-forms
        if let maybe_historical_forms = css_parser_parse_specific_keyword_value(this, tokens, css_data.Keyword.historical_forms):
            if historical_forms != none:
                return none

            historical_forms = maybe_historical_forms
            continue

        let next = css_syntax.token_stream_next_token(tokens)
        if not css_syntax.component_value_is_function(&next):
            break

        var transaction = css_syntax.token_stream_begin_transaction(tokens)
        defer css_syntax.state_transaction_destroy(&transaction)

        let function_token = css_syntax.token_stream_consume_a_token(tokens)
        let function = css_syntax.component_value_function(&function_token)

        var argument_token_stream = css_syntax.token_stream_create(function.value)
        let arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &argument_token_stream)

        if ak.vector_size(&arguments) == 0:
            break

        var feature_value_names = ak.Vector[CssStyleValue*]()
        ak.vector_ensure_capacity(&feature_value_names, ak.vector_size(&arguments))

        for argument_values in ak.vector_span_const(&arguments):
            var argument_tokens = css_syntax.token_stream_create(argument_values)

            var no_blacklist: const ak.StringView[]
            let ident = css_parser_parse_custom_ident_value(this, &argument_tokens, no_blacklist)

            css_syntax.token_stream_discard_whitespace(&argument_tokens)

            if ident == none or css_syntax.token_stream_has_next_token(&argument_tokens):
                return none

            ak.vector_append_t(&feature_value_names, (ident else trap("VERIFY: an ident")).css_style_value())

        # stylistic(<feature-value-name>)
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("stylistic")):
            if ak.vector_size(&feature_value_names) != 1 or stylistic != none:
                return none

            css_syntax.state_transaction_commit(&transaction)
            stylistic = css_feature_value_function("stylistic", feature_value_names)
            continue

        # styleset(<feature-value-name>#)
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("styleset")):
            if styleset != none:
                return none

            css_syntax.state_transaction_commit(&transaction)
            styleset = css_feature_value_function("styleset", feature_value_names)
            continue

        # character-variant(<feature-value-name>#)
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("character-variant")):
            if character_variant != none:
                return none

            css_syntax.state_transaction_commit(&transaction)
            character_variant = css_feature_value_function("character-variant", feature_value_names)
            continue

        # swash(<feature-value-name>)
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("swash")):
            if ak.vector_size(&feature_value_names) != 1 or swash != none:
                return none

            css_syntax.state_transaction_commit(&transaction)
            swash = css_feature_value_function("swash", feature_value_names)
            continue

        # ornaments(<feature-value-name>)
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("ornaments")):
            if ak.vector_size(&feature_value_names) != 1 or ornaments != none:
                return none

            css_syntax.state_transaction_commit(&transaction)
            ornaments = css_feature_value_function("ornaments", feature_value_names)
            continue

        # annotation(<feature-value-name>)
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("annotation")):
            if ak.vector_size(&feature_value_names) != 1 or annotation != none:
                return none

            css_syntax.state_transaction_commit(&transaction)
            annotation = css_feature_value_function("annotation", feature_value_names)
            continue

        break

    var values = ak.Vector[CssStyleValue*]()
    if let value = stylistic:
        ak.vector_append_t(&values, value)
    if let value = historical_forms:
        ak.vector_append_t(&values, value)
    if let value = styleset:
        ak.vector_append_t(&values, value)
    if let value = character_variant:
        ak.vector_append_t(&values, value)
    if let value = swash:
        ak.vector_append_t(&values, value)
    if let value = ornaments:
        ak.vector_append_t(&values, value)
    if let value = annotation:
        ak.vector_append_t(&values, value)

    if ak.vector_is_empty(&values):
        return none

    return css_style_value_list_create(values, CssStyleValueListSeparator.space).css_style_value()

# mark: Keyword tuples ==========================================================================

## `any_of(tuple, [](auto& value) { return value != nullptr; })`.
func css_style_value_tuple_has_any(tuple: const ak.Vector[CssStyleValue*?]*) -> bool:
    for value in ak.vector_span_const(tuple):
        if value != none:
            return true
    return false

## One step of the keyword-tuple parsers: store `value` in the tuple slot `index` unless it is already set.
## Answers false when the slot was taken (the C++ returns nullptr); commits the keyword's transaction otherwise.
func css_style_value_tuple_claim(tuple: ak.Vector[CssStyleValue*?]*, index: usize, value: CssStyleValue*, keyword_transaction: css_syntax.StateTransaction*) -> bool:
    if *ak.vector_at(tuple, index) != none:
        return false
    css_syntax.state_transaction_commit(keyword_transaction)
    *ak.vector_at(tuple, index) = value
    return true

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3766 Web::CSS::Parser::Parser::parse_font_variant_east_asian_value.
pub func css_parser_parse_font_variant_east_asian_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # 6.10 https://drafts.csswg.org/css-fonts/#propdef-font-variant-east-asian
    # [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]
    # <east-asian-variant-values> = [ jis78 | jis83 | jis90 | jis04 | simplified | traditional ]
    # <east-asian-width-values>   = [ full-width | proportional-width ]
    var tuple = css_empty_style_value_tuple(3)

    while css_syntax.token_stream_has_next_token(tokens):
        var keyword_transaction = css_syntax.token_stream_begin_transaction(tokens)
        defer css_syntax.state_transaction_destroy(&keyword_transaction)
        let maybe_value = css_parser_parse_keyword_value(this, tokens) else break

        if css_style_value_to_keyword(maybe_value) == css_data.Keyword.ruby:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_east_asian_ruby, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_east_asian_width(css_style_value_to_keyword(maybe_value)) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_east_asian_width, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_east_asian_variant(css_style_value_to_keyword(maybe_value)) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_east_asian_variant, maybe_value, &keyword_transaction):
                return none
            continue

        break

    if not css_style_value_tuple_has_any(&tuple):
        return none

    return css_tuple_style_value_create(tuple).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3814 Web::CSS::Parser::Parser::parse_font_variant_numeric_value.
pub func css_parser_parse_font_variant_numeric_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # 6.7 https://drafts.csswg.org/css-fonts/#propdef-font-variant-numeric
    # [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero]
    # <numeric-figure-values>       = [ lining-nums | oldstyle-nums ]
    # <numeric-spacing-values>      = [ proportional-nums | tabular-nums ]
    # <numeric-fraction-values>     = [ diagonal-fractions | stacked-fractions ]
    var tuple = css_empty_style_value_tuple(5)

    while css_syntax.token_stream_has_next_token(tokens):
        var keyword_transaction = css_syntax.token_stream_begin_transaction(tokens)
        defer css_syntax.state_transaction_destroy(&keyword_transaction)
        let maybe_value = css_parser_parse_keyword_value(this, tokens) else break

        let keyword = css_style_value_to_keyword(maybe_value)

        if css_data.keyword_to_numeric_figure_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_figure, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_numeric_spacing_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_spacing, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_numeric_fraction_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_fraction, maybe_value, &keyword_transaction):
                return none
            continue

        if keyword == css_data.Keyword.ordinal:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_ordinal, maybe_value, &keyword_transaction):
                return none
            continue

        if keyword == css_data.Keyword.slashed_zero:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_slashed_zero, maybe_value, &keyword_transaction):
                return none
            continue

        break

    if not css_style_value_tuple_has_any(&tuple):
        return none

    return css_tuple_style_value_create(tuple).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3881 Web::CSS::Parser::Parser::parse_font_variant_ligatures_value.
pub func css_parser_parse_font_variant_ligatures_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # 6.4 https://drafts.csswg.org/css-fonts/#propdef-font-variant-ligatures
    # [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]
    # <common-lig-values>       = [ common-ligatures | no-common-ligatures ]
    # <discretionary-lig-values> = [ discretionary-ligatures | no-discretionary-ligatures ]
    # <historical-lig-values>   = [ historical-ligatures | no-historical-ligatures ]
    # <contextual-alt-values>   = [ contextual | no-contextual ]
    var tuple = css_empty_style_value_tuple(4)

    while css_syntax.token_stream_has_next_token(tokens):
        var keyword_transaction = css_syntax.token_stream_begin_transaction(tokens)
        defer css_syntax.state_transaction_destroy(&keyword_transaction)

        let maybe_value = css_parser_parse_keyword_value(this, tokens) else break

        let keyword = css_style_value_to_keyword(maybe_value)

        if css_data.keyword_to_common_lig_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_common, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_discretionary_lig_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_discretionary, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_historical_lig_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_historical, maybe_value, &keyword_transaction):
                return none
            continue

        if css_data.keyword_to_contextual_alt_value(keyword) != none:
            if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_contextual, maybe_value, &keyword_transaction):
                return none
            continue

        break

    if not css_style_value_tuple_has_any(&tuple):
        return none

    return css_tuple_style_value_create(tuple).css_style_value()