atmos/os_lib/css/

shorthand.rs

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

pub(crate) fn parse_border_shorthand(s: &str) -> (Option<String>, Option<String>, Option<String>) {
    let mut width = None;
    let mut style = None;
    let mut color = None;

    for token in s.split_whitespace() {
        let t = token.trim();
        if t.is_empty() {
            continue;
        }
        let t_lower = t.to_lowercase();

        // 1. スタイルの判定。`BorderStyle` enum は None/Solid/Dashed/Dotted/Double の
        // 5種のみ対応（groove/ridge/inset/outset の立体的な描画は非対応）なので、
        // それらのキーワードは意味的に近い値へ縮退させる: `hidden`→`none`（描画上等価）、
        // `groove`/`ridge`/`inset`/`outset`→`solid`（何もマッチせず境界線ごと消えてしまう
        // よりは、実線として見える方が実害が小さいという判断）。
        if matches!(
            t_lower.as_str(),
            "none" | "solid" | "dashed" | "dotted" | "double"
        ) {
            style = Some(t_lower);
            continue;
        }
        if t_lower == "hidden" {
            style = Some(String::from("none"));
            continue;
        }
        if matches!(t_lower.as_str(), "groove" | "ridge" | "inset" | "outset") {
            style = Some(String::from("solid"));
            continue;
        }

        // 2. 幅の判定
        if t_lower.ends_with("px")
            || t_lower.parse::<f32>().is_ok()
            || t_lower == "thin"
            || t_lower == "medium"
            || t_lower == "thick"
        {
            let val = match t_lower.as_str() {
                "thin" => String::from("1px"),
                "medium" => String::from("3px"),
                "thick" => String::from("5px"),
                _ => t_lower,
            };
            width = Some(val);
            continue;
        }

        // 3. 色の判定
        if t_lower.starts_with('#') || t_lower.starts_with("rgb") || parse_color(&t_lower).is_some()
        {
            color = Some(t_lower);
            continue;
        }
    }

    (width, style, color)
}

/// CSS-wide keywords（`initial`/`inherit`/`unset`/`revert`）を持つプロパティを
/// specified_values から取り除く。取り除いた後の挙動:
/// - 継承プロパティ（`INHERITED_PROPS`）: 呼び出し側の継承伝搬処理（
///   `if !specified_values.contains_key(k)`）が自然に親の値で埋めるため、
///   `inherit`/`unset` の意味的にも正しい結果になる。
/// - 非継承プロパティ: 親の全プロパティを参照する仕組みがこの処理系には無いため、
///   `inherit` を厳密には解決できず「未指定（＝各所のデフォルト値）」へフォールバックする
///   簡略実装（`initial`/`revert` も同様に扱う）。値を素通りさせて壊れた文字列
///   （例: `color:inherit` がそのまま色として解釈されようとして失敗する）を残すよりは
///   安全という判断。
pub(crate) fn strip_css_wide_keywords(specified_values: &mut BTreeMap<String, String>) {
    let keys_to_remove: alloc::vec::Vec<String> = specified_values
        .iter()
        .filter(|(_, v)| {
            matches!(
                v.trim().to_ascii_lowercase().as_str(),
                "initial" | "inherit" | "unset" | "revert"
            )
        })
        .map(|(k, _)| k.clone())
        .collect();
    for k in keys_to_remove {
        specified_values.remove(&k);
    }
}

