Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   value_parsing_4 - parsing CSS values: the color functions
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/ValueParsing.cpp (lines 1495-2080): rgb()/rgba(),
#       hsl()/hsla() (legacy and modern syntax), hwb(), lab()/oklab() and lch()/oklch() through
#       their shared helpers, color() and <color-interpolation-method>.
#
#       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: Shared steps ============================================================================

## `auto& function_token = outer_tokens.consume_a_token(); if (!function_token.is_function(a) && !function_token.is_function(b))`:
## the function of the next component value when it is named `name` or `alternative_name`.
func css_consume_color_function(outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, name: str, alternative_name: str?) -> css_syntax.Function?:
    let function_token = css_syntax.token_stream_consume_a_token(outer_tokens)
    if css_syntax.component_value_is_function_string_view(&function_token, ak.sv(name)):
        return css_syntax.component_value_function(&function_token)
    if let alternative = alternative_name:
        if css_syntax.component_value_is_function_string_view(&function_token, ak.sv(alternative)):
            return css_syntax.component_value_function(&function_token)
    return none

## `FunctionContext { function_token.function().name }`.
func css_function_context_of(function: const css_syntax.Function*) -> CssValueParsingContext:
    return CssValueParsingContext.css_function_context(CssFunctionContext(name = ak.fly_string_bytes_as_string_view(&function.name)))

# mark: rgb() ===================================================================================

## The `is_percentage` lambda of parse_rgb_color_value.
func css_style_value_is_percentage_or_resolves_to_percentage(style_value: CssStyleValue*) -> bool:
    return css_style_value_is_percentage(style_value) or (css_style_value_is_calculated(style_value) and css_calculated_style_value_resolves_to_percentage(css_style_value_as_calculated(style_value)))

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1496 Web::CSS::Parser::Parser::parse_rgb_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-rgb
pub func css_parser_parse_rgb_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # rgb() = [ <legacy-rgb-syntax> | <modern-rgb-syntax> ]
    # rgba() = [ <legacy-rgba-syntax> | <modern-rgba-syntax> ]
    # <legacy-rgb-syntax> = rgb( <percentage>#{3} , <alpha-value>? ) |
    #                       rgb( <number>#{3} , <alpha-value>? )
    # <legacy-rgba-syntax> = rgba( <percentage>#{3} , <alpha-value>? ) |
    #                        rgba( <number>#{3} , <alpha-value>? )
    # <modern-rgb-syntax> = rgb(
    #     [ <number> | <percentage> | none]{3}
    #     [ / [<alpha-value> | none] ]?  )
    # <modern-rgba-syntax> = rgba(
    #     [ <number> | <percentage> | none]{3}
    #     [ / [<alpha-value> | none] ]?  )

    var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(outer_tokens)

    let function = css_consume_color_function(outer_tokens, "rgb", "rgba") else return none

    css_parser_push_temporary_value_parsing_context(this, css_function_context_of(&function))
    defer css_parser_pop_temporary_value_parsing_context(this)

    var green: CssStyleValue*? = none
    var blue: CssStyleValue*? = none
    var alpha: CssStyleValue*? = none

    var inner_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let red = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none

    css_syntax.token_stream_discard_whitespace(&inner_tokens)
    let legacy_syntax = css_next_token_is(&inner_tokens, .comma)
    if legacy_syntax:
        # Legacy syntax
        #   <percentage>#{3} , <alpha-value>?
        #   | <number>#{3} , <alpha-value>?
        # So, r/g/b can be numbers or percentages, as long as they're all the same type.

        # We accepted the 'none' keyword when parsing the red value, but it's not allowed in the legacy syntax.
        if css_style_value_is_keyword(red):
            return none

        css_syntax.token_stream_discard_a_token(&inner_tokens)  # comma
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        green = css_parser_parse_number_percentage_value(this, &inner_tokens, css_infinite_range, css_infinite_range)
        if green == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        if not css_next_token_is_consumed(&inner_tokens, .comma):
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        blue = css_parser_parse_number_percentage_value(this, &inner_tokens, css_infinite_range, css_infinite_range)
        if blue == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        if css_syntax.token_stream_has_next_token(&inner_tokens):
            # Try and read comma and alpha
            if not css_next_token_is_consumed(&inner_tokens, .comma):
                return none
            css_syntax.token_stream_discard_whitespace(&inner_tokens)

            alpha = css_parser_parse_number_percentage_value(this, &inner_tokens, css_infinite_range, css_infinite_range)

            if alpha == none:
                return none

            css_syntax.token_stream_discard_whitespace(&inner_tokens)

            if css_syntax.token_stream_has_next_token(&inner_tokens):
                return none

        # Verify we're all percentages or all numbers
        let red_is_percentage = css_style_value_is_percentage_or_resolves_to_percentage(red)
        let green_is_percentage = css_style_value_is_percentage_or_resolves_to_percentage(green else trap("VERIFY: green"))
        let blue_is_percentage = css_style_value_is_percentage_or_resolves_to_percentage(blue else trap("VERIFY: blue"))
        if red_is_percentage != green_is_percentage or red_is_percentage != blue_is_percentage:
            return none
    else:
        # Modern syntax
        #   [ <number> | <percentage> | none]{3}  [ / [<alpha-value> | none] ]?

        green = css_parser_parse_number_percentage_none_value(this, &inner_tokens)
        if green == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        blue = css_parser_parse_number_percentage_none_value(this, &inner_tokens)
        if blue == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        if css_syntax.token_stream_has_next_token(&inner_tokens):
            alpha = css_parser_parse_solidus_and_alpha_value(this, &inner_tokens)
            if alpha == none or css_syntax.token_stream_has_next_token(&inner_tokens):
                return none

    if alpha == none:
        alpha = css_number_style_value_create(1.0).css_style_value()

    css_syntax.state_transaction_commit(&transaction)
    return css_color_function_style_value_create(CssColorStyleValueColorType.rgb, red, green else trap("VERIFY: green"), blue else trap("VERIFY: blue"), alpha, CssColorSyntax.legacy if legacy_syntax else CssColorSyntax.modern).css_style_value()

