Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / counter_style_definition.lucb

#==============================================================================================
#
#   counter_style_definition - CounterStyleDefinition: an @counter-style rule's descriptors,
#   resolved
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/CounterStyleDefinition.cpp (lines 1-243) and the inline members of
#       CounterStyleDefinition.h, in the order of the .cpp with the header's accessors after
#       from_counter_style_rule. The variant visits are matches.
#
#       Copyright (c) 2026, Callum Law <callumlaw1709@outlook.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: AutoRange ===============================================================================

## One `{ start, end }` range as a one-entry Vector.
func css_counter_style_single_range(start: i32, end: i32) -> ak.Vector[CssCounterStyleRangeEntry]:
    var ranges = ak.Vector[CssCounterStyleRangeEntry]()
    ak.vector_append_t(&ranges, CssCounterStyleRangeEntry(start = start, end = end))
    return ranges

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:16 Web::CSS::AutoRange::resolve.
# https://drafts.csswg.org/css-counter-styles-3/#valdef-counter-style-range-auto
pub func css_auto_range_resolve(algorithm: CssCounterStyleAlgorithm) -> ak.Vector[CssCounterStyleRangeEntry]:
    # The range depends on the counter system:
    match algorithm:
        .css_additive_counter_style_algorithm(_):
            # For additive systems, the range is 0 to positive infinity.
            return css_counter_style_single_range(0, 2147483647)
        .css_fixed_counter_style_algorithm(_):
            # For cyclic, numeric, and fixed systems, the range is negative infinity to positive infinity.
            # NB: cyclic and numeric are handled below.
            return css_counter_style_single_range(-2147483648, 2147483647)
        .css_generic_counter_style_algorithm(generic_algorithm):
            match generic_algorithm.type_:
                .cyclic, .numeric:
                    # For cyclic, numeric, and fixed systems, the range is negative infinity to positive infinity.
                    # NB: Fixed is handled above.
                    return css_counter_style_single_range(-2147483648, 2147483647)
                .alphabetic, .symbolic:
                    # For alphabetic and symbolic systems, the range is 1 to positive infinity.
                    return css_counter_style_single_range(1, 2147483647)
                .additive:
                    # NB: Additive is handled above.
                    trap("VERIFY_NOT_REACHED")
                _: trap("VERIFY_NOT_REACHED")
        .css_ethiopic_numeric_counter_style_algorithm(_):
            # NB: All complex predefined counter styles define their range explicitly (i.e. not via auto)
            trap("VERIFY_NOT_REACHED")
        .css_extended_cjk_counter_style_algorithm(_):
            # NB: All complex predefined counter styles define their range explicitly (i.e. not via auto)
            trap("VERIFY_NOT_REACHED")