/// `all: unset/initial/revert`（すべてのプロパティを一括リセットするショートハンド）を解決する。
/// **簡略化**: 本来はカスケードの中で `all` より後に書かれた個別プロパティだけが生き残るが、
/// この処理系はプロパティ名ごとに独立してカスケード解決した後の `specified_values` しか
/// 見えないため、そこまで厳密な順序判定はできない。実用上ほとんどの利用パターン
/// （`.reset{all:unset}` のように単独で使う）をカバーする近似として、`all` が
/// CSS-wide keyword なら、カスタムプロパティ（`--` 始まり）と `all` 自身を除く
/// 全プロパティを削除する。
pub(crate) fn resolve_all_shorthand(specified_values: &mut BTreeMap<String, String>) {
    let is_reset = specified_values
        .get("all")
        .map(|v| {
            matches!(
                v.trim().to_ascii_lowercase().as_str(),
                "unset" | "initial" | "revert"
            )
        })
        .unwrap_or(false);
    if !is_reset {
        return;
    }
    let keys_to_remove: alloc::vec::Vec<String> = specified_values
        .keys()
        .filter(|k| *k != "all" && !k.starts_with("--"))
        .cloned()
        .collect();
    for k in keys_to_remove {
        specified_values.remove(&k);
    }
    specified_values.remove("all");
}

/// `margin-block`/`margin-inline`/`padding-block`/`padding-inline`/`inset-block`/
/// `inset-inline`（1〜2値。1番目が start、2番目（省略時は1番目と同値）が end）を
/// `-start`/`-end` の longhand へ展開する。既に longhand 側が個別指定されていれば
/// そちらを優先し、shorthand 側は無視する（`resolve_logical_properties` の
/// 「物理プロパティが既にあれば論理プロパティを無視する」規則と同じ優先順位の考え方）。
pub(crate) fn expand_logical_box_shorthands(specified_values: &mut BTreeMap<String, String>) {
    for prefix in ["margin", "padding", "inset"] {
        for axis in ["block", "inline"] {
            let shorthand = alloc::format!("{prefix}-{axis}");
            let start_prop = alloc::format!("{prefix}-{axis}-start");
            let end_prop = alloc::format!("{prefix}-{axis}-end");
            if let Some(v) = specified_values.get(&shorthand).cloned() {
                let toks: Vec<&str> = v.split_whitespace().collect();
                if let Some(&start) = toks.first() {
                    let end = toks.get(1).copied().unwrap_or(start);
                    specified_values.entry(start_prop).or_insert_with(|| String::from(start));
                    specified_values.entry(end_prop).or_insert_with(|| String::from(end));
                }
            }
        }
    }
}

/// CSS 論理プロパティ（`margin-inline-start` 等）を物理プロパティ（`margin-left` 等）へ
/// 変換する。この処理系は縦書き（`writing-mode`）に対応していないため、block 軸は常に
/// 縦方向・inline 軸は常に横方向として扱う簡略実装。`direction:rtl` の場合のみ
/// inline-start/end を right/left（既定は left/right）へ入れ替える。
/// 対応する物理プロパティが既に指定されている場合は論理プロパティを無視する
/// （同じ要素内で両方書かれた場合、物理プロパティを優先する簡易な優先順位）。
pub(crate) fn resolve_logical_properties(specified_values: &mut BTreeMap<String, String>) {
    let rtl = specified_values
        .get("direction")
        .map(|v| v.trim().eq_ignore_ascii_case("rtl"))
        .unwrap_or(false);
    let (inline_start, inline_end) = if rtl {
        ("right", "left")
    } else {
        ("left", "right")
    };
    // (プロパティ種別プレフィックス, block-start, block-end, inline-start物理名, inline-end物理名)
    for prefix in ["margin", "padding", "border"] {
        let pairs = [
            (
                alloc::format!("{prefix}-block-start"),
                alloc::format!("{prefix}-top"),
            ),
            (
                alloc::format!("{prefix}-block-end"),
                alloc::format!("{prefix}-bottom"),
            ),
            (
                alloc::format!("{prefix}-inline-start"),
                alloc::format!("{prefix}-{inline_start}"),
            ),
            (
                alloc::format!("{prefix}-inline-end"),
                alloc::format!("{prefix}-{inline_end}"),
            ),
        ];
        for (logical, physical) in pairs {
            if specified_values.contains_key(&physical) {
                continue;
            }
            if let Some(v) = specified_values.get(&logical).cloned() {
                specified_values.insert(physical, v);
            }
        }
    }
    // border-{block,inline}-{start,end}-{width,style,color}（ショートハンドではなく
    // longhand 単体での論理方向指定。上のショートハンド版と同じ direction 解決を使う）。
    for suffix in ["width", "style", "color"] {
        let pairs = [
            (
                alloc::format!("border-block-start-{suffix}"),
                alloc::format!("border-top-{suffix}"),
            ),
            (
                alloc::format!("border-block-end-{suffix}"),
                alloc::format!("border-bottom-{suffix}"),
            ),
            (
                alloc::format!("border-inline-start-{suffix}"),
                alloc::format!("border-{inline_start}-{suffix}"),
            ),
            (
                alloc::format!("border-inline-end-{suffix}"),
                alloc::format!("border-{inline_end}-{suffix}"),
            ),
        ];
        for (logical, physical) in pairs {
            if specified_values.contains_key(&physical) {
                continue;
            }
            if let Some(v) = specified_values.get(&logical).cloned() {
                specified_values.insert(physical, v);
            }
        }
    }
    // inset-*（position:absolute/fixed 等のオフセット）。
    let inset_pairs = [
        (String::from("inset-block-start"), String::from("top")),
        (String::from("inset-block-end"), String::from("bottom")),
        (
            String::from("inset-inline-start"),
            inline_start.to_string(),
        ),
        (
            String::from("inset-inline-end"),
            inline_end.to_string(),
        ),
    ];
    for (logical, physical) in inset_pairs {
        if specified_values.contains_key(&physical) {
            continue;
        }
        if let Some(v) = specified_values.get(&logical).cloned() {
            specified_values.insert(physical, v);
        }
    }
}

