atmos/os_lib/css/

values.rs

// 分割: css.rs より機械的に移動（2026-07-16 リファクタ フェーズ3）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

/// Replace all `var(--name)` and `var(--name, fallback)` occurrences in a value string.
/// カスタムプロパティが別のカスタムプロパティを参照する間接参照
/// （例: `--a: var(--b); --b: red;` のとき `var(--a)` は `red` に解決される）に対応するため、
/// 1パスの置換結果にまだ `var(` が残っていれば再帰的に解決する。循環参照時に無限再帰へ
/// 陥らないよう、最大再帰深度（8）を設けて打ち切る。
pub fn resolve_css_var(value: &str, vars: &BTreeMap<String, String>) -> String {
    resolve_css_var_depth(value, vars, 0)
}

pub(crate) fn resolve_css_var_depth(value: &str, vars: &BTreeMap<String, String>, depth: u32) -> String {
    if depth >= 8 {
        return String::from(value);
    }
    let mut result = String::new();
    let mut rest = value;
    while let Some(start) = rest.find("var(") {
        result.push_str(rest.get(..start).unwrap_or(""));
        let after = rest.get(start + 4..).unwrap_or("");
        // find matching closing paren
        let mut depth_paren = 1usize;
        let mut end = 0;
        for (i, c) in after.char_indices() {
            match c {
                '(' => depth_paren += 1,
                ')' => {
                    depth_paren -= 1;
                    if depth_paren == 0 {
                        end = i;
                        break;
                    }
                }
                _ => {}
            }
        }
        let inner = after.get(..end).unwrap_or("");
        // split on first comma for fallback
        let (var_name, fallback) = if let Some(comma_pos) = inner.find(',') {
            (
                inner.get(..comma_pos).unwrap_or("").trim(),
                Some(inner.get(comma_pos + 1..).unwrap_or("").trim()),
            )
        } else {
            (inner.trim(), None)
        };
        let resolved = vars
            .get(var_name)
            .cloned()
            .or_else(|| fallback.map(|s| s.to_string()))
            .unwrap_or_default();
        // 参照先の値自体が別の var(...) を含む場合（間接参照）は再帰的に解決する。
        let resolved = if resolved.contains("var(") {
            resolve_css_var_depth(&resolved, vars, depth + 1)
        } else {
            resolved
        };
        result.push_str(&resolved);
        rest = after.get(end + 1..).unwrap_or("");
    }
    result.push_str(rest);
    result
}

/// `env(safe-area-inset-*)`等（CSS Environment Variables）を解決する。
/// この処理系にはノッチ/デバイスセーフエリアという概念自体が存在しない
/// （実機はRaspberry Pi 3B、ヘッドレスQEMU）ため、`var()`のような真の
/// 環境変数テーブルは持たず、既知の`safe-area-inset-*`/
/// `viewport-segment-*`系は常に`"0px"`、フォールバック指定があればそちらを
/// 優先する「正直な既定値ゼロ」として解決する（丸ごと未対応だった。
/// 2026-07-18 発見・実装）。
pub fn resolve_css_env(value: &str) -> String {
    let mut result = String::new();
    let mut rest = value;
    while let Some(start) = rest.find("env(") {
        result.push_str(rest.get(..start).unwrap_or(""));
        let after = rest.get(start + 4..).unwrap_or("");
        let mut depth_paren = 1usize;
        let mut end = 0;
        for (i, c) in after.char_indices() {
            match c {
                '(' => depth_paren += 1,
                ')' => {
                    depth_paren -= 1;
                    if depth_paren == 0 {
                        end = i;
                        break;
                    }
                }
                _ => {}
            }
        }
        let inner = after.get(..end).unwrap_or("");
        let (_env_name, fallback) = if let Some(comma_pos) = inner.find(',') {
            (
                inner.get(..comma_pos).unwrap_or("").trim(),
                Some(inner.get(comma_pos + 1..).unwrap_or("").trim()),
            )
        } else {
            (inner.trim(), None)
        };
        let resolved = fallback.unwrap_or("0px").to_string();
        let resolved = if resolved.contains("env(") {
            resolve_css_env(&resolved)
        } else {
            resolved
        };
        result.push_str(&resolved);
        rest = after.get(end + 1..).unwrap_or("");
    }
    result.push_str(rest);
    result
}

