atmos/os_lib/css/

parser.rs

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

fn resolve_or_add_layer(
    raw_name: &str,
    layer_names: &mut Vec<String>,
    parent_prefix: Option<&str>,
) -> usize {
    let raw_name = raw_name.trim();
    let full_name = if raw_name.is_empty() {
        let anon_id = layer_names.len();
        match parent_prefix {
            Some(p) => alloc::format!("{}.<anon-{}>", p, anon_id),
            None => alloc::format!("<anon-{}>", anon_id),
        }
    } else {
        match parent_prefix {
            Some(p) => alloc::format!("{}.{}", p, raw_name),
            None => raw_name.to_string(),
        }
    };

    if let Some(pos) = layer_names.iter().position(|n| *n == full_name) {
        pos
    } else {
        layer_names.push(full_name);
        layer_names.len() - 1
    }
}

pub fn parse_css(css: &str) -> StyleSheet {
    let mut layer_names = Vec::new();
    parse_css_with_layers(css, &mut layer_names)
}

pub fn parse_css_with_layers(css: &str, layer_names: &mut Vec<String>) -> StyleSheet {
    // 1. CSSコメントを除去
    let css_clean = strip_css_comments(css);
    parse_css_internal(&css_clean, layer_names, None)
}

fn parse_css_internal(
    css_clean: &str,
    layer_names: &mut Vec<String>,
    parent_prefix: Option<&str>,
) -> StyleSheet {
    let mut rules = Vec::new();
    let mut keyframes: Vec<Keyframes> = Vec::new();
    let mut counter_styles: Vec<CounterStyleDef> = Vec::new();
    let mut font_faces: Vec<FontFaceDef> = Vec::new();

    let items = split_css_items(css_clean);

    for item in items {
        match item {
            CssItem::Statement(stmt) => {
                let lower = stmt.to_lowercase();
                if lower.starts_with("@layer") {
                    let rest = stmt.trim_start_matches("@layer").trim();
                    for name in rest.split(',') {
                        let name = name.trim();
                        if !name.is_empty() {
                            resolve_or_add_layer(name, layer_names, parent_prefix);
                        }
                    }
                }
            }
            CssItem::Block(selector_part, decl_part) => {
                let selector_part = selector_part.trim();
                let decl_part = decl_part.trim();
                if selector_part.is_empty() || decl_part.is_empty() {
                    continue;
                }

                if selector_part.starts_with('@') {
                    // @keyframes / @font-face → パースして保持。@charset → スキップ。
                    // @media → メディアクエリを評価して内部ルールを再帰パース。
                    let lower = selector_part.to_lowercase();
                    if lower.starts_with("@font-face") {
                        if let Some(def) = parse_font_face_def(decl_part) {
                            font_faces.push(def);
                        }
                    } else if lower.starts_with("@keyframes") || lower.starts_with("@-webkit-keyframes") {
                        let name = selector_part
                            .trim_start_matches("@-webkit-keyframes")
                            .trim_start_matches("@keyframes")
                            .trim()
                            .to_string();
                        if !name.is_empty() {
                            if let Some(kf) = parse_keyframes(&name, decl_part) {
                                keyframes.push(kf);
                            }
                        }
                    } else if lower.starts_with("@media") {
                        let query = selector_part
                            .trim_start_matches("@media")
                            .trim()
                            .to_lowercase();
                        let inner_rules = parse_css_declarations(decl_part);
                        for mut r in inner_rules {
                            r.media_query = Some(match r.media_query {
                                Some(existing) => alloc::format!("{} and {}", existing, query),
                                None => query.clone(),
                            });
                            rules.push(r);
                        }
                    } else if lower.starts_with("@container") {
                        let prelude = selector_part.trim_start_matches("@container").trim();
                        let (name, cond) =
                            super::container_query::split_name_and_condition(prelude);
                        let tag = alloc::format!("{}|{}", name.unwrap_or_default(), cond);
                        let inner_rules = parse_css_declarations(decl_part);
                        for mut r in inner_rules {
                            r.container_query = Some(match r.container_query {
                                Some(existing) => alloc::format!("{}&&{}", existing, tag),
                                None => tag.clone(),
                            });
                            rules.push(r);
                        }
                    } else if lower.starts_with("@supports") {
                        let cond = selector_part.trim_start_matches("@supports").trim().to_lowercase();
                        if supports_condition_matches(&cond) {
                            let inner_rules = parse_css_declarations(decl_part);
                            rules.extend(inner_rules);
                        }
                    } else if lower.starts_with("@counter-style") {
                        let name = selector_part
                            .trim_start_matches("@counter-style")
                            .trim()
                            .to_string();
                        if !name.is_empty() {
                            if let Some(def) = parse_counter_style_def(&name, decl_part) {
                                counter_styles.push(def);
                            }
                        }
                    } else if lower.starts_with("@layer") {
                        // `@layer name { ... }` / 匿名 `@layer { ... }` / ネスト `@layer parent.sub { ... }`。
                        let raw_name = selector_part.trim_start_matches("@layer").trim();
                        let layer_idx = resolve_or_add_layer(raw_name, layer_names, parent_prefix);
                        let child_prefix = layer_names[layer_idx].clone();
                        let inner_sheet = parse_css_internal(decl_part, layer_names, Some(&child_prefix));
                        for mut r in inner_sheet.rules {
                            if r.layer.is_none() {
                                r.layer = Some(layer_idx);
                            }
                            rules.push(r);
                        }
                        keyframes.extend(inner_sheet.keyframes);
                        counter_styles.extend(inner_sheet.counter_styles);
                        font_faces.extend(inner_sheet.font_faces);
                    }
                    continue;
                }

                // トップレベルの comma だけで分割する（`:is(a, b)` 等の関数疑似クラス内の
                // comma で誤分割してルール全体が壊れないように、括弧の深さを見る）。
                let selectors: Vec<Selector> = split_top_level_commas(selector_part)
                    .into_iter()
                    .filter_map(|s| parse_selector(s.trim()))
                    .collect();
                if selectors.is_empty() {
                    continue;
                }

                // CSS Nesting Module Level 1（`.a { color:red; &:hover{...} }`）の簡易実装。
                let parent_selector_texts: Vec<String> = split_top_level_commas(selector_part)
                    .into_iter()
                    .map(|s| s.trim().to_string())
                    .collect();
                let declarations = parse_nested_body(&parent_selector_texts, decl_part, &mut rules, None);
                if declarations.is_empty() {
                    continue;
                }

                rules.push(Rule {
                    selectors,
                    declarations,
                    layer: None,
                    media_query: None,
                    container_query: None,
                });
            }
        }
    }

    StyleSheet {
        rules,
        keyframes,
        counter_styles,
        font_faces,
    }
}