/// 大文字小文字を無視して `from` を `to` へすべて置換する（`str::replace` は大小文字を
/// 区別するため使えない）。`currentColor`/`currentcolor`/`CURRENTCOLOR` 等の表記ゆれに対応する。
pub(crate) fn replace_ignore_case(haystack: &str, from: &str, to: &str) -> String {
    if from.is_empty() {
        return String::from(haystack);
    }
    let hay_lower = haystack.to_ascii_lowercase();
    let from_lower = from.to_ascii_lowercase();
    let mut result = String::new();
    let mut rest = haystack;
    let mut rest_lower: &str = &hay_lower;
    while let Some(pos) = rest_lower.find(from_lower.as_str()) {
        result.push_str(rest.get(..pos).unwrap_or(""));
        result.push_str(to);
        rest = rest.get(pos + from.len()..).unwrap_or("");
        rest_lower = rest_lower.get(pos + from.len()..).unwrap_or("");
    }
    result.push_str(rest);
    result
}

/// `currentColor` キーワードを、この要素で確定した `color` の値に置換する。
/// `color` 自身の継承伝搬が終わった直後（呼び出し元で保証）に実行する必要がある。
/// `color` プロパティ自体は対象外（`color:currentColor` は無限自己参照になるため触らない）。
pub(crate) fn resolve_current_color(specified_values: &mut BTreeMap<String, String>) {
    let Some(color_val) = specified_values.get("color").cloned() else {
        return;
    };
    let keys: alloc::vec::Vec<String> = specified_values
        .iter()
        .filter(|(k, v)| k.as_str() != "color" && v.to_ascii_lowercase().contains("currentcolor"))
        .map(|(k, _)| k.clone())
        .collect();
    for k in keys {
        if let Some(v) = specified_values.get(&k) {
            let replaced = replace_ignore_case(v, "currentcolor", &color_val);
            specified_values.insert(k, replaced);
        }
    }
}

