Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

29.7 KB
Raw Blame
use std::borrow::Cow;
use std::collections::BTreeMap;

use simd_json::borrowed::{Object, Value};

use crate::assets::{
    is_numbered_placeholder, numbered_placeholder, CSS_IMAGE_REFS_ATTR_PREFIX, PLACEHOLDER_SRC,
};
use crate::collect::{is_image_ref, is_image_ref_strict};
use crate::context::{Ctx, ImageSource};
use crate::data_uri::is_image_data_uri;
use crate::data_uri::ImageFallback;
use crate::json::{as_array_mut, as_object_mut, as_str, string_value};

pub const INLINED_STYLESHEET_ATTR: &str = "_cssText";

#[derive(Clone, Copy)]
pub enum CssContext<'a> {
    DeclarationList,
    Property(&'a str),
    Stylesheet,
}

pub struct CssRewrite {
    pub css: String,
    pub refs: BTreeMap<String, String>,
}

struct DeclarationRange {
    start: usize,
    end: usize,
    property: &'static str,
    collect_remote_urls: bool,
}

struct UrlFunctionScan {
    resume_at: usize,
    source: Option<String>,
}

const OTHER_CSS_PROPERTY: &str = "other";
const CUSTOM_CSS_PROPERTY: &str = "custom-property";

pub fn is_strict_css_refs(value: &Value<'_>) -> bool {
    let Some(encoded) = as_str(value) else {
        return false;
    };
    let Ok(refs) = serde_json::from_str::<BTreeMap<String, String>>(encoded) else {
        return false;
    };
    !refs.is_empty()
        && refs
            .values()
            .all(|reference| is_image_ref_strict(reference))
        && (0..refs.len()).all(|slot| refs.contains_key(&slot.to_string()))
}

pub fn scrub_css_images(
    ctx: &Ctx<'_>,
    container: &mut Object<'_>,
    key: &str,
    context: CssContext<'_>,
) -> bool {
    let Some(css) = container.get(key).and_then(as_str).map(str::to_string) else {
        return false;
    };
    let Some(rewrite) = rewrite(ctx, &css, context) else {
        return false;
    };
    container.insert(Cow::Owned(key.to_string()), string_value(rewrite.css));
    if !rewrite.refs.is_empty() {
        let encoded = serde_json::to_string(&rewrite.refs).expect("string map serializes");
        container.insert(
            Cow::Owned(format!("{CSS_IMAGE_REFS_ATTR_PREFIX}{key}")),
            string_value(encoded),
        );
    }
    true
}

pub fn scrub_style_sheet_rule(ctx: &Ctx<'_>, data: &mut Object<'_>) -> bool {
    let mut changed = scrub_css_images(ctx, data, "replace", CssContext::Stylesheet);
    changed |= scrub_css_images(ctx, data, "replaceSync", CssContext::Stylesheet);
    if let Some(adds) = data.get_mut("adds").and_then(as_array_mut) {
        changed |= scrub_rule_list(ctx, adds);
    }
    changed
}

pub fn scrub_style_declaration(ctx: &Ctx<'_>, data: &mut Object<'_>) -> bool {
    let Some(set) = data.get_mut("set").and_then(as_object_mut) else {
        return false;
    };
    let property = set
        .get("property")
        .and_then(as_str)
        .unwrap_or("")
        .to_string();
    scrub_css_images(ctx, set, "value", CssContext::Property(&property))
}

pub fn scrub_adopted_style_sheet(ctx: &Ctx<'_>, data: &mut Object<'_>) -> bool {
    let Some(styles) = data.get_mut("styles").and_then(as_array_mut) else {
        return false;
    };
    let mut changed = false;
    for style in styles.iter_mut() {
        if let Some(style) = as_object_mut(style) {
            if let Some(rules) = style.get_mut("rules").and_then(as_array_mut) {
                changed |= scrub_rule_list(ctx, rules);
            }
        }
    }
    changed
}

fn scrub_rule_list(ctx: &Ctx<'_>, rules: &mut Vec<Value<'_>>) -> bool {
    let mut changed = false;
    for rule in rules.iter_mut() {
        if let Some(rule) = as_object_mut(rule) {
            changed |= scrub_css_images(ctx, rule, "rule", CssContext::Stylesheet);
        }
    }
    changed
}