/// `@font-face { font-family: 'X'; src: url(a) format('woff2'), url(b) format('truetype'); }`の
/// 宣言ブロックから`font-family`名と、読込可能な形式（TTF/OTF）を優先したURLを1件抽出する。
fn parse_font_face_def(decl_part: &str) -> Option<FontFaceDef> {
    let mut family = None;
    let mut best_url: Option<String> = None;
    let mut best_is_preferred_format = false;
    // `font-weight` 未指定は CSS 既定の 400。
    let mut weight: u16 = 400;
    for decl in decl_part.split(';') {
        let decl = decl.trim();
        let Some((prop, val)) = decl.split_once(':') else {
            continue;
        };
        let prop = prop.trim().to_lowercase();
        let val = val.trim();
        if prop == "font-family" {
            let name = val.trim_matches(|c| c == '\'' || c == '"').trim();
            if !name.is_empty() {
                family = Some(name.to_string());
            }
        } else if prop == "font-weight" {
            // `100`〜`900` の数値のみ扱う。`bold` は 700、`normal` は 400。
            // 範囲指定（`400 900`）は先頭を採る。
            let first = val.split_whitespace().next().unwrap_or("");
            weight = match first.to_lowercase().as_str() {
                "bold" => 700,
                "normal" => 400,
                other => other.parse::<u16>().unwrap_or(400),
            };
        } else if prop == "src" {
            // カンマ区切りの複数候補（`local()`/`url() format()`）から
            // `url(...)`とそれに続く`format('...')`ヒントをペアで抜き出す。
            for part in val.split(',') {
                let part = part.trim();
                let Some(after_url) = part.strip_prefix("url(") else {
                    continue;
                };
                let Some((url_raw, rest)) = after_url.split_once(')') else {
                    continue;
                };
                let url = url_raw.trim_matches(|c| c == '\'' || c == '"').trim();
                if url.is_empty() {
                    continue;
                }
                let rest_lower = rest.to_lowercase();
                let is_preferred = rest_lower.contains("truetype")
                    || rest_lower.contains("opentype")
                    || rest_lower.contains("woff2");
                if best_url.is_none() || (is_preferred && !best_is_preferred_format) {
                    best_url = Some(url.to_string());
                    best_is_preferred_format = is_preferred;
                }
            }
        }
    }
    let family = family?;
    Some(FontFaceDef {
        family,
        src_url: best_url,
        weight,
    })
}

