atmos/os_lib/css/

selector.rs

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

pub(crate) fn parse_selector(s: &str) -> Option<Selector> {
    let chain = parse_selector_chain(s)?;
    if chain.len() == 1 && chain[0].combinator.is_none() {
        Some(Selector::Simple(chain[0].simple.clone()))
    } else {
        Some(Selector::Chain(chain))
    }
}

#[inline]
fn is_ident_byte(b: u8) -> bool {
    b.is_ascii_alphanumeric() || b == b'-' || b == b'_'
}

pub(crate) fn parse_simple_selector(s: &str) -> Option<SimpleSelector> {
    if s.is_empty() {
        return None;
    }

    let mut selector = SimpleSelector::default();
    let bytes = s.as_bytes();
    let mut i = 0usize;
    while i < bytes.len() {
        match bytes[i] {
            b'#' => {
                i += 1;
                let start = i;
                while i < bytes.len() && is_ident_byte(bytes[i]) {
                    i += 1;
                }
                if start < i {
                    if let Some(id_str) = s.get(start..i) {
                        selector.id = Some(String::from(id_str));
                    }
                }
            }
            b'.' => {
                i += 1;
                let start = i;
                while i < bytes.len() && is_ident_byte(bytes[i]) {
                    i += 1;
                }
                if start < i {
                    if let Some(cls_str) = s.get(start..i) {
                        selector.class.push(String::from(cls_str));
                    }
                }
            }
            b'*' => {
                selector.universal = true;
                i += 1;
            }
            b'[' => {
                i += 1;
                let inner_start = i;
                while i < bytes.len() && bytes[i] != b']' {
                    i += 1;
                }
                let inner = s.get(inner_start..i).unwrap_or("");
                if i < bytes.len() {
                    i += 1;
                } // ']'
                if let Some(attr) = parse_attr_selector(inner) {
                    selector.attrs.push(attr);
                }
            }
            b':' => {
                i += 1;
                if i < bytes.len() && bytes[i] == b':' {
                    i += 1;
                }
                let start = i;
                while i < bytes.len() && is_ident_byte(bytes[i]) {
                    i += 1;
                }
                let name = s.get(start..i).unwrap_or("").to_ascii_lowercase();
                let mut arg = String::new();
                if i < bytes.len() && bytes[i] == b'(' {
                    i += 1;
                    let arg_start = i;
                    let mut depth = 1;
                    while i < bytes.len() && depth > 0 {
                        match bytes[i] {
                            b'(' => depth += 1,
                            b')' => {
                                depth -= 1;
                                if depth == 0 {
                                    break;
                                }
                            }
                            _ => {}
                        }
                        i += 1;
                    }
                    arg = String::from(s.get(arg_start..i).unwrap_or(""));
                    if i < bytes.len() {
                        i += 1;
                    } // ')'
                }
                if !name.is_empty() {
                    match name.as_str() {
                        "before" => selector.pseudo_element = Some(PseudoElement::Before),
                        "after" => selector.pseudo_element = Some(PseudoElement::After),
                        "marker" => selector.pseudo_element = Some(PseudoElement::Marker),
                        "placeholder" => selector.pseudo_element = Some(PseudoElement::Placeholder),
                        "first-line" => selector.pseudo_element = Some(PseudoElement::FirstLine),
                        "first-letter" => selector.pseudo_element = Some(PseudoElement::FirstLetter),
                        _ => {
                            let pseudo = match name.as_str() {
                                "first-child" => PseudoClass::FirstChild,
                                "last-child" => PseudoClass::LastChild,
                                "nth-child" => {
                                    let (a, b, sel) = parse_nth_of(&arg);
                                    PseudoClass::NthChild(a, b, sel.map(alloc::boxed::Box::new))
                                }
                                "nth-last-child" => {
                                    let (a, b, sel) = parse_nth_of(&arg);
                                    PseudoClass::NthLastChild(
                                        a,
                                        b,
                                        sel.map(alloc::boxed::Box::new),
                                    )
                                }
                                "not" => match parse_simple_selector(arg.trim()) {
                                    Some(inner) => PseudoClass::Not(alloc::boxed::Box::new(inner)),
                                    None => PseudoClass::Other(name),
                                },
                                "is" | "where" | "matches" | "any" => {
                                    let is_where = name == "where";
                                    let list: Vec<SimpleSelector> = split_top_level_commas(&arg)
                                        .iter()
                                        .filter_map(|s| parse_simple_selector(s.trim()))
                                        .collect();
                                    if list.is_empty() {
                                        PseudoClass::Other(name)
                                    } else if is_where {
                                        PseudoClass::Where(list)
                                    } else {
                                        PseudoClass::Is(list)
                                    }
                                }
                                "has" => {
                                    let list: Vec<(HasCombinator, SimpleSelector)> =
                                        split_top_level_commas(&arg)
                                            .iter()
                                            .filter_map(|s| {
                                                let s = s.trim();
                                                let (comb, rest) = match s.strip_prefix('>') {
                                                    Some(r) => (HasCombinator::Child, r.trim()),
                                                    None => match s.strip_prefix('+') {
                                                        Some(r) => {
                                                            (HasCombinator::NextSibling, r.trim())
                                                        }
                                                        None => match s.strip_prefix('~') {
                                                            Some(r) => (
                                                                HasCombinator::SubsequentSibling,
                                                                r.trim(),
                                                            ),
                                                            None => {
                                                                (HasCombinator::Descendant, s)
                                                            }
                                                        },
                                                    },
                                                };
                                                parse_simple_selector(rest).map(|sel| (comb, sel))
                                            })
                                            .collect();
                                    if list.is_empty() {
                                        PseudoClass::Other(name)
                                    } else {
                                        PseudoClass::Has(list)
                                    }
                                }
                                "checked" => PseudoClass::Checked,
                                "disabled" => PseudoClass::Disabled,
                                "lang" => {
                                    let code = arg
                                        .trim()
                                        .trim_matches(|c| c == '\'' || c == '"')
                                        .to_ascii_lowercase();
                                    if code.is_empty() {
                                        PseudoClass::Other(name)
                                    } else {
                                        PseudoClass::Lang(code)
                                    }
                                }
                                "dir" => {
                                    let d = arg.trim().to_ascii_lowercase();
                                    if d == "ltr" || d == "rtl" {
                                        PseudoClass::Dir(d)
                                    } else {
                                        PseudoClass::Other(name)
                                    }
                                }
                                "first-of-type" => PseudoClass::FirstOfType,
                                "last-of-type" => PseudoClass::LastOfType,
                                "nth-of-type" => {
                                    let (a, b) = parse_nth(&arg);
                                    PseudoClass::NthOfType(a, b)
                                }
                                "nth-last-of-type" => {
                                    let (a, b) = parse_nth(&arg);
                                    PseudoClass::NthLastOfType(a, b)
                                }
                                "only-of-type" => PseudoClass::OnlyOfType,
                                "only-child" => PseudoClass::OnlyChild,
                                "target" => PseudoClass::Target,
                                "empty" => PseudoClass::Empty,
                                _ => PseudoClass::Other(name),
                            };
                            selector.pseudo_classes.push(pseudo);
                        }
                    }
                }
            }
            b if is_ident_byte(b) => {
                let start = i;
                while i < bytes.len() && is_ident_byte(bytes[i]) {
                    i += 1;
                }
                if start < i {
                    if let Some(tag_str) = s.get(start..i) {
                        selector.tag_name = Some(tag_str.to_ascii_lowercase());
                    }
                }
            }
            _ => i += 1,
        }
    }

    if !selector.universal
        && selector.tag_name.is_none()
        && selector.id.is_none()
        && selector.class.is_empty()
        && selector.pseudo_classes.is_empty()
        && selector.attrs.is_empty()
    {
        None
    } else {
        Some(selector)
    }
}