pub(crate) fn rewrite(ctx: &Ctx<'_>, css: &str, context: CssContext<'_>) -> Option<CssRewrite> {
    let ranges = declaration_value_ranges(css, context);
    let mut refs = BTreeMap::new();
    let mut output = String::with_capacity(css.len());
    let mut copied_to = 0;
    let mut changed = false;
    for range in ranges {
        let (rewritten, value_changed) = rewrite_value(
            ctx,
            &css[copied_to..range.start],
            OTHER_CSS_PROPERTY,
            false,
            &mut refs,
        );
        output.push_str(&rewritten);
        changed |= value_changed;
        let (rewritten, value_changed) = rewrite_value(
            ctx,
            &css[range.start..range.end],
            range.property,
            range.collect_remote_urls,
            &mut refs,
        );
        output.push_str(&rewritten);
        copied_to = range.end;
        changed |= value_changed;
    }
    let (rewritten, value_changed) =
        rewrite_value(ctx, &css[copied_to..], OTHER_CSS_PROPERTY, false, &mut refs);
    output.push_str(&rewritten);
    changed |= value_changed;
    if !changed {
        return None;
    }
    Some(CssRewrite { css: output, refs })
}

fn declaration_value_ranges(css: &str, context: CssContext<'_>) -> Vec<DeclarationRange> {
    if let CssContext::Property(property) = context {
        return css_property(property)
            .map(|(property, collect_remote_urls)| DeclarationRange {
                start: 0,
                end: css.len(),
                property,
                collect_remote_urls,
            })
            .into_iter()
            .collect();
    }

    let bytes = css.as_bytes();
    let mut ranges = Vec::new();
    let mut segment_start = 0;
    let mut brace_depth = 0usize;
    let mut paren_depth = 0usize;
    let mut bracket_depth = 0usize;
    let mut position = 0;
    while position < bytes.len() {
        if starts_with(bytes, position, b"/*") {
            position = skip_comment(bytes, position).unwrap_or(bytes.len());
            continue;
        }
        if matches!(bytes[position], b'\'' | b'"') {
            position = skip_quoted(bytes, position).unwrap_or(bytes.len());
            continue;
        }
        match bytes[position] {
            b'(' => paren_depth += 1,
            b')' => paren_depth = paren_depth.saturating_sub(1),
            b'[' => bracket_depth += 1,
            b']' => bracket_depth = bracket_depth.saturating_sub(1),
            b'{' if paren_depth == 0 && bracket_depth == 0 => {
                brace_depth += 1;
                segment_start = position + 1;
            }
            b'}' if paren_depth == 0 && bracket_depth == 0 => {
                brace_depth = brace_depth.saturating_sub(1);
                segment_start = position + 1;
            }
            b';' if paren_depth == 0 && bracket_depth == 0 => {
                segment_start = position + 1;
            }
            // A colon in a custom property value, as in `--link: https://…` or a nested block, is not a new declaration.
            b':' if paren_depth == 0
                && bracket_depth == 0
                && ranges
                    .last()
                    .is_none_or(|previous: &DeclarationRange| position >= previous.end) =>
            {
                if let Some((property, collect_remote_urls)) =
                    css_property(css[segment_start..position].trim())
                {
                    ranges.push(DeclarationRange {
                        start: position + 1,
                        end: declaration_end(bytes, position + 1, brace_depth),
                        property,
                        collect_remote_urls,
                    });
                }
            }
            _ => {}
        }
        position += 1;
    }
    ranges
}

fn css_property(property: &str) -> Option<(&'static str, bool)> {
    image_property(property)
        .map(|property| (property, true))
        .or_else(|| {
            property
                .trim()
                .starts_with("--")
                .then_some((CUSTOM_CSS_PROPERTY, false))
        })
}