# mark: CounterStyleDefinition ==================================================================

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:97 Web::CSS::CounterStyleDefinition::create.
pub func css_counter_style_definition_create(name: ak.FlyString, algorithm: CssCounterStyleAlgorithmOrExtends, negative_sign: CssCounterStyleNegativeSign?, prefix: ak.FlyString?, suffix: ak.FlyString?, range: EmptyOrCssAutoRangeOrVectorCssCounterStyleRangeEntry, fallback: ak.FlyString?, pad_: CssCounterStylePad?) -> CssCounterStyleDefinition:
    var definition: CssCounterStyleDefinition = ---
    css_counter_style_definition_construct(&definition, name, algorithm, negative_sign, prefix, suffix, range, fallback, pad_)
    return definition

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:56 Web::CSS::CounterStyleDefinition::from_counter_style_rule.
pub func css_counter_style_definition_from_counter_style_rule(rule: CssCounterStyleRule*, computation_context: CssComputationContext) -> CssCounterStyleDefinition?:
    let system_style_value = css_counter_style_rule_system_style_value(rule) else css_counter_style_system_style_value_create(css_data.CounterStyleSystem.symbolic)
    let maybe_algorithm = css_counter_style_definition_resolve_algorithm(system_style_value, css_counter_style_rule_symbols_style_value(rule), css_counter_style_rule_additive_symbols_style_value(rule), computation_context)
    # maybe_algorithm.downcast<CounterStyleAlgorithm, CounterStyleSystemStyleValue::Extends>()
    var algorithm: CssCounterStyleAlgorithmOrExtends = ---
    match maybe_algorithm:
        .empty: return none
        .css_counter_style_algorithm(value): algorithm = .css_counter_style_algorithm(value)
        .css_counter_style_system_style_value_extends(value): algorithm = .css_counter_style_system_style_value_extends(value)

    var negative_sign: CssCounterStyleNegativeSign? = none
    if let negative_style_value = css_counter_style_rule_negative_style_value(rule):
        negative_sign = css_counter_style_definition_resolve_negative_sign(negative_style_value)
    var prefix: ak.FlyString? = none
    if let prefix_style_value = css_counter_style_rule_prefix_style_value(rule):
        prefix = css_string_from_style_value(prefix_style_value)
    var suffix: ak.FlyString? = none
    if let suffix_style_value = css_counter_style_rule_suffix_style_value(rule):
        suffix = css_string_from_style_value(suffix_style_value)
    var range = EmptyOrCssAutoRangeOrVectorCssCounterStyleRangeEntry.empty
    if let range_style_value = css_counter_style_rule_range_style_value(rule):
        range = match css_counter_style_definition_resolve_range(range_style_value, computation_context):
            .css_auto_range(value) => .css_auto_range(value)
            .vector_css_counter_style_range_entry(value) => .vector_css_counter_style_range_entry(value)
    var fallback: ak.FlyString? = none
    if let fallback_style_value = css_counter_style_rule_fallback_style_value(rule):
        fallback = css_string_from_style_value(fallback_style_value)
    var pad_: CssCounterStylePad? = none
    if let pad_style_value = css_counter_style_rule_pad_style_value(rule):
        pad_ = css_counter_style_definition_resolve_pad(pad_style_value, computation_context)

    return css_counter_style_definition_create(css_counter_style_rule_name(rule), algorithm, negative_sign, prefix, suffix, range, fallback, pad_)

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:104 Web::CSS::CounterStyleDefinition::name.
pub func css_counter_style_definition_name(this: const CssCounterStyleDefinition*) -> ak.FlyString:
    return this.m_name

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:106 Web::CSS::CounterStyleDefinition::algorithm.
pub func css_counter_style_definition_algorithm(this: const CssCounterStyleDefinition*) -> CssCounterStyleAlgorithmOrExtends:
    return this.m_algorithm

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:107 Web::CSS::CounterStyleDefinition::set_algorithm.
pub func css_counter_style_definition_set_algorithm(this: CssCounterStyleDefinition*, algorithm: CssCounterStyleAlgorithmOrExtends):
    this.m_algorithm = algorithm

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:109 Web::CSS::CounterStyleDefinition::negative_sign.
pub func css_counter_style_definition_negative_sign(this: const CssCounterStyleDefinition*) -> CssCounterStyleNegativeSign?:
    return this.m_negative_sign

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:111 Web::CSS::CounterStyleDefinition::prefix.
pub func css_counter_style_definition_prefix(this: const CssCounterStyleDefinition*) -> ak.FlyString?:
    return this.m_prefix

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:113 Web::CSS::CounterStyleDefinition::suffix.
pub func css_counter_style_definition_suffix(this: const CssCounterStyleDefinition*) -> ak.FlyString?:
    return this.m_suffix

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:115 Web::CSS::CounterStyleDefinition::range.
pub func css_counter_style_definition_range(this: const CssCounterStyleDefinition*) -> EmptyOrCssAutoRangeOrVectorCssCounterStyleRangeEntry:
    return this.m_range

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:117 Web::CSS::CounterStyleDefinition::fallback.
pub func css_counter_style_definition_fallback(this: const CssCounterStyleDefinition*) -> ak.FlyString?:
    return this.m_fallback

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:119 Web::CSS::CounterStyleDefinition::pad.
pub func css_counter_style_definition_pad(this: const CssCounterStyleDefinition*) -> CssCounterStylePad?:
    return this.m_pad

