atmos/os_lib/css/

parser.rs

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

pub fn parse_css(css: &str) -> StyleSheet {
    // 1. CSSコメントを除去
    let css_clean = strip_css_comments(css);

    // 2. トップレベルの {} ブロックを正しく分割（ネスト対応）
    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();
    // `@layer` の宣言順（後で宣言されたレイヤーほど通常宣言の優先度が高い）。
    // 同名レイヤーは初出の位置にマージする（仕様通り）。匿名レイヤー（名前無し）は
    // 常に新規スロットを割り当てる。
    let mut layer_names: Vec<String> = Vec::new();
    let blocks = split_css_blocks(&css_clean);

    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('@') {
            // @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") {
                // 【2026-07-24変更】以前はここで`media_query_matches`が偽の場合
                // ブロックを丸ごと除外していたが、CSS解析はコンテンツ変化時の
                // 一度きりしか走らないため、その一度きりの評価時点のウィンドウ幅
                // が実際の表示時と異なると（起動直後のプレースホルダー表示中等）、
                // モバイルファーストCSSのナビゲーション等が永久に消えたままになる
                // バグの原因だった。常に内部ルールを保持し、`media_query`として
                // タグ付けしてカスケード時に動的判定する。
                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") {
                // 【2026-09-03】`@container`（コンテナクエリ）。
                //
                // `@media` と同じく**解析時に評価して落とさない**。
                // 基準がビューポートではなく問い合わせコンテナなので、
                // コンテナ寸法はレイアウトが決まるまで分からず、解析時点の
                // 評価は必ず誤る（`@media` を静的評価してページが白紙化した
                // 2026-07-24 の失敗と同じ轍を踏まないこと）。
                // ルールは常に保持し、カスケード時に動的判定する。
                //
                // 保持形式は `名前|条件`（名前省略時は `|条件`）。
                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 {
                    // 入れ子の `@container` は両方を満たす必要がある。
                    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") {
                // `not`/`and`/`or` の論理結合は評価するが、葉の `(property: value)`
                // 自体は「このエンジンが構文解析できる宣言は常に対応している」扱いの
                // 簡略方針（`:where()` を `:is()` と同一視する簡略化と同じ方針）。
                // 以前は条件式を一切評価せず常に内部ルールを適用していたため、
                // `@supports not (display: grid) { ...フォールバック... }` という
                // 定番のプログレッシブエンハンスメント・パターンで、本来適用しては
                // いけないフォールバックブロックまで常に適用されてしまうバグが
                // あった。
                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 name1, name2;`（波括弧無しの順序宣言のみの構文）は
                // split_css_blocks が `{}` ブロックしか認識しないため非対応。
                let name = selector_part.trim_start_matches("@layer").trim().to_string();
                let layer_idx = if name.is_empty() {
                    layer_names.push(alloc::format!("<anon-{}>", layer_names.len()));
                    layer_names.len() - 1
                } else if let Some(pos) = layer_names.iter().position(|n| *n == name) {
                    pos
                } else {
                    layer_names.push(name);
                    layer_names.len() - 1
                };
                // 内容はトップレベルの CSS と同じ規則（ネスト・@media 等含む）で
                // 再帰的にパースし、結果の全ルールにこのレイヤー番号を付与する。
                let inner_sheet = parse_css(decl_part);
                for mut r in inner_sheet.rules {
                    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{...} }`）の簡易実装。
        // ネストしたルールは `&` を親セレクタのテキストに置換（`&` が無ければ親の後ろに
        // 半角スペースで連結＝子孫結合子）してデシュガーし、トップレベルの `rules` に
        // 積む。`:is()` によるラップ等の厳密な仕様は行わず単純な文字列連結で近似する
        // （本エンジンの `:is()`/`:where()` 簡略化方針と同じ割り切り）。
        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
}

pub(crate) fn split_css_blocks(css: &str) -> Vec<(String, String)> {
    let mut blocks = Vec::new();
    let mut depth = 0;
    let mut selector_start = 0;
    let mut block_start = 0;
    let bytes = css.as_bytes();

    for i in 0..bytes.len() {
        match bytes[i] {
            b'{' => {
                if depth == 0 {
                    block_start = i + 1;
                }
                depth += 1;
            }
            b'}' => {
                depth -= 1;
                if depth <= 0 {
                    depth = 0;
                    if let (Some(selector), Some(body)) = (
                        css.get(selector_start..block_start.saturating_sub(1)),
                        css.get(block_start..i),
                    ) {
                        blocks.push((selector.to_string(), body.to_string()));
                    }
                    selector_start = i + 1;
                }
            }
            _ => {}
        }
    }

    blocks
}

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