/// `[name]` / `[name op value]` の中身をパース。
pub(crate) fn parse_attr_selector(inner: &str) -> Option<AttrSelector> {
    let inner = inner.trim();
    if inner.is_empty() {
        return None;
    }
    // 演算子を探す（長い順）。
    for (token, op) in &[
        ("^=", AttrOp::Prefix),
        ("$=", AttrOp::Suffix),
        ("*=", AttrOp::Contains),
        ("~=", AttrOp::Word),
        ("|=", AttrOp::Dash),
        ("=", AttrOp::Eq),
    ] {
        if let Some(pos) = inner.find(token) {
            let name = inner.get(..pos).unwrap_or("").trim().to_lowercase();
            let mut raw = inner.get(pos + token.len()..).unwrap_or("").trim();
            // `[attr=val i]`/`[attr=val s]`（Selectors Level 4 §6.4.1）。フラグは値の後ろに
            // 空白で区切って置く。`s`（大文字小文字を区別。既定と同じ）は読み捨てるだけでよい。
            // クォート付き値なら閉じクォートがフラグの直前に来るため、値中の空白+`i`と
            // 混同しない（`"show i"` は末尾が `i"` であって ` i` ではないので誤判定しない）。
            let mut case_insensitive = false;
            for flag in [" i", " I", " s", " S"] {
                if let Some(stripped) = raw.strip_suffix(flag) {
                    case_insensitive = flag.eq_ignore_ascii_case(" i");
                    raw = stripped.trim_end();
                    break;
                }
            }
            let value = raw.trim_matches('"').trim_matches('\'').to_string();
            if name.is_empty() {
                return None;
            }
            return Some(AttrSelector {
                name,
                op: op.clone(),
                value,
                case_insensitive,
            });
        }
    }
    Some(AttrSelector {
        name: inner.to_lowercase(),
        op: AttrOp::Exists,
        value: String::new(),
        case_insensitive: false,
    })
}

/// `:nth-child(An+B of S)`（Selectors Level 4）用: `of` より前の `An+B` 部分を `parse_nth`
/// に、`of` より後ろの `S` 部分を `parse_simple_selector` に、それぞれ渡す。`of` が無ければ
/// 従来どおり `S` は `None`。以前は `parse_nth` が `S` 部分を丸ごと読み捨てるだけで
/// フィルタ自体が非対応だったため、`:nth-child(2n+1 of .foo)` が `.foo` に関係なく
/// 単なる `:nth-child(2n+1)` と同じ結果になっていた。
pub(crate) fn parse_nth_of(arg: &str) -> (i64, i64, Option<SimpleSelector>) {
    let full = arg.trim();
    let lower = full.to_lowercase();
    match lower.find(" of ") {
        Some(pos) => {
            let an_b_part = full.get(..pos).unwrap_or(full);
            let sel_part = full.get(pos + 4..).unwrap_or("");
            let (a, b) = parse_nth(an_b_part);
            (a, b, parse_simple_selector(sel_part.trim()))
        }
        None => {
            let (a, b) = parse_nth(full);
            (a, b, None)
        }
    }
}

/// `:nth-child(...)` の引数 `an+b` / `odd` / `even` / `b` を (a, b) に。
pub(crate) fn parse_nth(arg: &str) -> (i64, i64) {
    let full = arg.trim().to_lowercase();
    // Selectors Level 4 の `:nth-child(An+B of S)` 構文: `S` は呼び出し元
    // （`parse_nth_of`）側で切り出す。ここでは念のため `of` 以降が残っていても
    // 無害に切り捨てるだけの防御的処理として残す（`parse_nth` 単体呼び出しの
    // `nth-of-type`/`nth-last-of-type` は `of S` 構文自体を持たないため通常は無関係）。
    let s = full.split(" of ").next().unwrap_or(&full).trim();
    match s {
        "odd" => return (2, 1),
        "even" => return (2, 0),
        _ => {}
    }
    if let Some(npos) = s.find('n') {
        // a 部分
        let a_str = s.get(..npos).unwrap_or("").trim();
        let a: i64 = match a_str {
            "" | "+" => 1,
            "-" => -1,
            _ => a_str.parse().unwrap_or(1),
        };
        // b 部分（n の後ろ）
        let b_str: String = s
            .get(npos + 1..)
            .unwrap_or("")
            .chars()
            .filter(|c| !c.is_whitespace())
            .collect();
        let b: i64 = if b_str.is_empty() {
            0
        } else {
            b_str.parse().unwrap_or(0)
        };
        (a, b)
    } else {
        // 定数のみ → a=0, b=n
        (0, s.parse().unwrap_or(0))
    }
}

pub(crate) fn parse_selector_chain(s: &str) -> Option<Vec<SelectorStep>> {
    if s.is_empty() {
        return None;
    }

    let mut tokens: Vec<(Option<Combinator>, String)> = Vec::new();
    let chars: Vec<char> = s.chars().collect();
    let mut i = 0usize;
    let mut current = String::new();
    let mut pending_combinator: Option<Combinator> = None;
    let mut depth = 0i32; // [] () の入れ子内では結合子を区切らない。

    while i < chars.len() {
        let c = chars[i];
        if c == '[' || c == '(' {
            depth += 1;
            current.push(c);
            i += 1;
            continue;
        }
        if c == ']' || c == ')' {
            depth -= 1;
            current.push(c);
            i += 1;
            continue;
        }
        if depth > 0 {
            current.push(c);
            i += 1;
            continue;
        }
        if c == '>' || c == '+' || c == '~' {
            if !current.trim().is_empty() {
                tokens.push((pending_combinator, current.trim().to_string()));
                current.clear();
            }
            pending_combinator = Some(match c {
                '>' => Combinator::Child,
                '+' => Combinator::NextSibling,
                _ => Combinator::SubsequentSibling,
            });
            i += 1;
            while i < chars.len() && chars[i].is_ascii_whitespace() {
                i += 1;
            }
            continue;
        }
        if c.is_ascii_whitespace() {
            if !current.trim().is_empty() {
                tokens.push((pending_combinator, current.trim().to_string()));
                current.clear();
                pending_combinator = Some(Combinator::Descendant);
            }
            i += 1;
            while i < chars.len() && chars[i].is_ascii_whitespace() {
                i += 1;
            }
            continue;
        }
        current.push(c);
        i += 1;
    }
    if !current.trim().is_empty() {
        tokens.push((pending_combinator, current.trim().to_string()));
    }
    if tokens.is_empty() {
        return None;
    }

    let mut steps = Vec::new();
    for (idx, (comb, tok)) in tokens.into_iter().enumerate() {
        let simple = parse_simple_selector(&tok)?;
        let combinator = if idx == 0 { None } else { comb };
        steps.push(SelectorStep { simple, combinator });
    }
    Some(steps)
}

pub(crate) fn is_selector_ident_char(c: char) -> bool {
    c.is_ascii_alphanumeric() || c == '-' || c == '_'
}

/// セレクタの特異度 (id数, class/属性/擬似クラス数, タグ数) を算出する。
/// CSS Selectors Level 4 の規定に従い、`:not()`/`:is()` はその引数の特異度を
/// （`:is()` は引数中の最大値を）加算し、`:where()` は常に0を加算する
/// （それ以外の擬似クラスは従来通り class 数として1を加算）。
pub(crate) fn simple_specificity(sel: &SimpleSelector) -> (u32, u32, u32) {
    let mut spec = (
        sel.id.as_ref().map_or(0u32, |_| 1),
        sel.class.len() as u32 + sel.attrs.len() as u32,
        sel.tag_name.as_ref().map_or(0u32, |_| 1),
    );
    for pc in &sel.pseudo_classes {
        let add = match pc {
            PseudoClass::Not(inner) => simple_specificity(inner.as_ref()),
            PseudoClass::Is(list) => list.iter().map(simple_specificity).max().unwrap_or((0, 0, 0)),
            PseudoClass::Has(list) => list
                .iter()
                .map(|(_, sel)| simple_specificity(sel))
                .max()
                .unwrap_or((0, 0, 0)),
            PseudoClass::Where(_) => (0, 0, 0),
            _ => (0, 1, 0),
        };
        spec.0 += add.0;
        spec.1 += add.1;
        spec.2 += add.2;
    }
    // 疑似要素（::before/::after 等）はタグ名セレクタと同じ重み（タグ数バケット）で
    // 特異度に寄与する（CSS Selectors 仕様通り）。以前はここが未加算で、
    // 疑似要素の有無が特異度計算に一切反映されないバグだった。
    if sel.pseudo_element.is_some() {
        spec.2 += 1;
    }
    spec
}