/// `calc()`内の単一トークン（`10px`/`50%`/`2rem`/裸の数値等）をpxへ変換する。
fn parse_calc_unit(s: &str, containing_width: i32) -> Option<f32> {
    parse_calc_unit_with_font(s, containing_width, 16.0)
}

fn parse_calc_unit_with_font(s: &str, containing_width: i32, font_px: f32) -> Option<f32> {
    let s = s.trim();
    if s.is_empty() {
        return None;
    }
    let font = if font_px > 0.0 { font_px } else { 16.0 };
    if let Some(n) = s.strip_suffix("px") {
        return n.trim().parse::<f32>().ok();
    }
    if let Some(n) = s.strip_suffix("vh") {
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * h as f32);
    }
    if let Some(n) = s.strip_suffix("vw") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w as f32);
    }
    if let Some(n) = s.strip_suffix("vmin") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.min(h) as f32);
    }
    if let Some(n) = s.strip_suffix("vmax") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.max(h) as f32);
    }
    if let Some(n) = s.strip_suffix("rem") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = s.strip_suffix("em") {
        return n.trim().parse::<f32>().ok().map(|v| v * font);
    }
    if let Some(n) = s.strip_suffix('%') {
        return n
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| v / 100.0 * containing_width as f32);
    }
    if let Some(n) = s.strip_suffix("in") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0);
    }
    if let Some(n) = s.strip_suffix("cm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 2.54);
    }
    if let Some(n) = s.strip_suffix("mm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 25.4);
    }
    if let Some(n) = s.strip_suffix("pt") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 72.0);
    }
    if let Some(n) = s.strip_suffix("pc") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = s.strip_suffix('q') {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 101.6);
    }
    s.parse::<f32>().ok()
}

/// バイト位置`*pos`以降の空白をスキップする。
fn calc_skip_ws(bytes: &[u8], pos: &mut usize) {
    while *pos < bytes.len() && bytes[*pos] == b' ' {
        *pos += 1;
    }
}

/// `factor := '(' expr ')' | <数値+単位トークン>`。
fn parse_calc_factor(s: &str, pos: &mut usize, containing_width: i32) -> Option<f32> {
    parse_calc_factor_with_font(s, pos, containing_width, 16.0)
}

fn parse_calc_factor_with_font(s: &str, pos: &mut usize, containing_width: i32, font_px: f32) -> Option<f32> {
    let bytes = s.as_bytes();
    calc_skip_ws(bytes, pos);
    if bytes.get(*pos) == Some(&b'(') {
        *pos += 1;
        let start = *pos;
        let mut depth = 1i32;
        while *pos < bytes.len() && depth > 0 {
            match bytes[*pos] {
                b'(' => depth += 1,
                b')' => depth -= 1,
                _ => {}
            }
            *pos += 1;
        }
        if depth != 0 {
            return None;
        }
        let inner = s.get(start..pos.saturating_sub(1)).unwrap_or("");
        return parse_calc_expr_with_font(inner.trim(), containing_width, font_px);
    }
    let start = *pos;
    while *pos < bytes.len() {
        let c = bytes[*pos];
        // 【2026-10-18】`*`・`/` でも区切る（従来は `215px*-1` が 1 語扱いで解析に失敗していた。
        // YouTube の `bottom:calc(var(--controls-height)*-1)`）。
        if c == b' ' || c == b'(' || c == b')' || c == b'*' || c == b'/' {
            break;
        }
        if (c == b'+' || c == b'-') && *pos > start {
            break;
        }
        *pos += 1;
    }
    let token = s.get(start..*pos).unwrap_or("");
    parse_calc_unit_with_font(token, containing_width, font_px)
}