fn declaration_end(bytes: &[u8], start: usize, brace_depth: usize) -> usize {
    let mut position = start;
    let mut paren_depth = 0usize;
    let mut bracket_depth = 0usize;
    while position < bytes.len() {
        if starts_with(bytes, position, b"/*") {
            position = skip_comment(bytes, position).unwrap_or(bytes.len());
            continue;
        }
        if matches!(bytes[position], b'\'' | b'"') {
            position = skip_quoted(bytes, position).unwrap_or(bytes.len());
            continue;
        }
        match bytes[position] {
            b'(' => paren_depth += 1,
            b')' => paren_depth = paren_depth.saturating_sub(1),
            b'[' => bracket_depth += 1,
            b']' => bracket_depth = bracket_depth.saturating_sub(1),
            b';' if paren_depth == 0 && bracket_depth == 0 => return position,
            b'}' if paren_depth == 0 && bracket_depth == 0 && brace_depth > 0 => return position,
            _ => {}
        }
        position += 1;
    }
    bytes.len()
}

fn image_property(property: &str) -> Option<&'static str> {
    match property.trim().to_ascii_lowercase().as_str() {
        "background" => Some("background"),
        "background-image" => Some("background-image"),
        "border-image" => Some("border-image"),
        "border-image-source" => Some("border-image-source"),
        "content" => Some("content"),
        "cursor" => Some("cursor"),
        "list-style" => Some("list-style"),
        "list-style-image" => Some("list-style-image"),
        "mask" => Some("mask"),
        "mask-border" => Some("mask-border"),
        "mask-border-source" => Some("mask-border-source"),
        "mask-image" => Some("mask-image"),
        "shape-outside" => Some("shape-outside"),
        "symbols" => Some("symbols"),
        "-webkit-border-image" => Some("-webkit-border-image"),
        "-webkit-border-image-source" => Some("-webkit-border-image-source"),
        "-webkit-box-reflect" => Some("-webkit-box-reflect"),
        "-webkit-mask" => Some("-webkit-mask"),
        "-webkit-mask-box-image" => Some("-webkit-mask-box-image"),
        "-webkit-mask-box-image-source" => Some("-webkit-mask-box-image-source"),
        "-webkit-mask-image" => Some("-webkit-mask-image"),
        _ => None,
    }
}

fn rewrite_value(
    ctx: &Ctx<'_>,
    value: &str,
    property: &'static str,
    collect_remote_urls: bool,
    refs: &mut BTreeMap<String, String>,
) -> (String, bool) {
    let bytes = value.as_bytes();
    let mut output = String::with_capacity(value.len());
    let mut copied_to = 0;
    let mut position = 0;
    let mut changed = false;
    while position < bytes.len() {
        if starts_with(bytes, position, b"/*") {
            position = skip_comment(bytes, position).unwrap_or(bytes.len());
            continue;
        }
        if matches!(bytes[position], b'\'' | b'"') {
            position = skip_quoted(bytes, position).unwrap_or(bytes.len());
            continue;
        }
        if function_at(bytes, position, b"image-set")
            || function_at(bytes, position, b"-webkit-image-set")
        {
            let name_len = if bytes[position] == b'-' {
                b"-webkit-image-set".len()
            } else {
                b"image-set".len()
            };
            let open = position + name_len;
            let Some(end) = matching_paren(bytes, open) else {
                break;
            };
            let contents = &value[open + 1..end - 1];
            let selected = select_image_set_candidate(contents);
            let replacement = if collect_remote_urls {
                Some(
                    selected
                        .as_deref()
                        .and_then(|source| {
                            replacement_url(ctx, source, property, collect_remote_urls, refs)
                        })
                        .unwrap_or_else(|| format!("url(\"{PLACEHOLDER_SRC}\")")),
                )
            } else if image_set_contains_inline_image(contents) {
                Some(
                    selected
                        .as_deref()
                        .filter(|source| is_image_data_uri(source))
                        .and_then(|source| {
                            replacement_url(ctx, source, property, collect_remote_urls, refs)
                        })
                        .unwrap_or_else(|| format!("url(\"{PLACEHOLDER_SRC}\")")),
                )
            } else {
                None
            };
            if let Some(replacement) = replacement {
                output.push_str(&value[copied_to..position]);
                output.push_str(&replacement);
                copied_to = end;
                changed = true;
            }
            position = end;
            continue;
        }
        if function_at(bytes, position, b"url") {
            let start = position;
            let UrlFunctionScan { resume_at, source } = scan_url_function(value, start);
            position = resume_at;
            let Some(source) = source else {
                continue;
            };
            let original = &value[start..resume_at];
            if let Some(replacement) =
                replacement_url(ctx, &source, property, collect_remote_urls, refs)
            {
                if replacement != original {
                    output.push_str(&value[copied_to..start]);
                    output.push_str(&replacement);
                    copied_to = resume_at;
                    changed = true;
                }
            }
            continue;
        }
        position += 1;
    }
    if !changed {
        return (value.to_string(), false);
    }
    output.push_str(&value[copied_to..]);
    (output, true)
}