/// `::before` / `::after` の `content` 値を解析する。
/// 文字列リテラル（"..." / '...'）、`attr(name)`（対象要素自身の属性値、無ければ空）、
/// `counter(name)` / `counter(name, style)`（style 引数は無視し常に十進数表記）に対応。
/// 複数トークンの連結（例 `attr(href) " "`）も可。それ以外の未対応関数形式や
/// none/normal は「表示なし」として空文字列を返す（テキストとして誤描画しないため）。
/// `quotes: "«" "»" "‹" "›"` のような文字列リテラルの並びから、入れ子レベルごとの
/// 全ペア（レベル1, レベル2, ...）を取り出す。以前は最初の1組しか取り出さず、
/// `open-quote`/`close-quote` の入れ子（`<q>` の入れ子）に対応する複数組指定を
/// 常に無視していたが、ここで全ペアを保持し、呼び出し側（`quote_depth` を使う
/// `parse_content_value`）で入れ子レベルに応じたペアを選べるようにする。
/// 戻り値: `None`＝`quotes` 未指定（呼び出し側で既定の二重引用符へフォールバック）、
/// `Some(vec![])`＝`quotes:none`（仕様どおり何も出力しない）、
/// `Some(pairs)`＝ペア列（レベルが手持ちのペア数を超える場合は最後のペアを繰り返す、仕様どおり）。
pub(crate) fn parse_quotes_pairs(v: &str) -> Option<alloc::vec::Vec<(String, String)>> {
    let t = v.trim();
    if t.eq_ignore_ascii_case("none") {
        return Some(alloc::vec::Vec::new());
    }
    let mut lits: alloc::vec::Vec<String> = alloc::vec::Vec::new();
    let bytes = t.as_bytes();
    let mut i = 0usize;
    while i < bytes.len() {
        if bytes[i] == b'"' || bytes[i] == b'\'' {
            let quote = bytes[i];
            let start = i + 1;
            let mut j = start;
            while j < bytes.len() && bytes[j] != quote {
                j += 1;
            }
            if let Some(sub) = t.get(start..j) {
                lits.push(String::from(sub));
            }
            i = j + 1;
        } else {
            i += 1;
        }
    }
    let mut pairs: alloc::vec::Vec<(String, String)> = alloc::vec::Vec::new();
    let mut it = lits.into_iter();
    while let (Some(a), Some(b)) = (it.next(), it.next()) {
        pairs.push((a, b));
    }
    if pairs.is_empty() {
        None
    } else {
        Some(pairs)
    }
}

/// CSS文字列内のエスケープ（`\` + 1〜6桁16進 + 任意の空白1つ＝Unicodeコードポイント、
/// または `\"` 等の単純なリテラルエスケープ）をデコードする。
/// FontAwesome等のアイコンフォントは `content: "\f2c9";` のように private-use-area
/// コードポイントをこの16進エスケープで埋め込むため、これを未対応のまま生バイト列
/// （バックスラッシュ込みの文字そのまま）として扱うと、アイコン文字が表示されず
/// 代わりに "\f2c9" という文字列がそのまま描画されてしまう。
pub(crate) fn unescape_css_string(s: &str) -> String {
    let mut out = String::with_capacity(s.len());
    let mut chars = s.chars().peekable();
    while let Some(c) = chars.next() {
        if c != '\\' {
            out.push(c);
            continue;
        }
        let Some(&next) = chars.peek() else {
            break;
        };
        if next.is_ascii_hexdigit() {
            let mut hex = String::with_capacity(6);
            while hex.len() < 6 {
                match chars.peek() {
                    Some(&h) if h.is_ascii_hexdigit() => {
                        hex.push(h);
                        chars.next();
                    }
                    _ => break,
                }
            }
            if let Ok(code) = u32::from_str_radix(&hex, 16) {
                if let Some(ch) = char::from_u32(code) {
                    out.push(ch);
                }
            }
            // 仕様どおり、16進の直後の空白1つは区切りとして消費する。
            if let Some(&w) = chars.peek() {
                if w.is_ascii_whitespace() {
                    chars.next();
                }
            }
        } else {
            out.push(next);
            chars.next();
        }
    }
    out
}

pub(crate) fn parse_content_value(
    v: &str,
    attributes: &BTreeMap<String, String>,
    counters: &BTreeMap<String, i64>,
    quotes_pairs: Option<&[(String, String)]>,
    quote_depth: usize,
    counter_styles: &[CounterStyleDef],
) -> String {
    let t = v.trim();
    let mut out = String::new();
    let mut i = 0usize;
    let bytes = t.as_bytes();
    while i < bytes.len() {
        // 空白は連結トークン間の区切りなので読み飛ばす。
        if bytes[i].is_ascii_whitespace() {
            i += 1;
            continue;
        }
        if bytes[i] == b'"' || bytes[i] == b'\'' {
            let quote = bytes[i];
            let start = i + 1;
            let mut j = start;
            while j < bytes.len() && bytes[j] != quote {
                j += 1;
            }
            if let Some(sub) = t.get(start..j) {
                out.push_str(&unescape_css_string(sub));
            }
            i = j + 1;
            continue;
        }
        if let Some(rest) = t.get(i..).and_then(|r| r.strip_prefix("attr(")) {
            if let Some(close) = rest.find(')') {
                if let Some(inner) = rest.get(..close) {
                    // `attr(name, fallback)`（CSS Values and Units Level 5）の第2引数
                    // フォールバックが丸ごと未対応で、それどころかカンマ以降を含めた
                    // 文字列全体を属性名として扱ってしまい、フォールバック指定時は
                    // 常に属性名が一致せず空文字列に落ちる（本来の属性値も読めなくなる）
                    // バグだった。
                    let mut parts = inner.splitn(2, ',');
                    let name = parts.next().unwrap_or("").trim();
                    let fallback = parts.next().map(|s| {
                        let s = s.trim();
                        s.trim_matches('"').trim_matches('\'')
                    });
                    match attributes.get(name) {
                        Some(val) => out.push_str(val),
                        None => {
                            if let Some(fb) = fallback {
                                out.push_str(fb);
                            }
                        }
                    }
                }
                i += "attr(".len() + close + 1;
                continue;
            }
        }
        if let Some(rest) = t.get(i..).and_then(|r| r.strip_prefix("counter(")) {
            if let Some(close) = rest.find(')') {
                if let Some(inner) = rest.get(..close) {
                    // `counter(name)` / `counter(name, style)`: style は upper-roman/lower-roman/
                    // upper-alpha/lower-alpha に対応（list-style-type で使う既存の変換関数を再利用）。
                    // それ以外の未対応 style（decimal含む）は十進数表記にフォールバックする。
                    let mut parts = inner.splitn(2, ',');
                    let name = parts.next().unwrap_or("").trim();
                    let style = parts.next().map(|s| s.trim().to_lowercase());
                    let val = counters.get(name).copied().unwrap_or(0);
                    let val_u32 = val.max(0) as u32;
                    let formatted = match style.as_deref() {
                        Some("upper-roman") => super::super::web_engine::number_to_roman(val_u32, true),
                        Some("lower-roman") => super::super::web_engine::number_to_roman(val_u32, false),
                        Some("upper-alpha") | Some("upper-latin") => {
                            super::super::web_engine::number_to_alpha(val_u32, true)
                        }
                        Some("lower-alpha") | Some("lower-latin") => {
                            super::super::web_engine::number_to_alpha(val_u32, false)
                        }
                        // 上記の組み込みキーワードに一致しなければ、`@counter-style` で
                        // 定義されたカスタムスタイル名として登録済みか調べる。
                        Some(custom) => match counter_styles.iter().find(|d| d.name == custom) {
                            Some(def) => format_with_counter_style(def, val),
                            None => alloc::format!("{}", val),
                        },
                        None => alloc::format!("{}", val),
                    };
                    out.push_str(&formatted);
                }
                i += "counter(".len() + close + 1;
                continue;
            }
        }
        if let Some(rest) = t.get(i..).and_then(|r| r.strip_prefix("counters(")) {
            if let Some(close) = rest.find(')') {
                if let Some(inner) = rest.get(..close) {
                    // `counters(name, "sep")` / `counters(name, "sep", style)`:
                    // 本来は祖先スコープごとに積み上がった値を sep で連結するが、
                    // counter-reset/counter-increment 自体が全カウンタをフラットに共有する
                    // 簡略実装（本ファイル冒頭のコメント参照）のため、ここも同じ簡略化方針で
                    // 単一の現在値をそのまま1セグメントとして出す（sep 自体は消費するが
                    // 実質未使用）。style は counter() と同じ変換ロジックを再利用する。
                    let mut parts = inner.splitn(3, ',');
                    let name = parts.next().unwrap_or("").trim();
                    let _sep = parts.next().map(|s| {
                        s.trim()
                            .trim_matches(|c| c == '"' || c == '\'')
                            .to_string()
                    });
                    let style = parts.next().map(|s| s.trim().to_lowercase());
                    let val = counters.get(name).copied().unwrap_or(0);
                    let val_u32 = val.max(0) as u32;
                    let formatted = match style.as_deref() {
                        Some("upper-roman") => super::super::web_engine::number_to_roman(val_u32, true),
                        Some("lower-roman") => super::super::web_engine::number_to_roman(val_u32, false),
                        Some("upper-alpha") | Some("upper-latin") => {
                            super::super::web_engine::number_to_alpha(val_u32, true)
                        }
                        Some("lower-alpha") | Some("lower-latin") => {
                            super::super::web_engine::number_to_alpha(val_u32, false)
                        }
                        Some(custom) => match counter_styles.iter().find(|d| d.name == custom) {
                            Some(def) => format_with_counter_style(def, val),
                            None => alloc::format!("{}", val),
                        },
                        None => alloc::format!("{}", val),
                    };
                    out.push_str(&formatted);
                }
                i += "counters(".len() + close + 1;
                continue;
            }
        }
        // open-quote/close-quote: `quotes` プロパティが指定されていれば入れ子レベル
        // （`quote_depth`、祖先の `<q>` の個数から算出、手持ちのペア数を超えたら
        // 最後のペアを繰り返す仕様どおりの挙動）に応じたペアを使い、無指定なら既定の
        // 二重引用符（“/”）、`quotes:none` なら何も出力しない。
        // no-open-quote/no-close-quote は入れ子レベルを追跡しないため何もしない扱い。
        if let Some(rest) = t.get(i..) {
            if let Some(r2) = rest.strip_prefix("no-open-quote") {
                let _ = r2;
                i += "no-open-quote".len();
                continue;
            }
            if let Some(r2) = rest.strip_prefix("no-close-quote") {
                let _ = r2;
                i += "no-close-quote".len();
                continue;
            }
            if rest.starts_with("open-quote") {
                match quotes_pairs {
                    Some(pairs) if !pairs.is_empty() => {
                        let idx = quote_depth.min(pairs.len() - 1);
                        out.push_str(&pairs[idx].0);
                    }
                    Some(_) => {} // quotes:none — 何も出力しない
                    None => out.push('\u{201C}'),
                }
                i += "open-quote".len();
                continue;
            }
            if rest.starts_with("close-quote") {
                match quotes_pairs {
                    Some(pairs) if !pairs.is_empty() => {
                        let idx = quote_depth.min(pairs.len() - 1);
                        out.push_str(&pairs[idx].1);
                    }
                    Some(_) => {} // quotes:none — 何も出力しない
                    None => out.push('\u{201D}'),
                }
                i += "close-quote".len();
                continue;
            }
        }
        // 未対応トークンは表示なし扱いで丸ごとスキップする。
        // 次のホワイトスペースまで読み飛ばして解析を継続する。
        while i < bytes.len() && !bytes[i].is_ascii_whitespace() {
            i += 1;
        }
    }
    out
}

