# Mutants that cannot be killed by any test, with the reason each one is
# equivalent to the code it replaces. Recorded from the first two mutation runs
# of this crate (infra `c1b3900b`, 2026-08-26: 31 survivors, then 6 after the
# boundary tests landed). Excluding them is what keeps a later run's "0 missed"
# meaningful; a run that always reports six survivors teaches nobody to read it.
#
# Add to this list only with the reason written out, and only after trying to
# kill the mutant with a test. A survivor is a coverage gap until proven
# otherwise, and five of the original six looked equivalent at a glance and were
# not.
exclude_re = [
    # `CssRule::Ignored` prints as nothing, so sending it to `scopable` instead
    # of dropping it produces byte-identical CSS: `print_rules` yields "" and
    # the `scopable_css.trim().is_empty()` branch is taken either way.
    "delete match arm CssRule::Ignored in scope_and_sanitize",

    # The `worst > u32::MAX` early return at the foot of `projected_expansion`
    # is an optimisation, not a decision: anything that large is already an
    # order of magnitude past MAX_SELECTORS and is refused whether the walk
    # stops there or runs to the end. `>=` and `==` differ from `>` only at
    # exactly u32::MAX, which no stylesheet can be built to hit on purpose.
    # (`<` is NOT excluded: it returns early on the first cheap rule and misses
    # a bomb placed second, which `the_projection_walks_past_the_first_rule`
    # catches.)
    "replace > with >= in projected_expansion",
    "replace > with == in projected_expansion",

    # `flags: ParserFlags::NESTING` is inert at the pinned lightningcss version:
    # `ParserFlags::NESTING` is defined in parser.rs and read nowhere in
    # 1.0.0-alpha.71, so nesting parses regardless. The field stays because the
    # pin is deliberate and a later version may start reading the flag again,
    # but no test can observe its absence today (the reason is also at the
    # field itself, which is where a reader meets it).
    #
    # THIS ENTRY DOES NOT TAKE EFFECT, and is kept as the record. Measured
    # against cargo-mutants 27.1.0: `exclude_re` does not filter "delete field
    # X from struct Y expression" mutants at all, by any pattern, while it
    # filters every other kind. So a clean run of this crate reports one
    # survivor rather than none, and this is it.
    "delete field flags from struct ParserOptions expression in parser_options",

    # `token.ends_with('s')` and `ends_with('%')` in `update_max_iterations` are
    # a fast path, not a filter: a token they let through, such as `2s` or
    # `50%`, fails `parse::<f32>()` on the next line and is discarded there. So
    # `&&` in place of `||` changes which line rejects the token, never whether
    # it is rejected. Same for the `is_empty()` term.
    # (the pipes are escaped because these patterns are regexes, and a bare `||`
    # is an empty alternation that matches every mutant in the crate)
    "replace \\|\\| with && in update_max_iterations",
]