/// `term := factor (('*' | '/') factor)*`。乗除算は加減算より優先度が高い。
fn parse_calc_term(s: &str, pos: &mut usize, containing_width: i32) -> Option<f32> {
    parse_calc_term_with_font(s, pos, containing_width, 16.0)
}

fn parse_calc_term_with_font(s: &str, pos: &mut usize, containing_width: i32, font_px: f32) -> Option<f32> {
    let bytes = s.as_bytes();
    let mut value = parse_calc_factor_with_font(s, pos, containing_width, font_px)?;
    loop {
        calc_skip_ws(bytes, pos);
        match bytes.get(*pos) {
            Some(b'*') => {
                *pos += 1;
                calc_skip_ws(bytes, pos);
                let rhs = parse_calc_factor_with_font(s, pos, containing_width, font_px)?;
                value *= rhs;
            }
            Some(b'/') => {
                *pos += 1;
                calc_skip_ws(bytes, pos);
                let rhs = parse_calc_factor_with_font(s, pos, containing_width, font_px)?;
                if rhs == 0.0 {
                    return None;
                }
                value /= rhs;
            }
            _ => break,
        }
    }
    Some(value)
}

/// `expr := term (('+' | '-') term)*`。任意個数の項を左結合で畳み込む。
fn parse_calc_expr(s: &str, containing_width: i32) -> Option<f32> {
    parse_calc_expr_with_font(s, containing_width, 16.0)
}

fn parse_calc_expr_with_font(s: &str, containing_width: i32, font_px: f32) -> Option<f32> {
    let bytes = s.as_bytes();
    let mut pos = 0usize;
    let mut value = parse_calc_term_with_font(s, &mut pos, containing_width, font_px)?;
    loop {
        calc_skip_ws(bytes, &mut pos);
        match bytes.get(pos) {
            Some(b'+') => {
                pos += 1;
                calc_skip_ws(bytes, &mut pos);
                let rhs = parse_calc_term_with_font(s, &mut pos, containing_width, font_px)?;
                value += rhs;
            }
            Some(b'-') => {
                pos += 1;
                calc_skip_ws(bytes, &mut pos);
                let rhs = parse_calc_term_with_font(s, &mut pos, containing_width, font_px)?;
                value -= rhs;
            }
            _ => break,
        }
    }
    calc_skip_ws(bytes, &mut pos);
    if pos != bytes.len() {
        return None;
    }
    Some(value)
}

/// `calc()`式をpxへ評価する。四則演算・任意個数の項・丸括弧によるネストに対応する。
pub fn eval_calc(expr: &str, containing_width: i32) -> Option<i32> {
    eval_calc_with_font(expr, containing_width, 16.0)
}

/// 要素のフォントサイズ（`font_px`）を考慮して `calc()` 式を px へ評価する。
pub fn eval_calc_with_font(expr: &str, containing_width: i32, font_px: f32) -> Option<i32> {
    let inner = expr.trim();
    let inner = inner
        .strip_prefix("calc(")
        .and_then(|s| s.strip_suffix(')'))?;
    parse_calc_expr_with_font(inner.trim(), containing_width, font_px).map(|v| v as i32)
}

/// `min()` / `max()` / `clamp()` の引数を最上位のカンマだけで分割する。
/// 引数内に `calc()`/`min()`/`max()`/`clamp()` がネストしていても、その内側の
/// カンマは分割対象にしない（括弧の深さを追跡する）。
pub(crate) fn split_top_level_commas(s: &str) -> alloc::vec::Vec<&str> {
    let mut parts = alloc::vec::Vec::new();
    let bytes = s.as_bytes();
    let mut depth = 0i32;
    let mut start = 0usize;
    for (i, &b) in bytes.iter().enumerate() {
        match b {
            b'(' => depth += 1,
            b')' => depth -= 1,
            b',' if depth == 0 => {
                parts.push(s.get(start..i).unwrap_or("").trim());
                start = i + 1;
            }
            _ => {}
        }
    }
    parts.push(s.get(start..).unwrap_or("").trim());
    parts
}