/// `place-items`/`place-content`/`place-self`（`align-*`/`justify-*` を1行にまとめる
/// ショートハンド）を展開する。`place-x: A` は `align-x:A; justify-x:A`、
/// `place-x: A B` は `align-x:A; justify-x:B` となる。対応する longhand が既に
/// 指定されていればそちらを優先し、ショートハンドでは上書きしない。
pub(crate) fn expand_place_shorthands(specified_values: &mut BTreeMap<String, String>) {
    for prefix in ["items", "content", "self"] {
        let shorthand_key = alloc::format!("place-{prefix}");
        let Some(v) = specified_values.get(&shorthand_key).cloned() else {
            continue;
        };
        let toks: alloc::vec::Vec<&str> = v.split_whitespace().collect();
        let (align_v, justify_v) = match toks.as_slice() {
            [a] => (*a, *a),
            [a, j] => (*a, *j),
            _ => continue,
        };
        specified_values
            .entry(alloc::format!("align-{prefix}"))
            .or_insert_with(|| String::from(align_v));
        specified_values
            .entry(alloc::format!("justify-{prefix}"))
            .or_insert_with(|| String::from(justify_v));
    }
}

/// 文字列リテラル（`"..."`/`'...'`）区間をすべて取り除き、残ったトークンを空白区切りで
/// 連結して返す。`grid-template` の `"area row" 1fr "area row" 2fr` のような
/// エリア名と行トラックサイズが交互に並ぶ記法から、トラックサイズだけを取り出すのに使う。
pub(crate) fn strip_quoted_segments(s: &str) -> String {
    let mut out = String::new();
    let mut chars = s.chars().peekable();
    while let Some(c) = chars.next() {
        if c == '"' || c == '\'' {
            let quote = c;
            for c2 in chars.by_ref() {
                if c2 == quote {
                    break;
                }
            }
        } else {
            out.push(c);
        }
    }
    out.split_whitespace().collect::<alloc::vec::Vec<_>>().join(" ")
}

/// `grid-template: <rows> / <columns>` および `grid-template-areas` を含む記法
/// （`"a a" 1fr "b c" 1fr / 1fr 2fr` のようにエリア名の文字列リテラルと行トラック
/// サイズが交互に並び、任意で `/ <columns>` が続く）を展開する。
/// エリア名部分はそのまま `grid-template-areas` へ、文字列リテラルを取り除いた
/// 残りのトークンを `grid-template-rows` へ、`/` 以降を `grid-template-columns` へ
/// 展開する。対応する longhand が既に指定されていればそちらを優先する。
pub(crate) fn expand_grid_template_shorthand(specified_values: &mut BTreeMap<String, String>) {
    let Some(v) = specified_values.get("grid-template").cloned() else {
        return;
    };
    let (rows_part, cols_part) = match v.split_once('/') {
        Some((r, c)) => (r.trim(), Some(c.trim())),
        None => (v.trim(), None),
    };
    if rows_part.contains('"') || rows_part.contains('\'') {
        // エリア名の文字列リテラルはそのまま grid-template-areas へ。
        specified_values
            .entry(String::from("grid-template-areas"))
            .or_insert_with(|| String::from(rows_part));
        // 文字列リテラルを除いた残り（行トラックサイズ）を grid-template-rows へ。
        let tracks = strip_quoted_segments(rows_part);
        if !tracks.is_empty() {
            specified_values
                .entry(String::from("grid-template-rows"))
                .or_insert(tracks);
        }
    } else if !rows_part.is_empty() {
        specified_values
            .entry(String::from("grid-template-rows"))
            .or_insert_with(|| String::from(rows_part));
    }
    if let Some(cols) = cols_part {
        if !cols.is_empty() {
            specified_values
                .entry(String::from("grid-template-columns"))
                .or_insert_with(|| String::from(cols));
        }
    }
}