/// `counter-reset` / `counter-increment` 宣言をパースし、`name [value]` の
/// 空白区切りペア列として (name, value) を返す。value 省略時は `default` を使う
/// （reset のデフォルトは 0、increment のデフォルトは 1）。`none` は空を返す。
pub(crate) fn parse_counter_decl(v: &str, default: i64) -> alloc::vec::Vec<(String, i64)> {
    let t = v.trim();
    if t.is_empty() || t.eq_ignore_ascii_case("none") {
        return alloc::vec::Vec::new();
    }
    let tokens: alloc::vec::Vec<&str> = t.split_whitespace().collect();
    let mut out = alloc::vec::Vec::new();
    let mut i = 0usize;
    while i < tokens.len() {
        let name = tokens[i];
        i += 1;
        let value = if i < tokens.len() {
            if let Ok(n) = tokens[i].parse::<i64>() {
                i += 1;
                n
            } else {
                default
            }
        } else {
            default
        };
        out.push((name.to_string(), value));
    }
    out
}

/// `counter-reset` / `counter-increment` を現在のカウンタ集合に適用する。
/// 戻り値は、この要素自身が `counter-reset` した（＝新しいスコープを作った）カウンタ名の集合。
/// 呼び出し側（`style_tree_with_ancestors_vars`）が、この集合を使って「入れ子の
/// `counter-reset` の効果を兄弟要素へ漏らさない」というスコープ復元を行う
/// （`apply_counter_decls` 自体はフラットな1つのマップを直接書き換えるだけで、
/// スコープの概念は呼び出し側が別途管理する）。
pub(crate) fn apply_counter_decls(
    specified_values: &BTreeMap<String, String>,
    counters: &mut BTreeMap<String, i64>,
) -> alloc::collections::BTreeSet<String> {
    let mut reset_names = alloc::collections::BTreeSet::new();
    if let Some(reset) = specified_values.get("counter-reset") {
        for (name, value) in parse_counter_decl(reset, 0) {
            counters.insert(name.clone(), value);
            reset_names.insert(name);
        }
    }
    if let Some(incr) = specified_values.get("counter-increment") {
        for (name, value) in parse_counter_decl(incr, 1) {
            let cur = counters.get(&name).copied().unwrap_or(0);
            counters.insert(name, cur + value);
        }
    }
    reset_names
}

/// セレクタ末尾（サブジェクトのコンパウンドセレクタ）に付与された疑似要素を返す。
/// `::before` / `::after` は末尾にのみ意味を持つため最後のステップだけを見る。
pub(crate) fn selector_pseudo_element(sel: &Selector) -> Option<PseudoElement> {
    match sel {
        Selector::Simple(s) => s.pseudo_element,
        Selector::Chain(steps) => steps.last().and_then(|s| s.simple.pseudo_element),
    }
}

pub(crate) fn selector_specificity(sel: &Selector) -> (u32, u32, u32) {
    match sel {
        Selector::Simple(s) => simple_specificity(s),
        Selector::Chain(steps) => {
            let mut a = 0u32;
            let mut b = 0u32;
            let mut c = 0u32;
            for step in steps {
                let (sa, sb, sc) = simple_specificity(&step.simple);
                a += sa;
                b += sb;
                c += sc;
            }
            (a, b, c)
        }
    }
}