fn replacement_url(
    ctx: &Ctx<'_>,
    source: &str,
    property: &'static str,
    collect_remote_urls: bool,
    refs: &mut BTreeMap<String, String>,
) -> Option<String> {
    let source = source.trim();
    if source == PLACEHOLDER_SRC || is_numbered_placeholder(source) {
        return Some(format!("url(\"{source}\")"));
    }
    if source.starts_with('#') {
        return collect_remote_urls.then(|| format!("url(\"{source}\")"));
    }
    if ctx.keeps_image_refs() && is_image_ref_strict(source) {
        return collect_remote_urls.then(|| format!("url(\"{source}\")"));
    }
    let reference = if is_image_data_uri(source) {
        let replacement = ctx.scrub_image_from(
            source,
            ImageFallback::Blank,
            ImageSource::CssProperty(property),
        );
        if is_image_ref(&replacement) {
            Some(replacement)
        } else {
            return Some(format!("url(\"{replacement}\")"));
        }
    } else if !collect_remote_urls {
        return None;
    } else if source.contains('\\') {
        None
    } else {
        ctx.collect_url_from(source, ImageSource::CssProperty(property))
    };
    match reference {
        Some(reference) => {
            let slot = refs.len();
            refs.insert(slot.to_string(), reference);
            Some(format!("url(\"{}\")", numbered_placeholder(slot)))
        }
        None => Some(format!("url(\"{PLACEHOLDER_SRC}\")")),
    }
}

fn scan_url_function(value: &str, start: usize) -> UrlFunctionScan {
    let bytes = value.as_bytes();
    let Some(resume_at) = matching_paren(bytes, start + 3) else {
        return UrlFunctionScan {
            resume_at: bytes.len(),
            source: None,
        };
    };
    let contents_end = resume_at - 1;
    let mut position = start + 4;
    skip_whitespace(bytes, &mut position);
    let source = if matches!(bytes.get(position), Some(b'\'' | b'"')) {
        let content_start = position + 1;
        let Some(end) = skip_quoted(bytes, position) else {
            return UrlFunctionScan {
                resume_at,
                source: None,
            };
        };
        let content_end = end - 1;
        position = end;
        skip_whitespace(bytes, &mut position);
        if position != contents_end {
            return UrlFunctionScan {
                resume_at,
                source: None,
            };
        }
        &value[content_start..content_end]
    } else {
        &value[position..contents_end]
    };
    let source = source.trim();
    UrlFunctionScan {
        resume_at,
        source: (!source.is_empty() && !source.as_bytes().contains(&b'\\'))
            .then(|| source.to_string()),
    }
}

fn select_image_set_candidate(contents: &str) -> Option<String> {
    let mut best: Option<(f64, String)> = None;
    for candidate in split_image_set_candidates(contents)? {
        let (source, remainder) = parse_image_set_source(candidate.trim())?;
        let resolution = parse_resolution(remainder)?;
        if best
            .as_ref()
            .is_none_or(|(best_resolution, _)| resolution > *best_resolution)
        {
            best = Some((resolution, source));
        }
    }
    best.map(|(_, source)| source)
}

fn image_set_contains_inline_image(contents: &str) -> bool {
    split_image_set_candidates(contents).is_some_and(|candidates| {
        candidates.into_iter().any(|candidate| {
            parse_image_set_source(candidate.trim())
                .is_some_and(|(source, _)| is_image_data_uri(&source))
        })
    })
}