/// 単一の `name: value` 宣言（`!important` 込み）をパースする。
/// 空の name/value や区切りの `:` が無い場合は `None`。
pub(crate) fn parse_one_declaration(raw: &str) -> Option<Declaration> {
    let mut kv = raw.splitn(2, ':');
    let name = kv.next()?.trim();
    let raw_value = kv.next()?.trim();
    let (value, important) = match raw_value.rfind('!') {
        Some(pos)
            if raw_value
                .get(pos + 1..)
                .unwrap_or("")
                .trim()
                .eq_ignore_ascii_case("important") =>
        {
            (raw_value.get(..pos).unwrap_or("").trim(), true)
        }
        _ => (raw_value, false),
    };
    if name.is_empty() || value.is_empty() {
        return None;
    }
    Some(Declaration {
        name: String::from(name),
        value: String::from(value),
        important,
    })
}

/// CSS Nesting のルール本体をパースする。トップレベル（このネストの深さ）の `;` で
/// 宣言を区切り、トップレベルの `{` はネストしたルールの開始とみなして対応する `}`
/// までを取り出し再帰する。ネストしたセレクタの各カンマ枝は、`&` を含めば親セレクタの
/// テキストで置換し、含まなければ親セレクタの後ろに半角スペースで連結する（子孫結合子
/// 扱い）。戻り値はこのレベル自身の宣言一覧（ネストしたルールは `out_rules` に積む）。
pub(crate) fn parse_nested_body(
    parent_selector_texts: &[String],
    body: &str,
    out_rules: &mut Vec<Rule>,
    layer: Option<usize>,
) -> Vec<Declaration> {
    let mut declarations = Vec::new();
    let chars: Vec<char> = body.chars().collect();
    let mut i = 0usize;
    let mut buf = String::new();
    while i < chars.len() {
        match chars[i] {
            '{' => {
                let nested_selector_text = buf.trim().to_string();
                buf.clear();
                // 対応する `}` を探す（ネストの深さを追跡）。
                let mut depth = 1i32;
                let start = i + 1;
                let mut j = start;
                while j < chars.len() && depth > 0 {
                    match chars[j] {
                        '{' => depth += 1,
                        '}' => depth -= 1,
                        _ => {}
                    }
                    if depth > 0 {
                        j += 1;
                    }
                }
                let inner_body: String = chars[start..j.min(chars.len())].iter().collect();
                i = j;
                if !nested_selector_text.is_empty() {
                    let mut resolved_texts: Vec<String> = Vec::new();
                    for nb in split_top_level_commas(&nested_selector_text) {
                        let nb = nb.trim();
                        if nb.is_empty() {
                            continue;
                        }
                        for parent in parent_selector_texts {
                            let resolved = if nb.contains('&') {
                                nb.replace('&', parent)
                            } else {
                                alloc::format!("{} {}", parent, nb)
                            };
                            resolved_texts.push(resolved);
                        }
                    }
                    let nested_selectors: Vec<Selector> = resolved_texts
                        .iter()
                        .filter_map(|s| parse_selector(s.trim()))
                        .collect();
                    let nested_decls =
                        parse_nested_body(&resolved_texts, &inner_body, out_rules, layer);
                    if !nested_selectors.is_empty() && !nested_decls.is_empty() {
                        out_rules.push(Rule {
                            selectors: nested_selectors,
                            declarations: nested_decls,
                            layer,
                            media_query: None,
                            container_query: None,
                        });
                    }
                }
            }
            ';' => {
                if let Some(d) = parse_one_declaration(&buf) {
                    declarations.push(d);
                }
                buf.clear();
            }
            c => buf.push(c),
        }
        i += 1;
    }
    // 末尾の `;` は省略可能なので、残った buf も最後の宣言として扱う。
    if let Some(d) = parse_one_declaration(&buf) {
        declarations.push(d);
    }
    declarations
}