/// `@counter-style <name> { system: cyclic|numeric; symbols: a b c; suffix: ". "; }` をパースする。
/// `symbols` はクォート付き文字列（`"a" "b"`）またはクォート無し空白区切り両方を許容する。
/// `system` 未指定は `cyclic` 扱い。`negative`/`range`/`pad`/`prefix`/`fallback` は非対応で無視。
pub(crate) fn parse_counter_style_def(name: &str, decl_part: &str) -> Option<CounterStyleDef> {
    let mut system = String::from("cyclic");
    let mut symbols: Vec<String> = Vec::new();
    let mut suffix = String::from(". ");
    for decl in decl_part.split(';') {
        let mut parts = decl.splitn(2, ':');
        let key = parts.next()?.trim().to_lowercase();
        let Some(val) = parts.next() else { continue };
        let val = val.trim();
        match key.as_str() {
            "system" => system = val.to_lowercase(),
            "symbols" => {
                symbols = split_top_level_commas(val)
                    .into_iter()
                    .flat_map(|seg| seg.split_whitespace())
                    .map(|s| String::from(s.trim_matches(|c| c == '"' || c == '\'')))
                    .filter(|s| !s.is_empty())
                    .collect();
            }
            "suffix" => {
                suffix = String::from(val.trim_matches(|c| c == '"' || c == '\''));
            }
            _ => {}
        }
    }
    if symbols.is_empty() {
        return None;
    }
    Some(CounterStyleDef {
        name: String::from(name),
        system,
        symbols,
        suffix,
    })
}

/// @keyframes ブロックの中身（`0% { ... } 50% { ... } to { ... }`）をパース。
pub(crate) fn parse_keyframes(name: &str, body: &str) -> Option<Keyframes> {
    let blocks = split_css_blocks(body);
    let mut frames: Vec<(f32, Vec<Declaration>)> = Vec::new();
    for (sel, decl_part) in blocks {
        // セレクタはカンマ区切りの複数オフセット（`0%, 50%` 等）を取り得る。
        let decls = parse_declaration_list(&decl_part);
        if decls.is_empty() {
            continue;
        }
        for off_tok in sel.split(',') {
            let tok = off_tok.trim().to_lowercase();
            let offset = match tok.as_str() {
                "from" => 0.0,
                "to" => 1.0,
                _ => match tok.trim_end_matches('%').trim().parse::<f32>() {
                    Ok(p) => p / 100.0,
                    Err(_) => continue,
                },
            };
            if (0.0..=1.0).contains(&offset) {
                frames.push((offset, decls.clone()));
            }
        }
    }
    if frames.is_empty() {
        return None;
    }
    frames.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(core::cmp::Ordering::Equal));
    Some(Keyframes {
        name: name.to_string(),
        frames,
    })
}

/// `name: value; ...` 形式の宣言リストをパース（!important 対応）。
pub(crate) fn parse_declaration_list(decl_part: &str) -> Vec<Declaration> {
    decl_part
        .split(';')
        .filter_map(|decl| {
            let mut kv = decl.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,
            })
        })
        .collect()
}