## `tokens.consume_a_token().is(type)`.
func css_next_token_is_consumed(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, type_: css_syntax.TokenType) -> bool:
    let consumed = css_syntax.token_stream_consume_a_token(tokens)
    return css_syntax.component_value_is(&consumed, type_)

# mark: hsl() and hwb() =========================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1618 Web::CSS::Parser::Parser::parse_hsl_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-hsl
pub func css_parser_parse_hsl_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # hsl() = [ <legacy-hsl-syntax> | <modern-hsl-syntax> ]
    # hsla() = [ <legacy-hsla-syntax> | <modern-hsla-syntax> ]
    # <modern-hsl-syntax> = hsl(
    #     [<hue> | none]
    #     [<percentage> | <number> | none]
    #     [<percentage> | <number> | none]
    #     [ / [<alpha-value> | none] ]? )
    # <modern-hsla-syntax> = hsla(
    #     [<hue> | none]
    #     [<percentage> | <number> | none]
    #     [<percentage> | <number> | none]
    #     [ / [<alpha-value> | none] ]? )
    # <legacy-hsl-syntax> = hsl( <hue>, <percentage>, <percentage>, <alpha-value>? )
    # <legacy-hsla-syntax> = hsla( <hue>, <percentage>, <percentage>, <alpha-value>? )

    var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(outer_tokens)

    let function = css_consume_color_function(outer_tokens, "hsl", "hsla") else return none

    css_parser_push_temporary_value_parsing_context(this, css_function_context_of(&function))
    defer css_parser_pop_temporary_value_parsing_context(this)

    var s: CssStyleValue*? = none
    var l: CssStyleValue*? = none
    var alpha: CssStyleValue*? = none

    var inner_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let h = css_parser_parse_hue_none_value(this, &inner_tokens) else return none

    css_syntax.token_stream_discard_whitespace(&inner_tokens)
    let legacy_syntax = css_next_token_is(&inner_tokens, .comma)
    if legacy_syntax:
        # Legacy syntax
        #   <hue>, <percentage>, <percentage>, <alpha-value>?

        # We accepted the 'none' keyword when parsing the h value, but it's not allowed in the legacy syntax.
        if css_style_value_is_keyword(h):
            return none

        _ = css_syntax.token_stream_consume_a_token(&inner_tokens)  # comma
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        s = css_parser_parse_percentage_value(this, &inner_tokens, css_infinite_range)
        if s == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        if not css_next_token_is_consumed(&inner_tokens, .comma):
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        l = css_parser_parse_percentage_value(this, &inner_tokens, css_infinite_range)
        if l == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        if css_syntax.token_stream_has_next_token(&inner_tokens):
            # Try and read comma and alpha
            if not css_next_token_is_consumed(&inner_tokens, .comma):
                return none
            css_syntax.token_stream_discard_whitespace(&inner_tokens)

            alpha = css_parser_parse_number_percentage_value(this, &inner_tokens, css_infinite_range, css_infinite_range)
            # The parser has consumed a comma, so the alpha value is now required
            if alpha == none:
                return none
            css_syntax.token_stream_discard_whitespace(&inner_tokens)

            if css_syntax.token_stream_has_next_token(&inner_tokens):
                return none
    else:
        # Modern syntax
        #   [<hue> | none]
        #   [<percentage> | <number> | none]
        #   [<percentage> | <number> | none]
        #   [ / [<alpha-value> | none] ]?

        s = css_parser_parse_number_percentage_none_value(this, &inner_tokens)
        if s == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        l = css_parser_parse_number_percentage_none_value(this, &inner_tokens)
        if l == none:
            return none
        css_syntax.token_stream_discard_whitespace(&inner_tokens)

        if css_syntax.token_stream_has_next_token(&inner_tokens):
            alpha = css_parser_parse_solidus_and_alpha_value(this, &inner_tokens)
            if alpha == none or css_syntax.token_stream_has_next_token(&inner_tokens):
                return none

    if alpha == none:
        alpha = css_number_style_value_create(1.0).css_style_value()

    css_syntax.state_transaction_commit(&transaction)
    return css_color_function_style_value_create(CssColorStyleValueColorType.hsl, h, s else trap("VERIFY: s"), l else trap("VERIFY: l"), alpha, CssColorSyntax.legacy if legacy_syntax else CssColorSyntax.modern).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1730 Web::CSS::Parser::Parser::parse_hwb_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-hwb