/// `text-emphasis: [<style>] [<color>]` ショートハンドを `text-emphasis-style`/
/// `text-emphasis-color` へ展開する。`filled`/`open` の fill キーワードは非対応で
/// 読み飛ばす（常に塗りつぶし形状として扱う簡略実装）。
pub(crate) fn expand_text_emphasis_shorthand(specified_values: &mut BTreeMap<String, String>) {
    let Some(v) = specified_values.get("text-emphasis").cloned() else {
        return;
    };
    let mut style_tok: Option<&str> = None;
    let mut color_tok: Option<&str> = None;
    for tok in v.split_whitespace() {
        if matches!(tok, "filled" | "open") {
            continue;
        }
        if matches!(tok, "none" | "dot" | "circle" | "double-circle" | "triangle" | "sesame") {
            style_tok = Some(tok);
        } else if parse_color(tok).is_some() {
            color_tok = Some(tok);
        } else if style_tok.is_none() {
            // クォート付きの1文字カスタムマーク（例: `"*"`）
            style_tok = Some(tok);
        }
    }
    if let Some(s) = style_tok {
        specified_values
            .entry(String::from("text-emphasis-style"))
            .or_insert_with(|| String::from(s));
    }
    if let Some(c) = color_tok {
        specified_values
            .entry(String::from("text-emphasis-color"))
            .or_insert_with(|| String::from(c));
    }
}

/// `font: [style] [weight] size[/line-height] family-list` ショートハンドを
/// `font-style`/`font-weight`/`font-size`/`line-height`/`font-family` へ展開する。
/// **簡略化**: `font-variant`（`small-caps` 等）と `font-stretch` は longhand の消費側が
/// 存在しないため読み飛ばす（値としては無視するだけで、パース自体は失敗させない）。
/// `caption`/`icon`/`menu`/`message-box`/`small-caption`/`status-bar` のシステムフォント
/// キーワードは非対応のため素通りする。対応する longhand が既に指定されていればそちらを
/// 優先する（`.entry().or_insert()` パターン、他のショートハンド展開関数と同じ方針）。
pub(crate) fn expand_font_shorthand(specified_values: &mut BTreeMap<String, String>) {
    let Some(font) = specified_values.get("font").cloned() else {
        return;
    };
    let trimmed = font.trim();
    let lower_whole = trimmed.to_ascii_lowercase();
    if matches!(
        lower_whole.as_str(),
        "caption" | "icon" | "menu" | "message-box" | "small-caption" | "status-bar"
    ) {
        return;
    }

    // `size` トークンの判定: サイズキーワード、または数字始まり＋単位(px/em/%等)を持つ値。
    // これにより `font-weight` の裸の数値（`700` 等、単位を持たない）と区別する。
    fn is_size_token(t: &str) -> bool {
        let low = t.to_ascii_lowercase();
        const SIZE_KEYWORDS: &[&str] = &[
            "xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large", "larger",
            "smaller",
        ];
        if SIZE_KEYWORDS.contains(&low.as_str()) {
            return true;
        }
        let first_part = low.split('/').next().unwrap_or(&low);
        let starts_digit = first_part
            .chars()
            .next()
            .map(|c| c.is_ascii_digit())
            .unwrap_or(false);
        if !starts_digit {
            return false;
        }
        // 単位は既知のサイズ単位のみを許容する。以前は「数字始まり＋任意の英字を含む」
        // という緩すぎる判定だったため、`oblique <angle>`（CSS Fonts 4、例:
        // `font: oblique 10deg 12px/1.5 sans-serif`）の `10deg` を size と誤認し、
        // 本来の size トークン（`12px/1.5`）が見えなくなる/family に混入するバグがあった。
        const SIZE_UNITS: &[&str] = &[
            "px", "em", "rem", "pt", "pc", "in", "cm", "mm", "q", "%", "vh", "vw", "vmin", "vmax",
            "ex", "ch",
        ];
        SIZE_UNITS.iter().any(|u| first_part.ends_with(u))
    }

    let toks: alloc::vec::Vec<&str> = trimmed.split_whitespace().collect();
    let mut style: Option<alloc::string::String> = None;
    let mut weight: Option<alloc::string::String> = None;
    let mut size_idx = None;
    for (i, t) in toks.iter().enumerate() {
        if is_size_token(t) {
            size_idx = Some(i);
            break;
        }
        match t.to_ascii_lowercase().as_str() {
            "italic" | "oblique" => style = Some(String::from(*t)),
            "bold" | "bolder" | "lighter" => weight = Some(String::from(*t)),
            _ => {
                if t.parse::<u32>().is_ok() {
                    weight = Some(String::from(*t));
                }
                // normal/small-caps 等はいずれかの軸のデフォルトを明示するだけなので読み飛ばす。
            }
        }
    }
    let Some(size_idx) = size_idx else {
        // サイズトークンが見つからない = 不正な `font` 値として非対応、何もしない。
        return;
    };
    let size_tok = toks[size_idx];
    let (size_part, line_height_part) = match size_tok.split_once('/') {
        Some((s, l)) => (s, Some(l)),
        None => (size_tok, None),
    };
    specified_values
        .entry(String::from("font-size"))
        .or_insert_with(|| String::from(size_part));
    if let Some(lh) = line_height_part {
        specified_values
            .entry(String::from("line-height"))
            .or_insert_with(|| String::from(lh));
    }
    if let Some(s) = style {
        specified_values.entry(String::from("font-style")).or_insert(s);
    }
    if let Some(w) = weight {
        specified_values.entry(String::from("font-weight")).or_insert(w);
    }
    let family = toks[size_idx + 1..].join(" ");
    if !family.is_empty() {
        specified_values
            .entry(String::from("font-family"))
            .or_insert(family);
    }
}