# mark: Resolving the descriptors ===============================================================

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:77 Web::CSS::CounterStyleDefinition::resolve_algorithm.
# https://drafts.csswg.org/css-counter-styles-3/#counter-style-system
func css_counter_style_definition_resolve_algorithm(system_style_value: CssStyleValue*, symbols_style_value: CssStyleValue*?, additive_symbols_style_value: CssStyleValue*?, computation_context: CssComputationContext) -> EmptyOrCssCounterStyleAlgorithmOrCssCounterStyleSystemStyleValueExtends:
    # https://drafts.csswg.org/css-counter-styles-3/#counter-style-symbols
    # The @counter-style rule must have a valid symbols descriptor if the counter system is cyclic,
    # numeric, alphabetic, symbolic, or fixed, or a valid additive-symbols descriptor if the counter system
    # is additive; otherwise, the @counter-style does not define a counter style (but is still a valid
    # at-rule).
    let counter_style_system = css_style_value_as_counter_style_system(system_style_value)
    match css_counter_style_system_style_value_value(counter_style_system):
        .counter_style_system(system):
            match system:
                .cyclic, .alphabetic, .symbolic, .numeric:
                    let symbols = symbols_style_value else return .empty
                    let parsed_symbols = css_counter_style_definition_resolve_symbols(symbols)
                    if not css_counter_style_system_style_value_is_valid_symbol_count(counter_style_system, ak.vector_size(&parsed_symbols)):
                        return .empty
                    return .css_counter_style_algorithm(.css_generic_counter_style_algorithm(CssGenericCounterStyleAlgorithm(
                        type_ = system,
                        symbol_list = parsed_symbols,
                    )))
                .additive:
                    let additive_symbols = additive_symbols_style_value else return .empty
                    let additive_tuples = css_counter_style_definition_resolve_additive_symbols(additive_symbols, computation_context)
                    if not css_counter_style_system_style_value_is_valid_additive_symbol_count(counter_style_system, ak.vector_size(&additive_tuples)):
                        return .empty
                    return .css_counter_style_algorithm(.css_additive_counter_style_algorithm(CssAdditiveCounterStyleAlgorithm(symbol_list = additive_tuples)))
                _: trap("VERIFY_NOT_REACHED")
        .css_counter_style_system_style_value_fixed(fixed):
            let symbols = symbols_style_value else return .empty
            let parsed_symbols = css_counter_style_definition_resolve_symbols(symbols)
            if not css_counter_style_system_style_value_is_valid_symbol_count(counter_style_system, ak.vector_size(&parsed_symbols)):
                return .empty

            # https://drafts.csswg.org/css-counter-styles-3/#fixed-system
            # If it is omitted, the first symbol value is 1.
            var first_symbol: i32 = 1
            if let first_symbol_value = fixed.first_symbol:
                first_symbol = css_int_from_style_value(css_style_value_absolutized(first_symbol_value, computation_context))

            return .css_counter_style_algorithm(.css_fixed_counter_style_algorithm(CssFixedCounterStyleAlgorithm(
                first_symbol = first_symbol,
                symbol_list = parsed_symbols,
            )))
        .css_counter_style_system_style_value_extends(extends):
            return .css_counter_style_system_style_value_extends(extends)

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:150 Web::CSS::CounterStyleDefinition::resolve_symbols.
# https://drafts.csswg.org/css-counter-styles-3/#descdef-counter-style-symbols
func css_counter_style_definition_resolve_symbols(symbols_style_value: CssStyleValue*) -> ak.Vector[ak.FlyString]:
    let entries = css_style_value_list_values(css_style_value_as_value_list(symbols_style_value))
    var symbols = ak.Vector[ak.FlyString]()
    ak.vector_ensure_capacity(&symbols, ak.vector_size(&entries))
    for entry in ak.vector_span_const(&entries):
        ak.vector_append_t(&symbols, css_string_from_style_value(entry))
    return symbols

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:164 Web::CSS::CounterStyleDefinition::resolve_additive_symbols.
# https://drafts.csswg.org/css-counter-styles-3/#descdef-counter-style-additive-symbols
func css_counter_style_definition_resolve_additive_symbols(additive_symbols_style_value: CssStyleValue*, computation_context: CssComputationContext) -> ak.Vector[CssAdditiveCounterStyleAlgorithmAdditiveTuple]:
    let entries = css_style_value_list_values(css_style_value_as_value_list(additive_symbols_style_value))
    var additive_tuples = ak.Vector[CssAdditiveCounterStyleAlgorithmAdditiveTuple]()
    ak.vector_ensure_capacity(&additive_tuples, ak.vector_size(&entries))
    for entry in ak.vector_span_const(&entries):
        let tuple = css_style_value_list_values(css_style_value_as_value_list(entry))
        assert(ak.vector_size(&tuple) == 2)
        let weight = ak.clamp_to_i32_i32(css_int_from_style_value(css_style_value_absolutized(*ak.vector_at_const(&tuple, 0), computation_context)))
        let symbol = css_string_from_style_value(*ak.vector_at_const(&tuple, 1))
        ak.vector_append_t(&additive_tuples, CssAdditiveCounterStyleAlgorithmAdditiveTuple(weight = weight, symbol = symbol))
    return additive_tuples

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:185 Web::CSS::CounterStyleDefinition::resolve_negative_sign.
# https://drafts.csswg.org/css-counter-styles-3/#counter-style-negative
func css_counter_style_definition_resolve_negative_sign(style_value: CssStyleValue*) -> CssCounterStyleNegativeSign:
    let negative_entries = css_style_value_list_values(css_style_value_as_value_list(style_value))
    return CssCounterStyleNegativeSign(
        prefix = css_string_from_style_value(*ak.vector_at_const(&negative_entries, 0)),
        suffix = css_string_from_style_value(*ak.vector_at_const(&negative_entries, 1)) if ak.vector_size(&negative_entries) > 1 else ak.fly_string_from_str(""),
    )

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:196 Web::CSS::CounterStyleDefinition::resolve_range.
# https://drafts.csswg.org/css-counter-styles-3/#counter-style-range
func css_counter_style_definition_resolve_range(style_value: CssStyleValue*, computation_context: CssComputationContext) -> CssAutoRangeOrVectorCssCounterStyleRangeEntry:
    # auto
    # NB: Resolving auto depends on the algorithm, which we may not know at parse time i.e. if the system is 'extends'
    #     To handle this we return an intermediate value which we resolve when creating the CounterStyle.
    if css_style_value_has_auto(style_value):
        return .css_auto_range(CssAutoRange())

    # [ [ <integer> | infinite ]{2} ]#
    # This defines a comma-separated list of ranges. For each individual range, the first value is the lower bound and
    # the second value is the upper bound. This range is inclusive - it contains both the lower and upper bound
    # numbers. If infinite is used as the first value in a range, it represents negative infinity; if used as the
    # second value, it represents positive infinity. The range of the counter style is the union of all the ranges
    # defined in the list.
    let range_entries = css_style_value_list_values(css_style_value_as_value_list(style_value))
    var ranges = ak.Vector[CssCounterStyleRangeEntry]()
    ak.vector_ensure_capacity(&ranges, ak.vector_size(&range_entries))
    for entry in ak.vector_span_const(&range_entries):
        let range_values = css_style_value_list_values(css_style_value_as_value_list(entry))
        assert(ak.vector_size(&range_values) == 2)
        let start = css_counter_style_definition_resolve_range_value(*ak.vector_at_const(&range_values, 0), -2147483648, computation_context)
        let end = css_counter_style_definition_resolve_range_value(*ak.vector_at_const(&range_values, 1), 2147483647, computation_context)
        ak.vector_append_t(&ranges, CssCounterStyleRangeEntry(start = start, end = end))
    return .vector_css_counter_style_range_entry(ranges)

