Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / content_security_policy / directives / source_expression.lucb

#==============================================================================================
#
#   source_expression - ContentSecurityPolicy::Directives::SourceExpressionParser: parsing a
#   source expression as a scheme-, host-, keyword-, nonce- or hash-source
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp (lines
#       1-439). SourceExpressionParser::StateTransaction restores the parser's state in its
#       destructor unless committed; here each parse function that makes one runs
#       content_security_policy_state_transaction_destruct in a `defer`, after the result is
#       computed, as the C++ destructor runs.
#
#       Copyright (c) 2025, Luke Wilde <luke@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: StateTransaction ========================================================================

## Web::ContentSecurityPolicy::Directives::SourceExpressionParser::StateTransaction (SourceExpression.cpp:378): the
## parser's state when the transaction began, restored when it ends uncommitted.
struct ContentSecurityPolicyStateTransaction:
    var m_parser: ContentSecurityPolicySourceExpressionParser*
    var m_saved_state: ContentSecurityPolicySourceExpressionParserState
    var m_start_index: usize
    var m_commit: bool

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:379 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::StateTransaction::StateTransaction.
func content_security_policy_state_transaction_create(parser: ContentSecurityPolicySourceExpressionParser*) -> ContentSecurityPolicyStateTransaction:
    return ContentSecurityPolicyStateTransaction(m_parser = parser, m_saved_state = parser.m_state, m_start_index = ak.generic_lexer_tell(&parser.m_state.lexer), m_commit = false)

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:386 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::StateTransaction::~StateTransaction.
func content_security_policy_state_transaction_destruct(this: ContentSecurityPolicyStateTransaction*):
    if not this.m_commit:
        this.m_parser.m_state = this.m_saved_state

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:392 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::StateTransaction::commit.
func content_security_policy_state_transaction_commit(this: ContentSecurityPolicyStateTransaction*):
    this.m_commit = true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:393 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::StateTransaction::parsed_string_view.
func content_security_policy_state_transaction_parsed_string_view(this: const ContentSecurityPolicyStateTransaction*) -> ak.StringView:
    return ak.string_view_substring_view_usize(&this.m_parser.m_input, this.m_start_index, ak.generic_lexer_tell(&this.m_parser.m_state.lexer) - this.m_start_index)

# mark: Predicates ==============================================================================

## The predicate of parse_scheme's consume_while: `is_ascii_alpha(ch) || is_ascii_digit(ch) || ch == '+' || ch == '-' || ch == '.'`.
struct ContentSecurityPolicySchemeCharacter: ak.CharPredicate:
    var unused: u8

    func matches(ch: u8) -> bool:
        return ak.is_ascii_alpha(ch) or ak.is_ascii_digit(ch) or ch == '+' or ch == '-' or ch == '.'

## The `is_main_part` lambda of parse_base64_value: `is_ascii_alpha(ch) || is_ascii_digit(ch) || ch == '+' || ch == '/' || ch == '-' || ch == '_'`.
struct ContentSecurityPolicyBase64MainPart: ak.CharPredicate:
    var unused: u8

    func matches(ch: u8) -> bool:
        return ak.is_ascii_alpha(ch) or ak.is_ascii_digit(ch) or ch == '+' or ch == '/' or ch == '-' or ch == '_'

## `m_state.lexer.consume_specific_with_predicate(function)` for a ctype-like function.
func content_security_policy_consume_specific_with_function(this: ContentSecurityPolicySourceExpressionParser*, function: func(u32) -> bool) -> bool:
    let predicate = ak.CharPredicateFunction(function = function)
    return ak.generic_lexer_consume_specific_with_predicate(&this.m_state.lexer, &predicate)

## `m_state.lexer.consume_specific_with_predicate(is_any_of(values))`.
func content_security_policy_consume_specific_any_of(this: ContentSecurityPolicySourceExpressionParser*, values: str) -> bool:
    let predicate = ak.is_any_of(ak.sv(values))
    return ak.generic_lexer_consume_specific_with_predicate(&this.m_state.lexer, &predicate)

# mark: SourceExpressionParser ==================================================================

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:16 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::SourceExpressionParser.
pub func content_security_policy_source_expression_parser_construct(this: ContentSecurityPolicySourceExpressionParser*, input: ak.StringView):
    this.m_input = input
    this.m_state = ContentSecurityPolicySourceExpressionParserState(lexer = ak.generic_lexer_new(input), parse_result = ContentSecurityPolicySourceExpressionParseResult())

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:25 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::lexer.
pub func content_security_policy_source_expression_parser_lexer(this: const ContentSecurityPolicySourceExpressionParser*) -> const ak.GenericLexer[u8]*:
    return &this.m_state.lexer

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:26 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_result.
pub func content_security_policy_source_expression_parser_parse_result(this: const ContentSecurityPolicySourceExpressionParser*) -> const ContentSecurityPolicySourceExpressionParseResult*:
    return &this.m_state.parse_result

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:29 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_scheme_source.
# https://w3c.github.io/webappsec-csp/#grammardef-scheme-source
pub func content_security_policy_source_expression_parser_parse_scheme_source(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # ; Schemes: "https:" / "custom-scheme:" / "another.custom-scheme:"
    # scheme-source = scheme-part ":"
    if not content_security_policy_source_expression_parser_parse_scheme_part(this):
        return false

    return ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, ':')

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:40 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_scheme_part.
# https://w3c.github.io/webappsec-csp/#grammardef-scheme-part
pub func content_security_policy_source_expression_parser_parse_scheme_part(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # scheme-part = scheme
    # ; scheme is defined in section 3.1 of RFC 3986.
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    if not content_security_policy_source_expression_parser_parse_scheme(this):
        return false

    this.m_state.parse_result.scheme_part = content_security_policy_state_transaction_parsed_string_view(&transaction)
    content_security_policy_state_transaction_commit(&transaction)
    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:55 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_scheme.
# https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
pub func content_security_policy_source_expression_parser_parse_scheme(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
    if not content_security_policy_consume_specific_with_function(this, ak.is_ascii_alpha):
        return false

    let scheme_character = ContentSecurityPolicySchemeCharacter(unused = 0)
    _ = ak.generic_lexer_consume_while(&this.m_state.lexer, &scheme_character)
    return true

## The `parse_scheme` lambda of parse_host_source: an optional `scheme-part "://"`.
func content_security_policy_source_expression_parser_parse_host_source_scheme(this: ContentSecurityPolicySourceExpressionParser*):
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    if not content_security_policy_source_expression_parser_parse_scheme_part(this):
        return

    if not ak.generic_lexer_consume_specific_string_view(&this.m_state.lexer, ak.sv("://")):
        this.m_state.parse_result.scheme_part = none
        return

    content_security_policy_state_transaction_commit(&transaction)

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:68 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_host_source.
# https://w3c.github.io/webappsec-csp/#grammardef-host-source
pub func content_security_policy_source_expression_parser_parse_host_source(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # ; Hosts: "example.com" / "*.example.com" / "https://*.example.com:12/path/to/file.js"
    # host-source = [ scheme-part "://" ] host-part [ ":" port-part ] [ path-part ]
    content_security_policy_source_expression_parser_parse_host_source_scheme(this)

    if not content_security_policy_source_expression_parser_parse_host_part(this):
        return false

    if ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, ':'):
        if not content_security_policy_source_expression_parser_parse_port_part(this):
            return false

    _ = content_security_policy_source_expression_parser_parse_path_part(this)

    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:102 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_host_part.
# https://w3c.github.io/webappsec-csp/#grammardef-host-part
pub func content_security_policy_source_expression_parser_parse_host_part(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # host-part = "*" / [ "*." ] 1*host-char *( "." 1*host-char ) [ "." ]
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    if ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '*') and not ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '.'):
        this.m_state.parse_result.host_part = content_security_policy_state_transaction_parsed_string_view(&transaction)
        content_security_policy_state_transaction_commit(&transaction)
        return true

    if not content_security_policy_source_expression_parser_parse_host_char(this):
        return false

    while content_security_policy_source_expression_parser_parse_host_char(this):
        continue

    while ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '.'):
        if content_security_policy_source_expression_parser_parse_host_char(this):
            while content_security_policy_source_expression_parser_parse_host_char(this):
                continue
        else:
            break

    this.m_state.parse_result.host_part = content_security_policy_state_transaction_parsed_string_view(&transaction)
    content_security_policy_state_transaction_commit(&transaction)
    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:134 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_host_char.
# https://w3c.github.io/webappsec-csp/#grammardef-host-char
pub func content_security_policy_source_expression_parser_parse_host_char(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # host-char = ALPHA / DIGIT / "-"
    return (content_security_policy_consume_specific_with_function(this, ak.is_ascii_alpha) or content_security_policy_consume_specific_with_function(this, ak.is_ascii_digit) or ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '-'))

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:143 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_port_part.
# https://w3c.github.io/webappsec-csp/#grammardef-port-part
pub func content_security_policy_source_expression_parser_parse_port_part(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # port-part = 1*DIGIT / "*"
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    if ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '*'):
        this.m_state.parse_result.port_part = content_security_policy_state_transaction_parsed_string_view(&transaction)
        content_security_policy_state_transaction_commit(&transaction)
        return true

    if not content_security_policy_consume_specific_with_function(this, ak.is_ascii_digit):
        return false

    let is_ascii_digit = ak.CharPredicateFunction(function = ak.is_ascii_digit)
    _ = ak.generic_lexer_consume_while(&this.m_state.lexer, &is_ascii_digit)

    this.m_state.parse_result.port_part = content_security_policy_state_transaction_parsed_string_view(&transaction)
    content_security_policy_state_transaction_commit(&transaction)
    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:165 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_path_part.
# https://w3c.github.io/webappsec-csp/#grammardef-path-part
pub func content_security_policy_source_expression_parser_parse_path_part(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # path-part = path-absolute (but not including ";" or ",")
    # ; path-absolute is defined in section 3.3 of RFC 3986.
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    if not content_security_policy_source_expression_parser_parse_path_absolute(this):
        return false

    this.m_state.parse_result.path_part = content_security_policy_state_transaction_parsed_string_view(&transaction)
    content_security_policy_state_transaction_commit(&transaction)
    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:180 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_path_absolute.
# https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
pub func content_security_policy_source_expression_parser_parse_path_absolute(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # path-absolute = "/" [ segment-nz *( "/" segment ) ]
    if not ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '/'):
        return false

    if content_security_policy_source_expression_parser_parse_segment_non_zero(this):
        while ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '/'):
            content_security_policy_source_expression_parser_parse_segment(this)

    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:196 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_segment.
# https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
pub func content_security_policy_source_expression_parser_parse_segment(this: ContentSecurityPolicySourceExpressionParser*):
    # segment = *pchar
    while content_security_policy_source_expression_parser_parse_path_character(this):
        continue

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:204 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_segment_non_zero.
# https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
pub func content_security_policy_source_expression_parser_parse_segment_non_zero(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # segment-nz = 1*pchar
    if not content_security_policy_source_expression_parser_parse_path_character(this):
        return false

    while content_security_policy_source_expression_parser_parse_path_character(this):
        continue

    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:217 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_path_character.
# https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
pub func content_security_policy_source_expression_parser_parse_path_character(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    return (content_security_policy_source_expression_parser_parse_unreserved(this) or content_security_policy_source_expression_parser_parse_percent_encoded(this) or content_security_policy_source_expression_parser_parse_sub_delims(this) or content_security_policy_consume_specific_any_of(this, ":@"))

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:227 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_unreserved.
# https://datatracker.ietf.org/doc/html/rfc3986#section-2.3
pub func content_security_policy_source_expression_parser_parse_unreserved(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    return (content_security_policy_consume_specific_with_function(this, ak.is_ascii_alpha) or content_security_policy_consume_specific_with_function(this, ak.is_ascii_digit) or content_security_policy_consume_specific_any_of(this, "-._~"))

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:236 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_percent_encoded.
# https://datatracker.ietf.org/doc/html/rfc3986#section-2.1
pub func content_security_policy_source_expression_parser_parse_percent_encoded(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # pct-encoded = "%" HEXDIG HEXDIG
    # "The uppercase hexadecimal digits 'A' through 'F' are equivalent to
    #  the lowercase digits 'a' through 'f', respectively.  If two URIs
    #  differ only in the case of hexadecimal digits used in percent-encoded
    #  octets, they are equivalent.  For consistency, URI producers and
    #  normalizers should use uppercase hexadecimal digits for all percent-
    #  encodings."
    return (ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '%') and content_security_policy_consume_specific_with_function(this, ak.is_ascii_hex_digit) and content_security_policy_consume_specific_with_function(this, ak.is_ascii_hex_digit))

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:251 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_sub_delims.
# https://datatracker.ietf.org/doc/html/rfc3986#section-2.2
pub func content_security_policy_source_expression_parser_parse_sub_delims(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"
    #             / "*" / "+" / "," / ";" / "="
    # NOTE: This does not contain ';' and ',' as per the requirement specified in parse_path_part.
    return content_security_policy_consume_specific_any_of(this, "!$&'()*+=")

## The keyword-source expressions in ENUMERATE_KEYWORD_SOURCES order (KeywordSources.h), which parse_keyword_source tries.
let content_security_policy_keyword_source_values: str[8] = ["'self'", "'unsafe-inline'", "'unsafe-eval'", "'strict-dynamic'", "'unsafe-hashes'", "'report-sample'", "'unsafe-allow-redirects'", "'wasm-unsafe-eval'"]

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:260 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_keyword_source.
# https://w3c.github.io/webappsec-csp/#grammardef-keyword-source
pub func content_security_policy_source_expression_parser_parse_keyword_source(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # ; Keywords:
    # keyword-source = "'self'" / "'unsafe-inline'" / "'unsafe-eval'"
    #                  / "'strict-dynamic'" / "'unsafe-hashes'" /
    #                  / "'report-sample'" / "'unsafe-allow-redirects'"
    #                  / "'wasm-unsafe-eval'"
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    # (#define __ENUMERATE_KEYWORD_SOURCE ... ENUMERATE_KEYWORD_SOURCES)
    for value in content_security_policy_keyword_source_values:
        if ak.generic_lexer_consume_specific_string_view(&this.m_state.lexer, ak.sv(value)):
            this.m_state.parse_result.keyword_source = content_security_policy_state_transaction_parsed_string_view(&transaction)
            content_security_policy_state_transaction_commit(&transaction)
            return true

    return false

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:282 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_nonce_source.
# https://w3c.github.io/webappsec-csp/#grammardef-nonce-source
pub func content_security_policy_source_expression_parser_parse_nonce_source(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # ; Nonces: 'nonce-[nonce goes here]'
    # nonce-source = "'nonce-" base64-value "'"
    let prefix = ak.generic_lexer_consume_usize(&this.m_state.lexer, 7)
    if ak.string_view_length(&prefix) != 7:
        return false

    if not ak.string_view_equals_ignoring_ascii_case(&prefix, ak.sv("'nonce-")):
        return false

    if not content_security_policy_source_expression_parser_parse_base64_value(this):
        return false

    return ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '\'')

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:300 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_base64_value.
# https://w3c.github.io/webappsec-csp/#grammardef-base64-value
pub func content_security_policy_source_expression_parser_parse_base64_value(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # base64-value = 1*( ALPHA / DIGIT / "+" / "/" / "-" / "_" )*2( "=" )
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    let is_main_part = ContentSecurityPolicyBase64MainPart(unused = 0)

    if not ak.generic_lexer_consume_specific_with_predicate(&this.m_state.lexer, &is_main_part):
        return false

    _ = ak.generic_lexer_consume_while(&this.m_state.lexer, &is_main_part)
    _ = ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '=')
    _ = ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '=')

    this.m_state.parse_result.base64_value = content_security_policy_state_transaction_parsed_string_view(&transaction)
    content_security_policy_state_transaction_commit(&transaction)
    return true

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:322 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_hash_source.
# https://w3c.github.io/webappsec-csp/#grammardef-hash-source
pub func content_security_policy_source_expression_parser_parse_hash_source(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # ; Digests: 'sha256-[digest goes here]'
    # hash-source = "'" hash-algorithm "-" base64-value "'"
    if not ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '\''):
        return false

    if not content_security_policy_source_expression_parser_parse_hash_algorithm(this):
        return false

    if not ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '-'):
        return false

    if not content_security_policy_source_expression_parser_parse_base64_value(this):
        return false

    return ak.generic_lexer_consume_specific_t_char_type(&this.m_state.lexer, '\'')

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:342 Web::ContentSecurityPolicy::Directives::SourceExpressionParser::parse_hash_algorithm.
# https://w3c.github.io/webappsec-csp/#grammardef-hash-algorithm
pub func content_security_policy_source_expression_parser_parse_hash_algorithm(this: ContentSecurityPolicySourceExpressionParser*) -> bool:
    # hash-algorithm = "sha256" / "sha384" / "sha512"
    var transaction = content_security_policy_state_transaction_create(this)
    defer content_security_policy_state_transaction_destruct(&transaction)

    let hash_algorithm = ak.generic_lexer_consume_usize(&this.m_state.lexer, 6)
    if ak.string_view_length(&hash_algorithm) != 6:
        return false

    if ak.string_view_equals_ignoring_ascii_case(&hash_algorithm, ak.sv("sha256")):
        this.m_state.parse_result.hash_algorithm = content_security_policy_state_transaction_parsed_string_view(&transaction)
        content_security_policy_state_transaction_commit(&transaction)
        return true

    if ak.string_view_equals_ignoring_ascii_case(&hash_algorithm, ak.sv("sha384")):
        this.m_state.parse_result.hash_algorithm = content_security_policy_state_transaction_parsed_string_view(&transaction)
        content_security_policy_state_transaction_commit(&transaction)
        return true

    if ak.string_view_equals_ignoring_ascii_case(&hash_algorithm, ak.sv("sha512")):
        this.m_state.parse_result.hash_algorithm = content_security_policy_state_transaction_parsed_string_view(&transaction)
        content_security_policy_state_transaction_commit(&transaction)
        return true

    return false

# mark: parse_source_expression =================================================================

## Ported from Libraries/LibWeb/ContentSecurityPolicy/Directives/SourceExpression.cpp:416 Web::ContentSecurityPolicy::Directives::parse_source_expression.
pub func content_security_policy_directives_parse_source_expression(production: ContentSecurityPolicyProduction, input: ak.StringView) -> ContentSecurityPolicySourceExpressionParseResult?:
    var parser: ContentSecurityPolicySourceExpressionParser = ---
    content_security_policy_source_expression_parser_construct(&parser, input)

    # (#define __ENUMERATE_SOURCE_EXPRESSION_PRODUCTION_PARSER ... ENUMERATE_SOURCE_EXPRESSION_PRODUCTION_PARSERS)
    match production:
        .scheme_source:
            if not content_security_policy_source_expression_parser_parse_scheme_source(&parser):
                return none
        .host_source:
            if not content_security_policy_source_expression_parser_parse_host_source(&parser):
                return none
        .keyword_source:
            if not content_security_policy_source_expression_parser_parse_keyword_source(&parser):
                return none
        .nonce_source:
            if not content_security_policy_source_expression_parser_parse_nonce_source(&parser):
                return none
        .hash_source:
            if not content_security_policy_source_expression_parser_parse_hash_source(&parser):
                return none
        _:
            trap("VERIFY_NOT_REACHED")

    # If we parsed successfully but didn't reach the end, the string doesn't match the given production.
    if not ak.generic_lexer_is_eof(content_security_policy_source_expression_parser_lexer(&parser)):
        return none

    return *content_security_policy_source_expression_parser_parse_result(&parser)