use annotate_snippets::{AnnotationKind, Group, Level, Snippet};use regex::Regex;use std::{collections::HashMap, ops::Range, path::Path, sync::LazyLock}; static GITHUB_INPUT_PATTERN: LazyLock<Regex> = LazyLock::new(|| {    Regex::new(r#"\$\{\{[[:blank:]]*([[:alnum:]]|[[:punct:]])+?[[:blank:]]*\}\}"#)        .expect("Should compile")}); pub struct RunValidationError {    found_injection_patterns: Vec<(String, Range<usize>)>,} impl RunValidationError {    /// Renders the GitHub input injection patterns found in a single `run:`    /// command as one diagnostic group.    pub fn annotation_group<'a>(&self, file_path: &Path, raw_content: &'a str) -> Group<'a> {        let mut identical_lines = HashMap::new();         let ranges = self            .found_injection_patterns            .iter()            .map(|(line, pattern_range)| {                let initial_offset = identical_lines                    .get(&(line.as_str(), pattern_range.start))                    .copied()                    .unwrap_or_default();                 let line_start = raw_content[initial_offset..]                    .find(line.as_str())                    .map(|offset| offset + initial_offset)                    .unwrap_or_default();                 let pattern_start = line_start + pattern_range.start;                let pattern_end = pattern_start + pattern_range.len();                 identical_lines.insert((line.as_str(), pattern_range.start), pattern_end);                 pattern_start..pattern_end            });         Level::ERROR            .primary_title("Found GitHub input injection in run command")            .element(                Snippet::source(raw_content)                    .path(file_path.display().to_string())                    .annotations(ranges.map(|range| {                        AnnotationKind::Primary                            .span(range)                            .label("This should be passed via an environment variable")                    })),            )    }} pub fn validate_run_command(command: &str) -> Result<(), RunValidationError> {    let patterns: Vec<_> = command        .lines()        .flat_map(move |line| {            GITHUB_INPUT_PATTERN                .find_iter(line)                .map(|m| (line.to_owned(), m.range()))        })        .collect();     if patterns.is_empty() {        Ok(())    } else {        Err(RunValidationError {            found_injection_patterns: patterns,        })    }}