pub func css_parser_parse_hwb_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # hwb() = hwb(
    #     [<hue> | none]
    #     [<percentage> | <number> | none]
    #     [<percentage> | <number> | none]
    #     [ / [<alpha-value> | none] ]? )

    var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(outer_tokens)

    let function = css_consume_color_function(outer_tokens, "hwb", none) else return none

    css_parser_push_temporary_value_parsing_context(this, css_function_context_of(&function))
    defer css_parser_pop_temporary_value_parsing_context(this)

    var alpha: CssStyleValue*? = none

    var inner_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let h = css_parser_parse_hue_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let w = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let b = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    if css_syntax.token_stream_has_next_token(&inner_tokens):
        alpha = css_parser_parse_solidus_and_alpha_value(this, &inner_tokens)
        if alpha == none or css_syntax.token_stream_has_next_token(&inner_tokens):
            return none

    if alpha == none:
        alpha = css_number_style_value_create(1.0).css_style_value()

    css_syntax.state_transaction_commit(&transaction)
    return css_color_function_style_value_create(CssColorStyleValueColorType.hwb, h, w, b, alpha).css_style_value()

# mark: lab(), oklab(), lch(), oklch() ==========================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1783 Web::CSS::Parser::Parser::parse_lab_like_color_value.
pub func css_parser_parse_lab_like_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, function_name: ak.StringView) -> ((CssStyleValue*?)[4])?:
    # This helper is designed to be compatible with lab and oklab and parses a function with a form like:
    # f() = f( [ <percentage> | <number> | none]
    #     [ <percentage> | <number> | none]
    #     [ <percentage> | <number> | none]
    #     [ / [<alpha-value> | none] ]? )

    var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(outer_tokens)

    let function_token = css_syntax.token_stream_consume_a_token(outer_tokens)
    if not css_syntax.component_value_is_function_string_view(&function_token, function_name):
        return none

    var alpha: CssStyleValue*? = none

    let function = css_syntax.component_value_function(&function_token)
    var inner_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let l = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let a = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let b = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    if css_syntax.token_stream_has_next_token(&inner_tokens):
        alpha = css_parser_parse_solidus_and_alpha_value(this, &inner_tokens)
        if alpha == none or css_syntax.token_stream_has_next_token(&inner_tokens):
            return none

    if alpha == none:
        alpha = css_number_style_value_create(1.0).css_style_value()

    css_syntax.state_transaction_commit(&transaction)

    return [l, a, b, alpha]

## `ColorFunctionStyleValue::create(color_type, color_values[0..3].release_nonnull())` of the lab()-like
## and lch()-like parsers.
func css_color_function_from_values(color_type: CssColorStyleValueColorType, color_values: (CssStyleValue*?)[4]) -> CssStyleValue*:
    return css_color_function_style_value_create(color_type,
                                                 color_values[0] else trap("VERIFY: a first channel"),
                                                 color_values[1] else trap("VERIFY: a second channel"),
                                                 color_values[2] else trap("VERIFY: a third channel"),
                                                 color_values[3] else trap("VERIFY: an alpha")).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1836 Web::CSS::Parser::Parser::parse_lab_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-lab