fn is_node_disabled(node: &Node, ancestors: &[AncestorContext<'_>]) -> bool {
    if let NodeType::Element { attributes, .. } = &node.node_type {
        if attributes.contains_key("disabled") {
            return true;
        }
    }
    for anc in ancestors {
        if let NodeType::Element { tag_name, attributes, .. } = &anc.node.node_type {
            if tag_name == "fieldset" && attributes.contains_key("disabled") {
                return true;
            }
        }
    }
    false
}

#[allow(clippy::too_many_arguments)]
pub(crate) fn matches_simple_selector(
    tag_name: &str,
    id: &Option<String>,
    classes: &Vec<String>,
    attributes: &BTreeMap<String, String>,
    sel: &SimpleSelector,
    sibling_index: Option<usize>,
    sibling_count: Option<usize>,
    active_pseudo_states: &[&str],
    type_index: Option<usize>,
    type_count: Option<usize>,
    is_empty: bool,
    node_ptr: usize,
    node_children: &[Node],
    own_siblings: Option<&[Node]>,
    is_disabled: bool,
) -> bool {
    if let Some(sel_tag) = &sel.tag_name {
        if sel_tag != tag_name {
            return false;
        }
    }
    if let Some(sel_id) = &sel.id {
        if id.as_ref() != Some(sel_id) {
            return false;
        }
    }
    for need in &sel.class {
        if !classes.iter().any(|c| c == need) {
            return false;
        }
    }
    for attr in &sel.attrs {
        if !attr_matches(attr, attributes) {
            return false;
        }
    }
    for pseudo in &sel.pseudo_classes {
        match pseudo {
            PseudoClass::FirstChild => {
                if sibling_index != Some(0) {
                    return false;
                }
            }
            PseudoClass::LastChild => match (sibling_index, sibling_count) {
                (Some(idx), Some(count)) if idx + 1 == count => {}
                _ => return false,
            },
            PseudoClass::NthChild(a, b, filter) => match filter {
                Some(sel) => match filtered_sibling_position(own_siblings, node_ptr, sel) {
                    Some((idx, _count)) => {
                        if !nth_matches(*a, *b, (idx + 1) as i64) {
                            return false;
                        }
                    }
                    None => return false,
                },
                None => match sibling_index {
                    Some(idx) => {
                        if !nth_matches(*a, *b, (idx + 1) as i64) {
                            return false;
                        }
                    }
                    None => return false,
                },
            },
            PseudoClass::NthLastChild(a, b, filter) => match filter {
                Some(sel) => match filtered_sibling_position(own_siblings, node_ptr, sel) {
                    Some((idx, count)) => {
                        if !nth_matches(*a, *b, (count - idx) as i64) {
                            return false;
                        }
                    }
                    None => return false,
                },
                None => match (sibling_index, sibling_count) {
                    (Some(idx), Some(count)) => {
                        if !nth_matches(*a, *b, (count - idx) as i64) {
                            return false;
                        }
                    }
                    _ => return false,
                },
            },
            PseudoClass::Checked => {
                if !attributes.contains_key("checked") {
                    return false;
                }
            }
            // `:disabled`は要素自身の`disabled`属性だけでなく、祖先の
            // `<fieldset disabled>`による暗黙の無効化も反映する必要がある
            // （`is_node_disabled`が計算した`is_disabled`パラメータが
            // 既にこれを含む）。以前は自身の属性だけを見ていたため、
            // `<fieldset disabled><input></fieldset>`のような暗黙無効化
            // ケースで`:disabled`がマッチしないバグだった（同じロジックが
            // `PseudoClass::Other("disabled")`アームに正しく実装済み
            // だったが、パーサが`"disabled"`を専用の`PseudoClass::
            // Disabled`列挙子へ先にマッピングするため、そちらのアームが
            // 到達不能な死んだコードになっていた）。2026-07-18 発見・
            // 修正）。
            PseudoClass::Disabled => {
                if !is_disabled {
                    return false;
                }
            }
            PseudoClass::FirstOfType => {
                if type_index != Some(0) {
                    return false;
                }
            }
            PseudoClass::LastOfType => match (type_index, type_count) {
                (Some(idx), Some(count)) if idx + 1 == count => {}
                _ => return false,
            },
            PseudoClass::NthOfType(a, b) => match type_index {
                Some(idx) => {
                    if !nth_matches(*a, *b, (idx + 1) as i64) {
                        return false;
                    }
                }
                None => return false,
            },
            PseudoClass::NthLastOfType(a, b) => match (type_index, type_count) {
                (Some(idx), Some(count)) => {
                    if !nth_matches(*a, *b, (count - idx) as i64) {
                        return false;
                    }
                }
                _ => return false,
            },
            PseudoClass::OnlyOfType => match (type_index, type_count) {
                (Some(0), Some(1)) => {}
                _ => return false,
            },
            PseudoClass::OnlyChild => match (sibling_index, sibling_count) {
                (Some(0), Some(1)) => {}
                _ => return false,
            },
            PseudoClass::Target => {
                let current = super::super::layout::CURRENT_TARGET_ID.lock();
                if current.is_empty() || id.as_deref() != Some(current.as_str()) {
                    return false;
                }
            }
            PseudoClass::Empty => {
                if !is_empty {
                    return false;
                }
            }
            PseudoClass::Not(inner) => {
                if matches_simple_selector(
                    tag_name,
                    id,
                    classes,
                    attributes,
                    inner,
                    sibling_index,
                    sibling_count,
                    active_pseudo_states,
                    type_index,
                    type_count,
                    is_empty,
                    node_ptr,
                    node_children,
                    own_siblings,
                    is_disabled,
                ) {
                    return false;
                }
            }
            PseudoClass::Is(list) | PseudoClass::Where(list) => {
                let any_match = list.iter().any(|inner| {
                    matches_simple_selector(
                        tag_name,
                        id,
                        classes,
                        attributes,
                        inner,
                        sibling_index,
                        sibling_count,
                        active_pseudo_states,
                        type_index,
                        type_count,
                        is_empty,
                        node_ptr,
                        node_children,
                        own_siblings,
                        is_disabled,
                    )
                });
                if !any_match {
                    return false;
                }
            }
            PseudoClass::Has(list) => {
                let (sibling_list, descendant_list): (
                    Vec<&(HasCombinator, SimpleSelector)>,
                    Vec<&(HasCombinator, SimpleSelector)>,
                ) = list.iter().partition(|(comb, _)| {
                    matches!(comb, HasCombinator::NextSibling | HasCombinator::SubsequentSibling)
                });
                let sibling_ok = !sibling_list.is_empty()
                    && own_siblings.zip(sibling_index).is_some_and(|(sibs, my_idx)| {
                        sibling_list.iter().any(|(comb, sel)| {
                            has_sibling_match(sibs, my_idx, *comb == HasCombinator::NextSibling, sel)
                        })
                    });
                let descendant_ok = !descendant_list.is_empty()
                    && {
                        let owned: Vec<(bool, SimpleSelector)> = descendant_list
                            .iter()
                            .map(|(comb, sel)| (*comb == HasCombinator::Child, sel.clone()))
                            .collect();
                        has_descendant_match(node_children, &owned)
                    };
                if !sibling_ok && !descendant_ok {
                    return false;
                }
            }
            PseudoClass::Dir(target) => {
                let effective = attributes
                    .get("dir")
                    .map(|v| v.trim().to_lowercase())
                    .filter(|v| v == "ltr" || v == "rtl")
                    .unwrap_or_else(|| String::from("ltr"));
                if effective != *target {
                    return false;
                }
            }
            PseudoClass::Lang(target) => {
                let own_lang = attributes.get("lang").map(|v| v.to_lowercase());
                let effective = match own_lang {
                    Some(l) if !l.is_empty() => l,
                    _ => super::super::layout::DOCUMENT_LANG.lock().clone(),
                };
                let matched = !effective.is_empty()
                    && (effective == *target
                        || effective.starts_with(&alloc::format!("{}-", target)));
                if !matched {
                    return false;
                }
            }
            PseudoClass::Other(p) => match p.as_str() {
                // `:checked`/`:disabled` は要素自身の属性から静的に判定できるため、
                // hover のような「動的状態リスト」の受け渡しなしに直接判定する。
                "checked" => {
                    if !attributes.contains_key("checked") {
                        return false;
                    }
                }
                "disabled" => {
                    if !is_disabled {
                        return false;
                    }
                }
                // `:enabled`（`:disabled` の対）が丸ごと未対応だった。既存の
                // `:disabled`/`:read-write` と同じ簡略方針（タグ種別は問わず
                // `disabled` 属性の有無だけで判定）に合わせ、単純にその否定とする。
                "enabled" => {
                    if is_disabled {
                        return false;
                    }
                }
                "required" => {
                    if !attributes.contains_key("required") {
                        return false;
                    }
                }
                // `:optional` は `:required` の否定（`required` 属性が無いフォーム要素）。
                "optional" => {
                    if attributes.contains_key("required") {
                        return false;
                    }
                }
                // `:valid`/`:invalid` が丸ごと未対応だった。`:checked`/`:required`/
                // `:in-range` 等と同じ簡略方針で、静的な HTML 属性のみから判定する
                // （`pattern`/`type=email` 等の書式チェックは JS 側の `validate_field`
                // に既にあるロジックをそのまま複製することになり css.rs 側の担当範囲を
                // 超えるため対象外。ここでは最も頻出する「`required` な空欄」と
                // `:in-range`/`:out-of-range` で既に対応済みの min/max 範囲のみを見る）。
                // checkbox/radio は「値」でなく「チェック状態」で`required`を判定する
                // 別のセマンティクス（JS側の`is_disabled`と対になる`required_satisfied`
                // で2026-07-17に修正済みの規則と同じ）。以前はここも他のinputと同じ
                // 「value属性が空か」で判定しており、`value`属性を持たないchecked済み
                // チェックボックスが常に`:invalid`になる等、チェック状態と無関係な
                // 結果になっていた。radioのグループ判定は`own_siblings`（同じ親を持つ
                // 兄弟のみ）の範囲に限定する簡略実装（JS側は文書全体を`name`で走査する
                // 完全な実装だが、CSSセレクタマッチングはこの関数の他の兄弟系疑似
                // クラスと同じスコープに合わせる）。
                // `:user-valid`/`:user-invalid`（CSS Selectors Level 4）が丸ごと
                // 未対応だった。`:valid`/`:invalid`と同一の妥当性判定ロジックに
                // 加え、ユーザーが実際にフォームコントロールを操作したこと
                // （`interp.rs`の`dispatch_event`が`input`/`change`発火時に
                // 記録する内部専用属性`_user_interacted`。`:indeterminate`の
                // `_indeterminate`と同じ方針）も要求する点のみ異なる。
                // 2026-07-18 発見・実装。
                "valid" | "invalid" | "user-valid" | "user-invalid" => {
                    let value = attributes.get("value").map(|s| s.trim()).unwrap_or("");
                    let ty = attributes.get("type").map(|s| s.as_str()).unwrap_or("");
                    let required_empty = if !attributes.contains_key("required") {
                        false
                    } else if tag_name == "input" && ty == "checkbox" {
                        !attributes.contains_key("checked")
                    } else if tag_name == "input" && ty == "radio" {
                        let group_checked = attributes.get("name").is_some_and(|nm| {
                            own_siblings.is_some_and(|sibs| {
                                sibs.iter().any(|sib| {
                                    if let NodeType::Element {
                                        tag_name: st,
                                        attributes: sa,
                                        ..
                                    } = &sib.node_type
                                    {
                                        st == "input"
                                            && sa.get("type").map(|t| t == "radio").unwrap_or(false)
                                            && sa.get("name") == Some(nm)
                                            && sa.contains_key("checked")
                                    } else {
                                        false
                                    }
                                })
                            })
                        });
                        !(attributes.contains_key("checked") || group_checked)
                    } else {
                        value.is_empty()
                    };
                    let min = attributes.get("min").and_then(|v| v.parse::<f64>().ok());
                    let max = attributes.get("max").and_then(|v| v.parse::<f64>().ok());
                    let out_of_range = if min.is_some() || max.is_some() {
                        value.parse::<f64>().ok().map(|v| {
                            !(min.is_none_or(|m| v >= m) && max.is_none_or(|m| v <= m))
                        })
                    } else {
                        None
                    }
                    .unwrap_or(false);
                    let is_invalid = required_empty || out_of_range;
                    let is_user_variant = p.as_str().starts_with("user-");
                    if is_user_variant && !attributes.contains_key("_user_interacted") {
                        return false;
                    }
                    let want_valid = p.as_str() == "valid" || p.as_str() == "user-valid";
                    if is_invalid == want_valid {
                        return false;
                    }
                }
                "readonly" | "read-only" => {
                    if !attributes.contains_key("readonly") {
                        return false;
                    }
                }
                // `:read-write`（`:read-only`/`:readonly` の対）が丸ごと未対応
                // だった。既存の `:read-only` と同じ簡略方針（タグ種別は問わず
                // `readonly` 属性の有無だけで判定）に合わせ、単純にその否定とする。
                "read-write" => {
                    if attributes.contains_key("readonly") {
                        return false;
                    }
                }
                // `:indeterminate` は本来 JS で設定される DOM プロパティ（HTML属性としては
                // 反映されない）。静的 HTML に `indeterminate` 属性が直接書かれている
                // ケース、`<progress>`（value 未指定）、そして `checkbox.indeterminate =
                // true`（JS の setter が書き込む内部専用の `_indeterminate` 属性キー。
                // 実属性 `indeterminate` とは別物で `hasAttribute('indeterminate')` は
                // 常に false のまま）の3パターンいずれかで真とする。
                "indeterminate" => {
                    let is_indeterminate_progress =
                        tag_name == "progress" && !attributes.contains_key("value");
                    let matched = attributes.contains_key("indeterminate")
                        || attributes.contains_key("_indeterminate")
                        || is_indeterminate_progress;
                    if !matched {
                        return false;
                    }
                }
                // `:focus-visible` はキーボード操作かポインタ操作かを区別する仕組みが
                // 無いため、`:focus` と同一視する簡略実装（`:where()`≒`:is()` と同じ方針）。
                "focus-visible" => {
                    if !active_pseudo_states.contains(&"focus") {
                        return false;
                    }
                }
                // `:focus-within` は自分自身、または子孫のいずれかが現在フォーカス中の
                // 場合に一致する。id ではなくノード実体のポインタ同一性で判定するため、
                // id を持たない要素（`<div>`/`<form>` のラッパー等）でも正しく機能する。
                "focus-within" => {
                    if !super::super::layout::FOCUS_WITHIN_PTRS.lock().contains(&node_ptr) {
                        return false;
                    }
                }
                // `:link`/`:visited` は `:checked`/`:disabled` と同様、要素自身の属性から
                // 静的に判定できる。閲覧履歴は保持していないため `:visited` は常に不一致
                // （プライバシー上安全側の簡略実装。多くの単純なエンジンや履歴を持たない
                // 環境と同じ挙動）。
                "link" => {
                    if !(tag_name == "a" || tag_name == "area") || !attributes.contains_key("href")
                    {
                        return false;
                    }
                }
                "visited" => {
                    return false;
                }
                // `:defined`（Selectors Level 4。標準組み込み要素は常に「定義済み」、
                // 未定義の`customElements`要素のみ不一致になる仕様）が丸ごと未対応
                // だった。この処理系は`customElements.define()`自体が未実装（別途
                // TODO.md「HTML5」節に大規模ギャップとして記載済み）で、パース
                // されるタグは全て標準組み込み要素のみのため、常に一致する
                // 「正直な簡略実装」（`:visited`が常に不一致なのと対称）。
                // 2026-07-18 発見・実装。
                "defined" => {}
                // `:fullscreen`が丸ごと未対応だった。`element.requestFullscreen()`が
                // 書き込む内部専用属性`_fullscreen`（`_indeterminate`と同じ方針）の
                // 有無で判定する。2026-07-18 発見・実装。
                "fullscreen" => {
                    if !attributes.contains_key("_fullscreen") {
                        return false;
                    }
                }
                // `:modal`が丸ごと未対応だった。フルスクリーン要素、および
                // `dialog.showModal()`（`.show()`とは区別される。`dom.rs`の
                // `dom_dialog_show_modal`が書き込む内部専用属性`_modal`）で
                // 開いている`<dialog>`のいずれかに一致する。2026-07-18
                // 発見・実装。
                "modal" => {
                    if !attributes.contains_key("_fullscreen") && !attributes.contains_key("_modal")
                    {
                        return false;
                    }
                }
                // `:popover-open`が丸ごと未対応だった。`element.showPopover()`/
                // `.hidePopover()`/`.togglePopover()`（`dom.rs`）が既に
                // 内部専用属性`_popover_open`を書き込んでいたため、CSS側の
                // 判定を追加するだけで済んだ（`:fullscreen`/`:modal`と違い
                // JS側の新規実装が不要だった兄弟ギャップ）。2026-07-18
                // 発見・実装。
                "popover-open" => {
                    if !attributes.contains_key("_popover_open") {
                        return false;
                    }
                }
                // `:root` は文書のルート要素（HTML文書では常に <html>）にのみ一致する。
                "root" => {
                    if tag_name != "html" {
                        return false;
                    }
                }
                // `:placeholder-shown` は `value` が空(または未指定)かつ `placeholder` 属性を
                // 持つ input/textarea にのみ一致する。checked/disabled と同様、属性から
                // 静的判定できる。**簡略化**: 初期パース時の `value` 属性のみを見るため、
                // ユーザーが実際に入力欄へ入力した後の再判定（動的な再マッチング）は非対応。
                "placeholder-shown" => {
                    let has_placeholder = attributes
                        .get("placeholder")
                        .map(|p| !p.is_empty())
                        .unwrap_or(false);
                    let value_empty = attributes
                        .get("value")
                        .map(|v| v.is_empty())
                        .unwrap_or(true);
                    if !has_placeholder || !value_empty {
                        return false;
                    }
                }
                // `:in-range`/`:out-of-range` は `min`/`max` 属性を持つ input の `value` が
                // その範囲内/範囲外かで判定する。checked/required 等と同様、静的な HTML 属性
                // から判定できる（JS による動的な value 変更後の再判定は非対応の簡略実装）。
                // min/max のどちらも指定が無ければ範囲制約自体が存在しないため、どちらにも
                // 一致しない（実ブラウザと同じ挙動）。
                "in-range" | "out-of-range" => {
                    let min = attributes.get("min").and_then(|v| v.parse::<f64>().ok());
                    let max = attributes.get("max").and_then(|v| v.parse::<f64>().ok());
                    if min.is_none() && max.is_none() {
                        return false;
                    }
                    let value = attributes.get("value").and_then(|v| v.parse::<f64>().ok());
                    let in_range = match value {
                        Some(v) => min.is_none_or(|m| v >= m) && max.is_none_or(|m| v <= m),
                        // value 未指定は制約違反ではない（実ブラウザ準拠）。
                        None => true,
                    };
                    let want_in_range = p.as_str() == "in-range";
                    if in_range != want_in_range {
                        return false;
                    }
                }
                // `:default` は「グループ内で既定選択された要素」（フォーム送信時にJSが何も
                // 変更しなければ選ばれる状態）を指す。`:checked`/`:required` と同じく静的な
                // HTML属性から判定する簡略実装: checkbox/radio は `checked` 属性、
                // `<option>` は `selected` 属性の有無で判定する（ユーザー操作後の動的な
                // 「既定値からの変化」追跡は非対応。実ブラウザは操作後も初期選択を
                // `:default` として扱い続けるが、ここでは常に静的属性を見る近似）。
                "default" => {
                    let is_checkable = attributes
                        .get("type")
                        .map(|t| t == "checkbox" || t == "radio")
                        .unwrap_or(false);
                    let matched = if tag_name == "option" {
                        attributes.contains_key("selected")
                    } else if tag_name == "input" && is_checkable {
                        attributes.contains_key("checked")
                    } else {
                        false
                    };
                    if !matched {
                        return false;
                    }
                }
                _ => {
                    if !active_pseudo_states.contains(&p.as_str()) {
                        return false;
                    }
                }
            },
        }
    }
    true
}

/// 親の子ノード一覧の中で、`node` と同じタグ名を持つノードだけを数えた「型フィルタ済み」
/// 兄弟位置(0-based)と総数を返す。`:first-of-type`/`:last-of-type`/`:nth-of-type`/
/// `:only-of-type` 用。祖先が無い（ルート要素）場合は自分だけの単一グループとして扱う。
/// サブジェクト（末尾コンパウンド）位置でのみ計算する（祖先位置での of-type 判定は非対応）。
pub(crate) fn type_sibling_position(
    node: &Node,
    ancestors: &[AncestorContext<'_>],
    sibling_index: Option<usize>,
) -> (Option<usize>, Option<usize>) {
    let NodeType::Element { tag_name, .. } = &node.node_type else {
        return (None, None);
    };
    let Some(parent_ctx) = ancestors.last() else {
        return (Some(0), Some(1));
    };
    let Some(my_idx) = sibling_index else {
        return (None, None);
    };
    let mut type_idx = None;
    let mut type_count = 0usize;
    for (i, child) in parent_ctx.node.children.iter().enumerate() {
        if let NodeType::Element { tag_name: t, .. } = &child.node_type {
            if t == tag_name {
                if i == my_idx {
                    type_idx = Some(type_count);
                }
                type_count += 1;
            }
        }
    }
    (type_idx, Some(type_count))
}

/// nth: position が a*n + b（n>=0）で表せるか。
pub(crate) fn nth_matches(a: i64, b: i64, position: i64) -> bool {
    if a == 0 {
        return position == b;
    }
    let diff = position - b;
    diff % a == 0 && diff / a >= 0
}

/// 属性セレクタの照合。
pub(crate) fn attr_matches(attr: &AttrSelector, attributes: &BTreeMap<String, String>) -> bool {
    // 属性名は小文字保持されている前提（dom 側で lower 化されていなければ線形探索）。
    let val = attributes.get(&attr.name).or_else(|| {
        attributes
            .iter()
            .find(|(k, _)| k.to_lowercase() == attr.name)
            .map(|(_, v)| v)
    });
    let val = match val {
        Some(v) => v,
        None => return false, // 属性が無ければどの演算子も不一致。
    };
    // `[attr=val i]`（大文字小文字を無視。Selectors Level 4 §6.4.1）。フラグが無ければ
    // 通常どおり大文字小文字を区別して比較する（`val`/`attr.value` をそのまま使う）。
    let (val_cmp, need_cmp): (String, String) = if attr.case_insensitive {
        (val.to_lowercase(), attr.value.to_lowercase())
    } else {
        (val.clone(), attr.value.clone())
    };
    let val = &val_cmp;
    let attr_value = &need_cmp;
    match attr.op {
        AttrOp::Exists => true,
        AttrOp::Eq => val == attr_value,
        AttrOp::Prefix => !attr_value.is_empty() && val.starts_with(attr_value.as_str()),
        AttrOp::Suffix => !attr_value.is_empty() && val.ends_with(attr_value.as_str()),
        AttrOp::Contains => !attr_value.is_empty() && val.contains(attr_value.as_str()),
        AttrOp::Word => val.split_whitespace().any(|w| w == attr_value),
        AttrOp::Dash => {
            val == attr_value || val.starts_with(&alloc::format!("{}-", attr_value))
        }
    }
}

/// 1 ノードに対して**一度だけ**計算すればよい照合用の前提情報。
///
/// 【2026-07-27 性能修正】従来これらは `matches_selector` の内部で
/// **ルールごとに毎回**計算されていた。実サイト規模（2403 ルール × 365 ノード
/// ＝ 約 88 万回）では、祖先を辿る `is_node_disabled` と兄弟を数える
/// `type_sibling_position` が支配的なコストになり、1 回のカスケードに
/// 約 46 秒を要していた。ノード単位で 1 回計算して使い回す。
pub(crate) struct NodeMatchContext<'a> {
    pub is_disabled: bool,
    pub type_index: Option<usize>,
    pub type_count: Option<usize>,
    pub own_siblings: Option<&'a [Node]>,
}

impl<'a> NodeMatchContext<'a> {
    pub fn new(
        current: &Node,
        ancestors: &'a [AncestorContext<'a>],
        sibling_index: Option<usize>,
    ) -> Self {
        let is_disabled = is_node_disabled(current, ancestors);
        // of-type 系はサブジェクト（末尾コンパウンド）でのみ判定する。
        let (type_index, type_count) = type_sibling_position(current, ancestors, sibling_index);
        // `:has(+ sel)`/`:has(~ sel)` 用。サブジェクト位置の自分の兄弟一覧。
        let own_siblings = ancestors.last().map(|a| a.node.children.as_slice());
        Self {
            is_disabled,
            type_index,
            type_count,
            own_siblings,
        }
    }
}

