tsv_css 0.8.0

CSS formatter and parser compatible with Svelte's parseCss — part of tsv
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use super::parser::ValueParser;
use crate::ast::CssValue;
use bumpalo::Bump;
use bumpalo::collections::Vec as BumpVec;
use tsv_lang::Span;

/// Parse function arguments as comma-separated values
///
/// Uses ValueParser for accurate span tracking through same-source recursion.
/// This ensures nested function arguments maintain correct byte positions.
///
/// # Arguments
/// * `args_str` - The function arguments string (e.g., "90deg, red 01%, blue 02%")
/// * `parent_span` - The span of the arguments in the full CSS document
///
/// # Returns
/// Arena-allocated slice of parsed argument values
pub(crate) fn parse_function_arguments<'arena>(
    args_str: &str,
    parent_span: Span,
    arena: &'arena Bump,
) -> &'arena [CssValue<'arena>] {
    // Strip leading whitespace by offset, then trailing on the remaining slice — one
    // boundary scan per side (vs a `.trim()` plus a separate `.trim_start()`/`.trim_end()`
    // recomputing the same two boundaries). The trailing trim stops at an escaped
    // whitespace (`var(--a, 50px\ )`), which would otherwise strand the backslash onto
    // the closing `)` — see `trim_end_preserving_escape`.
    let trim_start_offset = args_str.len() - crate::escapes::trim_start_css(args_str).len();
    let trimmed = crate::escapes::trim_end_preserving_escape(&args_str[trim_start_offset..]);

    if trimmed.is_empty() {
        return &[];
    }

    // Calculate adjusted span for trimmed args (same logic as parse_value_from_source)
    let trim_end_offset = args_str.len() - trim_start_offset - trimmed.len();
    let adjusted_span = Span {
        start: parent_span.start + trim_start_offset as u32,
        end: parent_span.end - trim_end_offset as u32,
    };

    // A function's argument list IS a group, which is what lets a `:` inside it be an
    // operator (`f(a: 1.5)`) where the same byte at a declaration's top level is not.
    let parser = ValueParser::new_within(trimmed, adjusted_span, true);
    let value = parser.parse(arena);

    // Function arguments are comma-separated, so we expect CommaSeparated
    // But if there's only one argument, it might be a single value
    match value {
        // Already an arena slice — return it directly (zero copy)
        CssValue::CommaSeparated { values, .. } => values,
        single => {
            let mut v = BumpVec::new_in(arena);
            v.push(single);
            v.into_bump_slice()
        }
    }
}