/// CSSコメント `/* ... */` を除去する。
/// バイト単位でコメント区切り（`/*`/`*/`、いずれも1バイトASCII）だけを検出し、それ以外の
/// バイトはそのままコピーする。UTF-8の継続バイト(0x80-0xBF)がASCIIの`/`/`*`と衝突すること
/// は無いため、この方式でマルチバイト文字（絵文字や `★` 等）を破壊せずに処理できる。
/// 旧実装は `bytes[i] as char` で1バイトずつchar化しており、マルチバイト文字が
/// Latin-1的に誤変換される致命的なバグがあった（例: `★`(E2 98 85) → 'â' + 制御文字2つ）。
pub(crate) fn strip_css_comments(css: &str) -> String {
    if !css.contains("/*") {
        return css.to_string();
    }
    let bytes = css.as_bytes();
    let mut out = Vec::with_capacity(css.len());
    let mut i = 0;
    while i < bytes.len() {
        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
            // コメント開始 → */ まで飛ばす
            i += 2;
            while i + 1 < bytes.len() {
                if bytes[i] == b'*' && bytes[i + 1] == b'/' {
                    i += 2;
                    break;
                }
                i += 1;
            }
        } else {
            out.push(bytes[i]);
            i += 1;
        }
    }
    String::from_utf8(out).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned())
}

/// `@supports <condition>` の真偽を判定する。`not`/`and`/`or` の論理結合は
/// 実際に評価するが、葉の `(property: value)`/`selector(...)` 自体は
/// 「このエンジンが構文解析できる宣言は常に対応している」扱いとする簡略方針
/// （`media_query_matches` の「未知のクエリは通過」方針と対になる設計）。
pub fn supports_condition_matches(cond: &str) -> bool {
    let cond = cond.trim();
    if cond.is_empty() {
        return true;
    }
    if cond.contains(" and ") && !cond.contains(" or ") {
        return cond.split(" and ").all(|p| supports_condition_matches(p.trim()));
    }
    if cond.contains(" or ") && !cond.contains(" and ") {
        return cond.split(" or ").any(|p| supports_condition_matches(p.trim()));
    }
    if let Some(rest) = cond.strip_prefix("not ") {
        return !supports_condition_matches(rest.trim());
    }
    if let Some(stripped) = cond.strip_prefix('(').and_then(|s| s.strip_suffix(')')) {
        return supports_condition_matches(stripped.trim());
    }
    // 葉: `property: value` や `selector(...)` 等。
    true
}