/// 単一の長さ値（`10px` / `50%` / `calc(...)` など、四則演算を含まない1トークン、
/// もしくは `calc()`/`min()`/`max()`/`clamp()` の再帰評価）を px へ解決する。
pub(crate) fn eval_length_token(s: &str, containing_width: i32) -> Option<f32> {
    eval_length_token_with_font(s, containing_width, 16.0)
}

pub(crate) fn eval_length_token_with_font(s: &str, containing_width: i32, font_px: f32) -> Option<f32> {
    let t = s.trim();
    if t.starts_with("calc(") || t.starts_with("min(") || t.starts_with("max(") || t.starts_with("clamp(")
        || t.starts_with("abs(") || t.starts_with("sign(") || t.starts_with("round(")
        || t.starts_with("mod(") || t.starts_with("rem(")
    {
        return eval_css_math_with_font(t, containing_width, font_px).map(|v| v as f32);
    }
    let font = if font_px > 0.0 { font_px } else { 16.0 };
    if let Some(n) = t.strip_suffix("px") {
        return n.trim().parse::<f32>().ok();
    }
    if let Some(n) = t.strip_suffix("vh") {
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * h as f32);
    }
    if let Some(n) = t.strip_suffix("vw") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w as f32);
    }
    if let Some(n) = t.strip_suffix("vmin") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.min(h) as f32);
    }
    if let Some(n) = t.strip_suffix("vmax") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.max(h) as f32);
    }
    if let Some(n) = t.strip_suffix("rem") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = t.strip_suffix("em") {
        return n.trim().parse::<f32>().ok().map(|v| v * font);
    }
    if let Some(n) = t.strip_suffix('%') {
        return n
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| v / 100.0 * containing_width as f32);
    }
    if let Some(n) = t.strip_suffix("in") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0);
    }
    if let Some(n) = t.strip_suffix("cm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 2.54);
    }
    if let Some(n) = t.strip_suffix("mm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 25.4);
    }
    if let Some(n) = t.strip_suffix("pt") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 72.0);
    }
    if let Some(n) = t.strip_suffix("pc") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = t.strip_suffix('q') {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 101.6);
    }
    t.parse::<f32>().ok()
}

/// CSS の数式関数（`calc()` / `min()` / `max()` / `clamp()` / `abs()` / `sign()` / `round()` / `mod()` / `rem()`）を px へ評価する。
pub fn eval_css_math(expr: &str, containing_width: i32) -> Option<i32> {
    eval_css_math_with_font(expr, containing_width, 16.0)
}