## resolve_range's lambda `resolve_value`: `infinite` is the given infinite value, an integer its value.
func css_counter_style_definition_resolve_range_value(value: CssStyleValue*, infinite_value: i32, computation_context: CssComputationContext) -> i32:
    if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.infinite:
        return infinite_value
    return css_int_from_style_value(css_style_value_absolutized(value, computation_context))

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.cpp:233 Web::CSS::CounterStyleDefinition::resolve_pad.
# https://drafts.csswg.org/css-counter-styles-3/#counter-style-pad
func css_counter_style_definition_resolve_pad(style_value: CssStyleValue*, computation_context: CssComputationContext) -> CssCounterStylePad:
    let pad_entries = css_style_value_list_values(css_style_value_as_value_list(style_value))
    return CssCounterStylePad(
        minimum_length = ak.clamp_to_i32_i32(css_int_from_style_value(css_style_value_absolutized(*ak.vector_at_const(&pad_entries, 0), computation_context))),
        symbol = css_string_from_style_value(*ak.vector_at_const(&pad_entries, 1)),
    )

## Ported from Libraries/LibWeb/CSS/CounterStyleDefinition.h:129 Web::CSS::CounterStyleDefinition::CounterStyleDefinition.
pub func css_counter_style_definition_construct(this: CssCounterStyleDefinition*, name: ak.FlyString, algorithm: CssCounterStyleAlgorithmOrExtends, negative_sign: CssCounterStyleNegativeSign?, prefix: ak.FlyString?, suffix: ak.FlyString?, range: EmptyOrCssAutoRangeOrVectorCssCounterStyleRangeEntry, fallback: ak.FlyString?, pad_: CssCounterStylePad?):
    this.m_name = name
    this.m_algorithm = algorithm
    this.m_negative_sign = negative_sign
    this.m_prefix = prefix
    this.m_suffix = suffix
    this.m_range = range
    this.m_fallback = fallback
    this.m_pad = pad_