pub(crate) fn expand_border_shorthands(specified_values: &mut BTreeMap<String, String>) {
    // border の展開
    if let Some(border) = specified_values.get("border").cloned() {
        let (width, style, color) = parse_border_shorthand(&border);
        if let Some(w) = width {
            specified_values
                .entry(String::from("border-top-width"))
                .or_insert(w.clone());
            specified_values
                .entry(String::from("border-right-width"))
                .or_insert(w.clone());
            specified_values
                .entry(String::from("border-bottom-width"))
                .or_insert(w.clone());
            specified_values
                .entry(String::from("border-left-width"))
                .or_insert(w.clone());
        }
        if let Some(s) = style {
            specified_values
                .entry(String::from("border-top-style"))
                .or_insert(s.clone());
            specified_values
                .entry(String::from("border-right-style"))
                .or_insert(s.clone());
            specified_values
                .entry(String::from("border-bottom-style"))
                .or_insert(s.clone());
            specified_values
                .entry(String::from("border-left-style"))
                .or_insert(s.clone());
        }
        if let Some(c) = color {
            specified_values
                .entry(String::from("border-top-color"))
                .or_insert(c.clone());
            specified_values
                .entry(String::from("border-right-color"))
                .or_insert(c.clone());
            specified_values
                .entry(String::from("border-bottom-color"))
                .or_insert(c.clone());
            specified_values
                .entry(String::from("border-left-color"))
                .or_insert(c.clone());
        }
    }

    // border-left, border-right, border-top, border-bottom の展開
    for side in &["top", "right", "bottom", "left"] {
        let key = alloc::format!("border-{}", side);
        if let Some(val) = specified_values.get(&key).cloned() {
            let (width, style, color) = parse_border_shorthand(&val);
            if let Some(w) = width {
                specified_values.insert(alloc::format!("border-{}-width", side), w);
            }
            if let Some(s) = style {
                specified_values.insert(alloc::format!("border-{}-style", side), s);
            }
            if let Some(c) = color {
                specified_values.insert(alloc::format!("border-{}-color", side), c);
            }
        }
    }
}