/// トップレベルの CSS ブロックを `{` / `}` の深さを追跡して正しく分割する
/// @media クエリが現在のビューポートにマッチするか評価。
pub fn media_query_matches(query: &str) -> bool {
    let vw = VIEWPORT_HINT_W.load(AtomicOrd::Relaxed);
    let vh = VIEWPORT_HINT_H.load(AtomicOrd::Relaxed);
    // "screen", "all" → 常にマッチ
    if query == "screen" || query == "all" || query.is_empty() {
        return true;
    }
    // "print" → スキップ
    if query == "print" {
        return false;
    }
    // "not print" → マッチ
    if query == "not print" {
        return true;
    }
    // カンマ区切り: いずれかがマッチすれば true
    if query.contains(',') {
        return query.split(',').any(|q| media_query_matches(q.trim()));
    }
    // " and " 区切りの複合条件（`screen and (min-width: 600px)` や、レンジ指定でよく使われる
    // `(min-width: 600px) and (max-width: 900px)` 等）: 全条件が真の場合のみマッチ。
    // 旧実装は「screen」「and」という固定文字列を先頭からのみ1回ずつ trim_start_matches していたため、
    // `screen and (...)` の直後に来る条件がそもそも判定式まで届かず、単一条件ですら常に
    // 素通り（trueへフォールバック）してしまっていた。再帰的に分割することで両方のケースを直す。
    if query.contains(" and ") {
        return query.split(" and ").all(|part| media_query_matches(part.trim()));
    }
    // "screen" 単体の media type 修飾子を取り除く（`screen (min-width: 600px)` のような
    // 稀な書き方にも耐性を持たせる）。
    let inner = query.trim_start_matches("screen").trim();
    // 括弧を除去して再評価
    let cond = inner.trim_matches(|c| c == '(' || c == ')');
    // max-width: Npx
    if let Some(rest) = cond
        .strip_prefix("max-width:")
        .or_else(|| cond.strip_prefix("max-width :"))
    {
        let px: i32 = rest
            .trim()
            .trim_end_matches("px")
            .trim()
            .parse()
            .unwrap_or(i32::MAX);
        return vw <= px;
    }
    // min-width: Npx
    if let Some(rest) = cond
        .strip_prefix("min-width:")
        .or_else(|| cond.strip_prefix("min-width :"))
    {
        let px: i32 = rest
            .trim()
            .trim_end_matches("px")
            .trim()
            .parse()
            .unwrap_or(0);
        return vw >= px;
    }
    // max-height: Npx
    if let Some(rest) = cond
        .strip_prefix("max-height:")
        .or_else(|| cond.strip_prefix("max-height :"))
    {
        let px: i32 = rest
            .trim()
            .trim_end_matches("px")
            .trim()
            .parse()
            .unwrap_or(i32::MAX);
        return vh <= px;
    }
    // min-height: Npx
    if let Some(rest) = cond
        .strip_prefix("min-height:")
        .or_else(|| cond.strip_prefix("min-height :"))
    {
        let px: i32 = rest
            .trim()
            .trim_end_matches("px")
            .trim()
            .parse()
            .unwrap_or(0);
        return vh >= px;
    }
    // orientation: landscape / portrait
    if let Some(rest) = cond.strip_prefix("orientation:") {
        let o = rest.trim();
        if o == "landscape" {
            return vw >= vh;
        }
        if o == "portrait" {
            return vh > vw;
        }
    }
    // `resolution`/`min-resolution`/`max-resolution`（HiDPI/retina 向けアセット
    // 出し分けの定番。`@media (min-resolution: 2dppx)` 等）が丸ごと未対応で、
    // `min-width`/`max-width` と同様の数値レンジ特性にもかかわらず末尾の
    // 「未知のクエリは通過」フォールバックに落ちていた。この処理系のフレーム
    // バッファは等倍密度（1dppx = 96dpi）固定として扱う。
    let parse_dppx = |s: &str| -> Option<f32> {
        let s = s.trim();
        if let Some(n) = s.strip_suffix("dppx") {
            n.trim().parse::<f32>().ok()
        } else if let Some(n) = s.strip_suffix("dpi") {
            n.trim().parse::<f32>().ok().map(|v| v / 96.0)
        } else if let Some(n) = s.strip_suffix("dpcm") {
            n.trim().parse::<f32>().ok().map(|v| v / 37.795_28)
        } else if let Some(n) = s.strip_suffix('x') {
            n.trim().parse::<f32>().ok()
        } else {
            None
        }
    };
    const DEVICE_DPPX: f32 = 1.0;
    if let Some(rest) = cond.strip_prefix("min-resolution:") {
        return parse_dppx(rest).is_some_and(|r| DEVICE_DPPX >= r);
    }
    if let Some(rest) = cond.strip_prefix("max-resolution:") {
        return parse_dppx(rest).is_some_and(|r| DEVICE_DPPX <= r);
    }
    if let Some(rest) = cond.strip_prefix("resolution:") {
        return parse_dppx(rest).is_some_and(|r| (DEVICE_DPPX - r).abs() < 0.001);
    }
    // `monochrome`/`min-monochrome`/`max-monochrome`（モノクロフレームバッファの
    // 階調ビット数。カラー表示なら常に0）も同型のフォールバックバグだった。
    if let Some(rest) = cond.strip_prefix("min-monochrome:") {
        return rest.trim().parse::<i32>().is_ok_and(|n| n <= 0);
    }
    if let Some(rest) = cond.strip_prefix("max-monochrome:") {
        return rest.trim().parse::<i32>().is_ok_and(|n| n >= 0);
    }
    if let Some(rest) = cond.strip_prefix("monochrome:") {
        return rest.trim().parse::<i32>() == Ok(0);
    }
    if cond.trim() == "monochrome" {
        return false;
    }
    // prefers-color-scheme: dark / light（PREFERS_DARK は既定 light、システムテーマとの
    // 実連動は未配線）。以前は未知クエリとして常にマッチしており、dark/light 両方の
    // 上書きルールが同時に適用されてしまう不具合があったため、明示的に判定する。
    if let Some(rest) = cond.strip_prefix("prefers-color-scheme:") {
        let scheme = rest.trim();
        let is_dark = PREFERS_DARK.load(AtomicOrd::Relaxed);
        if scheme == "dark" {
            return is_dark;
        }
        if scheme == "light" {
            return !is_dark;
        }
    }
    // prefers-reduced-motion: この処理系にアニメーション抑制機構は無いため常に
    // no-preference（reduce しない）として扱う。
    if let Some(rest) = cond.strip_prefix("prefers-reduced-motion:") {
        let pref = rest.trim();
        return pref == "no-preference";
    }
    // `prefers-contrast`（Media Queries Level 5）が丸ごと未対応で、`pointer`/
    // `hover` 等と同じ「末尾の未知クエリ通過フォールバック」に落ち、
    // `@media (prefers-contrast: more)` と `@media (prefers-contrast: less)`
    // が同時に真になってしまうバグだった。この OS にはコントラスト設定切替が
    // 無いため `prefers-reduced-motion` と同じ方針で常に no-preference。
    if let Some(rest) = cond.strip_prefix("prefers-contrast:") {
        let pref = rest.trim();
        return pref == "no-preference";
    }
    // `pointer`/`any-pointer`/`hover`/`any-hover`（Media Queries Level 4）が
    // 丸ごと未対応で、末尾の「未知のクエリは通過させる」フォールバックに落ちて
    // `@media (pointer: fine)` と `@media (pointer: coarse)` の両方が同時に
    // 真になってしまうバグだった（互いに矛盾するはずの分岐が同時適用される）。
    // この OS は USB HID マウス+キーボードを前提とするため、精密ポインタ・
    // ホバー可能として固定で答える。
    if let Some(rest) = cond.strip_prefix("any-pointer:") {
        return rest.trim() == "fine";
    }
    if let Some(rest) = cond.strip_prefix("pointer:") {
        return rest.trim() == "fine";
    }
    if let Some(rest) = cond.strip_prefix("any-hover:") {
        return rest.trim() == "hover";
    }
    if let Some(rest) = cond.strip_prefix("hover:") {
        return rest.trim() == "hover";
    }
    // `pointer`/`hover` と同じ「未知のクエリは通過」フォールバックが原因で
    // 相互排他のはずの分岐が同時に真になる同型のバグが `scripting`/
    // `forced-colors`/`inverted-colors`/`color-gamut` にもあった。
    // この処理系は常に JS を実行する（`<noscript>` を常に非表示にする既存の
    // 判断と同じ真実源）・強制配色モードや色反転機能は無い・
    // フレームバッファは sRGB 相当という前提で固定回答する。
    if let Some(rest) = cond.strip_prefix("scripting:") {
        return rest.trim() == "enabled";
    }
    if let Some(rest) = cond.strip_prefix("forced-colors:") {
        return rest.trim() == "none";
    }
    if let Some(rest) = cond.strip_prefix("inverted-colors:") {
        return rest.trim() == "none";
    }
    if let Some(rest) = cond.strip_prefix("color-gamut:") {
        return rest.trim() == "srgb";
    }
    // 同じ「未知のクエリは通過」フォールバックが原因の同型バグの続き。
    // `update`（画面更新能力。`none`/`slow`/`fast`）はこの処理系の VSync
    // ページフリップ機構により `fast` として固定回答。`grid`（ビットマップ
    // 画面か文字グリッド端末か。`0`/`1`）はフレームバッファを持つビットマップ
    // 画面のため常に `0`。`prefers-reduced-transparency`/`prefers-reduced-data`
    // はこの OS に対応する設定切替機構が無いため `prefers-reduced-motion`
    // と同じ方針で常に `no-preference`。
    if let Some(rest) = cond.strip_prefix("update:") {
        return rest.trim() == "fast";
    }
    if let Some(rest) = cond.strip_prefix("grid:") {
        return rest.trim() == "0";
    }
    if let Some(rest) = cond.strip_prefix("prefers-reduced-transparency:") {
        return rest.trim() == "no-preference";
    }
    if let Some(rest) = cond.strip_prefix("prefers-reduced-data:") {
        return rest.trim() == "no-preference";
    }
    true // それ以外の未知のクエリは通過させる
}