pub(crate) fn matches_selector(
    selector: &Selector,
    current: &Node,
    ancestors: &[AncestorContext<'_>],
    sibling_index: Option<usize>,
    sibling_count: Option<usize>,
    active_pseudo_states: &[&str],
    ctx: &NodeMatchContext<'_>,
) -> bool {
    let is_disabled = ctx.is_disabled;
    let (type_index, type_count) = (ctx.type_index, ctx.type_count);
    let own_siblings = ctx.own_siblings;
    match selector {
        Selector::Simple(simple) => matches_selector_step_node(
            current,
            simple,
            sibling_index,
            sibling_count,
            active_pseudo_states,
            type_index,
            type_count,
            own_siblings,
            is_disabled,
        ),
        Selector::Chain(steps) => matches_selector_chain(
            steps,
            current,
            ancestors,
            sibling_index,
            sibling_count,
            active_pseudo_states,
            type_index,
            type_count,
            own_siblings,
            is_disabled,
        ),
    }
}

#[allow(clippy::too_many_arguments)]
pub(crate) fn matches_selector_step_node(
    node: &Node,
    simple: &SimpleSelector,
    sibling_index: Option<usize>,
    sibling_count: Option<usize>,
    active_pseudo_states: &[&str],
    type_index: Option<usize>,
    type_count: Option<usize>,
    own_siblings: Option<&[Node]>,
    is_disabled: bool,
) -> bool {
    match &node.node_type {
        NodeType::Element {
            tag_name,
            classes,
            id,
            attributes,
        } => matches_simple_selector(
            tag_name,
            id,
            classes,
            attributes,
            simple,
            sibling_index,
            sibling_count,
            active_pseudo_states,
            type_index,
            type_count,
            node.children.is_empty(),
            node as *const Node as usize,
            &node.children,
            own_siblings,
            is_disabled,
        ),
        NodeType::Text(_) => false,
    }
}

/// `:has(sel1, sel2, ...)` 判定用: `children` 以下にリスト中いずれかの単純セレクタへ
/// 一致する要素が存在するかを探索する。タプルの `bool` が true（`> sel` 形式）の枝は
/// `children`（直接子）のみを見て、それより深くは再帰しない。false（通常の `:has(.foo)`）の
/// 枝は任意の深さまで再帰する。子孫側の疑似クラス判定は sibling_index 等の文脈を持たない
/// ため `None`/空リストで簡略化して渡す（`:has(.foo)` のようなタグ/クラス/id/属性ベースの
/// 判定が主な実用対象で、`:has(:first-child)` 等の兄弟文脈依存の疑似クラスは子孫探索側では
/// 正しく判定できない既知の制約）。
pub(crate) fn has_descendant_match(children: &[Node], list: &[(bool, SimpleSelector)]) -> bool {
    for child in children {
        if let NodeType::Element {
            tag_name,
            id,
            classes,
            attributes,
        } = &child.node_type
        {
            for (_, sel) in list {
                let is_disabled = attributes.contains_key("disabled");
                if matches_simple_selector(
                    tag_name,
                    id,
                    classes,
                    attributes,
                    sel,
                    None,
                    None,
                    &[],
                    None,
                    None,
                    child.children.is_empty(),
                    child as *const Node as usize,
                    &child.children,
                    None,
                    is_disabled,
                ) {
                    return true;
                }
            }
        }
        // 直接子限定（`> sel`）の枝は、これより深い子孫へは適用しない。
        let deeper_list: Vec<(bool, SimpleSelector)> = list
            .iter()
            .filter(|(direct_only, _)| !direct_only)
            .cloned()
            .collect();
        if !deeper_list.is_empty() && has_descendant_match(&child.children, &deeper_list) {
            return true;
        }
    }
    false
}

/// `:has(+ sel)`/`:has(~ sel)` 判定用: `siblings`（親の子ノード一覧）中の `my_idx` より
/// 後ろの要素ノードで `sel` に一致するものがあるか探索する。`adjacent` が true なら
/// 直後の要素兄弟1つのみ（`+`）、false なら以降の要素兄弟いずれか（`~`）を対象にする。
pub(crate) fn has_sibling_match(siblings: &[Node], my_idx: usize, adjacent: bool, sel: &SimpleSelector) -> bool {
    for sib in siblings.iter().skip(my_idx + 1) {
        if let NodeType::Element {
            tag_name,
            id,
            classes,
            attributes,
        } = &sib.node_type
        {
            let is_disabled = attributes.contains_key("disabled");
            if matches_simple_selector(
                tag_name,
                id,
                classes,
                attributes,
                sel,
                None,
                None,
                &[],
                None,
                None,
                sib.children.is_empty(),
                sib as *const Node as usize,
                &sib.children,
                None,
                is_disabled,
            ) {
                return true;
            }
            if adjacent {
                return false;
            }
        }
    }
    false
}

/// `:nth-child(An+B of S)`/`:nth-last-child(An+B of S)` 判定用: `own_siblings`（親の子ノード
/// 一覧）のうち `S` に一致する要素だけを数えた「フィルタ済み」0-based 位置と総数を返す。
/// 自分自身が `S` に一致しない場合は `None`（=不一致。フィルタ済み集合に属さない）。
pub(crate) fn filtered_sibling_position(
    own_siblings: Option<&[Node]>,
    node_ptr: usize,
    sel: &SimpleSelector,
) -> Option<(usize, usize)> {
    let siblings = own_siblings?;
    let mut my_pos = None;
    let mut count = 0usize;
    for sib in siblings {
        if let NodeType::Element {
            tag_name,
            id,
            classes,
            attributes,
        } = &sib.node_type
        {
            let is_disabled = attributes.contains_key("disabled");
            let is_match = matches_simple_selector(
                tag_name,
                id,
                classes,
                attributes,
                sel,
                None,
                None,
                &[],
                None,
                None,
                sib.children.is_empty(),
                sib as *const Node as usize,
                &sib.children,
                None,
                is_disabled,
            );
            if is_match {
                if sib as *const Node as usize == node_ptr {
                    my_pos = Some(count);
                }
                count += 1;
            }
        }
    }
    my_pos.map(|idx| (idx, count))
}

#[allow(clippy::too_many_arguments)]
pub(crate) fn matches_selector_chain(
    steps: &[SelectorStep],
    current: &Node,
    ancestors: &[AncestorContext<'_>],
    sibling_index: Option<usize>,
    sibling_count: Option<usize>,
    active_pseudo_states: &[&str],
    type_index: Option<usize>,
    type_count: Option<usize>,
    own_siblings: Option<&[Node]>,
    is_disabled: bool,
) -> bool {
    if steps.is_empty() {
        return false;
    }
    let mut idx = steps.len() - 1;
    if !matches_selector_step_node(
        current,
        &steps[idx].simple,
        sibling_index,
        sibling_count,
        active_pseudo_states,
        type_index,
        type_count,
        own_siblings,
        is_disabled,
    ) {
        return false;
    }

    let mut anc_pos = ancestors.len();
    // 兄弟結合子用に「現在ノードの兄弟内インデックス」を追跡する。
    let mut cur_sib_index = sibling_index;
    while idx > 0 {
        let comb = steps[idx].combinator.unwrap_or(Combinator::Descendant);
        idx -= 1;
        match comb {
            Combinator::Child => {
                if anc_pos == 0 {
                    return false;
                }
                anc_pos -= 1;
                let anc = ancestors[anc_pos];
                let anc_disabled = is_node_disabled(anc.node, &ancestors[0..anc_pos]);
                // 祖先位置の of-type 判定は非対応（None,None で常に不一致）。実用上は
                // サブジェクト位置での使用がほとんどのため許容する。
                if !matches_selector_step_node(
                    anc.node,
                    &steps[idx].simple,
                    anc.sibling_index,
                    anc.sibling_count,
                    active_pseudo_states,
                    None,
                    None,
                    None,
                    anc_disabled,
                ) {
                    return false;
                }
                cur_sib_index = anc.sibling_index;
            }
            Combinator::Descendant => {
                let mut found = false;
                while anc_pos > 0 {
                    anc_pos -= 1;
                    let anc = ancestors[anc_pos];
                    let anc_disabled = is_node_disabled(anc.node, &ancestors[0..anc_pos]);
                    if matches_selector_step_node(
                        anc.node,
                        &steps[idx].simple,
                        anc.sibling_index,
                        anc.sibling_count,
                        active_pseudo_states,
                        None,
                        None,
                        None,
                        anc_disabled,
                    ) {
                        found = true;
                        cur_sib_index = anc.sibling_index;
                        break;
                    }
                }
                if !found {
                    return false;
                }
            }
            Combinator::NextSibling | Combinator::SubsequentSibling => {
                // 親（兄弟を列挙するため）は ancestors の末尾側を消費せず参照する。
                if anc_pos == 0 {
                    return false;
                }
                let parent = ancestors[anc_pos - 1].node;
                let ci = match cur_sib_index {
                    Some(i) => i,
                    None => return false,
                };
                let count = Some(parent.children.len());
                let adjacent = comb == Combinator::NextSibling;
                let mut found = false;
                let mut j = ci;
                while j > 0 {
                    j -= 1;
                    if matches!(parent.children[j].node_type, NodeType::Element { .. }) {
                        let sib_disabled = is_node_disabled(&parent.children[j], &ancestors[0..anc_pos - 1]);
                        let m = matches_selector_step_node(
                            &parent.children[j],
                            &steps[idx].simple,
                            Some(j),
                            count,
                            active_pseudo_states,
                            None,
                            None,
                            None,
                            sib_disabled,
                        );
                        if m {
                            found = true;
                            cur_sib_index = Some(j);
                            break;
                        }
                        if adjacent {
                            // 直後兄弟は最初の要素兄弟のみが対象。一致しなければ失敗。
                            break;
                        }
                    }
                }
                if !found {
                    return false;
                }
            }
        }
    }
    true
}