pub func css_parser_parse_lab_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # lab() = lab( [<percentage> | <number> | none]
    #      [ <percentage> | <number> | none]
    #      [ <percentage> | <number> | none]
    #      [ / [<alpha-value> | none] ]? )

    let color_values = css_parser_parse_lab_like_color_value(this, outer_tokens, ak.sv("lab")) else return none

    return css_color_function_from_values(CssColorStyleValueColorType.lab, color_values)

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1857 Web::CSS::Parser::Parser::parse_oklab_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-oklab
pub func css_parser_parse_oklab_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # oklab() = oklab( [ <percentage> | <number> | none]
    #     [ <percentage> | <number> | none]
    #     [ <percentage> | <number> | none]
    #     [ / [<alpha-value> | none] ]? )

    let color_values = css_parser_parse_lab_like_color_value(this, outer_tokens, ak.sv("oklab")) else return none

    return css_color_function_from_values(CssColorStyleValueColorType.ok_lab, color_values)

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1877 Web::CSS::Parser::Parser::parse_lch_like_color_value.
pub func css_parser_parse_lch_like_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, function_name: ak.StringView) -> ((CssStyleValue*?)[4])?:
    # This helper is designed to be compatible with lch and oklch and parses a function with a form like:
    # f() = f( [<percentage> | <number> | none]
    #     [ <percentage> | <number> | none]
    #     [ <hue> | none]
    #     [ / [<alpha-value> | none] ]? )

    var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(outer_tokens)

    let function_token = css_syntax.token_stream_consume_a_token(outer_tokens)
    if not css_syntax.component_value_is_function_string_view(&function_token, function_name):
        return none

    let function = css_syntax.component_value_function(&function_token)
    var inner_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let l = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let c = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let h = css_parser_parse_hue_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    var alpha: CssStyleValue*? = none
    if css_syntax.token_stream_has_next_token(&inner_tokens):
        alpha = css_parser_parse_solidus_and_alpha_value(this, &inner_tokens)
        if alpha == none or css_syntax.token_stream_has_next_token(&inner_tokens):
            return none

    if alpha == none:
        alpha = css_number_style_value_create(1.0).css_style_value()

    css_syntax.state_transaction_commit(&transaction)

    return [l, c, h, alpha]

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1926 Web::CSS::Parser::Parser::parse_lch_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-lch
pub func css_parser_parse_lch_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # lch() = lch( [<percentage> | <number> | none]
    #      [ <percentage> | <number> | none]
    #      [ <hue> | none]
    #      [ / [<alpha-value> | none] ]? )

    let color_values = css_parser_parse_lch_like_color_value(this, outer_tokens, ak.sv("lch")) else return none

    return css_color_function_from_values(CssColorStyleValueColorType.lch, color_values)

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1946 Web::CSS::Parser::Parser::parse_oklch_color_value.
# https://www.w3.org/TR/css-color-4/#funcdef-oklch
pub func css_parser_parse_oklch_color_value(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # oklch() = oklch( [ <percentage> | <number> | none]
    #     [ <percentage> | <number> | none]
    #     [ <hue> | none]
    #     [ / [<alpha-value> | none] ]? )

    let color_values = css_parser_parse_lch_like_color_value(this, outer_tokens, ak.sv("oklch")) else return none

    return css_color_function_from_values(CssColorStyleValueColorType.oklch, color_values)

# mark: color() =================================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1966 Web::CSS::Parser::Parser::parse_color_function.
# https://www.w3.org/TR/css-color-4/#funcdef-color
pub func css_parser_parse_color_function(this: CssParser*, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # color() = color( <colorspace-params> [ / [ <alpha-value> | none ] ]? )
    #     <colorspace-params> = [ <predefined-rgb-params> | <xyz-params>]
    #     <predefined-rgb-params> = <predefined-rgb> [ <number> | <percentage> | none ]{3}
    #     <predefined-rgb> = srgb | srgb-linear | display-p3 | a98-rgb | prophoto-rgb | rec2020
    #     <xyz-params> = <xyz-space> [ <number> | <percentage> | none ]{3}
    #     <xyz-space> = xyz | xyz-d50 | xyz-d65

    var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(outer_tokens)

    let function = css_consume_color_function(outer_tokens, "color", none) else return none

    css_parser_push_temporary_value_parsing_context(this, css_function_context_of(&function))
    defer css_parser_pop_temporary_value_parsing_context(this)

    var inner_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let maybe_color_space = css_syntax.token_stream_consume_a_token(&inner_tokens)
    css_syntax.token_stream_discard_whitespace(&inner_tokens)
    if not css_syntax.component_value_is(&maybe_color_space, .ident):
        return none

    let ident = css_component_value_ident(&maybe_color_space)
    let color_space = ak.fly_string_to_ascii_lowercase(&ident)
    if css_color_type_from_color_function_name(ak.fly_string_bytes_as_string_view(&color_space)) == none:
        return none

    let c1 = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let c2 = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    let c3 = css_parser_parse_number_percentage_none_value(this, &inner_tokens) else return none
    css_syntax.token_stream_discard_whitespace(&inner_tokens)

    var alpha: CssStyleValue*? = none
    if css_syntax.token_stream_has_next_token(&inner_tokens):
        alpha = css_parser_parse_solidus_and_alpha_value(this, &inner_tokens)
        if alpha == none or css_syntax.token_stream_has_next_token(&inner_tokens):
            return none

    if alpha == none:
        alpha = css_number_style_value_create(1.0).css_style_value()

    css_syntax.state_transaction_commit(&transaction)
    let color_type = css_color_type_from_color_function_name(ak.fly_string_bytes_as_string_view(&color_space)) else trap("VERIFY: a color type")
    return css_color_function_style_value_create(color_type, c1, c2, c3, alpha).css_style_value()

# mark: <color-interpolation-method> ============================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:2032 Web::CSS::Parser::Parser::parse_color_interpolation_method_value.
# https://drafts.csswg.org/css-color-5/#color-interpolation-method
pub func css_parser_parse_color_interpolation_method_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssColorInterpolationMethodStyleValue*?:
    # <rectangular-color-space> = srgb | srgb-linear | display-p3 | display-p3-linear | a98-rgb | prophoto-rgb | rec2020 | lab | oklab | <xyz-space>
    # <polar-color-space> = hsl | hwb | lch | oklch
    # <custom-color-space> = <dashed-ident>
    # <hue-interpolation-method> = [ shorter | longer | increasing | decreasing ] hue
    # <color-interpolation-method> = in [ <rectangular-color-space> | <polar-color-space> <hue-interpolation-method>? | <custom-color-space> ]
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)
    let in_token = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is_ident(&in_token, ak.sv("in")):
        return none

    css_syntax.token_stream_discard_whitespace(tokens)

    if let maybe_keyword_value = css_parser_parse_keyword_value(this, tokens):
        let keyword = css_style_value_to_keyword(maybe_keyword_value)

        # <rectangular-color-space>
        if let rectangular_color_space = css_data.keyword_to_rectangular_color_space(keyword):
            var color_space = rectangular_color_space
            if color_space == css_data.RectangularColorSpace.xyz:
                color_space = css_data.RectangularColorSpace.xyz_d65
            css_syntax.state_transaction_commit(&transaction)
            return css_color_interpolation_method_style_value_create(display_list.ColorInterpolationMethod.rectangular_color_space(color_space))

        # <polar-color-space> <hue-interpolation-method>?
        if let polar_color_space = css_data.keyword_to_polar_color_space(keyword):
            var hue_interpolation_method = css_data.HueInterpolationMethod.shorter
            css_syntax.token_stream_discard_whitespace(tokens)
            if let hue_interpolation_method_keyword = css_parser_parse_keyword_value(this, tokens):
                let maybe_hue_interpolation_method = css_data.keyword_to_hue_interpolation_method(css_style_value_to_keyword(hue_interpolation_method_keyword)) else return none

                hue_interpolation_method = maybe_hue_interpolation_method
                css_syntax.token_stream_discard_whitespace(tokens)
                let hue_token = css_syntax.token_stream_consume_a_token(tokens)
                if not css_syntax.component_value_is_ident(&hue_token, ak.sv("hue")):
                    return none

            css_syntax.state_transaction_commit(&transaction)
            return css_color_interpolation_method_style_value_create(display_list.ColorInterpolationMethod.polar_color_interpolation_method(display_list.PolarColorInterpolationMethod(color_space = polar_color_space, hue_interpolation_method = hue_interpolation_method)))

    # TODO: Support <custom-color-space> once we support @color-profile rules

    return none