/// 要素のフォントサイズ（`font_px`）を考慮して CSS 数式関数を px へ評価する。
pub fn eval_css_math_with_font(expr: &str, containing_width: i32, font_px: f32) -> Option<i32> {
    let t = expr.trim();
    if t.starts_with("calc(") {
        return eval_calc_with_font(t, containing_width, font_px);
    }
    if let Some(inner) = t.strip_prefix("min(").and_then(|s| s.strip_suffix(')')) {
        let vals: alloc::vec::Vec<f32> = split_top_level_commas(inner)
            .iter()
            .filter_map(|a| eval_length_token_with_font(a, containing_width, font_px))
            .collect();
        return vals
            .into_iter()
            .fold(None, |acc, v| Some(acc.map_or(v, |m: f32| m.min(v))))
            .map(|v| v as i32);
    }
    if let Some(inner) = t.strip_prefix("max(").and_then(|s| s.strip_suffix(')')) {
        let vals: alloc::vec::Vec<f32> = split_top_level_commas(inner)
            .iter()
            .filter_map(|a| eval_length_token_with_font(a, containing_width, font_px))
            .collect();
        return vals
            .into_iter()
            .fold(None, |acc, v| Some(acc.map_or(v, |m: f32| m.max(v))))
            .map(|v| v as i32);
    }
    if let Some(inner) = t.strip_prefix("clamp(").and_then(|s| s.strip_suffix(')')) {
        let parts = split_top_level_commas(inner);
        if parts.len() != 3 {
            return None;
        }
        let min_v = eval_length_token_with_font(parts[0], containing_width, font_px)?;
        let pref_v = eval_length_token_with_font(parts[1], containing_width, font_px)?;
        let max_v = eval_length_token_with_font(parts[2], containing_width, font_px)?;
        let effective_max = max_v.max(min_v);
        return Some(pref_v.clamp(min_v, effective_max) as i32);
    }
    // W3C CSS Values and Units Level 4 数学関数
    if let Some(inner) = t.strip_prefix("abs(").and_then(|s| s.strip_suffix(')')) {
        let v = eval_length_token_with_font(inner.trim(), containing_width, font_px)?;
        return Some(v.abs() as i32);
    }
    if let Some(inner) = t.strip_prefix("sign(").and_then(|s| s.strip_suffix(')')) {
        let v = eval_length_token_with_font(inner.trim(), containing_width, font_px)?;
        if v > 0.0 {
            return Some(1);
        } else if v < 0.0 {
            return Some(-1);
        } else {
            return Some(0);
        }
    }
    if let Some(inner) = t.strip_prefix("round(").and_then(|s| s.strip_suffix(')')) {
        let parts = split_top_level_commas(inner);
        let (strategy, val_tok, step_tok) = match parts.len() {
            1 => ("nearest", parts[0], "1px"),
            2 => {
                let p0 = parts[0].trim().to_ascii_lowercase();
                if p0 == "up" || p0 == "down" || p0 == "nearest" || p0 == "to-zero" {
                    (parts[0].trim(), parts[1], "1px")
                } else {
                    ("nearest", parts[0], parts[1])
                }
            }
            3 => (parts[0].trim(), parts[1], parts[2]),
            _ => return None,
        };
        let val = eval_length_token_with_font(val_tok, containing_width, font_px)?;
        let step = eval_length_token_with_font(step_tok, containing_width, font_px)?.abs();
        if step == 0.0 {
            return Some(val as i32);
        }
        let rounded = match strategy.to_ascii_lowercase().as_str() {
            "up" => libm::ceilf(val / step) * step,
            "down" => libm::floorf(val / step) * step,
            "to-zero" => libm::truncf(val / step) * step,
            _ => libm::roundf(val / step) * step,
        };
        return Some(rounded as i32);
    }
    if let Some(inner) = t.strip_prefix("mod(").and_then(|s| s.strip_suffix(')')) {
        let parts = split_top_level_commas(inner);
        if parts.len() != 2 {
            return None;
        }
        let a = eval_length_token_with_font(parts[0], containing_width, font_px)?;
        let b = eval_length_token_with_font(parts[1], containing_width, font_px)?;
        if b == 0.0 {
            return None;
        }
        let m = (a % b + b) % b;
        return Some(m as i32);
    }
    if let Some(inner) = t.strip_prefix("rem(").and_then(|s| s.strip_suffix(')')) {
        let parts = split_top_level_commas(inner);
        if parts.len() != 2 {
            return None;
        }
        let a = eval_length_token_with_font(parts[0], containing_width, font_px)?;
        let b = eval_length_token_with_font(parts[1], containing_width, font_px)?;
        if b == 0.0 {
            return None;
        }
        return Some((a % b) as i32);
    }
    None
}

// 簡易CSSパーサ（tag / #id / .class と宣言ブロックをサポート）