fn split_image_set_candidates(contents: &str) -> Option<Vec<&str>> {
    let bytes = contents.as_bytes();
    let mut candidates = Vec::new();
    let mut start = 0;
    let mut position = 0;
    let mut depth = 0usize;
    while position < bytes.len() {
        if starts_with(bytes, position, b"/*") {
            position = skip_comment(bytes, position)?;
            continue;
        }
        if matches!(bytes[position], b'\'' | b'"') {
            position = skip_quoted(bytes, position)?;
            continue;
        }
        match bytes[position] {
            b'(' => depth += 1,
            b')' => depth = depth.saturating_sub(1),
            b',' if depth == 0 => {
                candidates.push(&contents[start..position]);
                start = position + 1;
            }
            _ => {}
        }
        position += 1;
    }
    candidates.push(&contents[start..]);
    (!candidates
        .iter()
        .any(|candidate| candidate.trim().is_empty()))
    .then_some(candidates)
}

fn parse_image_set_source(candidate: &str) -> Option<(String, &str)> {
    let bytes = candidate.as_bytes();
    if function_at(bytes, 0, b"url") {
        let UrlFunctionScan { resume_at, source } = scan_url_function(candidate, 0);
        return Some((source?, &candidate[resume_at..]));
    }
    if matches!(bytes.first(), Some(b'\'' | b'"')) {
        let end = skip_quoted(bytes, 0)?;
        let source = candidate[1..end - 1].to_string();
        if source.as_bytes().contains(&b'\\') {
            return None;
        }
        return Some((source, &candidate[end..]));
    }
    None
}

fn parse_resolution(remainder: &str) -> Option<f64> {
    let mut resolution = None;
    for token in remainder.split_ascii_whitespace() {
        let parsed = if let Some(value) = token.strip_suffix("dppx") {
            value.parse::<f64>().ok()
        } else if let Some(value) = token.strip_suffix("dpi") {
            value.parse::<f64>().ok().map(|value| value / 96.0)
        } else if let Some(value) = token.strip_suffix("dpcm") {
            value.parse::<f64>().ok().map(|value| value * 2.54 / 96.0)
        } else if let Some(value) = token.strip_suffix('x') {
            value.parse::<f64>().ok()
        } else if token.starts_with("type(") {
            continue;
        } else {
            return None;
        };
        let value = parsed?;
        if resolution.replace(value).is_some() {
            return None;
        }
    }
    let value = resolution.unwrap_or(1.0);
    (value.is_finite() && value > 0.0).then_some(value)
}