/// @media ブロック内の CSS を再帰的にパースして Rule リストを返す。
pub(crate) fn parse_css_declarations(css: &str) -> Vec<Rule> {
    let mut rules = Vec::new();
    let blocks = split_css_blocks(css);
    for (selector_part, decl_part) in blocks {
        let selector_part = selector_part.trim();
        let decl_part = decl_part.trim();
        if selector_part.is_empty() || decl_part.is_empty() {
            continue;
        }
        if selector_part.starts_with('@') {
            continue;
        }
        // トップレベルの comma だけで分割する（`:is(a, b)` 等の関数疑似クラス内の
        // comma で誤分割してルール全体が壊れないように、括弧の深さを見る）。
        let selectors: Vec<Selector> = split_top_level_commas(selector_part)
            .into_iter()
            .filter_map(|s| parse_selector(s.trim()))
            .collect();
        if selectors.is_empty() {
            continue;
        }
        // CSS Nesting は非対応。ネストしたルールの `{`/`}` や内部の `;` が同じブロック内の
        // 正当な宣言を巻き添えで壊さないよう、`{` 以降（ネストしたルール全体）を切り捨てる
        // （上の `parse_css` 本体の同種処理と同じ方針）。
        let decl_part = match decl_part.find('{') {
            Some(pos) => decl_part.get(..pos).unwrap_or(decl_part).trim(),
            None => decl_part,
        };
        let declarations: Vec<Declaration> = decl_part
            .split(';')
            .filter_map(|decl| {
                let mut kv = decl.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,
                })
            })
            .collect();
        if !declarations.is_empty() {
            rules.push(Rule {
                selectors,
                declarations,
                layer: None,
                media_query: None,
            container_query: None,
            });
        }
    }
    rules
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum CssItem {
    Statement(String),
    Block(String, String),
}