/// `background` ショートハンド（`background: url(...) center/cover no-repeat` 等）から
/// `background-position`/`background-size`/`background-repeat` を抜き出し、明示的な
/// longhand 指定が無い場合のみカスケード時点で補う。
///
/// 元々このスラッシュ構文（`<position> / <size>`）の分解ロジックは`web_engine/layout.rs`
/// 内のローカル関数として存在していたが、`background`ショートハンドを読む同種のコード
/// ブロックが同ファイル内に10箇所以上重複しており、実際にこの分解ロジックが配線されて
/// いたのはそのうち1箇所のみだった（残りは`background-size`/`-position`/`-repeat`を
/// 素通しするだけで、シェアされた `styled.value("background-size")` 経由の longhand
/// フォールバックしか効かず、ショートハンド内の`/size`が無視されていた）。カスケード
/// 時点で一度だけ展開して`specified_values`に書き戻すことで、全ての呼び出し箇所が
/// 自動的に正しい値を受け取るようにする（2026-07-21 発見・修正。詳細は
/// walkthrough.md 参照）。
pub(crate) fn expand_background_shorthand(specified_values: &mut BTreeMap<String, String>) {
    let Some(bg) = specified_values.get("background").cloned() else {
        return;
    };
    // size は `<position> / <size>` のスラッシュの後ろにしか現れない。トークンを
    // 無条件に2個取ると、`center/cover no-repeat`のように直後に`background-repeat`
    // 等の別サブ値が続く場合に誤って取り込んでしまう（2026-07-21発見・修正。
    // `cover`/`contain`/`auto`キーワードまたは長さ/割合に見えるトークンのみを
    // 最大2個まで採用する）。
    if let Some((_, after)) = bg.split_once('/') {
        let toks: Vec<&str> = after
            .split_whitespace()
            .take_while(|t| {
                matches!(*t, "cover" | "contain" | "auto")
                    || t.ends_with('%')
                    || t.ends_with("px")
                    || t.ends_with("em")
                    || t.ends_with("vw")
                    || t.ends_with("vh")
            })
            .take(2)
            .collect();
        if !toks.is_empty() {
            specified_values
                .entry(String::from("background-size"))
                .or_insert_with(|| toks.join(" "));
        }
    }
    let repeat_toks: Vec<&str> = bg
        .split_whitespace()
        .filter(|t| {
            matches!(
                *t,
                "no-repeat" | "repeat" | "repeat-x" | "repeat-y" | "space" | "round"
            )
        })
        .take(2)
        .collect();
    if !repeat_toks.is_empty() {
        specified_values
            .entry(String::from("background-repeat"))
            .or_insert_with(|| repeat_toks.join(" "));
    }
    // position はスラッシュより手前側のみを対象にする（後ろは size）。
    let position_part = bg.split_once('/').map(|(before, _)| before).unwrap_or(&bg);
    let position_toks: Vec<&str> = position_part
        .split_whitespace()
        .filter(|t| {
            matches!(*t, "center" | "top" | "bottom" | "left" | "right")
                || t.ends_with('%')
                || t.ends_with("px")
        })
        .collect();
    if !position_toks.is_empty() {
        specified_values
            .entry(String::from("background-position"))
            .or_insert_with(|| position_toks.join(" "));
    }
}

/// `text-transform` を適用する（uppercase / lowercase / capitalize）。
pub fn apply_text_transform(text: &str, mode: &str) -> String {
    match mode.trim() {
        "uppercase" => text.to_uppercase(),
        "lowercase" => text.to_lowercase(),
        "capitalize" => {
            // 各単語の先頭文字を大文字化（空白区切り）。
            let mut out = String::with_capacity(text.len());
            let mut at_word_start = true;
            for c in text.chars() {
                if c.is_whitespace() {
                    at_word_start = true;
                    out.push(c);
                } else if at_word_start {
                    out.extend(c.to_uppercase());
                    at_word_start = false;
                } else {
                    out.push(c);
                }
            }
            out
        }
        _ => text.to_string(),
    }
}

// ===================================================================
// CSS Transitions / Animations
// ===================================================================