fn function_at(bytes: &[u8], start: usize, name: &[u8]) -> bool {
    let Some(candidate) = bytes.get(start..start + name.len()) else {
        return false;
    };
    candidate.eq_ignore_ascii_case(name)
        && bytes.get(start + name.len()) == Some(&b'(')
        && (start == 0
            || !matches!(bytes[start - 1], b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-'))
}

fn matching_paren(bytes: &[u8], open: usize) -> Option<usize> {
    if bytes.get(open) != Some(&b'(') {
        return None;
    }
    let mut position = open + 1;
    let mut depth = 1usize;
    while position < bytes.len() {
        if starts_with(bytes, position, b"/*") {
            position = skip_comment(bytes, position)?;
            continue;
        }
        if matches!(bytes[position], b'\'' | b'"') {
            position = skip_quoted(bytes, position)?;
            continue;
        }
        match bytes[position] {
            b'(' => depth += 1,
            b')' => {
                depth -= 1;
                if depth == 0 {
                    return Some(position + 1);
                }
            }
            _ => {}
        }
        position += 1;
    }
    None
}

fn skip_quoted(bytes: &[u8], start: usize) -> Option<usize> {
    let quote = *bytes.get(start)?;
    let mut position = start + 1;
    while position < bytes.len() {
        match bytes[position] {
            b'\\' => position += 2,
            value if value == quote => return Some(position + 1),
            _ => position += 1,
        }
    }
    None
}

fn skip_comment(bytes: &[u8], start: usize) -> Option<usize> {
    let relative = bytes
        .get(start + 2..)?
        .windows(2)
        .position(|pair| pair == b"*/")?;
    Some(start + 2 + relative + 2)
}

fn skip_whitespace(bytes: &[u8], position: &mut usize) {
    while matches!(bytes.get(*position), Some(value) if value.is_ascii_whitespace()) {
        *position += 1;
    }
}

fn starts_with(bytes: &[u8], start: usize, needle: &[u8]) -> bool {
    bytes.get(start..start + needle.len()) == Some(needle)
}

#[cfg(test)]
mod tests {
    use super::{rewrite, CssContext};
    use crate::allow_lists::AllowLists;
    use crate::collect::ImageCollection;
    use crate::context::{Ctx, ImageSourceCount};
    use crate::testkit::png_data_uri;
    use crate::url_collect::UrlCollection;

    #[test]
    fn remote_urls_use_valid_placeholders() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let css = "color:red;background-image:url('https://example.com/a.png');mask-image:url(https://example.com/b.png);content:url(\"https://example.com/<metadata id='anon-image-slot-7'/>\")";
        let rewritten = rewrite(&ctx, css, CssContext::DeclarationList).expect("images change");
        assert!(rewritten.refs.is_empty());
        assert_eq!(rewritten.css.matches("data:image/svg+xml").count(), 3);
        assert!(!rewritten.css.contains("https://example.com"));
    }

    #[test]
    fn non_image_css_urls_are_left_alone() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let css = "@import url('https://example.com/a.css');@font-face{src:url('https://example.com/a.woff2')}";
        assert!(rewrite(&ctx, css, CssContext::Stylesheet).is_none());
    }

    #[test]
    fn inline_images_still_use_the_inline_scrubber() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let original = png_data_uri(8, 8, [10, 20, 30, 255]);
        let css = format!("background-image:url('{original}')");
        let rewritten = rewrite(&ctx, &css, CssContext::DeclarationList).expect("image changes");
        assert!(!rewritten.css.contains(&original));
        assert!(rewritten.css.contains("data:image/"));
    }

    #[test]
    fn escaped_url_does_not_stop_later_inline_image_scrubbing() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let original = png_data_uri(8, 8, [10, 20, 30, 255]);
        let escaped_url = r#"url("https://example.com/a\2e png")"#;
        let css = format!("background-image:{escaped_url},url('{original}')");
        let rewritten = rewrite(&ctx, &css, CssContext::DeclarationList).expect("image changes");
        assert!(rewritten.css.contains(escaped_url));
        assert!(!rewritten.css.contains(&original));
    }

    #[test]
    fn colons_and_blocks_inside_a_custom_property_value_do_not_start_a_declaration() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let original = png_data_uri(8, 8, [10, 20, 30, 255]);
        for (css, kept) in [
            (
                format!(":root{{--link:https://example.com/a;--hero:url('{original}')}}"),
                ":root{--link:https://example.com/a;--hero:",
            ),
            (
                format!(":root{{--block:{{--nested:url('{original}')}}}}"),
                ":root{--block:{--nested:",
            ),
        ] {
            let rewritten = rewrite(&ctx, &css, CssContext::Stylesheet).expect("image changes");
            assert!(rewritten.css.starts_with(kept), "{}", rewritten.css);
            assert!(!rewritten.css.contains(&original));
        }
    }

    #[test]
    fn repeated_unterminated_urls_do_not_rescan_the_suffix() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let css = format!("background-image:{}", "url(".repeat(20_000));
        assert!(rewrite(&ctx, &css, CssContext::DeclarationList).is_none());
    }

    #[test]
    fn collected_inline_images_use_numbered_placeholders() {
        let allow = AllowLists::default();
        let ctx = Ctx::with_image_collection(
            &allow,
            Some(ImageCollection::new(
                "0123456789abcdef0123456789abcdef".to_string(),
                "fedcba9876543210fedcba9876543210".to_string(),
            )),
        );
        let original = png_data_uri(8, 8, [10, 20, 30, 255]);
        let css = format!("background-image:url('{original}')");
        let rewritten = rewrite(&ctx, &css, CssContext::DeclarationList).expect("image changes");
        assert!(rewritten.css.contains("anon-image-slot-0"));
        assert_eq!(rewritten.refs.len(), 1);
        assert!(rewritten.refs["0"].starts_with("image:"));
        assert_eq!(
            ctx.take_image_source_counts(),
            vec![ImageSourceCount {
                source: "css",
                property: "background-image",
                kind: "inline",
                count: 1,
            }]
        );
    }

    #[test]
    fn custom_properties_scrub_inline_images_without_collecting_remote_urls() {
        let allow = AllowLists::default();
        let ctx = Ctx::with_image_collection(
            &allow,
            Some(ImageCollection::new(
                "0123456789abcdef0123456789abcdef".to_string(),
                "fedcba9876543210fedcba9876543210".to_string(),
            )),
        )
        .collecting_urls(Some(UrlCollection {
            reference_namespace: None,
            url_key: "0123456789abcdef0123456789abcdef".to_string(),
        }));
        let original = png_data_uri(8, 8, [10, 20, 30, 255]);
        let remote = "https://cdn.example.com/hero.png";
        let css = format!("--hero:url('{original}');--hero-set:image-set('{original}' 2x);--remote:url('{remote}');background-image:var(--hero)");
        let rewritten = rewrite(&ctx, &css, CssContext::DeclarationList).expect("image changes");
        assert!(!rewritten.css.contains(&original));
        assert!(rewritten.css.contains("anon-image-slot-0"));
        assert!(rewritten.css.contains("anon-image-slot-1"));
        assert!(rewritten.css.contains(remote));
        assert_eq!(rewritten.refs.len(), 2);
        assert!(rewritten.refs["0"].starts_with("image:"));
        assert!(rewritten.refs["1"].starts_with("image:"));
        assert_eq!(
            ctx.take_image_source_counts(),
            vec![ImageSourceCount {
                source: "css",
                property: "custom-property",
                kind: "inline",
                count: 2,
            }]
        );
    }

    #[test]
    fn collected_remote_images_record_the_css_property() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow).collecting_urls(Some(UrlCollection {
            reference_namespace: None,
            url_key: "0123456789abcdef0123456789abcdef".to_string(),
        }));
        let css = "mask-image:url('https://cdn.example.com/mask.png')";
        let rewritten = rewrite(&ctx, css, CssContext::DeclarationList).expect("image changes");
        assert!(rewritten.refs["0"].starts_with("imageurl:"));
        assert_eq!(
            ctx.take_image_source_counts(),
            vec![ImageSourceCount {
                source: "css",
                property: "mask-image",
                kind: "url",
                count: 1,
            }]
        );
    }

    #[test]
    fn inline_svg_in_css_reaches_the_collection_lane_as_its_document() {
        let allow = AllowLists::default();
        let ctx = Ctx::with_image_collection(
            &allow,
            Some(ImageCollection::new(
                "0123456789abcdef0123456789abcdef".to_string(),
                "fedcba9876543210fedcba9876543210".to_string(),
            )),
        );
        let original = "data:image/svg+xml;base64,PHN2Zz48dGV4dD5qb2huLmZha2VuYW1lQGV4YW1wbGUuY29tPC90ZXh0Pjwvc3ZnPg==";
        let css = format!("background-image:url('{original}')");
        let rewritten = rewrite(&ctx, &css, CssContext::DeclarationList).expect("image changes");
        assert_eq!(rewritten.refs.len(), 1);
        assert!(!rewritten.css.contains(original));
        let images = ctx.into_collected_images();
        assert_eq!(images.len(), 1);
        assert!(images[0].bytes.starts_with(b"<svg>"));
    }

    #[test]
    fn image_set_uses_the_largest_candidate() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let css = "background-image:image-set(url('https://example.com/a.png') 1x, url('https://example.com/b.png') 2x)";
        let rewritten = rewrite(&ctx, css, CssContext::DeclarationList).expect("image changes");
        assert_eq!(rewritten.css.matches("data:image/svg+xml").count(), 1);
        assert!(!rewritten.css.contains("example.com"));
    }

    #[test]
    fn strings_and_comments_do_not_create_image_fetches() {
        let allow = AllowLists::default();
        let ctx = Ctx::new(&allow);
        let css = "content:'url(https://example.com/a.png)';background-image:/* url(https://example.com/b.png) */none";
        assert!(rewrite(&ctx, css, CssContext::DeclarationList).is_none());
    }
}