pub(crate) fn split_css_items(css: &str) -> Vec<CssItem> {
    let mut items = Vec::new();
    let mut depth = 0;
    let mut item_start = 0;
    let mut block_start = 0;
    let bytes = css.as_bytes();
    let mut in_quote: Option<u8> = None;
    let mut escaped = false;

    for i in 0..bytes.len() {
        let b = bytes[i];
        if escaped {
            escaped = false;
            continue;
        }
        if b == b'\\' {
            escaped = true;
            continue;
        }
        if let Some(q) = in_quote {
            if b == q {
                in_quote = None;
            }
            continue;
        }
        if b == b'"' || b == b'\'' {
            in_quote = Some(b);
            continue;
        }

        match b {
            b';' if depth == 0 => {
                if let Some(stmt) = css.get(item_start..i) {
                    let trimmed = stmt.trim();
                    if !trimmed.is_empty() {
                        items.push(CssItem::Statement(trimmed.to_string()));
                    }
                }
                item_start = i + 1;
            }
            b'{' => {
                if depth == 0 {
                    block_start = i + 1;
                }
                depth += 1;
            }
            b'}' => {
                if depth > 0 {
                    depth -= 1;
                    if depth == 0 {
                        if let (Some(selector), Some(body)) = (
                            css.get(item_start..block_start.saturating_sub(1)),
                            css.get(block_start..i),
                        ) {
                            items.push(CssItem::Block(selector.trim().to_string(), body.to_string()));
                        }
                        item_start = i + 1;
                    }
                }
            }
            _ => {}
        }
    }

    items
}

pub(crate) fn split_css_blocks(css: &str) -> Vec<(String, String)> {
    split_css_items(css)
        .into_iter()
        .filter_map(|item| match item {
            CssItem::Block(sel, body) => Some((sel, body)),
            CssItem::Statement(_) => None,
        })
        .collect()
}

// DOM ツリーにスタイルを適用する