From d9e697961c3bd0f9e102fb3e2b8399a8ab2c84b3 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Tue, 26 May 2026 01:02:14 -0700 Subject: [PATCH 1/9] test: add safety coverage for CLI, LSP, and path discovery --- Cargo.lock | 1 + crates/cli-lib/src/commands_fix.rs | 29 +++++ crates/cli/Cargo.toml | 3 + crates/cli/tests/fix_parse_errors.rs | 34 ++++++ crates/cli/tests/fix_return_code.rs | 77 +++++++++++++ crates/cli/tests/path_discovery.rs | 97 ++++++++++++++++ crates/cli/tests/ui.rs | 8 +- crates/cli/tests/ui_github.rs | 8 +- crates/cli/tests/ui_json.rs | 13 ++- crates/lib/src/core/linter/core.rs | 159 +++++++++++++++++++++------ crates/lsp/Cargo.toml | 1 + 11 files changed, 390 insertions(+), 40 deletions(-) create mode 100644 crates/cli/tests/path_discovery.rs diff --git a/Cargo.lock b/Cargo.lock index ea97be506..0e3640dea 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1645,6 +1645,7 @@ version = "0.39.0" dependencies = [ "console_error_panic_hook", "hashbrown 0.17.1", + "ignore", "js-sys", "lsp-server", "lsp-types", diff --git a/crates/cli-lib/src/commands_fix.rs b/crates/cli-lib/src/commands_fix.rs index d1ada8c7b..a42e4ef15 100644 --- a/crates/cli-lib/src/commands_fix.rs +++ b/crates/cli-lib/src/commands_fix.rs @@ -37,6 +37,13 @@ pub(crate) fn run_fix( if !file.has_fixes() { continue; } + if file + .violations() + .iter() + .any(|violation| violation.rule.is_none()) + { + continue; + } let path = std::mem::take(&mut file.path); let fixed = file.fix_string(); std::fs::write(path, fixed).unwrap(); @@ -112,4 +119,26 @@ mod tests { let after = std::fs::metadata(&path).unwrap().modified().unwrap(); assert_eq!(before, after); } + + #[test] + fn run_fix_writes_file_when_changes_exist() { + let mut tmp = NamedTempFile::new().unwrap(); + write!(tmp, "SELECT foo bar FROM tabs").unwrap(); + tmp.flush().unwrap(); + let tmp = tmp.into_temp_path(); + let path = tmp.to_path_buf(); + + let args = FixArgs { + paths: vec![path.clone()], + format: Format::Human, + }; + let config = FluffConfig::from_source("[sqruff]\nrules = AL02\n", None); + let exit_code = run_fix(args, config, ignore_none, true); + + assert_eq!(exit_code, 0); + assert_eq!( + std::fs::read_to_string(&path).unwrap(), + "SELECT foo AS bar FROM tabs" + ); + } } diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index a2caeedc2..30102cb87 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -69,6 +69,9 @@ harness = false [[test]] name = "none_format" + +[[test]] +name = "path_discovery" harness = false [package.metadata.cargo-machete] diff --git a/crates/cli/tests/fix_parse_errors.rs b/crates/cli/tests/fix_parse_errors.rs index 11f947d4c..c3ad2cd20 100644 --- a/crates/cli/tests/fix_parse_errors.rs +++ b/crates/cli/tests/fix_parse_errors.rs @@ -1,10 +1,12 @@ use core::str; +use std::fs; use std::path::{Path, PathBuf}; use assert_cmd::Command; fn main() { parse_errors(); + parse_errors_do_not_rewrite_files(); multiple_add_column_errors(); } @@ -43,6 +45,38 @@ fn parse_errors() { assert_eq!(output.status.code().unwrap(), 1); } +fn parse_errors_do_not_rewrite_files() { + let profile = if cfg!(debug_assertions) { + "debug" + } else { + "release" + }; + + let cargo_folder = Path::new(env!("CARGO_MANIFEST_DIR")); + let mut sqruff_path = PathBuf::from(cargo_folder); + sqruff_path.push(format!("../../target/{}/sqruff", profile)); + + let temp_dir = tempfile::tempdir().unwrap(); + let sql_path = temp_dir.path().join("parse_error.sql"); + let original = "SelEc"; + fs::write(&sql_path, original).unwrap(); + + let mut cmd = Command::new(sqruff_path); + cmd.env("HOME", PathBuf::from(env!("CARGO_MANIFEST_DIR"))); + cmd.arg("fix") + .arg("-f") + .arg("human") + .arg("--parsing-errors") + .arg(&sql_path); + cmd.current_dir(cargo_folder); + + let assert = cmd.assert(); + let output = assert.get_output(); + + assert_eq!(output.status.code().unwrap(), 1); + assert_eq!(fs::read_to_string(&sql_path).unwrap(), original); +} + fn multiple_add_column_errors() { let profile = if cfg!(debug_assertions) { "debug" diff --git a/crates/cli/tests/fix_return_code.rs b/crates/cli/tests/fix_return_code.rs index 09f8ccf36..122b20f3e 100644 --- a/crates/cli/tests/fix_return_code.rs +++ b/crates/cli/tests/fix_return_code.rs @@ -1,10 +1,14 @@ use core::str; +use std::fs; use std::path::{Path, PathBuf}; +use std::thread::sleep; +use std::time::Duration; use assert_cmd::Command; fn main() { fix_return_code(); + file_fix_return_code_and_writes(); } fn fix_return_code() { @@ -115,3 +119,76 @@ fn fix_return_code() { ); assert_eq!(output.status.code().unwrap(), 1); } + +fn file_fix_return_code_and_writes() { + let profile = if cfg!(debug_assertions) { + "debug" + } else { + "release" + }; + + let cargo_folder = Path::new(env!("CARGO_MANIFEST_DIR")); + let mut sqruff_path = PathBuf::from(cargo_folder); + sqruff_path.push(format!("../../target/{}/sqruff", profile)); + let temp_dir = tempfile::tempdir().unwrap(); + + let config_file = cargo_folder.join("tests/fix_return_code/fix_everything.cfg"); + let unchanged = temp_dir.path().join("unchanged.sql"); + fs::write(&unchanged, "SELECT foo AS bar FROM tabs\n").unwrap(); + let before = fs::metadata(&unchanged).unwrap().modified().unwrap(); + sleep(Duration::from_secs(1)); + + let mut cmd = Command::new(&sqruff_path); + cmd.env("HOME", cargo_folder); + cmd.arg("fix") + .arg("-f") + .arg("human") + .arg("--config") + .arg(&config_file) + .arg(&unchanged); + let output = cmd.assert(); + assert_eq!(output.get_output().status.code().unwrap(), 0); + assert_eq!( + fs::read_to_string(&unchanged).unwrap(), + "SELECT foo AS bar FROM tabs\n" + ); + assert_eq!( + fs::metadata(&unchanged).unwrap().modified().unwrap(), + before + ); + + let fixable = temp_dir.path().join("fixable.sql"); + fs::write(&fixable, "SELECT foo bar FROM tabs").unwrap(); + let mut cmd = Command::new(&sqruff_path); + cmd.env("HOME", cargo_folder); + cmd.arg("fix") + .arg("-f") + .arg("human") + .arg("--config") + .arg(&config_file) + .arg(&fixable); + let output = cmd.assert(); + assert_eq!(output.get_output().status.code().unwrap(), 0); + assert_eq!( + fs::read_to_string(&fixable).unwrap(), + "SELECT foo AS bar FROM tabs" + ); + + let config_file = cargo_folder.join("tests/fix_return_code/fix_some.cfg"); + let partially_fixable = temp_dir.path().join("partially_fixable.sql"); + fs::write(&partially_fixable, "SELECT foo bar, * FROM tabs").unwrap(); + let mut cmd = Command::new(&sqruff_path); + cmd.env("HOME", cargo_folder); + cmd.arg("fix") + .arg("-f") + .arg("human") + .arg("--config") + .arg(&config_file) + .arg(&partially_fixable); + let output = cmd.assert(); + assert_eq!(output.get_output().status.code().unwrap(), 1); + assert_eq!( + fs::read_to_string(&partially_fixable).unwrap(), + "SELECT foo AS bar, * FROM tabs" + ); +} diff --git a/crates/cli/tests/path_discovery.rs b/crates/cli/tests/path_discovery.rs new file mode 100644 index 000000000..ac5c712a9 --- /dev/null +++ b/crates/cli/tests/path_discovery.rs @@ -0,0 +1,97 @@ +use core::str; +use std::fs; +use std::path::{Path, PathBuf}; + +use assert_cmd::Command; + +fn main() { + ignored_directories_are_not_traversed(); + explicit_ignored_files_still_work(); + missing_paths_return_controlled_errors(); +} + +fn sqruff_path(cargo_folder: &Path) -> PathBuf { + let profile = if cfg!(debug_assertions) { + "debug" + } else { + "release" + }; + + let mut sqruff_path = PathBuf::from(cargo_folder); + sqruff_path.push(format!("../../target/{}/sqruff", profile)); + sqruff_path +} + +fn ignored_directories_are_not_traversed() { + let cargo_folder = Path::new(env!("CARGO_MANIFEST_DIR")); + let temp_dir = tempfile::tempdir().unwrap(); + let project = temp_dir.path(); + + fs::write(project.join(".sqruffignore"), "ignored/\n").unwrap(); + fs::write(project.join("regular.sql"), "SELECT 1;\n").unwrap(); + fs::create_dir_all(project.join("ignored").join("nested")).unwrap(); + fs::write( + project.join("ignored").join("nested").join("hidden.sql"), + "SELECT FROM\n", + ) + .unwrap(); + + let mut cmd = Command::new(sqruff_path(cargo_folder)); + cmd.arg("lint") + .arg("-f") + .arg("json") + .arg(project) + .current_dir(project) + .env("HOME", cargo_folder); + let output = cmd.assert(); + let stdout = str::from_utf8(&output.get_output().stdout).unwrap(); + let stderr = str::from_utf8(&output.get_output().stderr).unwrap(); + + assert!(!stdout.contains("hidden.sql")); + assert!(!stderr.contains("hidden.sql")); + assert!(stdout.contains("regular.sql") || stderr.contains("regular.sql")); +} + +fn explicit_ignored_files_still_work() { + let cargo_folder = Path::new(env!("CARGO_MANIFEST_DIR")); + let temp_dir = tempfile::tempdir().unwrap(); + let project = temp_dir.path(); + let ignored = project.join("ignored.sql"); + + fs::write(project.join(".sqruffignore"), "ignored.sql\n").unwrap(); + fs::write(&ignored, "SELECT 1;\n").unwrap(); + + let mut cmd = Command::new(sqruff_path(cargo_folder)); + cmd.arg("lint") + .arg("-f") + .arg("json") + .arg(&ignored) + .current_dir(project) + .env("HOME", cargo_folder); + let output = cmd.assert(); + let stdout = str::from_utf8(&output.get_output().stdout).unwrap(); + + assert_eq!(output.get_output().status.code().unwrap(), 1); + assert!(stdout.contains("ignored.sql")); + assert!(stdout.contains("LT01")); +} + +fn missing_paths_return_controlled_errors() { + let cargo_folder = Path::new(env!("CARGO_MANIFEST_DIR")); + let temp_dir = tempfile::tempdir().unwrap(); + let missing = temp_dir.path().join("missing.sql"); + + let mut cmd = Command::new(sqruff_path(cargo_folder)); + cmd.arg("lint") + .arg("-f") + .arg("human") + .arg(&missing) + .current_dir(temp_dir.path()) + .env("HOME", cargo_folder); + let output = cmd.assert(); + let stderr = str::from_utf8(&output.get_output().stderr).unwrap(); + + assert_eq!(output.get_output().status.code().unwrap(), 1); + assert!(stderr.contains("Specified path does not exist")); + assert!(!stderr.contains("panicked at")); +} diff --git a/crates/cli/tests/ui.rs b/crates/cli/tests/ui.rs index 1b028a2ba..5e194baa1 100644 --- a/crates/cli/tests/ui.rs +++ b/crates/cli/tests/ui.rs @@ -52,8 +52,12 @@ fn main() { let exit_code_str = output.status.code().unwrap().to_string(); let test_dir_str = lint_dir.to_string_lossy().to_string(); - let stderr_normalized: String = stderr_str.replace(&test_dir_str, "tests/lint"); - let stdout_normalized: String = stdout_str.replace(&test_dir_str, "tests/lint"); + let stderr_normalized: String = stderr_str + .replace(&test_dir_str, "tests/lint") + .replace('\\', "/"); + let stdout_normalized: String = stdout_str + .replace(&test_dir_str, "tests/lint") + .replace('\\', "/"); expect_file![expected_output_path_stderr].assert_eq(&stderr_normalized); expect_file![expected_output_path_stdout].assert_eq(&stdout_normalized); diff --git a/crates/cli/tests/ui_github.rs b/crates/cli/tests/ui_github.rs index 0db9e5d0e..b1d0bc628 100644 --- a/crates/cli/tests/ui_github.rs +++ b/crates/cli/tests/ui_github.rs @@ -55,8 +55,12 @@ fn main() { let exit_code_str = output.status.code().unwrap().to_string(); let test_dir_str = lint_dir.to_string_lossy().to_string(); - let stderr_normalized: String = stderr_str.replace(&test_dir_str, "tests/lint"); - let stdout_normalized: String = stdout_str.replace(&test_dir_str, "tests/lint"); + let stderr_normalized: String = stderr_str + .replace(&test_dir_str, "tests/lint") + .replace('\\', "/"); + let stdout_normalized: String = stdout_str + .replace(&test_dir_str, "tests/lint") + .replace('\\', "/"); expect_file![expected_output_path_stderr].assert_eq(&stderr_normalized); expect_file![expected_output_path_stdout].assert_eq(&stdout_normalized); diff --git a/crates/cli/tests/ui_json.rs b/crates/cli/tests/ui_json.rs index 4184cb003..a52075394 100644 --- a/crates/cli/tests/ui_json.rs +++ b/crates/cli/tests/ui_json.rs @@ -56,8 +56,17 @@ fn main() { let exit_code_str = output.status.code().unwrap().to_string(); let test_dir_str = lint_dir.to_string_lossy().to_string(); - let stderr_normalized: String = stderr_str.replace(&test_dir_str, "tests/lint"); - let stdout_normalized: String = stdout_str.replace(&test_dir_str, "tests/lint"); + let test_dir_json = test_dir_str.replace('\\', "\\\\"); + let stderr_normalized: String = stderr_str + .replace(&test_dir_json, "tests/lint") + .replace(&test_dir_str, "tests/lint") + .replace("tests/lint\\\\", "tests/lint/") + .replace("tests/lint\\", "tests/lint/"); + let stdout_normalized: String = stdout_str + .replace(&test_dir_json, "tests/lint") + .replace(&test_dir_str, "tests/lint") + .replace("tests/lint\\\\", "tests/lint/") + .replace("tests/lint\\", "tests/lint/"); expect_file![expected_output_path_stderr].assert_eq(&stderr_normalized); expect_file![expected_output_path_stdout].assert_eq(&stdout_normalized); diff --git a/crates/lib/src/core/linter/core.rs b/crates/lib/src/core/linter/core.rs index 3ccc8cd48..97788c497 100644 --- a/crates/lib/src/core/linter/core.rs +++ b/crates/lib/src/core/linter/core.rs @@ -119,22 +119,23 @@ impl Linter { for path in paths { if path.is_file() { - expanded_paths.push(path.to_string_lossy().to_string()); + expanded_paths.push((path.to_string_lossy().to_string(), true)); } else { - expanded_paths.extend(self.paths_from_path( - path, - None, - None, - None, - None, - Some(ignorer), - )); + expanded_paths.extend( + self.paths_from_path(path, None, None, None, None, Some(ignorer))? + .into_iter() + .map(|path| (path, false)), + ); }; } let paths: Vec = expanded_paths .into_iter() - .filter(|path| { + .filter(|(path, is_explicit)| { + if *is_explicit { + return true; + } + let should_ignore = ignorer(Path::new(path)); if should_ignore { log::debug!( @@ -144,6 +145,7 @@ impl Linter { } !should_ignore }) + .map(|(path, _)| path) .collect_vec(); let mut files = Vec::with_capacity(paths.len()); @@ -698,7 +700,7 @@ impl Linter { ignore_files: Option, working_path: Option, ignorer: Option<&(dyn Fn(&Path) -> bool + Send + Sync)>, - ) -> Vec { + ) -> Result, SQLFluffUserError> { let ignore_file_name = ignore_file_name.unwrap_or_else(|| String::from(".sqlfluffignore")); let ignore_non_existent_files = ignore_non_existent_files.unwrap_or(false); let ignore_files = ignore_files.unwrap_or(true); @@ -707,9 +709,11 @@ impl Linter { let Ok(metadata) = std::fs::metadata(&path) else { if ignore_non_existent_files { - return Vec::new(); + return Ok(Vec::new()); } else { - panic!("Specified path does not exist. Check it/they exist(s): {path:?}"); + return Err(SQLFluffUserError::new(format!( + "Specified path does not exist. Check it/they exist(s): {path:?}" + ))); } }; @@ -847,7 +851,7 @@ impl Linter { let mut files = filtered_buffer.into_iter().collect_vec(); files.sort(); - files + Ok(files) } pub fn config(&self) -> &FluffConfig { @@ -879,6 +883,10 @@ impl Linter { #[cfg(test)] mod tests { + use std::fs; + use std::path::{Path, PathBuf}; + use std::time::{SystemTime, UNIX_EPOCH}; + use sqruff_lib_core::parser::segments::Tables; use crate::core::config::FluffConfig; @@ -904,6 +912,16 @@ rules = all .collect() } + fn temp_project(name: &str) -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos(); + let path = std::env::temp_dir().join(format!("sqruff-{name}-{nanos}")); + fs::create_dir_all(&path).unwrap(); + path + } + #[test] fn test_linter_path_from_paths_dir() { // Test extracting paths from directories. @@ -914,8 +932,9 @@ rules = all false, ) .unwrap(); - let paths = - lntr.paths_from_path("test/fixtures/lexer".into(), None, None, None, None, None); + let paths = lntr + .paths_from_path("test/fixtures/lexer".into(), None, None, None, None, None) + .unwrap(); let expected = vec![ "test.fixtures.lexer.basic.sql", "test.fixtures.lexer.block_comment.sql", @@ -934,14 +953,10 @@ rules = all false, ) .unwrap(); - let paths = normalise_paths(lntr.paths_from_path( - "test/fixtures/linter".into(), - None, - None, - None, - None, - None, - )); + let paths = normalise_paths( + lntr.paths_from_path("test/fixtures/linter".into(), None, None, None, None, None) + .unwrap(), + ); assert!(paths.contains(&"test.fixtures.linter.passing.sql".to_string())); assert!(paths.contains(&"test.fixtures.linter.passing_cap_extension.SQL".to_string())); assert!(!paths.contains(&"test.fixtures.linter.discovery_file.txt".to_string())); @@ -955,8 +970,9 @@ rules = all FluffConfig::new(<_>::default(), None, None).with_sql_file_exts(vec![".txt".into()]); let lntr = Linter::new(config, None, None, false).unwrap(); - let paths = - lntr.paths_from_path("test/fixtures/linter".into(), None, None, None, None, None); + let paths = lntr + .paths_from_path("test/fixtures/linter".into(), None, None, None, None, None) + .unwrap(); // Normalizing paths as in the Python version let normalized_paths = normalise_paths(paths); @@ -978,14 +994,16 @@ rules = all false, ) .unwrap(); - let paths = lntr.paths_from_path( - "test/fixtures/linter/indentation_errors.sql".into(), - None, - None, - None, - None, - None, - ); + let paths = lntr + .paths_from_path( + "test/fixtures/linter/indentation_errors.sql".into(), + None, + None, + None, + None, + None, + ) + .unwrap(); assert_eq!( normalise_paths(paths), @@ -993,6 +1011,79 @@ rules = all ); } + #[test] + fn test_linter_path_from_paths_missing_returns_error() { + let lntr = Linter::new( + FluffConfig::new(<_>::default(), None, None), + None, + None, + false, + ) + .unwrap(); + + let err = lntr + .paths_from_path( + "test/fixtures/linter/does_not_exist.sql".into(), + None, + None, + None, + None, + None, + ) + .unwrap_err(); + + assert!(err.value.contains("Specified path does not exist")); + } + + #[test] + fn test_linter_path_from_paths_prunes_ignored_directories() { + let project = temp_project("ignored-dir"); + let ignored_dir = project.join("ignored").join("nested"); + fs::create_dir_all(&ignored_dir).unwrap(); + fs::write(project.join("regular.sql"), "SELECT 1;\n").unwrap(); + fs::write(ignored_dir.join("hidden.sql"), "SELECT bad FROM hidden;\n").unwrap(); + + let lntr = Linter::new( + FluffConfig::new(<_>::default(), None, None), + None, + None, + false, + ) + .unwrap(); + let ignorer = |path: &Path| path.file_name().is_some_and(|name| name == "ignored"); + + let paths = lntr + .paths_from_path(project.clone(), None, None, None, None, Some(&ignorer)) + .unwrap(); + + assert_eq!(paths.len(), 1); + assert!(paths[0].ends_with("regular.sql")); + + fs::remove_dir_all(project).unwrap(); + } + + #[test] + fn test_linter_lint_paths_keeps_explicit_ignored_files() { + let project = temp_project("explicit-ignored-file"); + let file = project.join("explicit.sql"); + fs::write(&file, "SELECT 1;\n").unwrap(); + + let config = FluffConfig::from_source("[sqruff]\ndialect = ansi\n", None); + let mut lntr = Linter::new(config, None, None, false).unwrap(); + let explicit_file = file.clone(); + let ignorer = move |path: &Path| path == explicit_file; + + let result = lntr + .lint_paths(vec![file.clone()], false, &ignorer) + .unwrap(); + let files = result.into_iter().collect::>(); + + assert_eq!(files.len(), 1); + assert!(files[0].path().ends_with("explicit.sql")); + + fs::remove_dir_all(project).unwrap(); + } + // test__linter__skip_large_bytes // test__linter__path_from_paths__not_exist // test__linter__path_from_paths__not_exist_ignore diff --git a/crates/lsp/Cargo.toml b/crates/lsp/Cargo.toml index f59b095ce..a51bb21ee 100644 --- a/crates/lsp/Cargo.toml +++ b/crates/lsp/Cargo.toml @@ -16,6 +16,7 @@ bench = false [dependencies] hashbrown.workspace = true console_error_panic_hook = "0.1.7" +ignore = "0.4.23" js-sys = "0.3.74" lsp-server = "0.8.0" lsp-types = "0.97" From c47d2e8ad85740cf27a5e84507434a92be38be9c Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Tue, 26 May 2026 01:08:48 -0700 Subject: [PATCH 2/9] feat(lib): introduce public engine API --- crates/lib/src/api.rs | 12 +++ crates/lib/src/api/diagnostic.rs | 11 ++ crates/lib/src/api/engine.rs | 167 +++++++++++++++++++++++++++++ crates/lib/src/api/options.rs | 32 ++++++ crates/lib/src/api/report.rs | 19 ++++ crates/lib/src/api/source.rs | 15 +++ crates/lib/src/core/linter/core.rs | 4 + crates/lib/src/lib.rs | 1 + 8 files changed, 261 insertions(+) create mode 100644 crates/lib/src/api.rs create mode 100644 crates/lib/src/api/diagnostic.rs create mode 100644 crates/lib/src/api/engine.rs create mode 100644 crates/lib/src/api/options.rs create mode 100644 crates/lib/src/api/report.rs create mode 100644 crates/lib/src/api/source.rs diff --git a/crates/lib/src/api.rs b/crates/lib/src/api.rs new file mode 100644 index 000000000..ce35421dd --- /dev/null +++ b/crates/lib/src/api.rs @@ -0,0 +1,12 @@ +pub mod diagnostic; +pub mod engine; +pub mod options; +pub mod report; +pub mod source; + +pub use diagnostic::LintDiagnostic; +pub use engine::Engine; +pub use options::{EngineOptions, Mode, ParseErrors, RunRequest}; +pub use report::{FileReport, RunReport, SkipReason}; +pub use source::{Source, SourceId}; +pub use sqruff_lib_core::errors::SQLFluffUserError as SqruffError; diff --git a/crates/lib/src/api/diagnostic.rs b/crates/lib/src/api/diagnostic.rs new file mode 100644 index 000000000..d78ea19b4 --- /dev/null +++ b/crates/lib/src/api/diagnostic.rs @@ -0,0 +1,11 @@ +use std::ops::Range; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct LintDiagnostic { + pub message: String, + pub code: Option, + pub line: usize, + pub column: usize, + pub source_range: Range, + pub fixable: bool, +} diff --git a/crates/lib/src/api/engine.rs b/crates/lib/src/api/engine.rs new file mode 100644 index 000000000..914d610a3 --- /dev/null +++ b/crates/lib/src/api/engine.rs @@ -0,0 +1,167 @@ +use crate::core::config::FluffConfig; +use crate::core::linter::core::Linter; +use crate::core::linter::linted_file::LintedFile; +use sqruff_lib_core::errors::{SQLBaseError, SQLFluffUserError}; + +use super::{ + EngineOptions, FileReport, LintDiagnostic, Mode, ParseErrors, RunReport, RunRequest, Source, + SourceId, SqruffError, +}; + +pub struct Engine { + inner: Linter, +} + +impl Engine { + pub fn new(config: FluffConfig, options: EngineOptions) -> Result { + let include_parse_errors = matches!(options.parse_errors, ParseErrors::Include); + let inner = Linter::new(config, None, None, include_parse_errors) + .map_err(SQLFluffUserError::new)?; + + Ok(Self { inner }) + } + + pub fn check_source(&self, source: Source<'_>) -> Result { + self.lint_source(source, false) + } + + pub fn fix_source(&self, source: Source<'_>) -> Result { + self.lint_source(source, true) + } + + pub fn run(&self, request: RunRequest<'_>) -> Result { + let mut files = Vec::with_capacity(request.sources.len()); + + for source in request.sources { + let report = match request.mode { + Mode::Check => self.check_source(source)?, + Mode::Fix => self.fix_source(source)?, + }; + files.push(report); + } + + Ok(RunReport { files }) + } + + pub fn reload_config(&mut self, config: FluffConfig) -> Result<(), SqruffError> { + let include_parse_errors = self.inner.include_parse_errors(); + let formatter = self.inner.formatter().cloned(); + self.inner = Linter::new(config, formatter, None, include_parse_errors) + .map_err(SQLFluffUserError::new)?; + + Ok(()) + } + + fn lint_source(&self, source: Source<'_>, fix: bool) -> Result { + let filename = filename_for_source_id(&source.id); + let linted_file = self + .inner + .lint_string(source.text.as_ref(), filename, fix)?; + + Ok(file_report_from_linted_file(linted_file, source.id, fix)) + } +} + +fn filename_for_source_id(source_id: &SourceId) -> Option { + match source_id { + SourceId::Stdin => None, + SourceId::Path(path) => Some(path.to_string_lossy().into_owned()), + SourceId::Virtual(name) => Some(name.clone()), + } +} + +fn file_report_from_linted_file( + linted_file: LintedFile, + source_id: SourceId, + include_fixed_source: bool, +) -> FileReport { + let diagnostics = linted_file + .violations() + .iter() + .map(lint_diagnostic_from_error) + .collect(); + let fixed_source = include_fixed_source.then(|| linted_file.fix_string()); + + FileReport { + source_id, + diagnostics, + fixed_source, + skipped: None, + } +} + +fn lint_diagnostic_from_error(error: &SQLBaseError) -> LintDiagnostic { + LintDiagnostic { + message: error.desc().to_string(), + code: error.rule.as_ref().map(|rule| rule.code.to_string()), + line: error.line_no, + column: error.line_pos, + source_range: error.source_slice.clone(), + fixable: error.fixable, + } +} + +#[cfg(test)] +mod tests { + use std::borrow::Cow; + + use super::*; + + fn test_engine() -> Engine { + let config = FluffConfig::from_source( + r#" +[sqruff] +dialect = ansi +rules = LT01 +"#, + None, + ); + + Engine::new( + config, + EngineOptions { + parse_errors: ParseErrors::Include, + }, + ) + .unwrap() + } + + #[test] + fn check_source_reports_diagnostics() { + let report = test_engine() + .check_source(Source { + id: SourceId::Virtual("query.sql".into()), + text: Cow::Borrowed("select 1\n"), + }) + .unwrap(); + + assert_eq!(report.source_id, SourceId::Virtual("query.sql".into())); + assert!(report.fixed_source.is_none()); + assert!(report.skipped.is_none()); + assert!( + report + .diagnostics + .iter() + .any(|diagnostic| diagnostic.code.as_deref() == Some("LT01")) + ); + } + + #[test] + fn fix_source_returns_fixed_source() { + let report = test_engine() + .fix_source(Source { + id: SourceId::Stdin, + text: Cow::Borrowed("select 1\n"), + }) + .unwrap(); + + assert_eq!(report.source_id, SourceId::Stdin); + assert_eq!(report.fixed_source.as_deref(), Some("select 1\n")); + assert!( + report + .diagnostics + .iter() + .any(|diagnostic| diagnostic.code.as_deref() == Some("LT01")) + ); + } +} diff --git a/crates/lib/src/api/options.rs b/crates/lib/src/api/options.rs new file mode 100644 index 000000000..b2aae1f12 --- /dev/null +++ b/crates/lib/src/api/options.rs @@ -0,0 +1,32 @@ +use super::Source; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Mode { + Check, + Fix, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ParseErrors { + Suppress, + Include, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EngineOptions { + pub parse_errors: ParseErrors, +} + +impl Default for EngineOptions { + fn default() -> Self { + Self { + parse_errors: ParseErrors::Suppress, + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RunRequest<'a> { + pub mode: Mode, + pub sources: Vec>, +} diff --git a/crates/lib/src/api/report.rs b/crates/lib/src/api/report.rs new file mode 100644 index 000000000..2749d9a8d --- /dev/null +++ b/crates/lib/src/api/report.rs @@ -0,0 +1,19 @@ +use super::{LintDiagnostic, SourceId}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RunReport { + pub files: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FileReport { + pub source_id: SourceId, + pub diagnostics: Vec, + pub fixed_source: Option, + pub skipped: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SkipReason { + pub message: String, +} diff --git a/crates/lib/src/api/source.rs b/crates/lib/src/api/source.rs new file mode 100644 index 000000000..03546a554 --- /dev/null +++ b/crates/lib/src/api/source.rs @@ -0,0 +1,15 @@ +use std::borrow::Cow; +use std::path::PathBuf; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum SourceId { + Stdin, + Path(PathBuf), + Virtual(String), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Source<'a> { + pub id: SourceId, + pub text: Cow<'a, str>, +} diff --git a/crates/lib/src/core/linter/core.rs b/crates/lib/src/core/linter/core.rs index 97788c497..d2a2948cc 100644 --- a/crates/lib/src/core/linter/core.rs +++ b/crates/lib/src/core/linter/core.rs @@ -879,6 +879,10 @@ impl Linter { pub fn formatter_mut(&mut self) -> Option<&mut Arc> { self.formatter.as_mut() } + + pub(crate) fn include_parse_errors(&self) -> bool { + self.include_parse_errors + } } #[cfg(test)] diff --git a/crates/lib/src/lib.rs b/crates/lib/src/lib.rs index a77f88e58..822ae0d04 100644 --- a/crates/lib/src/lib.rs +++ b/crates/lib/src/lib.rs @@ -1,3 +1,4 @@ +pub mod api; pub mod core; #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))] pub mod ignore; From 39d3e6b132904c364e7618fcfab105061391a5f4 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Tue, 26 May 2026 01:11:01 -0700 Subject: [PATCH 3/9] refactor(lsp): migrate diagnostics and formatting to engine API --- crates/cli/Cargo.toml | 1 + crates/lsp/src/lib.rs | 740 ++++++++++++++++++++++-------------------- 2 files changed, 382 insertions(+), 359 deletions(-) diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 30102cb87..2bce2b9a2 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -69,6 +69,7 @@ harness = false [[test]] name = "none_format" +harness = false [[test]] name = "path_discovery" diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index 4d06eac72..e9ec81782 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -1,6 +1,5 @@ -use std::path::{Path, PathBuf}; - use hashbrown::HashMap; +use ignore::gitignore::Gitignore; use lsp_server::{Connection, Message, Request, RequestId, Response}; use lsp_types::notification::{ DidChangeTextDocument, DidCloseTextDocument, DidOpenTextDocument, DidSaveTextDocument, @@ -15,13 +14,12 @@ use lsp_types::{ TextDocumentSyncCapability, TextDocumentSyncKind, Uri, VersionedTextDocumentIdentifier, }; use serde_json::Value; -#[cfg(not(target_arch = "wasm32"))] -use sqruff_lib::core::config::ConfigLoader; +use sqruff_lib::api::{ + Engine, EngineOptions, LintDiagnostic, ParseErrors, Source, SourceId, SqruffError, +}; use sqruff_lib::core::config::FluffConfig; -use sqruff_lib::core::linter::core::Linter; -#[cfg(not(target_arch = "wasm32"))] -use sqruff_lib::ignore::IgnoreFile; -use sqruff_lib::templaters::RAW_TEMPLATER; +use std::borrow::Cow; +use std::path::{Path, PathBuf}; use wasm_bindgen::prelude::*; #[cfg(not(target_arch = "wasm32"))] @@ -38,7 +36,7 @@ fn load_config(root: Option<&Path>) -> FluffConfig { } #[cfg(target_arch = "wasm32")] -fn load_config(_root: Option<&Path>) -> FluffConfig { +fn load_config() -> FluffConfig { FluffConfig::default() } @@ -54,13 +52,9 @@ fn server_initialize_result() -> InitializeResult { } pub struct LanguageServer { - linter: Linter, + engine: Engine, send_diagnostics_callback: Box, documents: HashMap, - #[cfg(not(target_arch = "wasm32"))] - workspace_root: PathBuf, - #[cfg(not(target_arch = "wasm32"))] - ignore_file: IgnoreFile, } #[wasm_bindgen] @@ -89,8 +83,12 @@ impl Wasm { #[wasm_bindgen(js_name = updateConfig)] pub fn update_config(&mut self, source: &str) { - *self.0.linter.config_mut() = FluffConfig::from_source(source, None); - self.0.recheck_files(); + let new_config = FluffConfig::from_source(source, None); + if self.0.set_config(new_config).is_ok() { + self.0.recheck_files(); + } else { + eprintln!("Invalid templater in config, keeping previous configuration"); + } } #[wasm_bindgen(js_name = onInitialize)] @@ -113,41 +111,17 @@ impl Wasm { #[wasm_bindgen(js_name = formatSource)] pub fn format_source(&mut self, source: &str) -> String { - self.0.format_source(source, None) + self.0.format_source(source) } } impl LanguageServer { pub fn new(send_diagnostics_callback: impl Fn(PublishDiagnosticsParams) + 'static) -> Self { - Self::new_with_workspace_root(None, send_diagnostics_callback) - } - - fn new_with_workspace_root( - workspace_root: Option, - send_diagnostics_callback: impl Fn(PublishDiagnosticsParams) + 'static, - ) -> Self { - #[cfg(not(target_arch = "wasm32"))] - let workspace_root = workspace_root - .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))); - - #[cfg(not(target_arch = "wasm32"))] - let config = load_config(Some(&workspace_root)); - - #[cfg(target_arch = "wasm32")] - let _ = workspace_root; - - #[cfg(target_arch = "wasm32")] - let config = load_config(None); - - let templater = Linter::get_templater(&config).unwrap_or(&RAW_TEMPLATER); + let config = load_config(); Self { - linter: Linter::new(config, None, Some(templater), false).unwrap(), + engine: Self::new_engine(config).unwrap(), send_diagnostics_callback: Box::new(send_diagnostics_callback), documents: HashMap::new(), - #[cfg(not(target_arch = "wasm32"))] - ignore_file: load_ignore_file(&workspace_root), - #[cfg(not(target_arch = "wasm32"))] - workspace_root, } } @@ -167,20 +141,17 @@ impl LanguageServer { } fn format(&mut self, uri: Uri) -> Vec { - if self.is_ignored(&uri) { - return Vec::new(); - } - let text = self.documents.get(&uri).cloned().unwrap(); - let filename = file_uri_to_path(&uri).map(|path| path.to_string_lossy().to_string()); - let new_text = self.format_source(&text, filename); - self.documents.insert(uri.clone(), new_text.clone()); - Self::build_edits(new_text) + let new_text = self.format_source(&text); + build_full_document_edit(&text, new_text) } - fn format_source(&mut self, source: &str, filename: Option) -> String { - match self.linter.lint_string(source, filename, true) { - Ok(tree) => tree.fix_string(), + fn format_source(&mut self, source: &str) -> String { + match self.engine.fix_source(Source { + id: SourceId::Stdin, + text: Cow::Borrowed(source), + }) { + Ok(report) => report.fixed_source.unwrap_or_else(|| source.to_string()), Err(e) => { eprintln!("Failed to format source: {}", e.value); source.to_string() @@ -188,20 +159,18 @@ impl LanguageServer { } } - fn build_edits(new_text: String) -> Vec { - let start_position = Position { - line: 0, - character: 0, - }; - let end_position = Position { - line: new_text.lines().count() as u32, - character: new_text.chars().count() as u32, - }; + fn set_config(&mut self, new_config: FluffConfig) -> Result<(), SqruffError> { + self.engine.reload_config(new_config)?; + Ok(()) + } - vec![lsp_types::TextEdit { - range: lsp_types::Range::new(start_position, end_position), - new_text, - }] + fn new_engine(config: FluffConfig) -> Result { + Engine::new( + config, + EngineOptions { + parse_errors: ParseErrors::Include, + }, + ) } pub fn on_notification(&mut self, method: &str, params: Value) { @@ -236,12 +205,12 @@ impl LanguageServer { let uri = params.text_document.uri.as_str(); if uri.ends_with(".sqlfluff") || uri.ends_with(".sqruff") { - if self.reload_config() { + let new_config = load_config(); + if self.set_config(new_config).is_ok() { self.recheck_files(); + } else { + eprintln!("Invalid templater in config, keeping previous configuration"); } - } else if uri.ends_with(".sqruffignore") { - self.reload_ignore_file(); - self.recheck_files(); } } _ => {} @@ -255,102 +224,69 @@ impl LanguageServer { } fn check_file(&self, uri: Uri, text: &str) { - if self.is_ignored(&uri) { + if Self::is_ignored(&uri) { let diagnostics = PublishDiagnosticsParams::new(uri.clone(), Vec::new(), None); (self.send_diagnostics_callback)(diagnostics); return; } - let filename = file_uri_to_path(&uri).map(|path| path.to_string_lossy().to_string()); - let result = match self.linter.lint_string(text, filename, false) { - Ok(result) => result, + let report = match self.engine.check_source(Source { + id: source_id_from_uri(&uri), + text: Cow::Borrowed(text), + }) { + Ok(report) => report, Err(e) => { eprintln!("Failed to check file: {}", e.value); return; } }; - let diagnostics = result - .into_violations() - .into_iter() - .map(|violation| { - let range = { - let pos = Position::new( - (violation.line_no as u32).saturating_sub(1), - (violation.line_pos as u32).saturating_sub(1), - ); - lsp_types::Range::new(pos, pos) - }; - - let code = violation - .rule - .map(|rule| NumberOrString::String(rule.code.to_string())); - - Diagnostic::new( - range, - DiagnosticSeverity::WARNING.into(), - code, - Some("sqruff".to_string()), - violation.description, - None, - None, - ) - }) + let line_index = LineIndex::new(text); + let diagnostics = report + .diagnostics + .iter() + .map(|diag| to_lsp_diagnostic(diag, &line_index)) .collect(); let diagnostics = PublishDiagnosticsParams::new(uri.clone(), diagnostics, None); (self.send_diagnostics_callback)(diagnostics); } - fn is_ignored(&self, uri: &Uri) -> bool { - #[cfg(not(target_arch = "wasm32"))] - { - file_uri_to_path(uri).is_some_and(|path| self.ignore_file.is_ignored(&path)) + fn is_ignored(uri: &Uri) -> bool { + let Some(path) = Self::uri_to_file_path(uri) else { + return false; + }; + let Ok(root) = std::env::current_dir() else { + return false; + }; + let ignore_file = root.join(".sqruffignore"); + if !ignore_file.exists() { + return false; } - #[cfg(target_arch = "wasm32")] - { - let _ = uri; - false + let (gitignore, err) = Gitignore::new(ignore_file); + if err.is_some() { + return false; } - } - - fn reload_config(&mut self) -> bool { - let new_config = { - #[cfg(not(target_arch = "wasm32"))] - { - load_config(Some(&self.workspace_root)) - } - #[cfg(target_arch = "wasm32")] - { - load_config(None) - } - }; + gitignore.matched(&path, path.is_dir()).is_ignore() + } - if Linter::get_templater(&new_config).is_ok() { - *self.linter.config_mut() = new_config; - true - } else { - eprintln!("Invalid templater in config, keeping previous configuration"); - false + fn uri_to_file_path(uri: &Uri) -> Option { + if uri.scheme()?.as_str() != "file" { + return None; } - } - fn reload_ignore_file(&mut self) { - #[cfg(not(target_arch = "wasm32"))] + let mut path = uri.path().as_str().to_string(); + #[cfg(windows)] { - self.ignore_file = load_ignore_file(&self.workspace_root); + if path.len() >= 3 && path.as_bytes()[0] == b'/' && path.as_bytes()[2] == b':' { + path.remove(0); + } } - } -} -#[cfg(not(target_arch = "wasm32"))] -fn load_ignore_file(root: &Path) -> IgnoreFile { - IgnoreFile::new_from_root(root).unwrap_or_else(|err| { - eprintln!("Failed to load .sqruffignore: {err}"); - IgnoreFile::empty() - }) + Some(Path::new(&path).to_path_buf()) + } } pub fn run() { @@ -366,10 +302,9 @@ pub fn run() { io_threads.join().unwrap(); } -fn main_loop(connection: Connection, init_param: InitializeParams) { +fn main_loop(connection: Connection, _init_param: InitializeParams) { let sender = connection.sender.clone(); - let workspace_root = workspace_root_from_initialize(&init_param); - let mut lsp = LanguageServer::new_with_workspace_root(workspace_root, move |diagnostics| { + let mut lsp = LanguageServer::new(move |diagnostics| { let notification = new_notification::(diagnostics); sender.send(Message::Notification(notification)).unwrap(); }); @@ -404,125 +339,6 @@ fn main_loop(connection: Connection, init_param: InitializeParams) { } } -#[cfg(not(target_arch = "wasm32"))] -fn workspace_root_from_initialize(params: &InitializeParams) -> Option { - params - .workspace_folders - .as_ref() - .and_then(|folders| folders.first()) - .and_then(|folder| file_uri_to_path(&folder.uri)) - .or_else(|| { - #[allow(deprecated)] - params.root_uri.as_ref().and_then(file_uri_to_path) - }) - .or_else(|| { - #[allow(deprecated)] - params.root_path.as_ref().map(PathBuf::from) - }) -} - -#[cfg(target_arch = "wasm32")] -fn workspace_root_from_initialize(_params: &InitializeParams) -> Option { - None -} - -fn file_uri_to_path(uri: &Uri) -> Option { - if uri - .scheme() - .is_some_and(|scheme| scheme.eq_lowercase("file")) - { - if let Some(authority) = uri.authority() { - let host = authority.host().as_str(); - if !host.is_empty() && !host.eq_ignore_ascii_case("localhost") { - return None; - } - } - - let path = uri.path().as_estr().decode().into_bytes(); - - #[cfg(target_os = "windows")] - { - let path = String::from_utf8(path.into_owned()).ok()?; - let path = if path.starts_with('/') - && path - .as_bytes() - .get(2) - .is_some_and(|character| *character == b':') - { - &path[1..] - } else { - path.as_str() - }; - return Some(PathBuf::from(path.replace('/', "\\"))); - } - - #[cfg(target_family = "unix")] - { - use std::ffi::OsStr; - use std::os::unix::ffi::OsStrExt; - - return Some(PathBuf::from(OsStr::from_bytes(path.as_ref()))); - } - - #[cfg(not(any(target_os = "windows", target_family = "unix")))] - { - let path = String::from_utf8(path.into_owned()).ok()?; - return Some(PathBuf::from(path)); - } - } - - let uri = uri.as_str(); - let path = uri.strip_prefix("file://")?; - let path = percent_decode(path)?; - - #[cfg(target_os = "windows")] - { - let path = if path.starts_with('/') - && path - .as_bytes() - .get(2) - .is_some_and(|character| *character == b':') - { - &path[1..] - } else { - path.as_str() - }; - - return Some(PathBuf::from(path.replace('/', "\\"))); - } - - #[cfg(not(target_os = "windows"))] - { - Some(PathBuf::from(path)) - } -} - -fn percent_decode(input: &str) -> Option { - let mut output = Vec::with_capacity(input.len()); - let mut bytes = input.as_bytes().iter().copied(); - - while let Some(byte) = bytes.next() { - if byte == b'%' { - let high = bytes.next()?; - let low = bytes.next()?; - output.push((hex_value(high)? << 4) | hex_value(low)?); - } else { - output.push(byte); - } - } - - String::from_utf8(output).ok() -} - -fn hex_value(byte: u8) -> Option { - match byte { - b'0'..=b'9' => Some(byte - b'0'), - b'a'..=b'f' => Some(byte - b'a' + 10), - b'A'..=b'F' => Some(byte - b'A' + 10), - _ => None, - } -} - pub fn save_registration_options() -> lsp_types::RegistrationParams { let save_registration_options = lsp_types::TextDocumentSaveRegistrationOptions { include_text: false.into(), @@ -538,11 +354,6 @@ pub fn save_registration_options() -> lsp_types::RegistrationParams { scheme: None, pattern: Some("**/.sqruff".into()), }, - lsp_types::DocumentFilter { - language: None, - scheme: None, - pattern: Some("**/.sqruffignore".into()), - }, ]), }, }; @@ -568,149 +379,360 @@ where } } +fn to_lsp_diagnostic(diag: &LintDiagnostic, line_index: &LineIndex) -> Diagnostic { + let range = if diag.source_range.is_empty() && diag.line > 0 && diag.column > 0 { + let pos = Position::new((diag.line as u32) - 1, (diag.column as u32) - 1); + lsp_types::Range::new(pos, pos) + } else { + let start = line_index.position(diag.source_range.start); + let end = line_index.position(diag.source_range.end); + lsp_types::Range::new(start, end) + }; + + let code = diag.code.clone().map(NumberOrString::String); + + Diagnostic::new( + range, + DiagnosticSeverity::WARNING.into(), + code, + Some("sqruff".to_string()), + diag.message.clone(), + None, + None, + ) +} + +fn source_id_from_uri(uri: &Uri) -> SourceId { + LanguageServer::uri_to_file_path(uri) + .map_or_else(|| SourceId::Virtual(uri.to_string()), SourceId::Path) +} + +fn build_full_document_edit(old_text: &str, new_text: String) -> Vec { + vec![lsp_types::TextEdit { + range: full_document_range(old_text), + new_text, + }] +} + +fn full_document_range(text: &str) -> lsp_types::Range { + lsp_types::Range::new(Position::new(0, 0), LineIndex::new(text).end_position()) +} + +struct LineIndex { + line_starts: Vec, + text: String, +} + +impl LineIndex { + fn new(text: &str) -> Self { + let mut line_starts = vec![0]; + line_starts.extend( + text.bytes() + .enumerate() + .filter_map(|(idx, byte)| (byte == b'\n').then_some(idx + 1)), + ); + + Self { + line_starts, + text: text.to_string(), + } + } + + fn position(&self, byte_offset: usize) -> Position { + let byte_offset = byte_offset.min(self.text.len()); + let line = self.line_for_offset(byte_offset); + let line_start = self.line_starts[line]; + let character = self.text[line_start..byte_offset] + .chars() + .map(char::len_utf16) + .sum::(); + + Position::new(line as u32, character as u32) + } + + fn end_position(&self) -> Position { + self.position(self.text.len()) + } + + fn line_for_offset(&self, byte_offset: usize) -> usize { + match self.line_starts.binary_search(&byte_offset) { + Ok(line) => line, + Err(next_line) => next_line.saturating_sub(1), + } + } +} + #[cfg(test)] mod tests { use std::fs; + use std::str::FromStr; use std::sync::{Arc, Mutex}; use std::time::{SystemTime, UNIX_EPOCH}; + use lsp_types::notification::{ + DidChangeTextDocument, DidOpenTextDocument, DidSaveTextDocument, + }; + use lsp_types::{ + DidChangeTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams, + TextDocumentContentChangeEvent, + }; + use super::*; - struct TempRoot { - path: PathBuf, + static CWD_LOCK: Mutex<()> = Mutex::new(()); + + struct Workspace { + root: PathBuf, + previous: PathBuf, } - impl TempRoot { - fn new() -> Self { - let suffix = SystemTime::now() + impl Workspace { + fn new(name: &str, config: &str) -> Self { + let previous = std::env::current_dir().unwrap(); + let nanos = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap() .as_nanos(); - let path = std::env::temp_dir() - .join(format!("sqruff-lsp-test-{}-{suffix}", std::process::id())); - fs::create_dir_all(&path).unwrap(); - Self { path } + let root = std::env::temp_dir().join(format!("sqruff-lsp-{name}-{nanos}")); + fs::create_dir_all(&root).unwrap(); + fs::write(root.join(".sqruff"), config).unwrap(); + std::env::set_current_dir(&root).unwrap(); + + Self { root, previous } + } + + fn uri(&self, relative: &str) -> Uri { + file_uri(&self.root.join(relative)) + } + + fn write_config(&self, config: &str) { + fs::write(self.root.join(".sqruff"), config).unwrap(); } } - impl Drop for TempRoot { + impl Drop for Workspace { fn drop(&mut self) { - let _ = fs::remove_dir_all(&self.path); + std::env::set_current_dir(&self.previous).unwrap(); + fs::remove_dir_all(&self.root).unwrap(); } } - fn path_to_uri(path: &Path) -> Uri { - let path = path.canonicalize().unwrap(); + fn config(dialect: &str, templater: &str) -> String { + format!("[sqruff]\ndialect = {dialect}\ntemplater = {templater}\n") + } + + fn file_uri(path: &Path) -> Uri { let path = path.to_string_lossy().replace('\\', "/"); - let uri = if cfg!(windows) { - format!("file:///{path}") + let path = if path.starts_with('/') { + path } else { - format!("file://{path}") + format!("/{path}") }; - uri.parse().unwrap() + Uri::from_str(&format!("file://{path}")).unwrap() } - fn diagnostics_lsp(root: &Path) -> (LanguageServer, Arc>>) { + fn server_with_diagnostics() -> (LanguageServer, Arc>>) { let diagnostics = Arc::new(Mutex::new(Vec::new())); - let sent_diagnostics = Arc::clone(&diagnostics); - let lsp = - LanguageServer::new_with_workspace_root(Some(root.to_path_buf()), move |params| { - sent_diagnostics.lock().unwrap().push(params) - }); + let captured = Arc::clone(&diagnostics); + let server = LanguageServer::new(move |params| { + captured.lock().unwrap().push(params); + }); + + (server, diagnostics) + } + + fn open(server: &mut LanguageServer, uri: Uri, text: &str) { + let params = DidOpenTextDocumentParams { + text_document: TextDocumentItem { + uri, + language_id: "sql".to_string(), + version: 1, + text: text.to_string(), + }, + }; + server.on_notification( + DidOpenTextDocument::METHOD, + serde_json::to_value(params).unwrap(), + ); + } - (lsp, diagnostics) + fn change(server: &mut LanguageServer, uri: Uri, text: &str) { + let params = DidChangeTextDocumentParams { + text_document: VersionedTextDocumentIdentifier { uri, version: 2 }, + content_changes: vec![TextDocumentContentChangeEvent { + range: None, + range_length: None, + text: text.to_string(), + }], + }; + server.on_notification( + DidChangeTextDocument::METHOD, + serde_json::to_value(params).unwrap(), + ); + } + + fn save_config(server: &mut LanguageServer, uri: Uri) { + let params = DidSaveTextDocumentParams { + text_document: TextDocumentIdentifier { uri }, + text: None, + }; + server.on_notification( + DidSaveTextDocument::METHOD, + serde_json::to_value(params).unwrap(), + ); } #[test] - fn loads_config_from_workspace_root() { - let root = TempRoot::new(); - fs::write(root.path.join(".sqruff"), "[sqruff]\ndialect = postgres\n").unwrap(); + fn invalid_sql_publishes_diagnostics() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new("invalid-sql", &config("ansi", "raw")); + let (mut server, diagnostics) = server_with_diagnostics(); - let (lsp, _) = diagnostics_lsp(&root.path); + open(&mut server, workspace.uri("bad.sql"), "SELECT FROM\n"); - assert_eq!(lsp.linter.config().dialect_kind().as_ref(), "postgres"); + let diagnostics = diagnostics.lock().unwrap(); + assert!(!diagnostics.last().unwrap().diagnostics.is_empty()); } #[test] - fn clears_diagnostics_for_sqruffignored_file() { - let root = TempRoot::new(); - fs::write( - root.path.join(".sqruff"), - "[sqruff]\ndialect = ansi\nrules = all\n", - ) - .unwrap(); - fs::write(root.path.join(".sqruffignore"), "ignored.sql\n").unwrap(); + fn ignored_files_publish_empty_diagnostics() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new("ignored-file", &config("ansi", "raw")); + fs::write(workspace.root.join(".sqruffignore"), "ignored.sql\n").unwrap(); + let (mut server, diagnostics) = server_with_diagnostics(); - let checked = root.path.join("checked.sql"); - fs::write(&checked, "select 1").unwrap(); - let ignored = root.path.join("ignored.sql"); - fs::write(&ignored, "select 1").unwrap(); + open(&mut server, workspace.uri("ignored.sql"), "SELECT FROM\n"); - let (lsp, diagnostics) = diagnostics_lsp(&root.path); + let diagnostics = diagnostics.lock().unwrap(); + assert!(diagnostics.last().unwrap().diagnostics.is_empty()); + } - lsp.check_file(path_to_uri(&checked), "select 1"); - assert!( - !diagnostics - .lock() - .unwrap() - .last() - .unwrap() - .diagnostics - .is_empty(), - "test fixture should produce diagnostics for a non-ignored file", - ); + #[test] + fn formatting_returns_full_document_edit_for_old_range() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new("format-range", &config("ansi", "raw")); + let (mut server, _diagnostics) = server_with_diagnostics(); + let uri = workspace.uri("format.sql"); - lsp.check_file(path_to_uri(&ignored), "select 1"); - assert!( - diagnostics - .lock() - .unwrap() - .last() - .unwrap() - .diagnostics - .is_empty(), - "ignored files should publish an empty diagnostics set", - ); + open(&mut server, uri.clone(), "SELECT 1"); + let edits = server.format(uri); + + assert_eq!(edits.len(), 1); + assert_eq!(edits[0].range.start, Position::new(0, 0)); + assert_eq!(edits[0].range.end, Position::new(0, 9)); + assert_eq!(edits[0].new_text, "SELECT 1\n"); } #[test] - fn skips_formatting_sqruffignored_file() { - let root = TempRoot::new(); - fs::write( - root.path.join(".sqruff"), - "[sqruff]\ndialect = ansi\nrules = all\n", - ) - .unwrap(); - fs::write(root.path.join(".sqruffignore"), "ignored.sql\n").unwrap(); + fn formatting_does_not_mutate_document_before_did_change() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new("format-no-mutate", &config("ansi", "raw")); + let (mut server, _diagnostics) = server_with_diagnostics(); + let uri = workspace.uri("format.sql"); - let ignored = root.path.join("ignored.sql"); - fs::write(&ignored, "select 1").unwrap(); + open(&mut server, uri.clone(), "SELECT 1"); + let edits = server.format(uri.clone()); - let (mut lsp, _) = diagnostics_lsp(&root.path); - let uri = path_to_uri(&ignored); - lsp.documents.insert(uri.clone(), "select 1".to_string()); + assert_eq!(edits[0].new_text, "SELECT 1\n"); + assert_eq!(server.documents.get(&uri).unwrap(), "SELECT 1"); - assert!( - lsp.format(uri).is_empty(), - "ignored files should not receive formatting edits", - ); + change(&mut server, uri.clone(), &edits[0].new_text); + assert_eq!(server.documents.get(&uri).unwrap(), "SELECT 1\n"); } #[test] - fn file_uri_with_localhost_authority_is_supported() { - let uri: Uri = if cfg!(windows) { - "file://localhost/C:/tmp/sqruff.sql".parse().unwrap() - } else { - "file://localhost/tmp/sqruff.sql".parse().unwrap() - }; + fn changing_dialect_reloads_diagnostics() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new("reload-dialect", &config("ansi", "raw")); + let (mut server, diagnostics) = server_with_diagnostics(); + let uri = workspace.uri("postgres.sql"); + let sql = "SELECT DISTINCT ON (customer_id)\n customer_id\nFROM orders\nORDER BY customer_id;\n"; + + open(&mut server, uri, sql); + let ansi_count = diagnostics + .lock() + .unwrap() + .last() + .unwrap() + .diagnostics + .len(); + + workspace.write_config(&config("postgres", "raw")); + save_config(&mut server, workspace.uri(".sqruff")); + let postgres_count = diagnostics + .lock() + .unwrap() + .last() + .unwrap() + .diagnostics + .len(); + + assert!(ansi_count > postgres_count); + } - let path = file_uri_to_path(&uri).unwrap(); - assert!(path.ends_with("sqruff.sql")); + #[test] + fn changing_templater_reloads_templater() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new("reload-templater", &config("postgres", "raw")); + let (mut server, diagnostics) = server_with_diagnostics(); + let uri = workspace.uri("placeholder.sql"); + let sql = "SELECT :x AS value\n"; + + open(&mut server, uri, sql); + let raw_count = diagnostics + .lock() + .unwrap() + .last() + .unwrap() + .diagnostics + .len(); + + workspace.write_config( + "[sqruff]\ndialect = postgres\ntemplater = placeholder\n\n[sqruff:templater:placeholder]\nparam_style = colon\nx = 1\n", + ); + save_config(&mut server, workspace.uri(".sqruff")); + let placeholder_count = diagnostics + .lock() + .unwrap() + .last() + .unwrap() + .diagnostics + .len(); + + assert!(raw_count > placeholder_count); } #[test] - fn file_uri_with_non_local_authority_is_rejected() { - let uri: Uri = "file://example.com/tmp/sqruff.sql".parse().unwrap(); - assert!(file_uri_to_path(&uri).is_none()); + fn invalid_templater_keeps_previous_config() { + let _guard = CWD_LOCK.lock().unwrap(); + let workspace = Workspace::new( + "invalid-templater", + "[sqruff]\ndialect = postgres\ntemplater = placeholder\n\n[sqruff:templater:placeholder]\nparam_style = colon\nx = 1\n", + ); + let (mut server, diagnostics) = server_with_diagnostics(); + let uri = workspace.uri("placeholder.sql"); + let sql = "SELECT :x AS value\n"; + + open(&mut server, uri, sql); + let before = diagnostics + .lock() + .unwrap() + .last() + .unwrap() + .diagnostics + .len(); + + workspace.write_config("[sqruff]\ndialect = postgres\ntemplater = not_real\n"); + save_config(&mut server, workspace.uri(".sqruff")); + let after = diagnostics + .lock() + .unwrap() + .last() + .unwrap() + .diagnostics + .len(); + + assert_eq!(before, 0); + assert_eq!(after, 0); } } From 83b75cdb5f4475063f362ef762805522077388a9 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Tue, 26 May 2026 01:13:29 -0700 Subject: [PATCH 4/9] refactor(wasm): migrate lint and format paths to engine API --- crates/lib-wasm/src/lib.rs | 142 +++++++++++++++++++++++++++---------- 1 file changed, 106 insertions(+), 36 deletions(-) diff --git a/crates/lib-wasm/src/lib.rs b/crates/lib-wasm/src/lib.rs index 7fd890350..f69a864a2 100644 --- a/crates/lib-wasm/src/lib.rs +++ b/crates/lib-wasm/src/lib.rs @@ -1,11 +1,15 @@ use line_index::LineIndex; use lineage::{Lineage, Node}; use serde::Serialize; +use sqruff_lib::api::{ + Engine, EngineOptions, LintDiagnostic, ParseErrors, Source, SourceId, SqruffError, +}; use sqruff_lib::core::config::FluffConfig; use sqruff_lib::core::linter::core::Linter as SqruffLinter; use sqruff_lib::templaters::RAW_TEMPLATER; use sqruff_lib_core::parser::segments::{ErasedSegment, Tables}; use sqruff_lib_core::parser::{IndentationConfig, Parser}; +use std::borrow::Cow; use wasm_bindgen::prelude::*; #[wasm_bindgen] @@ -28,6 +32,7 @@ impl Diagnostic { #[wasm_bindgen] pub struct Linter { + engine: Engine, base: SqruffLinter, } @@ -76,14 +81,48 @@ impl Linter { let config = FluffConfig::from_source(source, None); let templater = SqruffLinter::get_templater(&config).unwrap_or(&RAW_TEMPLATER); Self { + engine: Engine::new( + config.clone(), + EngineOptions { + parse_errors: ParseErrors::Include, + }, + ) + .unwrap(), base: SqruffLinter::new(config, None, Some(templater), true).unwrap(), } } #[wasm_bindgen] pub fn check(&self, sql: &str, tool: Tool) -> Result { - let line_index = LineIndex::new(sql); + match tool { + Tool::Format => self.check_with_engine(sql, true), + Tool::Cst | Tool::Lineage | Tool::Templater | Tool::Lexer => { + self.check_developer_tool(sql, tool) + } + Tool::__Invalid => Result { + diagnostics: Vec::new(), + secondary: String::from("Error: unsupported tool"), + }, + } + } + + fn check_with_engine(&self, sql: &str, fix: bool) -> Result { + let report = match self.engine_report(sql, fix) { + Ok(report) => report, + Err(e) => return result_from_error(e), + }; + + Result { + diagnostics: diagnostics_from_lint_diagnostics(sql, &report.diagnostics), + secondary: report.fixed_source.unwrap_or_default(), + } + } + fn check_developer_tool(&self, sql: &str, tool: Tool) -> Result { + let report = match self.engine_report(sql, false) { + Ok(report) => report, + Err(e) => return result_from_error(e), + }; let tables = Tables::default(); let parsed = self.base.parse_string(&tables, sql, None).unwrap(); @@ -98,41 +137,7 @@ impl Linter { None }; - let result = match self.base.lint_parsed(&tables, parsed, tool == Tool::Format) { - Ok(result) => result, - Err(e) => { - return Result { - diagnostics: vec![Diagnostic { - message: e.value, - start_line_number: 1, - start_column: 1, - end_line_number: 1, - end_column: 1, - }], - secondary: String::new(), - }; - } - }; - let violations = result.violations(); - - let diagnostics = violations - .iter() - .map(|violation| { - let start = line_index.line_col(violation.source_slice.start.try_into().unwrap()); - let end = line_index.line_col(violation.source_slice.end.try_into().unwrap()); - - Diagnostic { - message: violation.description.clone(), - start_line_number: start.line + 1, - start_column: start.col + 1, - end_line_number: end.line + 1, - end_column: end.col + 1, - } - }) - .collect(); - let secondary = match tool { - Tool::Format => result.fix_string(), Tool::Cst => cst.unwrap().stringify(false), Tool::Lineage => { let parser = Parser::new( @@ -150,14 +155,79 @@ impl Linter { let (segments, _errors) = lexer.lex(&lex_tables, sql); format_lexer_output(&segments) } + Tool::Format => String::new(), Tool::__Invalid => String::from("Error: unsupported tool"), }; Result { - diagnostics, + diagnostics: diagnostics_from_lint_diagnostics(sql, &report.diagnostics), secondary, } } + + fn engine_report( + &self, + sql: &str, + fix: bool, + ) -> std::result::Result { + let source = Source { + id: SourceId::Stdin, + text: Cow::Borrowed(sql), + }; + + if fix { + self.engine.fix_source(source) + } else { + self.engine.check_source(source) + } + } +} + +fn diagnostics_from_lint_diagnostics(sql: &str, diagnostics: &[LintDiagnostic]) -> Vec { + let line_index = LineIndex::new(sql); + diagnostics + .iter() + .map(|diag| diagnostic_from_lint_diagnostic(diag, &line_index)) + .collect() +} + +fn diagnostic_from_lint_diagnostic( + diagnostic: &LintDiagnostic, + line_index: &LineIndex, +) -> Diagnostic { + if diagnostic.source_range.is_empty() && diagnostic.line > 0 && diagnostic.column > 0 { + return Diagnostic { + message: diagnostic.message.clone(), + start_line_number: diagnostic.line as u32, + start_column: diagnostic.column as u32, + end_line_number: diagnostic.line as u32, + end_column: diagnostic.column as u32, + }; + } + + let start = line_index.line_col(diagnostic.source_range.start.try_into().unwrap()); + let end = line_index.line_col(diagnostic.source_range.end.try_into().unwrap()); + + Diagnostic { + message: diagnostic.message.clone(), + start_line_number: start.line + 1, + start_column: start.col + 1, + end_line_number: end.line + 1, + end_column: end.col + 1, + } +} + +fn result_from_error(error: SqruffError) -> Result { + Result { + diagnostics: vec![Diagnostic { + message: error.value, + start_line_number: 1, + start_column: 1, + end_line_number: 1, + end_column: 1, + }], + secondary: String::new(), + } } fn print_tree( From e4028c989528eab162d322b17f70f905f61119a4 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Wed, 8 Jul 2026 03:44:54 -0700 Subject: [PATCH 5/9] fix(lsp): repair config loading after engine migration --- crates/lsp/BUILD.bazel | 1 + crates/lsp/src/lib.rs | 17 +++++++++++------ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/crates/lsp/BUILD.bazel b/crates/lsp/BUILD.bazel index af0a8d965..35d87a817 100644 --- a/crates/lsp/BUILD.bazel +++ b/crates/lsp/BUILD.bazel @@ -16,6 +16,7 @@ rust_library( LSP_WASM_CRATE_NAMES = [ "console_error_panic_hook", "hashbrown", + "ignore", "js-sys", "lsp-server", "lsp-types", diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index e9ec81782..818f8d59f 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -17,6 +17,8 @@ use serde_json::Value; use sqruff_lib::api::{ Engine, EngineOptions, LintDiagnostic, ParseErrors, Source, SourceId, SqruffError, }; +#[cfg(not(target_arch = "wasm32"))] +use sqruff_lib::core::config::ConfigLoader; use sqruff_lib::core::config::FluffConfig; use std::borrow::Cow; use std::path::{Path, PathBuf}; @@ -36,7 +38,7 @@ fn load_config(root: Option<&Path>) -> FluffConfig { } #[cfg(target_arch = "wasm32")] -fn load_config() -> FluffConfig { +fn load_config(_root: Option<&Path>) -> FluffConfig { FluffConfig::default() } @@ -117,7 +119,7 @@ impl Wasm { impl LanguageServer { pub fn new(send_diagnostics_callback: impl Fn(PublishDiagnosticsParams) + 'static) -> Self { - let config = load_config(); + let config = load_config(None); Self { engine: Self::new_engine(config).unwrap(), send_diagnostics_callback: Box::new(send_diagnostics_callback), @@ -205,7 +207,7 @@ impl LanguageServer { let uri = params.text_document.uri.as_str(); if uri.ends_with(".sqlfluff") || uri.ends_with(".sqruff") { - let new_config = load_config(); + let new_config = load_config(None); if self.set_config(new_config).is_ok() { self.recheck_files(); } else { @@ -277,13 +279,16 @@ impl LanguageServer { return None; } - let mut path = uri.path().as_str().to_string(); + let path = uri.path().as_str().to_string(); #[cfg(windows)] - { + let path = { + let mut path = path; + if path.len() >= 3 && path.as_bytes()[0] == b'/' && path.as_bytes()[2] == b':' { path.remove(0); } - } + path + }; Some(Path::new(&path).to_path_buf()) } From a0bdb78bf065295f401f594183c7956841357e8e Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Tue, 26 May 2026 01:22:27 -0700 Subject: [PATCH 6/9] refactor(cli): unify lint and fix command runner --- crates/cli-lib/src/commands_fix.rs | 88 ++--- crates/cli-lib/src/commands_lint.rs | 355 ++++++++++++++++-- crates/cli-lib/src/formatters.rs | 95 ++++- .../github_annotation_native_formatter.rs | 19 +- crates/cli-lib/src/formatters/json.rs | 17 +- crates/cli-lib/src/formatters/json_types.rs | 16 + crates/cli-lib/src/lib.rs | 45 +-- 7 files changed, 499 insertions(+), 136 deletions(-) diff --git a/crates/cli-lib/src/commands_fix.rs b/crates/cli-lib/src/commands_fix.rs index a42e4ef15..838bd6812 100644 --- a/crates/cli-lib/src/commands_fix.rs +++ b/crates/cli-lib/src/commands_fix.rs @@ -1,6 +1,7 @@ use crate::commands::FixArgs; use crate::commands::Format; -use crate::linter; +use crate::commands_lint::{ApplyFixes, Input, LintCommand, run_lint_command}; +use sqruff_lib::api::Mode; use sqruff_lib::core::config::FluffConfig; use std::path::Path; @@ -11,48 +12,17 @@ pub(crate) fn run_fix( collect_parse_errors: bool, ) -> i32 { let FixArgs { paths, format } = args; - let mut linter = match linter(config, format, collect_parse_errors) { - Ok(l) => l, - Err(e) => { - eprintln!("{}", e); - return 1; - } - }; - let result = match linter.lint_paths(paths, true, &ignorer) { - Ok(result) => result, - Err(e) => { - eprintln!("{}", e.value); - return 1; - } - }; - - if !result.has_violations() { - println!("{} files processed, nothing to fix.", result.len()); - 0 - } else { - let any_unfixable_errors = result.has_unfixable_violations(); - let files = result.len(); - - for mut file in result { - if !file.has_fixes() { - continue; - } - if file - .violations() - .iter() - .any(|violation| violation.rule.is_none()) - { - continue; - } - let path = std::mem::take(&mut file.path); - let fixed = file.fix_string(); - std::fs::write(path, fixed).unwrap(); - } - - linter.formatter_mut().unwrap().completion_message(files); - - any_unfixable_errors as i32 - } + run_lint_command( + LintCommand { + mode: Mode::Fix, + input: Input::Paths(paths), + apply: ApplyFixes::ToDisk, + format, + }, + config, + ignorer, + collect_parse_errors, + ) } pub(crate) fn run_fix_stdin( @@ -62,27 +32,17 @@ pub(crate) fn run_fix_stdin( ) -> i32 { let read_in = crate::stdin::read_std_in().unwrap(); - let linter = match linter(config, format, collect_parse_errors) { - Ok(l) => l, - Err(e) => { - eprintln!("{}", e); - return 1; - } - }; - let result = match linter.lint_string(&read_in, None, true) { - Ok(result) => result, - Err(e) => { - eprintln!("{}", e.value); - return 1; - } - }; - - let has_unfixable_errors = result.has_unfixable_violations(); - - println!("{}", result.fix_string()); - - // if all fixable violations are fixable, return 0 else return 1 - has_unfixable_errors as i32 + run_lint_command( + LintCommand { + mode: Mode::Fix, + input: Input::Stdin(read_in), + apply: ApplyFixes::Stdout, + format, + }, + config, + |_| false, + collect_parse_errors, + ) } #[cfg(test)] diff --git a/crates/cli-lib/src/commands_lint.rs b/crates/cli-lib/src/commands_lint.rs index 71296d0d4..eefaa2acc 100644 --- a/crates/cli-lib/src/commands_lint.rs +++ b/crates/cli-lib/src/commands_lint.rs @@ -1,7 +1,44 @@ use crate::commands::{Format, LintArgs}; -use crate::linter; +use crate::formatters::OutputStreamFormatter; +use crate::formatters::github_annotation_native_formatter::GithubAnnotationNativeFormatter; +use crate::formatters::json::JsonFormatter; +use sqruff_lib::api::{ + Engine, EngineOptions, FileReport, Mode, ParseErrors, RunRequest, Source, SourceId, +}; use sqruff_lib::core::config::FluffConfig; -use std::path::Path; +use sqruff_lib_core::helpers; +use std::borrow::Cow; +use std::collections::BTreeSet; +use std::path::{Path, PathBuf}; + +pub(crate) struct LintCommand { + pub mode: Mode, + pub input: Input, + pub apply: ApplyFixes, + pub format: Format, +} + +pub(crate) enum Input { + Paths(Vec), + Stdin(String), +} + +pub(crate) enum ApplyFixes { + Never, + ToDisk, + Stdout, +} + +struct LoadedSource { + id: SourceId, + text: String, +} + +enum CliFormatter { + Human(OutputStreamFormatter), + GithubAnnotationNative(GithubAnnotationNativeFormatter), + Json(JsonFormatter), +} pub(crate) fn run_lint( args: LintArgs, @@ -10,24 +47,17 @@ pub(crate) fn run_lint( collect_parse_errors: bool, ) -> i32 { let LintArgs { paths, format } = args; - let mut linter = match linter(config, format, collect_parse_errors) { - Ok(l) => l, - Err(e) => { - eprintln!("{}", e); - return 1; - } - }; - let result = match linter.lint_paths(paths, false, &ignorer) { - Ok(result) => result, - Err(e) => { - eprintln!("{}", e.value); - return 1; - } - }; - - linter.formatter().unwrap().completion_message(result.len()); - - result.has_violations() as i32 + run_lint_command( + LintCommand { + mode: Mode::Check, + input: Input::Paths(paths), + apply: ApplyFixes::Never, + format, + }, + config, + ignorer, + collect_parse_errors, + ) } pub(crate) fn run_lint_stdin( @@ -37,22 +67,293 @@ pub(crate) fn run_lint_stdin( ) -> i32 { let read_in = crate::stdin::read_std_in().unwrap(); - let linter = match linter(config, format, collect_parse_errors) { - Ok(l) => l, + run_lint_command( + LintCommand { + mode: Mode::Check, + input: Input::Stdin(read_in), + apply: ApplyFixes::Never, + format, + }, + config, + |_| false, + collect_parse_errors, + ) +} + +pub(crate) fn run_lint_command( + command: LintCommand, + config: FluffConfig, + ignorer: impl Fn(&Path) -> bool + Send + Sync, + collect_parse_errors: bool, +) -> i32 { + let formatter = CliFormatter::new(command.format, &config); + let loaded_sources = match load_sources(&command.input, &config, &ignorer) { + Ok(sources) => sources, Err(e) => { - eprintln!("{}", e); + eprintln!("{e}"); + return 1; + } + }; + let engine = match Engine::new( + config, + EngineOptions { + parse_errors: if collect_parse_errors { + ParseErrors::Include + } else { + ParseErrors::Suppress + }, + }, + ) { + Ok(engine) => engine, + Err(e) => { + eprintln!("{}", e.value); return 1; } }; - let result = match linter.lint_string(&read_in, None, false) { - Ok(result) => result, + let sources = loaded_sources + .iter() + .map(|loaded| Source { + id: loaded.id.clone(), + text: Cow::Borrowed(loaded.text.as_str()), + }) + .collect(); + let report = match engine.run(RunRequest { + mode: command.mode, + sources, + }) { + Ok(report) => report, Err(e) => { eprintln!("{}", e.value); return 1; } }; - linter.formatter().unwrap().completion_message(1); + for file in &report.files { + formatter.dispatch_file_report(file); + } + + let files = report.files.len(); + let has_violations = report.files.iter().any(|file| !file.diagnostics.is_empty()); + + match command.apply { + ApplyFixes::Never => { + formatter.completion_message(files); + has_violations as i32 + } + ApplyFixes::Stdout => { + let any_unfixable_errors = report.files.iter().any(has_unfixable_diagnostics); + for file in report.files { + if let Some(fixed_source) = file.fixed_source { + println!("{fixed_source}"); + } + } + + any_unfixable_errors as i32 + } + ApplyFixes::ToDisk => { + if !has_violations { + println!("{files} files processed, nothing to fix."); + return 0; + } + + let any_unfixable_errors = report.files.iter().any(has_unfixable_diagnostics); + + for (file, loaded) in report.files.iter().zip(loaded_sources.iter()) { + write_fix_to_disk(file, loaded); + } + + formatter.completion_message(files); + any_unfixable_errors as i32 + } + } +} - result.has_violations() as i32 +fn load_sources( + input: &Input, + config: &FluffConfig, + ignorer: &(dyn Fn(&Path) -> bool + Send + Sync), +) -> Result, String> { + match input { + Input::Stdin(text) => Ok(vec![LoadedSource { + id: SourceId::Stdin, + text: text.clone(), + }]), + Input::Paths(paths) => load_path_sources(paths.clone(), config, ignorer), + } +} + +fn load_path_sources( + mut paths: Vec, + config: &FluffConfig, + ignorer: &(dyn Fn(&Path) -> bool + Send + Sync), +) -> Result, String> { + if paths.is_empty() { + paths.push(std::env::current_dir().unwrap()); + } + + let mut expanded_paths = Vec::new(); + + for path in paths { + if path.is_file() { + expanded_paths.push((path, true)); + } else { + expanded_paths.extend( + paths_from_path(path, config.sql_file_exts(), ignorer)? + .into_iter() + .map(|path| (path, false)), + ); + }; + } + + expanded_paths + .into_iter() + .filter(|(path, is_explicit)| *is_explicit || !ignorer(path)) + .map(|(path, _)| { + std::fs::read_to_string(&path) + .map(|text| LoadedSource { + id: SourceId::Path(path), + text, + }) + .map_err(|error| error.to_string()) + }) + .collect() +} + +fn paths_from_path( + path: PathBuf, + sql_file_exts: &[String], + ignorer: &(dyn Fn(&Path) -> bool + Send + Sync), +) -> Result, String> { + let Ok(metadata) = std::fs::metadata(&path) else { + return Err(format!( + "Specified path does not exist. Check it/they exist(s): {path:?}" + )); + }; + + let mut buffer = BTreeSet::new(); + + if metadata.is_file() { + buffer.insert(helpers::normalize(&path)); + } else { + collect_sql_paths(&path, sql_file_exts, ignorer, &mut buffer)?; + } + + Ok(buffer.into_iter().collect()) +} + +fn collect_sql_paths( + dir: &Path, + sql_file_exts: &[String], + ignorer: &(dyn Fn(&Path) -> bool + Send + Sync), + buffer: &mut BTreeSet, +) -> Result<(), String> { + if ignorer(dir) { + log::debug!( + "Skipping directory '{}' during file discovery traversal", + dir.display() + ); + return Ok(()); + } + + let entries = std::fs::read_dir(dir).map_err(|error| error.to_string())?; + + for entry in entries { + let entry = entry.map_err(|error| error.to_string())?; + let path = entry.path(); + let file_type = entry.file_type().map_err(|error| error.to_string())?; + + if file_type.is_dir() { + collect_sql_paths(&path, sql_file_exts, ignorer, buffer)?; + } else if file_type.is_file() && path_is_sql_file(&path, sql_file_exts) && !ignorer(&path) { + buffer.insert(helpers::normalize(&path)); + } + } + + Ok(()) +} + +fn path_is_sql_file(path: &Path, sql_file_exts: &[String]) -> bool { + let Some(file_name) = path.file_name().and_then(|name| name.to_str()) else { + return false; + }; + let file_name = file_name.to_lowercase(); + + sql_file_exts.iter().any(|ext| file_name.ends_with(ext)) +} + +fn write_fix_to_disk(file: &FileReport, loaded: &LoadedSource) { + if file + .diagnostics + .iter() + .any(|diagnostic| diagnostic.code.is_none()) + { + return; + } + + let Some(fixed_source) = &file.fixed_source else { + return; + }; + + if fixed_source == &loaded.text { + return; + } + + let SourceId::Path(path) = &file.source_id else { + return; + }; + + std::fs::write(path, fixed_source).unwrap(); +} + +fn has_unfixable_diagnostics(file: &FileReport) -> bool { + file.diagnostics + .iter() + .any(|diagnostic| !diagnostic.fixable) +} + +fn display_source_id(source_id: &SourceId) -> String { + match source_id { + SourceId::Stdin => "".into(), + SourceId::Path(path) => path.to_string_lossy().into_owned(), + SourceId::Virtual(name) => name.clone(), + } +} + +impl CliFormatter { + fn new(format: Format, config: &FluffConfig) -> Self { + match format { + Format::Human => Self::Human(OutputStreamFormatter::new( + std::io::stderr().into(), + config.get("nocolor", "core").as_bool().unwrap_or_default(), + config.get("verbose", "core").as_int().unwrap_or_default(), + )), + Format::GithubAnnotationNative => Self::GithubAnnotationNative( + GithubAnnotationNativeFormatter::new(std::io::stderr()), + ), + Format::Json => Self::Json(JsonFormatter::default()), + } + } + + fn dispatch_file_report(&self, file: &FileReport) { + let filename = display_source_id(&file.source_id); + match self { + Self::Human(formatter) => { + formatter.dispatch_file_diagnostics(&filename, &file.diagnostics); + } + Self::GithubAnnotationNative(formatter) => { + formatter.dispatch_file_diagnostics(&filename, &file.diagnostics); + } + Self::Json(formatter) => { + formatter.dispatch_file_diagnostics(&filename, &file.diagnostics); + } + } + } + + fn completion_message(&self, count: usize) { + match self { + Self::Human(formatter) => formatter.emit_completion(count), + Self::GithubAnnotationNative(formatter) => formatter.emit_completion(), + Self::Json(formatter) => formatter.emit_completion(), + } + } } diff --git a/crates/cli-lib/src/formatters.rs b/crates/cli-lib/src/formatters.rs index 1ca063b52..b2ba92f63 100644 --- a/crates/cli-lib/src/formatters.rs +++ b/crates/cli-lib/src/formatters.rs @@ -5,11 +5,14 @@ pub(crate) mod rules; pub(crate) mod utils; use std::borrow::Cow; +use std::collections::HashMap; use std::io::{Stderr, Write}; +use std::sync::OnceLock; use anstyle::{AnsiColor, Effects, Style}; -use sqruff_lib::Formatter; +use sqruff_lib::api::LintDiagnostic; use sqruff_lib::core::linter::linted_file::LintedFile; +use sqruff_lib::{Formatter, rules as sqruff_rules}; use sqruff_lib_core::errors::SQLBaseError; use crate::formatters::utils::{ @@ -18,6 +21,20 @@ use crate::formatters::utils::{ const LIGHT_GREY: Style = AnsiColor::Black.on_default().effects(Effects::BOLD); +fn rule_name_for_code(code: &str) -> Option<&'static str> { + static RULE_NAMES: OnceLock> = OnceLock::new(); + + RULE_NAMES + .get_or_init(|| { + sqruff_rules::rules() + .into_iter() + .map(|rule| (rule.code(), rule.name())) + .collect() + }) + .get(code) + .copied() +} + pub(crate) struct OutputStreamFormatter { output_stream: Option, plain_output: bool, @@ -79,6 +96,41 @@ impl OutputStreamFormatter { } } + pub(crate) fn dispatch_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) { + if self.verbosity < 0 { + return; + } + + let s = self.format_file_diagnostics(fname, diagnostics); + self.dispatch(&s); + } + + pub(crate) fn emit_completion(&self, count: usize) { + self.completion_message(count); + } + + fn format_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) -> String { + let mut text_buffer = String::new(); + + let show = !diagnostics.is_empty(); + + if self.verbosity > 0 || show { + let text = self.format_filename(fname, !show); + text_buffer.push_str(&text); + text_buffer.push('\n'); + } + + if show { + for diagnostic in diagnostics { + let text = self.format_diagnostic(diagnostic, self.output_line_length); + text_buffer.push_str(&text); + text_buffer.push('\n'); + } + } + + text_buffer + } + fn format_file_violations(&self, fname: &str, violations: &[SQLBaseError]) -> String { let mut text_buffer = String::new(); @@ -159,6 +211,47 @@ impl OutputStreamFormatter { out_buff } + + fn format_diagnostic(&self, diagnostic: &LintDiagnostic, max_line_length: usize) -> String { + let mut desc = diagnostic.message.clone(); + + let line_elem = format!("{:4}", diagnostic.line); + let pos_elem = format!("{:4}", diagnostic.column); + let code = diagnostic.code.as_deref().unwrap_or("????"); + + if let Some(rule_name) = diagnostic.code.as_deref().and_then(rule_name_for_code) { + let text = self.colorize(rule_name, LIGHT_GREY); + let text = format!(" [{text}]"); + desc.push_str(&text); + } + + let split_desc = split_string_on_spaces(&desc, max_line_length - 25); + let mut section_color = AnsiColor::Blue.on_default(); + + let mut out_buff = String::new(); + for (idx, line) in split_desc.into_iter().enumerate() { + if idx == 0 { + let rule_code = format!("{code:>4}"); + + if rule_code.contains("PRS") { + section_color = AnsiColor::Red.on_default(); + } + + let section = format!("L:{line_elem} | P:{pos_elem} | {rule_code} | "); + let section = self.colorize(§ion, section_color); + out_buff.push_str(§ion); + } else { + out_buff.push_str(&format!( + "\n{}{}", + " ".repeat(23), + self.colorize("| ", section_color), + )); + } + out_buff.push_str(line); + } + + out_buff + } } /// A formatter that produces no output at all. diff --git a/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs b/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs index 384b198f1..28ef6ff3e 100644 --- a/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs +++ b/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs @@ -1,8 +1,8 @@ use std::io::{Stderr, Write}; use std::sync::atomic::{AtomicBool, Ordering}; -use sqruff_lib::Formatter; use sqruff_lib::core::linter::linted_file::LintedFile; +use sqruff_lib::{Formatter, api::LintDiagnostic}; #[derive(Debug)] pub(crate) struct GithubAnnotationNativeFormatter { @@ -52,3 +52,20 @@ impl Formatter for GithubAnnotationNativeFormatter { // No-op } } + +impl GithubAnnotationNativeFormatter { + pub(crate) fn dispatch_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) { + for diagnostic in diagnostics { + let code = diagnostic.code.as_deref().unwrap_or("????"); + let message = format!( + "::error title=sqruff,file={},line={},col={}::{}: {}\n", + fname, diagnostic.line, diagnostic.column, code, diagnostic.message + ); + + self.dispatch(&message); + self.has_fail.store(true, Ordering::SeqCst); + } + } + + pub(crate) fn emit_completion(&self) {} +} diff --git a/crates/cli-lib/src/formatters/json.rs b/crates/cli-lib/src/formatters/json.rs index e63bd11d8..635578f5b 100644 --- a/crates/cli-lib/src/formatters/json.rs +++ b/crates/cli-lib/src/formatters/json.rs @@ -1,6 +1,6 @@ use std::sync::Mutex; -use sqruff_lib::{Formatter, core::linter::linted_file::LintedFile}; +use sqruff_lib::{Formatter, api::LintDiagnostic, core::linter::linted_file::LintedFile}; use super::json_types::{Diagnostic, DiagnosticCollection}; @@ -31,3 +31,18 @@ impl Formatter for JsonFormatter { println!("{json}"); } } + +impl JsonFormatter { + pub(crate) fn dispatch_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) { + let mut lock = self.violations.lock().unwrap(); + lock.entry(fname.into()) + .or_default() + .extend(diagnostics.iter().map(Diagnostic::from).collect::>()); + } + + pub(crate) fn emit_completion(&self) { + let lock = self.violations.lock().unwrap(); + let json = serde_json::to_string(&*lock).unwrap(); + println!("{json}"); + } +} diff --git a/crates/cli-lib/src/formatters/json_types.rs b/crates/cli-lib/src/formatters/json_types.rs index e9cbd6fcc..6067d35fc 100644 --- a/crates/cli-lib/src/formatters/json_types.rs +++ b/crates/cli-lib/src/formatters/json_types.rs @@ -1,6 +1,7 @@ use std::collections::BTreeMap; use serde::Serialize; +use sqruff_lib::api::LintDiagnostic; use sqruff_lib_core::errors::SQLBaseError; impl From for Diagnostic { @@ -19,6 +20,21 @@ impl From for Diagnostic { } } +impl From<&LintDiagnostic> for Diagnostic { + fn from(value: &LintDiagnostic) -> Self { + Diagnostic { + range: Range { + start: Position::new(value.line as u32, value.column as u32), + end: Position::new(value.line as u32, value.column as u32), + }, + message: value.message.clone(), + severity: DiagnosticSeverity::Warning, + source: Some("sqruff".to_string()), + code: value.code.clone(), + } + } +} + /// Represents a line and character position, such as the position of the cursor. #[derive(Serialize)] struct Position { diff --git a/crates/cli-lib/src/lib.rs b/crates/cli-lib/src/lib.rs index 161ec465d..2de106475 100644 --- a/crates/cli-lib/src/lib.rs +++ b/crates/cli-lib/src/lib.rs @@ -1,8 +1,5 @@ use clap::Parser as _; -use commands::Format; -use sqruff_lib::core::linter::core::Linter; -use sqruff_lib::ignore::IgnoreFile; -use sqruff_lib::{Formatter, core::config::FluffConfig}; +use sqruff_lib::core::config::FluffConfig; use sqruff_lib_core::dialects::init::DialectKind; use std::path::Path; use std::sync::Arc; @@ -11,10 +8,6 @@ use stdin::is_std_in_flag_input; use crate::commands::{Cli, Commands}; #[cfg(feature = "codegen-docs")] use crate::docs::codegen_docs; -use crate::formatters::github_annotation_native_formatter::GithubAnnotationNativeFormatter; -use crate::formatters::json::JsonFormatter; -use crate::formatters::{NullFormatter, OutputStreamFormatter}; - pub mod commands; mod commands_dialects; mod commands_fix; @@ -28,6 +21,7 @@ mod commands_templaters; mod docs; mod formatters; mod github_action; +mod ignore; mod logger; mod stdin; @@ -89,7 +83,7 @@ where } let current_path = std::env::current_dir().unwrap(); - let ignore_file = IgnoreFile::new_from_root(¤t_path).unwrap(); + let ignore_file = ignore::IgnoreFile::new_from_root(¤t_path).unwrap(); let ignore_file = Arc::new(ignore_file); let ignorer = { let ignore_file = Arc::clone(&ignore_file); @@ -137,36 +131,3 @@ where Commands::Parse(args) => commands_parse::run_parse(args, config), } } - -pub(crate) fn linter( - config: FluffConfig, - format: Format, - collect_parse_errors: bool, -) -> Result { - let formatter: Arc = match format { - Format::Human => { - let output_stream = std::io::stderr().into(); - let formatter = OutputStreamFormatter::new( - output_stream, - config.get("nocolor", "core").as_bool().unwrap_or_default(), - config.get("verbose", "core").as_int().unwrap_or_default(), - ); - Arc::new(formatter) - } - Format::GithubAnnotationNative => { - let output_stream = std::io::stderr(); - let formatter = GithubAnnotationNativeFormatter::new(output_stream); - Arc::new(formatter) - } - Format::Json => { - let formatter = JsonFormatter::default(); - Arc::new(formatter) - } - Format::None => { - let formatter = NullFormatter; - Arc::new(formatter) - } - }; - - Linter::new(config, Some(formatter), None, collect_parse_errors) -} From b45dc9fc1c667d5ac7edb579ada490dc0c3d413a Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Tue, 26 May 2026 01:29:56 -0700 Subject: [PATCH 7/9] refactor(cli): move reporting out of sqruff-lib --- crates/cli-lib/src/commands_lint.rs | 77 +++---------- crates/cli-lib/src/commands_parse.rs | 2 +- crates/cli-lib/src/formatters.rs | 66 ++--------- .../github_annotation_native_formatter.rs | 71 ------------ crates/cli-lib/src/formatters/json.rs | 48 -------- crates/cli-lib/src/formatters/json_types.rs | 10 +- crates/cli-lib/src/lib.rs | 1 + crates/cli-lib/src/reporters.rs | 53 +++++++++ crates/cli-lib/src/reporters/github.rs | 45 ++++++++ crates/cli-lib/src/reporters/human.rs | 36 ++++++ crates/cli-lib/src/reporters/json.rs | 42 +++++++ crates/cli/tests/ignore_data_directory.rs | 9 +- crates/lib-wasm/src/lib.rs | 2 +- crates/lib/benches/depth_map.rs | 2 +- crates/lib/benches/fix.rs | 1 - crates/lib/src/api/engine.rs | 9 +- crates/lib/src/core/linter/core.rs | 107 ++++-------------- crates/lib/src/core/rules/noqa.rs | 12 +- crates/lib/src/core/test_functions.rs | 2 +- crates/lib/src/lib.rs | 6 - crates/lib/src/rules/aliasing/al05.rs | 2 +- crates/lib/src/templaters.rs | 6 - crates/lib/src/templaters/dbt.rs | 5 +- crates/lib/src/templaters/jinja.rs | 9 +- crates/lib/src/templaters/placeholder.rs | 20 ++-- crates/lib/src/templaters/python.rs | 8 +- crates/lib/src/templaters/raw.rs | 11 +- crates/lib/src/tests.rs | 24 +--- crates/lib/src/utils/reflow/reindent.rs | 2 +- crates/lib/src/utils/reflow/respace.rs | 2 +- 30 files changed, 264 insertions(+), 426 deletions(-) delete mode 100644 crates/cli-lib/src/formatters/github_annotation_native_formatter.rs delete mode 100644 crates/cli-lib/src/formatters/json.rs create mode 100644 crates/cli-lib/src/reporters.rs create mode 100644 crates/cli-lib/src/reporters/github.rs create mode 100644 crates/cli-lib/src/reporters/human.rs create mode 100644 crates/cli-lib/src/reporters/json.rs diff --git a/crates/cli-lib/src/commands_lint.rs b/crates/cli-lib/src/commands_lint.rs index eefaa2acc..8c41dce3e 100644 --- a/crates/cli-lib/src/commands_lint.rs +++ b/crates/cli-lib/src/commands_lint.rs @@ -1,7 +1,5 @@ use crate::commands::{Format, LintArgs}; -use crate::formatters::OutputStreamFormatter; -use crate::formatters::github_annotation_native_formatter::GithubAnnotationNativeFormatter; -use crate::formatters::json::JsonFormatter; +use crate::reporters::Reporter; use sqruff_lib::api::{ Engine, EngineOptions, FileReport, Mode, ParseErrors, RunRequest, Source, SourceId, }; @@ -34,12 +32,6 @@ struct LoadedSource { text: String, } -enum CliFormatter { - Human(OutputStreamFormatter), - GithubAnnotationNative(GithubAnnotationNativeFormatter), - Json(JsonFormatter), -} - pub(crate) fn run_lint( args: LintArgs, config: FluffConfig, @@ -86,7 +78,7 @@ pub(crate) fn run_lint_command( ignorer: impl Fn(&Path) -> bool + Send + Sync, collect_parse_errors: bool, ) -> i32 { - let formatter = CliFormatter::new(command.format, &config); + let mut reporter = Reporter::new(command.format, &config); let loaded_sources = match load_sources(&command.input, &config, &ignorer) { Ok(sources) => sources, Err(e) => { @@ -128,20 +120,23 @@ pub(crate) fn run_lint_command( } }; - for file in &report.files { - formatter.dispatch_file_report(file); - } - let files = report.files.len(); let has_violations = report.files.iter().any(|file| !file.diagnostics.is_empty()); match command.apply { ApplyFixes::Never => { - formatter.completion_message(files); + if let Err(error) = reporter.emit(&report) { + eprintln!("{error}"); + return 1; + } has_violations as i32 } ApplyFixes::Stdout => { let any_unfixable_errors = report.files.iter().any(has_unfixable_diagnostics); + if let Err(error) = reporter.emit_diagnostics(&report) { + eprintln!("{error}"); + return 1; + } for file in report.files { if let Some(fixed_source) = file.fixed_source { println!("{fixed_source}"); @@ -162,7 +157,10 @@ pub(crate) fn run_lint_command( write_fix_to_disk(file, loaded); } - formatter.completion_message(files); + if let Err(error) = reporter.emit(&report) { + eprintln!("{error}"); + return 1; + } any_unfixable_errors as i32 } } @@ -310,50 +308,3 @@ fn has_unfixable_diagnostics(file: &FileReport) -> bool { .iter() .any(|diagnostic| !diagnostic.fixable) } - -fn display_source_id(source_id: &SourceId) -> String { - match source_id { - SourceId::Stdin => "".into(), - SourceId::Path(path) => path.to_string_lossy().into_owned(), - SourceId::Virtual(name) => name.clone(), - } -} - -impl CliFormatter { - fn new(format: Format, config: &FluffConfig) -> Self { - match format { - Format::Human => Self::Human(OutputStreamFormatter::new( - std::io::stderr().into(), - config.get("nocolor", "core").as_bool().unwrap_or_default(), - config.get("verbose", "core").as_int().unwrap_or_default(), - )), - Format::GithubAnnotationNative => Self::GithubAnnotationNative( - GithubAnnotationNativeFormatter::new(std::io::stderr()), - ), - Format::Json => Self::Json(JsonFormatter::default()), - } - } - - fn dispatch_file_report(&self, file: &FileReport) { - let filename = display_source_id(&file.source_id); - match self { - Self::Human(formatter) => { - formatter.dispatch_file_diagnostics(&filename, &file.diagnostics); - } - Self::GithubAnnotationNative(formatter) => { - formatter.dispatch_file_diagnostics(&filename, &file.diagnostics); - } - Self::Json(formatter) => { - formatter.dispatch_file_diagnostics(&filename, &file.diagnostics); - } - } - } - - fn completion_message(&self, count: usize) { - match self { - Self::Human(formatter) => formatter.emit_completion(count), - Self::GithubAnnotationNative(formatter) => formatter.emit_completion(), - Self::Json(formatter) => formatter.emit_completion(), - } - } -} diff --git a/crates/cli-lib/src/commands_parse.rs b/crates/cli-lib/src/commands_parse.rs index 129c98114..f200b3d8a 100644 --- a/crates/cli-lib/src/commands_parse.rs +++ b/crates/cli-lib/src/commands_parse.rs @@ -66,7 +66,7 @@ fn parse_and_output_tree( format: ParseFormat, ) -> i32 { // Create a linter and parse the SQL - let linter = match Linter::new(config.clone(), None, None, true) { + let linter = match Linter::new(config.clone(), None, true) { Ok(l) => l, Err(e) => { eprintln!("{}", e); diff --git a/crates/cli-lib/src/formatters.rs b/crates/cli-lib/src/formatters.rs index b2ba92f63..8a90c1f0b 100644 --- a/crates/cli-lib/src/formatters.rs +++ b/crates/cli-lib/src/formatters.rs @@ -1,5 +1,3 @@ -pub(crate) mod github_annotation_native_formatter; -pub(crate) mod json; pub(crate) mod json_types; pub(crate) mod rules; pub(crate) mod utils; @@ -11,8 +9,8 @@ use std::sync::OnceLock; use anstyle::{AnsiColor, Effects, Style}; use sqruff_lib::api::LintDiagnostic; -use sqruff_lib::core::linter::linted_file::LintedFile; -use sqruff_lib::{Formatter, rules as sqruff_rules}; +use sqruff_lib::rules as sqruff_rules; +#[cfg(test)] use sqruff_lib_core::errors::SQLBaseError; use crate::formatters::utils::{ @@ -43,36 +41,6 @@ pub(crate) struct OutputStreamFormatter { output_line_length: usize, } -impl Formatter for OutputStreamFormatter { - fn dispatch_file_violations(&self, linted_file: &LintedFile) { - if self.verbosity < 0 { - return; - } - - let s = self.format_file_violations(linted_file.path(), linted_file.violations()); - - self.dispatch(&s); - } - - fn dispatch_file_skip(&self, fname: &str, reason: &str) { - if self.verbosity < 0 { - return; - } - let filename = self.colorize(fname, LIGHT_GREY); - let skip = self.colorize("SKIP", AnsiColor::Yellow.on_default()); - self.dispatch(&format!("== [{filename}] {skip}: {reason}\n")); - } - - fn completion_message(&self, count: usize) { - self.dispatch(&format!("The linter processed {count} file(s).\n")); - self.dispatch(if self.plain_output { - "All Finished\n" - } else { - "All Finished 📜 🎉\n" - }); - } -} - impl OutputStreamFormatter { pub(crate) fn new(output_stream: Option, nocolor: bool, verbosity: i32) -> Self { Self { @@ -106,7 +74,12 @@ impl OutputStreamFormatter { } pub(crate) fn emit_completion(&self, count: usize) { - self.completion_message(count); + self.dispatch(&format!("The linter processed {count} file(s).\n")); + self.dispatch(if self.plain_output { + "All Finished\n" + } else { + "All Finished 📜 🎉\n" + }); } fn format_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) -> String { @@ -131,28 +104,6 @@ impl OutputStreamFormatter { text_buffer } - fn format_file_violations(&self, fname: &str, violations: &[SQLBaseError]) -> String { - let mut text_buffer = String::new(); - - let show = !violations.is_empty(); - - if self.verbosity > 0 || show { - let text = self.format_filename(fname, !show); - text_buffer.push_str(&text); - text_buffer.push('\n'); - } - - if show { - for violation in violations { - let text = self.format_violation(violation, self.output_line_length); - text_buffer.push_str(&text); - text_buffer.push('\n'); - } - } - - text_buffer - } - fn colorize<'a>(&self, s: &'a str, style: Style) -> Cow<'a, str> { colorize_helper(self.plain_output, s, style) } @@ -172,6 +123,7 @@ impl OutputStreamFormatter { format!("== [{filename}] {status}") } + #[cfg(test)] fn format_violation(&self, violation: &SQLBaseError, max_line_length: usize) -> String { let mut desc = violation.desc().to_string(); diff --git a/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs b/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs deleted file mode 100644 index 28ef6ff3e..000000000 --- a/crates/cli-lib/src/formatters/github_annotation_native_formatter.rs +++ /dev/null @@ -1,71 +0,0 @@ -use std::io::{Stderr, Write}; -use std::sync::atomic::{AtomicBool, Ordering}; - -use sqruff_lib::core::linter::linted_file::LintedFile; -use sqruff_lib::{Formatter, api::LintDiagnostic}; - -#[derive(Debug)] -pub(crate) struct GithubAnnotationNativeFormatter { - output_stream: Stderr, - pub has_fail: AtomicBool, -} - -impl GithubAnnotationNativeFormatter { - pub(crate) fn new(stderr: Stderr) -> Self { - Self { - output_stream: stderr, - has_fail: AtomicBool::new(false), - } - } - - fn dispatch(&self, s: &str) { - let mut output_stream = self.output_stream.lock(); - output_stream - .write_all(s.as_bytes()) - .and_then(|_| output_stream.flush()) - .unwrap_or_else(|e| panic!("failed to emit error: {e}")); - } -} - -impl Formatter for GithubAnnotationNativeFormatter { - fn dispatch_file_violations(&self, linted_file: &LintedFile) { - for violation in linted_file.violations() { - let message = format!( - "::error title=sqruff,file={},line={},col={}::{}: {}\n", - linted_file.path(), - violation.line_no, - violation.line_pos, - violation.rule_code(), - violation.description - ); - - self.dispatch(&message); - self.has_fail.store(true, Ordering::SeqCst); - } - } - - fn dispatch_file_skip(&self, _fname: &str, _reason: &str) { - // No-op for GitHub annotations - } - - fn completion_message(&self, _count: usize) { - // No-op - } -} - -impl GithubAnnotationNativeFormatter { - pub(crate) fn dispatch_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) { - for diagnostic in diagnostics { - let code = diagnostic.code.as_deref().unwrap_or("????"); - let message = format!( - "::error title=sqruff,file={},line={},col={}::{}: {}\n", - fname, diagnostic.line, diagnostic.column, code, diagnostic.message - ); - - self.dispatch(&message); - self.has_fail.store(true, Ordering::SeqCst); - } - } - - pub(crate) fn emit_completion(&self) {} -} diff --git a/crates/cli-lib/src/formatters/json.rs b/crates/cli-lib/src/formatters/json.rs deleted file mode 100644 index 635578f5b..000000000 --- a/crates/cli-lib/src/formatters/json.rs +++ /dev/null @@ -1,48 +0,0 @@ -use std::sync::Mutex; - -use sqruff_lib::{Formatter, api::LintDiagnostic, core::linter::linted_file::LintedFile}; - -use super::json_types::{Diagnostic, DiagnosticCollection}; - -#[derive(Default)] -pub(crate) struct JsonFormatter { - violations: Mutex, -} - -impl Formatter for JsonFormatter { - fn dispatch_file_violations(&self, linted_file: &LintedFile) { - let violations = linted_file.violations(); - let mut lock = self.violations.lock().unwrap(); - lock.entry(linted_file.path().into()).or_default().extend( - violations - .iter() - .map(|err| Diagnostic::from(err.clone())) - .collect::>(), - ); - } - - fn dispatch_file_skip(&self, _fname: &str, _reason: &str) { - // No-op for JSON output - } - - fn completion_message(&self, _count: usize) { - let lock = self.violations.lock().unwrap(); - let json = serde_json::to_string(&*lock).unwrap(); - println!("{json}"); - } -} - -impl JsonFormatter { - pub(crate) fn dispatch_file_diagnostics(&self, fname: &str, diagnostics: &[LintDiagnostic]) { - let mut lock = self.violations.lock().unwrap(); - lock.entry(fname.into()) - .or_default() - .extend(diagnostics.iter().map(Diagnostic::from).collect::>()); - } - - pub(crate) fn emit_completion(&self) { - let lock = self.violations.lock().unwrap(); - let json = serde_json::to_string(&*lock).unwrap(); - println!("{json}"); - } -} diff --git a/crates/cli-lib/src/formatters/json_types.rs b/crates/cli-lib/src/formatters/json_types.rs index 6067d35fc..c2fa90983 100644 --- a/crates/cli-lib/src/formatters/json_types.rs +++ b/crates/cli-lib/src/formatters/json_types.rs @@ -20,8 +20,8 @@ impl From for Diagnostic { } } -impl From<&LintDiagnostic> for Diagnostic { - fn from(value: &LintDiagnostic) -> Self { +impl Diagnostic { + pub(crate) fn from_lint_diagnostic(value: &LintDiagnostic) -> Self { Diagnostic { range: Range { start: Position::new(value.line as u32, value.column as u32), @@ -35,6 +35,12 @@ impl From<&LintDiagnostic> for Diagnostic { } } +impl From<&LintDiagnostic> for Diagnostic { + fn from(value: &LintDiagnostic) -> Self { + Self::from_lint_diagnostic(value) + } +} + /// Represents a line and character position, such as the position of the cursor. #[derive(Serialize)] struct Position { diff --git a/crates/cli-lib/src/lib.rs b/crates/cli-lib/src/lib.rs index 2de106475..56d84cb94 100644 --- a/crates/cli-lib/src/lib.rs +++ b/crates/cli-lib/src/lib.rs @@ -23,6 +23,7 @@ mod formatters; mod github_action; mod ignore; mod logger; +mod reporters; mod stdin; #[cfg(feature = "codegen-docs")] diff --git a/crates/cli-lib/src/reporters.rs b/crates/cli-lib/src/reporters.rs new file mode 100644 index 000000000..0c17f7048 --- /dev/null +++ b/crates/cli-lib/src/reporters.rs @@ -0,0 +1,53 @@ +pub(crate) mod github; +pub(crate) mod human; +pub(crate) mod json; + +use sqruff_lib::api::{RunReport, SourceId}; +use sqruff_lib::core::config::FluffConfig; + +use crate::commands::Format; +use crate::reporters::github::GithubReporter; +use crate::reporters::human::HumanReporter; +use crate::reporters::json::JsonReporter; + +pub(crate) type CliError = Box; + +pub(crate) enum Reporter { + Human(HumanReporter), + Json(JsonReporter), + Github(GithubReporter), +} + +impl Reporter { + pub(crate) fn new(format: Format, config: &FluffConfig) -> Self { + match format { + Format::Human => Self::Human(HumanReporter::new(config)), + Format::GithubAnnotationNative => Self::Github(GithubReporter::new()), + Format::Json => Self::Json(JsonReporter::default()), + } + } + + pub(crate) fn emit(&mut self, report: &RunReport) -> Result<(), CliError> { + match self { + Self::Human(r) => r.emit(report), + Self::Json(r) => r.emit(report), + Self::Github(r) => r.emit(report), + } + } + + pub(crate) fn emit_diagnostics(&mut self, report: &RunReport) -> Result<(), CliError> { + match self { + Self::Human(r) => r.emit_diagnostics(report), + Self::Json(r) => r.emit(report), + Self::Github(r) => r.emit(report), + } + } +} + +pub(crate) fn display_source_id(source_id: &SourceId) -> String { + match source_id { + SourceId::Stdin => "".into(), + SourceId::Path(path) => path.to_string_lossy().into_owned(), + SourceId::Virtual(name) => name.clone(), + } +} diff --git a/crates/cli-lib/src/reporters/github.rs b/crates/cli-lib/src/reporters/github.rs new file mode 100644 index 000000000..c805538c2 --- /dev/null +++ b/crates/cli-lib/src/reporters/github.rs @@ -0,0 +1,45 @@ +use std::io::{Stderr, Write}; + +use sqruff_lib::api::{LintDiagnostic, RunReport}; + +use crate::reporters::{CliError, display_source_id}; + +pub(crate) struct GithubReporter { + output_stream: Stderr, +} + +impl GithubReporter { + pub(crate) fn new() -> Self { + Self { + output_stream: std::io::stderr(), + } + } + + pub(crate) fn emit(&mut self, report: &RunReport) -> Result<(), CliError> { + for file in &report.files { + let filename = display_source_id(&file.source_id); + for diagnostic in &file.diagnostics { + self.emit_diagnostic(&filename, diagnostic)?; + } + } + + Ok(()) + } + + fn emit_diagnostic( + &mut self, + filename: &str, + diagnostic: &LintDiagnostic, + ) -> Result<(), CliError> { + let code = diagnostic.code.as_deref().unwrap_or("????"); + let message = format!( + "::error title=sqruff,file={},line={},col={}::{}: {}\n", + filename, diagnostic.line, diagnostic.column, code, diagnostic.message + ); + + let mut output_stream = self.output_stream.lock(); + output_stream.write_all(message.as_bytes())?; + output_stream.flush()?; + Ok(()) + } +} diff --git a/crates/cli-lib/src/reporters/human.rs b/crates/cli-lib/src/reporters/human.rs new file mode 100644 index 000000000..a8863d117 --- /dev/null +++ b/crates/cli-lib/src/reporters/human.rs @@ -0,0 +1,36 @@ +use sqruff_lib::api::RunReport; +use sqruff_lib::core::config::FluffConfig; + +use crate::formatters::OutputStreamFormatter; +use crate::reporters::{CliError, display_source_id}; + +pub(crate) struct HumanReporter { + formatter: OutputStreamFormatter, +} + +impl HumanReporter { + pub(crate) fn new(config: &FluffConfig) -> Self { + Self { + formatter: OutputStreamFormatter::new( + std::io::stderr().into(), + config.get("nocolor", "core").as_bool().unwrap_or_default(), + config.get("verbose", "core").as_int().unwrap_or_default(), + ), + } + } + + pub(crate) fn emit(&mut self, report: &RunReport) -> Result<(), CliError> { + self.emit_diagnostics(report)?; + self.formatter.emit_completion(report.files.len()); + Ok(()) + } + + pub(crate) fn emit_diagnostics(&mut self, report: &RunReport) -> Result<(), CliError> { + for file in &report.files { + self.formatter + .dispatch_file_diagnostics(&display_source_id(&file.source_id), &file.diagnostics); + } + + Ok(()) + } +} diff --git a/crates/cli-lib/src/reporters/json.rs b/crates/cli-lib/src/reporters/json.rs new file mode 100644 index 000000000..f78f7e8fd --- /dev/null +++ b/crates/cli-lib/src/reporters/json.rs @@ -0,0 +1,42 @@ +use serde::Serialize; +use sqruff_lib::api::RunReport; + +use crate::formatters::json_types::{Diagnostic, DiagnosticCollection}; +use crate::reporters::{CliError, display_source_id}; + +#[derive(Default)] +pub(crate) struct JsonReporter; + +impl JsonReporter { + pub(crate) fn emit(&mut self, report: &RunReport) -> Result<(), CliError> { + let json_report = JsonReport::from(report); + serde_json::to_writer(std::io::stdout(), &json_report.diagnostics)?; + println!(); + Ok(()) + } +} + +#[derive(Serialize)] +struct JsonReport { + diagnostics: DiagnosticCollection, +} + +impl From<&RunReport> for JsonReport { + fn from(report: &RunReport) -> Self { + let diagnostics = report + .files + .iter() + .map(|file| { + ( + display_source_id(&file.source_id), + file.diagnostics + .iter() + .map(Diagnostic::from) + .collect::>(), + ) + }) + .collect(); + + Self { diagnostics } + } +} diff --git a/crates/cli/tests/ignore_data_directory.rs b/crates/cli/tests/ignore_data_directory.rs index 355eddcb2..23170c895 100644 --- a/crates/cli/tests/ignore_data_directory.rs +++ b/crates/cli/tests/ignore_data_directory.rs @@ -210,13 +210,8 @@ fn test_lint_paths_traverses_ignored_directories() { fs::write(&sqruffignore_file, ".data\n").unwrap(); // Create a linter instance - let mut linter = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let mut linter = + Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); // Create a dummy ignorer that doesn't ignore anything (to test the current broken behavior) // In the current implementation, the ignorer is applied AFTER file discovery diff --git a/crates/lib-wasm/src/lib.rs b/crates/lib-wasm/src/lib.rs index f69a864a2..c17088f64 100644 --- a/crates/lib-wasm/src/lib.rs +++ b/crates/lib-wasm/src/lib.rs @@ -88,7 +88,7 @@ impl Linter { }, ) .unwrap(), - base: SqruffLinter::new(config, None, Some(templater), true).unwrap(), + base: SqruffLinter::new(config, Some(templater), true).unwrap(), } } diff --git a/crates/lib/benches/depth_map.rs b/crates/lib/benches/depth_map.rs index 9a37bd528..0359adfe0 100644 --- a/crates/lib/benches/depth_map.rs +++ b/crates/lib/benches/depth_map.rs @@ -71,7 +71,7 @@ SELECT construct_depth_info('uuid-2'); SELECT construct_depth_info('uuid-3');"#; fn depth_map(c: &mut Criterion) { - let linter = Linter::new(FluffConfig::default(), None, None, false).unwrap(); + let linter = Linter::new(FluffConfig::default(), None, false).unwrap(); let tables = Tables::default(); let tree = linter .parse_string(&tables, COMPLEX_QUERY, None) diff --git a/crates/lib/benches/fix.rs b/crates/lib/benches/fix.rs index 5c8e9accb..54e0f1891 100644 --- a/crates/lib/benches/fix.rs +++ b/crates/lib/benches/fix.rs @@ -69,7 +69,6 @@ fn fix(c: &mut Criterion) { let linter = Linter::new( sqruff_lib::core::config::FluffConfig::default(), None, - None, false, ) .unwrap(); diff --git a/crates/lib/src/api/engine.rs b/crates/lib/src/api/engine.rs index 914d610a3..a8c7520b9 100644 --- a/crates/lib/src/api/engine.rs +++ b/crates/lib/src/api/engine.rs @@ -15,8 +15,8 @@ pub struct Engine { impl Engine { pub fn new(config: FluffConfig, options: EngineOptions) -> Result { let include_parse_errors = matches!(options.parse_errors, ParseErrors::Include); - let inner = Linter::new(config, None, None, include_parse_errors) - .map_err(SQLFluffUserError::new)?; + let inner = + Linter::new(config, None, include_parse_errors).map_err(SQLFluffUserError::new)?; Ok(Self { inner }) } @@ -45,9 +45,8 @@ impl Engine { pub fn reload_config(&mut self, config: FluffConfig) -> Result<(), SqruffError> { let include_parse_errors = self.inner.include_parse_errors(); - let formatter = self.inner.formatter().cloned(); - self.inner = Linter::new(config, formatter, None, include_parse_errors) - .map_err(SQLFluffUserError::new)?; + self.inner = + Linter::new(config, None, include_parse_errors).map_err(SQLFluffUserError::new)?; Ok(()) } diff --git a/crates/lib/src/core/linter/core.rs b/crates/lib/src/core/linter/core.rs index d2a2948cc..ebdb8e1f7 100644 --- a/crates/lib/src/core/linter/core.rs +++ b/crates/lib/src/core/linter/core.rs @@ -2,9 +2,8 @@ use std::borrow::Cow; use std::fs::File; use std::io::{BufRead, BufReader}; use std::path::{Path, PathBuf}; -use std::sync::{Arc, OnceLock}; +use std::sync::OnceLock; -use crate::Formatter; use crate::core::config::FluffConfig; use crate::core::linter::common::{BatchRenderedResult, ParsedString, RenderedFile}; use crate::core::linter::linted_file::LintedFile; @@ -31,7 +30,6 @@ use walkdir::WalkDir; pub struct Linter { config: FluffConfig, - formatter: Option>, templater: &'static dyn Templater, rules: OnceLock>, @@ -42,7 +40,6 @@ pub struct Linter { impl Linter { pub fn new( config: FluffConfig, - formatter: Option>, templater: Option<&'static dyn Templater>, include_parse_errors: bool, ) -> Result { @@ -52,7 +49,6 @@ impl Linter { }; Ok(Linter { config, - formatter, templater, rules: OnceLock::new(), include_parse_errors, @@ -173,9 +169,7 @@ impl Linter { files.push(self.lint_rendered(rendered, fix)?); } BatchRenderedResult::Skipped { filename, reason } => { - if let Some(formatter) = &self.formatter { - formatter.dispatch_file_skip(&filename, &reason); - } + log::debug!("Skipping file '{filename}': {reason}"); } } } @@ -272,9 +266,7 @@ impl Linter { .collect(); // Process all files in batch - let results = self - .templater - .process(&file_refs, &self.config, &self.formatter); + let results = self.templater.process(&file_refs, &self.config); // Convert results to BatchRenderedResults, preserving order results @@ -367,10 +359,6 @@ impl Linter { ignore_mask, ); - if let Some(formatter) = &self.formatter { - formatter.dispatch_file_violations(&linted_file); - } - Ok(linted_file) } @@ -547,11 +535,9 @@ impl Linter { } let templater_violations = vec![]; - let mut results = self.templater.process( - &[(sql.as_ref(), filename.as_str())], - config, - &self.formatter, - ); + let mut results = self + .templater + .process(&[(sql.as_ref(), filename.as_str())], config); match results.pop() { Some(Ok(templated_file)) => Ok(RenderedFile { @@ -872,14 +858,6 @@ impl Linter { Ok(self.rules.get().unwrap()) } - pub fn formatter(&self) -> Option<&Arc> { - self.formatter.as_ref() - } - - pub fn formatter_mut(&mut self) -> Option<&mut Arc> { - self.formatter.as_mut() - } - pub(crate) fn include_parse_errors(&self) -> bool { self.include_parse_errors } @@ -906,7 +884,7 @@ rules = all None, ); - Linter::new(config, None, None, true).unwrap() + Linter::new(config, None, true).unwrap() } fn normalise_paths(paths: Vec) -> Vec { @@ -929,13 +907,7 @@ rules = all #[test] fn test_linter_path_from_paths_dir() { // Test extracting paths from directories. - let lntr = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lntr = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let paths = lntr .paths_from_path("test/fixtures/lexer".into(), None, None, None, None, None) .unwrap(); @@ -950,13 +922,7 @@ rules = all #[test] fn test_linter_path_from_paths_default() { // Test .sql files are found by default. - let lntr = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lntr = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let paths = normalise_paths( lntr.paths_from_path("test/fixtures/linter".into(), None, None, None, None, None) .unwrap(), @@ -972,7 +938,7 @@ rules = all // FluffConfig let config = FluffConfig::new(<_>::default(), None, None).with_sql_file_exts(vec![".txt".into()]); - let lntr = Linter::new(config, None, None, false).unwrap(); + let lntr = Linter::new(config, None, false).unwrap(); let paths = lntr .paths_from_path("test/fixtures/linter".into(), None, None, None, None, None) @@ -991,13 +957,7 @@ rules = all #[test] fn test_linter_path_from_paths_file() { - let lntr = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lntr = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let paths = lntr .paths_from_path( "test/fixtures/linter/indentation_errors.sql".into(), @@ -1017,13 +977,7 @@ rules = all #[test] fn test_linter_path_from_paths_missing_returns_error() { - let lntr = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lntr = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let err = lntr .paths_from_path( @@ -1047,13 +1001,7 @@ rules = all fs::write(project.join("regular.sql"), "SELECT 1;\n").unwrap(); fs::write(ignored_dir.join("hidden.sql"), "SELECT bad FROM hidden;\n").unwrap(); - let lntr = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lntr = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let ignorer = |path: &Path| path.file_name().is_some_and(|name| name == "ignored"); let paths = lntr @@ -1073,7 +1021,7 @@ rules = all fs::write(&file, "SELECT 1;\n").unwrap(); let config = FluffConfig::from_source("[sqruff]\ndialect = ansi\n", None); - let mut lntr = Linter::new(config, None, None, false).unwrap(); + let mut lntr = Linter::new(config, None, false).unwrap(); let explicit_file = file.clone(); let ignorer = move |path: &Path| path == explicit_file; @@ -1107,13 +1055,8 @@ rules = all // test__linter__linting_unexpected_error_handled_gracefully #[test] fn test_linter_empty_file() { - let linter = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let linter = + Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let tables = Tables::default(); let parsed = linter.parse_string(&tables, "", None).unwrap(); @@ -1140,13 +1083,8 @@ rules = all " .to_string(); - let linter = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let linter = + Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let tables = Tables::default(); let _parsed = linter.parse_string(&tables, &sql, None).unwrap(); } @@ -1171,13 +1109,8 @@ rules = all let source = "SELECT *\nFROM {{ ref('stg_users') }}\nWHERE created_at > '{{ var(\"start_date\") }}'"; - let linter = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let linter = + Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); // Simulate a failed templater by creating a RenderedFile with // templater_violations (this is what render_files_batch does when diff --git a/crates/lib/src/core/rules/noqa.rs b/crates/lib/src/core/rules/noqa.rs index 9faac0304..378975ef5 100644 --- a/crates/lib/src/core/rules/noqa.rs +++ b/crates/lib/src/core/rules/noqa.rs @@ -627,11 +627,10 @@ mod tests { [sqruff] dialect = bigquery rules = AL02 - "#, +"#, None, ), None, - None, false, ) .unwrap(); @@ -661,11 +660,10 @@ FROM foo [sqruff] dialect = bigquery rules = AL02 - "#, +"#, None, ), None, - None, false, ) .unwrap(); @@ -676,11 +674,10 @@ rules = AL02 dialect = bigquery rules = AL02 disable_noqa = True - "#, +"#, None, ), None, - None, false, ) .unwrap(); @@ -707,11 +704,10 @@ FROM foo [sqruff] dialect = bigquery rules = AL02 - "#, +"#, None, ), None, - None, false, ) .unwrap(); diff --git a/crates/lib/src/core/test_functions.rs b/crates/lib/src/core/test_functions.rs index d04e491c5..6f6f06762 100644 --- a/crates/lib/src/core/test_functions.rs +++ b/crates/lib/src/core/test_functions.rs @@ -7,7 +7,7 @@ use crate::core::linter::core::Linter; pub fn parse_ansi_string(sql: &str) -> ErasedSegment { let tables = Tables::default(); - let linter = Linter::new(<_>::default(), None, None, false).unwrap(); + let linter = Linter::new(<_>::default(), None, false).unwrap(); linter .parse_string(&tables, sql, None) .unwrap() diff --git a/crates/lib/src/lib.rs b/crates/lib/src/lib.rs index 822ae0d04..d5f0cbb1f 100644 --- a/crates/lib/src/lib.rs +++ b/crates/lib/src/lib.rs @@ -7,9 +7,3 @@ pub mod templaters; #[cfg(test)] mod tests; pub mod utils; - -pub trait Formatter: Send + Sync { - fn dispatch_file_violations(&self, linted_file: &core::linter::linted_file::LintedFile); - fn dispatch_file_skip(&self, fname: &str, reason: &str); - fn completion_message(&self, count: usize); -} diff --git a/crates/lib/src/rules/aliasing/al05.rs b/crates/lib/src/rules/aliasing/al05.rs index c58fa916d..48ef83794 100644 --- a/crates/lib/src/rules/aliasing/al05.rs +++ b/crates/lib/src/rules/aliasing/al05.rs @@ -605,7 +605,7 @@ dialect = postgres None, ); - Linter::new(config, None, None, true).unwrap() + Linter::new(config, None, true).unwrap() } #[test] diff --git a/crates/lib/src/templaters.rs b/crates/lib/src/templaters.rs index c925949bd..2a80b6946 100644 --- a/crates/lib/src/templaters.rs +++ b/crates/lib/src/templaters.rs @@ -1,9 +1,6 @@ -use std::sync::Arc; - use sqruff_lib_core::errors::SQLFluffUserError; use sqruff_lib_core::templaters::TemplatedFile; -use crate::Formatter; use crate::core::config::FluffConfig; use crate::templaters::placeholder::PlaceholderTemplater; use crate::templaters::raw::RawTemplater; @@ -79,13 +76,10 @@ pub trait Templater: Send + Sync { /// Arguments: /// - files: Slice of (file_content, file_name) tuples /// - config: The configuration to use - /// - formatter: Optional formatter for output - /// /// Returns a vector of results in the same order as the input files. fn process( &self, files: &[(&str, &str)], config: &FluffConfig, - formatter: &Option>, ) -> Vec>; } diff --git a/crates/lib/src/templaters/dbt.rs b/crates/lib/src/templaters/dbt.rs index 5ba2e761d..0e44ec921 100644 --- a/crates/lib/src/templaters/dbt.rs +++ b/crates/lib/src/templaters/dbt.rs @@ -2,14 +2,12 @@ use super::Templater; use super::python::PythonTemplatedFile; use crate::core::config::FluffConfig; use crate::templaters::python_shared::PythonFluffConfig; -use crate::templaters::{Formatter, ProcessingMode, TemplaterKind}; +use crate::templaters::{ProcessingMode, TemplaterKind}; use pyo3::prelude::*; use pyo3::types::PyList; use pyo3::{Py, PyAny, Python}; use sqruff_lib_core::errors::SQLFluffUserError; use sqruff_lib_core::templaters::TemplatedFile; -use std::sync::Arc; - pub struct DBTTemplater; impl Templater for DBTTemplater { @@ -126,7 +124,6 @@ The linter then operates on this compiled SQL."# &self, files: &[(&str, &str)], config: &FluffConfig, - _: &Option>, ) -> Vec> { if files.is_empty() { return Vec::new(); diff --git a/crates/lib/src/templaters/jinja.rs b/crates/lib/src/templaters/jinja.rs index 50bcee59f..995bdacf8 100644 --- a/crates/lib/src/templaters/jinja.rs +++ b/crates/lib/src/templaters/jinja.rs @@ -2,13 +2,11 @@ use super::Templater; use super::python::PythonTemplatedFile; use crate::core::config::FluffConfig; use crate::templaters::python_shared::PythonFluffConfig; -use crate::templaters::{Formatter, ProcessingMode, TemplaterKind}; +use crate::templaters::{ProcessingMode, TemplaterKind}; use pyo3::prelude::*; use pyo3::{Py, PyAny, Python}; use sqruff_lib_core::errors::SQLFluffUserError; use sqruff_lib_core::templaters::TemplatedFile; -use std::sync::Arc; - pub struct JinjaTemplater; impl JinjaTemplater { @@ -136,7 +134,6 @@ When `apply_dbt_builtins` is enabled (the default), common dbt functions like `r &self, files: &[(&str, &str)], config: &FluffConfig, - _: &Option>, ) -> Vec> { files .iter() @@ -171,7 +168,7 @@ FROM events let config = FluffConfig::from_source(source, None); let templater = JinjaTemplater; - let results = templater.process(&[(JINJA_STRING, "test.sql")], &config, &None); + let results = templater.process(&[(JINJA_STRING, "test.sql")], &config); let processed = results.into_iter().next().unwrap().unwrap(); assert_eq!( @@ -193,7 +190,7 @@ FROM events SELECT {{some_var}} {% endif %} "#; - let results = templater.process(&[(instr, "test.sql")], &config, &None); + let results = templater.process(&[(instr, "test.sql")], &config); let processed = results.into_iter().next().unwrap().unwrap(); assert_eq!(processed.templated(), "\n \n SELECT 1\n\n"); diff --git a/crates/lib/src/templaters/placeholder.rs b/crates/lib/src/templaters/placeholder.rs index cde5a08a9..8e2ebcf1f 100644 --- a/crates/lib/src/templaters/placeholder.rs +++ b/crates/lib/src/templaters/placeholder.rs @@ -1,13 +1,10 @@ -use hashbrown::HashMap; -use std::sync::Arc; - use fancy_regex::Regex; +use hashbrown::HashMap; use sqruff_lib_core::errors::SQLFluffUserError; use sqruff_lib_core::templaters::{ RawFileSlice, TemplateSliceKind, TemplatedFile, TemplatedFileSlice, }; -use crate::Formatter; use crate::core::config::FluffConfig; use crate::templaters::{PlaceholderStyle, ProcessingMode, Templater}; @@ -288,7 +285,6 @@ Also consider making a pull request to the project to have your style added, it &self, files: &[(&str, &str)], config: &FluffConfig, - _: &Option>, ) -> Vec> { files .iter() @@ -316,7 +312,7 @@ mod tests { param_style = colon", None, ); - let results = templater.process(&[(in_str, "test.sql")], &config, &None); + let results = templater.process(&[(in_str, "test.sql")], &config); let out_str = results.into_iter().next().unwrap().unwrap(); let out = out_str.templated(); assert_eq!(in_str, out) @@ -635,7 +631,7 @@ param_style = {} None, ); let templater = PlaceholderTemplater {}; - let results = templater.process(&[(in_str, "test.sql")], &config, &None); + let results = templater.process(&[(in_str, "test.sql")], &config); let out_str = results.into_iter().next().unwrap().unwrap(); let out = out_str.templated(); assert_eq!(expected_out, out) @@ -649,7 +645,7 @@ param_style = {} let config = FluffConfig::from_source("", None); let templater = PlaceholderTemplater {}; let in_str = "SELECT 2+2"; - let results = templater.process(&[(in_str, "test.sql")], &config, &None); + let results = templater.process(&[(in_str, "test.sql")], &config); let out_str = results.into_iter().next().unwrap(); assert!(out_str.is_err()); @@ -673,7 +669,7 @@ param_style = colon ); let templater = PlaceholderTemplater {}; let in_str = "SELECT 2+2"; - let results = templater.process(&[(in_str, "test.sql")], &config, &None); + let results = templater.process(&[(in_str, "test.sql")], &config); let out_str = results.into_iter().next().unwrap(); assert!(out_str.is_err()); @@ -696,7 +692,7 @@ my_name = john ); let templater = PlaceholderTemplater {}; let in_str = "SELECT bla FROM blob WHERE id = __my_name__"; - let results = templater.process(&[(in_str, "test")], &config, &None); + let results = templater.process(&[(in_str, "test")], &config); let out_str = results.into_iter().next().unwrap().unwrap(); let out = out_str.templated(); assert_eq!("SELECT bla FROM blob WHERE id = john", out) @@ -714,7 +710,7 @@ param_style = unknown ); let templater = PlaceholderTemplater {}; let in_str = "SELECT * FROM {{blah}} WHERE %(gnepr)s OR e~':'"; - let results = templater.process(&[(in_str, "test.sql")], &config, &None); + let results = templater.process(&[(in_str, "test.sql")], &config); let out_str = results.into_iter().next().unwrap(); assert!(out_str.is_err()); @@ -741,7 +737,7 @@ param_style = percent ); let sql = "SELECT a,b FROM users WHERE a = %s"; - let mut linter = Linter::new(config, None, None, false).unwrap(); + let mut linter = Linter::new(config, None, false).unwrap(); let result = linter.lint_string_wrapped(sql, true).unwrap().fix_string(); assert_eq!(result, "SELECT\n a,\n b\nFROM users\nWHERE a = %s\n"); diff --git a/crates/lib/src/templaters/python.rs b/crates/lib/src/templaters/python.rs index 3a8f170cd..1b8519562 100644 --- a/crates/lib/src/templaters/python.rs +++ b/crates/lib/src/templaters/python.rs @@ -8,13 +8,10 @@ use sqruff_lib_core::templaters::{ }; use super::Templater; -use crate::Formatter; use crate::core::config::FluffConfig; use crate::templaters::ProcessingMode; use crate::templaters::TemplaterKind; use crate::templaters::python_shared::PythonFluffConfig; -use std::sync::Arc; - #[derive(Default)] pub struct PythonTemplater; @@ -92,7 +89,6 @@ At the moment, dot notation is not supported in the templater." &self, files: &[(&str, &str)], config: &FluffConfig, - _formatter: &Option>, ) -> Vec> { files .iter() @@ -278,7 +274,7 @@ blah = foo let templater = PythonTemplater; - let results = templater.process(&[(PYTHON_STRING, "test.sql")], &config, &None); + let results = templater.process(&[(PYTHON_STRING, "test.sql")], &config); let templated_file = results.into_iter().next().unwrap().unwrap(); assert_eq!(templated_file.templated(), "SELECT * FROM foo"); @@ -375,7 +371,7 @@ noblah = foo let templater = PythonTemplater; - let results = templater.process(&[(PYTHON_STRING, "test.sql")], &config, &None); + let results = templater.process(&[(PYTHON_STRING, "test.sql")], &config); let templated_file = results.into_iter().next().unwrap(); assert!(templated_file.is_err()) diff --git a/crates/lib/src/templaters/raw.rs b/crates/lib/src/templaters/raw.rs index dbba20ba8..43c86970a 100644 --- a/crates/lib/src/templaters/raw.rs +++ b/crates/lib/src/templaters/raw.rs @@ -1,9 +1,6 @@ -use std::sync::Arc; - use sqruff_lib_core::errors::SQLFluffUserError; use sqruff_lib_core::templaters::TemplatedFile; -use crate::Formatter; use crate::core::config::FluffConfig; use crate::templaters::{ProcessingMode, Templater}; @@ -38,7 +35,6 @@ impl Templater for RawTemplater { &self, files: &[(&str, &str)], _config: &FluffConfig, - _formatter: &Option>, ) -> Vec> { files .iter() @@ -57,11 +53,8 @@ mod test { let templater = RawTemplater; let in_str = "SELECT * FROM {{blah}}"; - let results = templater.process( - &[(in_str, "test.sql")], - &FluffConfig::from_source("", None), - &None, - ); + let results = + templater.process(&[(in_str, "test.sql")], &FluffConfig::from_source("", None)); assert_eq!(results.len(), 1); let outstr = results.into_iter().next().unwrap().unwrap(); diff --git a/crates/lib/src/tests.rs b/crates/lib/src/tests.rs index bd848625d..8e8b31f58 100644 --- a/crates/lib/src/tests.rs +++ b/crates/lib/src/tests.rs @@ -190,13 +190,7 @@ fn test_dialect_ansi_specific_segment_not_parse() { ]; for (raw, err_locations) in tests { - let lnt = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lnt = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let tables = Tables::default(); let parsed = lnt.parse_string(&tables, raw, None).unwrap(); assert!(!parsed.violations.is_empty()); @@ -212,13 +206,7 @@ fn test_dialect_ansi_specific_segment_not_parse() { #[test] fn test_dialect_ansi_is_whitespace() { - let lnt = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lnt = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); let file_content = std::fs::read_to_string( "../lib-dialects/test/fixtures/dialects/ansi/sqlfluff/select_in_multiline_comment.sql", ) @@ -246,13 +234,7 @@ fn test_dialect_ansi_parse_indented_joins() { [1, 5, 8, 11, 15, 17, 19, 23, 24, 26, 29, 31, 33, 34, 35].as_slice(), ), ]; - let lnt = Linter::new( - FluffConfig::new(<_>::default(), None, None), - None, - None, - false, - ) - .unwrap(); + let lnt = Linter::new(FluffConfig::new(<_>::default(), None, None), None, false).unwrap(); for (sql_string, meta_loc) in cases { let tables = Tables::default(); diff --git a/crates/lib/src/utils/reflow/reindent.rs b/crates/lib/src/utils/reflow/reindent.rs index f790d27e9..1e8855d24 100644 --- a/crates/lib/src/utils/reflow/reindent.rs +++ b/crates/lib/src/utils/reflow/reindent.rs @@ -2100,7 +2100,7 @@ mod tests { use crate::core::linter::core::Linter; let sql = "with a as (select 1\nfrom t join u v on\n1=1\n)\nselect * from a\n"; - let linter = Linter::new(<_>::default(), None, None, false).unwrap(); + let linter = Linter::new(<_>::default(), None, false).unwrap(); let result = linter.lint_string(sql, None, false).unwrap(); // The panic is caught by catch_unwind and surfaced as an // "Unexpected exception" violation. Assert none are present. diff --git a/crates/lib/src/utils/reflow/respace.rs b/crates/lib/src/utils/reflow/respace.rs index d3698935f..23e52138c 100644 --- a/crates/lib/src/utils/reflow/respace.rs +++ b/crates/lib/src/utils/reflow/respace.rs @@ -602,7 +602,7 @@ mod tests { fn parse_string_with_config(sql: &str, config: &FluffConfig) -> ErasedSegment { let tables = Tables::default(); - let linter = Linter::new(config.clone(), None, None, false).unwrap(); + let linter = Linter::new(config.clone(), None, false).unwrap(); linter .parse_string(&tables, sql, None) .unwrap() From 2f0ef2991ef12d5d6f2388c5ae327c9dac60afb5 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Wed, 8 Jul 2026 03:53:15 -0700 Subject: [PATCH 8/9] fix(cli): repair reporting split fallout --- Cargo.lock | 1 + MODULE.bazel.lock | 6 ++-- crates/cli-lib/Cargo.toml | 1 + crates/cli-lib/src/formatters.rs | 14 --------- crates/cli-lib/src/ignore.rs | 50 ++++++++++++++++++++++++++++++++ crates/cli-lib/src/reporters.rs | 4 +++ 6 files changed, 59 insertions(+), 17 deletions(-) create mode 100644 crates/cli-lib/src/ignore.rs diff --git a/Cargo.lock b/Cargo.lock index 0e3640dea..c23f624f1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1541,6 +1541,7 @@ dependencies = [ "expect-test", "fancy-regex", "fern", + "ignore", "log", "minijinja", "pyo3", diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 63be34ca9..cccab3162 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -2706,10 +2706,10 @@ "REPO_MAPPING:rules_rust+,bazel_tools bazel_tools", "REPO_MAPPING:rules_rust+,rules_cc rules_cc+", "REPO_MAPPING:rules_rust+,rules_rust rules_rust+", - "FILE:@@//Cargo.lock ce742143d9a5758794b01425843394da1a57d7f7f61cbcfa0911af3d411b666b", + "FILE:@@//Cargo.lock 6129983b8503de4b1a52965b3d53aec9803e51b715c5968bf4e5048d6ee6b7fe", "FILE:@@//Cargo.toml 8fbb9d9ad8bd861d59b023729fe884865690704382155a6e2bf0cb01c97c6c16", "FILE:@@//crates/cli/Cargo.toml 69789bdb7a1ada8e986afa284402986c9a6e64055744c4af2f209941e1525a27", - "FILE:@@//crates/cli-lib/Cargo.toml da8973e7cfcfbbddcf7e1f506ae090a6ec3bdc7a8a9631950549a094ed8e5746", + "FILE:@@//crates/cli-lib/Cargo.toml 48ac2d77c8ce62c2d18732ec0bd4d3ef17041cdad18bfb27b0006b60e4cab1d6", "FILE:@@//crates/cli-python/Cargo.toml 1be309c34494f9590292f3eb091b24f009ca2619da98ce711968ff43b4947b71", "FILE:@@//crates/lib/Cargo.toml 6e6ee84636278cdbcc21490f7f89e68eb95eacd587448c209463de43df3de937", "FILE:@@//crates/lib-core/Cargo.toml dac961d744f0406b0cb2b12a40e979fde8e768ff584cfbac63edff3bce8af0a4", @@ -2726,7 +2726,7 @@ "contents": { "BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nexports_files(\n [\n \"cargo-bazel.json\",\n \"crates.bzl\",\n \"defs.bzl\",\n ] + glob(\n allow_empty = True,\n include = [\"*.bazel\"],\n ),\n)\n\nfilegroup(\n name = \"srcs\",\n srcs = glob(\n allow_empty = True,\n include = [\n \"*.bazel\",\n \"*.bzl\",\n ],\n ),\n)\n\n# Workspace Member Dependencies\nalias(\n name = \"anstyle-1.0.14\",\n actual = \"@crates__anstyle-1.0.14//:anstyle\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"anstyle\",\n actual = \"@crates__anstyle-1.0.14//:anstyle\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"append-only-vec-0.1.8\",\n actual = \"@crates__append-only-vec-0.1.8//:append_only_vec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"append-only-vec\",\n actual = \"@crates__append-only-vec-0.1.8//:append_only_vec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"assert_cmd-2.2.2\",\n actual = \"@crates__assert_cmd-2.2.2//:assert_cmd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"assert_cmd\",\n actual = \"@crates__assert_cmd-2.2.2//:assert_cmd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-4.6.1\",\n actual = \"@crates__clap-4.6.1//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap\",\n actual = \"@crates__clap-4.6.1//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-markdown-0.1.5\",\n actual = \"@crates__clap-markdown-0.1.5//:clap_markdown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-markdown\",\n actual = \"@crates__clap-markdown-0.1.5//:clap_markdown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"codspeed-criterion-compat-4.4.1\",\n actual = \"@crates__codspeed-criterion-compat-4.4.1//:codspeed_criterion_compat\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"criterion-4.4.1\",\n actual = \"@crates__codspeed-criterion-compat-4.4.1//:codspeed_criterion_compat\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"criterion\",\n actual = \"@crates__codspeed-criterion-compat-4.4.1//:codspeed_criterion_compat\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"common-path-1.0.0\",\n actual = \"@crates__common-path-1.0.0//:common_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"common-path\",\n actual = \"@crates__common-path-1.0.0//:common_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"configparser-3.2.0\",\n actual = \"@crates__configparser-3.2.0//:configparser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"configparser\",\n actual = \"@crates__configparser-3.2.0//:configparser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"console_error_panic_hook-0.1.7\",\n actual = \"@crates__console_error_panic_hook-0.1.7//:console_error_panic_hook\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"console_error_panic_hook\",\n actual = \"@crates__console_error_panic_hook-0.1.7//:console_error_panic_hook\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enum_dispatch-0.3.13\",\n actual = \"@crates__enum_dispatch-0.3.13//:enum_dispatch\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enum_dispatch\",\n actual = \"@crates__enum_dispatch-0.3.13//:enum_dispatch\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"expect-test-1.5.1\",\n actual = \"@crates__expect-test-1.5.1//:expect_test\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"expect-test\",\n actual = \"@crates__expect-test-1.5.1//:expect_test\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex-0.18.0\",\n actual = \"@crates__fancy-regex-0.18.0//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex\",\n actual = \"@crates__fancy-regex-0.18.0//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fern-0.7.1\",\n actual = \"@crates__fern-0.7.1//:fern\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fern\",\n actual = \"@crates__fern-0.7.1//:fern\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom-0.2.17\",\n actual = \"@crates__getrandom-0.2.17//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom\",\n actual = \"@crates__getrandom-0.2.17//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob-0.3.3\",\n actual = \"@crates__glob-0.3.3//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob\",\n actual = \"@crates__glob-0.3.3//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hashbrown-0.17.1\",\n actual = \"@crates__hashbrown-0.17.1//:hashbrown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hashbrown\",\n actual = \"@crates__hashbrown-0.17.1//:hashbrown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore-0.4.27\",\n actual = \"@crates__ignore-0.4.27//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore\",\n actual = \"@crates__ignore-0.4.27//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indexmap-2.14.0\",\n actual = \"@crates__indexmap-2.14.0//:indexmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indexmap\",\n actual = \"@crates__indexmap-2.14.0//:indexmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools-0.15.0\",\n actual = \"@crates__itertools-0.15.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools\",\n actual = \"@crates__itertools-0.15.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"js-sys-0.3.82\",\n actual = \"@crates__js-sys-0.3.82//:js_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"js-sys\",\n actual = \"@crates__js-sys-0.3.82//:js_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lazy-regex-3.6.0\",\n actual = \"@crates__lazy-regex-3.6.0//:lazy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lazy-regex\",\n actual = \"@crates__lazy-regex-3.6.0//:lazy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"line-index-0.1.2\",\n actual = \"@crates__line-index-0.1.2//:line_index\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"line-index\",\n actual = \"@crates__line-index-0.1.2//:line_index\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"log-0.4.33\",\n actual = \"@crates__log-0.4.33//:log\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"log\",\n actual = \"@crates__log-0.4.33//:log\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-server-0.8.0\",\n actual = \"@crates__lsp-server-0.8.0//:lsp_server\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-server\",\n actual = \"@crates__lsp-server-0.8.0//:lsp_server\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-types-0.97.0\",\n actual = \"@crates__lsp-types-0.97.0//:lsp_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-types\",\n actual = \"@crates__lsp-types-0.97.0//:lsp_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"mimalloc-0.1.52\",\n actual = \"@crates__mimalloc-0.1.52//:mimalloc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"mimalloc\",\n actual = \"@crates__mimalloc-0.1.52//:mimalloc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"minijinja-2.21.0\",\n actual = \"@crates__minijinja-2.21.0//:minijinja\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"minijinja\",\n actual = \"@crates__minijinja-2.21.0//:minijinja\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nohash-hasher-0.2.0\",\n actual = \"@crates__nohash-hasher-0.2.0//:nohash_hasher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nohash-hasher\",\n actual = \"@crates__nohash-hasher-0.2.0//:nohash_hasher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions-1.4.1\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pyo3-0.29.0\",\n actual = \"@crates__pyo3-0.29.0//:pyo3\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pyo3\",\n actual = \"@crates__pyo3-0.29.0//:pyo3\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon-1.12.0\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-1.12.4\",\n actual = \"@crates__regex-1.12.4//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex\",\n actual = \"@crates__regex-1.12.4//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-automata-0.4.14\",\n actual = \"@crates__regex-automata-0.4.14//:regex_automata\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-automata\",\n actual = \"@crates__regex-automata-0.4.14//:regex_automata\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-1.0.228\",\n actual = \"@crates__serde-1.0.228//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde\",\n actual = \"@crates__serde-1.0.228//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-wasm-bindgen-0.6.5\",\n actual = \"@crates__serde-wasm-bindgen-0.6.5//:serde_wasm_bindgen\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-wasm-bindgen\",\n actual = \"@crates__serde-wasm-bindgen-0.6.5//:serde_wasm_bindgen\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json-1.0.150\",\n actual = \"@crates__serde_json-1.0.150//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json\",\n actual = \"@crates__serde_json-1.0.150//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_with-3.21.0\",\n actual = \"@crates__serde_with-3.21.0//:serde_with\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_with\",\n actual = \"@crates__serde_with-3.21.0//:serde_with\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_yaml-0.9.34+deprecated\",\n actual = \"@crates__serde_yaml-0.9.34-deprecated//:serde_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_yaml\",\n actual = \"@crates__serde_yaml-0.9.34-deprecated//:serde_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smol_str-0.3.6\",\n actual = \"@crates__smol_str-0.3.6//:smol_str\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smol_str\",\n actual = \"@crates__smol_str-0.3.6//:smol_str\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum-0.28.0\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros-0.28.0\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile-3.27.0\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror-2.0.18\",\n actual = \"@crates__thiserror-2.0.18//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror\",\n actual = \"@crates__thiserror-2.0.18//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml-0.9.12+spec-1.1.0\",\n actual = \"@crates__toml-0.9.12-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml\",\n actual = \"@crates__toml-0.9.12-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"walkdir-2.5.0\",\n actual = \"@crates__walkdir-2.5.0//:walkdir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"walkdir\",\n actual = \"@crates__walkdir-2.5.0//:walkdir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"wasm-bindgen-0.2.105\",\n actual = \"@crates__wasm-bindgen-0.2.105//:wasm_bindgen\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"wasm-bindgen\",\n actual = \"@crates__wasm-bindgen-0.2.105//:wasm_bindgen\",\n tags = [\"manual\"],\n)\n", "alias_rules.bzl": "\"\"\"Alias that transitions its target to `compilation_mode=opt`. Use `transition_alias=\"opt\"` to enable.\"\"\"\n\nload(\"@rules_cc//cc:defs.bzl\", \"CcInfo\")\nload(\"@rules_rust//rust:rust_common.bzl\", \"COMMON_PROVIDERS\")\n\ndef _transition_alias_impl(ctx):\n # `ctx.attr.actual` is a list of 1 item due to the transition\n providers = [ctx.attr.actual[0][provider] for provider in COMMON_PROVIDERS]\n if CcInfo in ctx.attr.actual[0]:\n providers.append(ctx.attr.actual[0][CcInfo])\n return providers\n\ndef _change_compilation_mode(compilation_mode):\n def _change_compilation_mode_impl(_settings, _attr):\n return {\n \"//command_line_option:compilation_mode\": compilation_mode,\n }\n\n return transition(\n implementation = _change_compilation_mode_impl,\n inputs = [],\n outputs = [\n \"//command_line_option:compilation_mode\",\n ],\n )\n\ndef _transition_alias_rule(compilation_mode):\n return rule(\n implementation = _transition_alias_impl,\n provides = COMMON_PROVIDERS,\n attrs = {\n \"actual\": attr.label(\n mandatory = True,\n doc = \"`rust_library()` target to transition to `compilation_mode=opt`.\",\n providers = COMMON_PROVIDERS,\n cfg = _change_compilation_mode(compilation_mode),\n ),\n \"_allowlist_function_transition\": attr.label(\n default = \"@bazel_tools//tools/allowlists/function_transition_allowlist\",\n ),\n },\n doc = \"Transitions a Rust library crate to the `compilation_mode=opt`.\",\n )\n\ntransition_alias_dbg = _transition_alias_rule(\"dbg\")\ntransition_alias_fastbuild = _transition_alias_rule(\"fastbuild\")\ntransition_alias_opt = _transition_alias_rule(\"opt\")\n", - "defs.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\"\"\"\n# `crates_repository` API\n\n- [aliases](#aliases)\n- [crate_deps](#crate_deps)\n- [all_crate_deps](#all_crate_deps)\n- [crate_repositories](#crate_repositories)\n\n\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\", \"new_git_repository\")\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:utils.bzl\", \"maybe\")\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\nload(\"@rules_rust//crate_universe/private:local_crate_mirror.bzl\", \"local_crate_mirror\")\n\n###############################################################################\n# MACROS API\n###############################################################################\n\n# An identifier that represent common dependencies (unconditional).\n_COMMON_CONDITION = \"\"\n\ndef _flatten_dependency_maps(all_dependency_maps):\n \"\"\"Flatten a list of dependency maps into one dictionary.\n\n Dependency maps have the following structure:\n\n ```python\n DEPENDENCIES_MAP = {\n # The first key in the map is a Bazel package\n # name of the workspace this file is defined in.\n \"workspace_member_package\": {\n\n # Not all dependencies are supported for all platforms.\n # the condition key is the condition required to be true\n # on the host platform.\n \"condition\": {\n\n # An alias to a crate target. # The label of the crate target the\n # Aliases are only crate names. # package name refers to.\n \"package_name\": \"@full//:label\",\n }\n }\n }\n ```\n\n Args:\n all_dependency_maps (list): A list of dicts as described above\n\n Returns:\n dict: A dictionary as described above\n \"\"\"\n dependencies = {}\n\n for workspace_deps_map in all_dependency_maps:\n for pkg_name, conditional_deps_map in workspace_deps_map.items():\n if pkg_name not in dependencies:\n non_frozen_map = dict()\n for key, values in conditional_deps_map.items():\n non_frozen_map.update({key: dict(values.items())})\n dependencies.setdefault(pkg_name, non_frozen_map)\n continue\n\n for condition, deps_map in conditional_deps_map.items():\n # If the condition has not been recorded, do so and continue\n if condition not in dependencies[pkg_name]:\n dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))\n continue\n\n # Alert on any miss-matched dependencies\n inconsistent_entries = []\n for crate_name, crate_label in deps_map.items():\n existing = dependencies[pkg_name][condition].get(crate_name)\n if existing and existing != crate_label:\n inconsistent_entries.append((crate_name, existing, crate_label))\n dependencies[pkg_name][condition].update({crate_name: crate_label})\n\n return dependencies\n\ndef crate_deps(deps, package_name = None):\n \"\"\"Finds the fully qualified label of the requested crates for the package where this macro is called.\n\n Args:\n deps (list): The desired list of crate targets.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()`.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if not deps:\n return []\n\n if package_name == None:\n package_name = native.package_name()\n\n # Join both sets of dependencies\n dependencies = _flatten_dependency_maps([\n _NORMAL_DEPENDENCIES,\n _NORMAL_DEV_DEPENDENCIES,\n _PROC_MACRO_DEPENDENCIES,\n _PROC_MACRO_DEV_DEPENDENCIES,\n _BUILD_DEPENDENCIES,\n _BUILD_PROC_MACRO_DEPENDENCIES,\n ]).pop(package_name, {})\n\n # Combine all conditional packages so we can easily index over a flat list\n # TODO: Perhaps this should actually return select statements and maintain\n # the conditionals of the dependencies\n flat_deps = {}\n for deps_set in dependencies.values():\n for crate_name, crate_label in deps_set.items():\n flat_deps.update({crate_name: crate_label})\n\n missing_crates = []\n crate_targets = []\n for crate_target in deps:\n if crate_target not in flat_deps:\n missing_crates.append(crate_target)\n else:\n crate_targets.append(flat_deps[crate_target])\n\n if missing_crates:\n fail(\"Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`\".format(\n missing_crates,\n package_name,\n dependencies,\n ))\n\n return crate_targets\n\ndef all_crate_deps(\n normal = False, \n normal_dev = False, \n proc_macro = False, \n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Finds the fully qualified label of all requested direct crate dependencies \\\n for the package where this macro is called.\n\n If no parameters are set, all normal dependencies are returned. Setting any one flag will\n otherwise impact the contents of the returned list.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_dependency_maps = []\n if normal:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n if normal_dev:\n all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)\n if proc_macro:\n all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)\n if proc_macro_dev:\n all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)\n if build:\n all_dependency_maps.append(_BUILD_DEPENDENCIES)\n if build_proc_macro:\n all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)\n\n # Default to always using normal dependencies\n if not all_dependency_maps:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n\n dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)\n\n if not dependencies:\n if dependencies == None:\n fail(\"Tried to get all_crate_deps for package \" + package_name + \" but that package had no Cargo.toml file\")\n else:\n return []\n\n crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())\n for condition, deps in dependencies.items():\n crate_deps += selects.with_or({\n tuple(_CONDITIONS[condition]): deps.values(),\n \"//conditions:default\": [],\n })\n\n return crate_deps\n\ndef aliases(\n normal = False,\n normal_dev = False,\n proc_macro = False,\n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Produces a map of Crate alias names to their original label\n\n If no dependency kinds are specified, `normal` and `proc_macro` are used by default.\n Setting any one flag will otherwise determine the contents of the returned dict.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n dict: The aliases of all associated packages\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_aliases_maps = []\n if normal:\n all_aliases_maps.append(_NORMAL_ALIASES)\n if normal_dev:\n all_aliases_maps.append(_NORMAL_DEV_ALIASES)\n if proc_macro:\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n if proc_macro_dev:\n all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)\n if build:\n all_aliases_maps.append(_BUILD_ALIASES)\n if build_proc_macro:\n all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)\n\n # Default to always using normal aliases\n if not all_aliases_maps:\n all_aliases_maps.append(_NORMAL_ALIASES)\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n\n aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)\n\n if not aliases:\n return dict()\n\n common_items = aliases.pop(_COMMON_CONDITION, {}).items()\n\n # If there are only common items in the dictionary, immediately return them\n if not len(aliases.keys()) == 1:\n return dict(common_items)\n\n # Build a single select statement where each conditional has accounted for the\n # common set of aliases.\n crate_aliases = {\"//conditions:default\": dict(common_items)}\n for condition, deps in aliases.items():\n condition_triples = _CONDITIONS[condition]\n for triple in condition_triples:\n if triple in crate_aliases:\n crate_aliases[triple].update(deps)\n else:\n crate_aliases.update({triple: dict(deps.items() + common_items)})\n\n return select(crate_aliases)\n\n###############################################################################\n# WORKSPACE MEMBER DEPS AND ALIASES\n###############################################################################\n\n_NORMAL_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"append-only-vec\": Label(\"@crates//:append-only-vec-0.1.8\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n \"mimalloc\": Label(\"@crates//:mimalloc-0.1.52\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"anstyle\": Label(\"@crates//:anstyle-1.0.14\"),\n \"clap\": Label(\"@crates//:clap-4.6.1\"),\n \"fern\": Label(\"@crates//:fern-0.7.1\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"common-path\": Label(\"@crates//:common-path-1.0.0\"),\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"lazy-regex\": Label(\"@crates//:lazy-regex-3.6.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n \"regex\": Label(\"@crates//:regex-1.12.4\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"toml\": Label(\"@crates//:toml-0.9.12+spec-1.1.0\"),\n \"walkdir\": Label(\"@crates//:walkdir-2.5.0\"),\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n \"getrandom\": Label(\"@crates//:getrandom-0.2.17\"),\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"regex-automata\": Label(\"@crates//:regex-automata-0.4.14\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"thiserror\": Label(\"@crates//:thiserror-2.0.18\"),\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n \"console_error_panic_hook\": Label(\"@crates//:console_error_panic_hook-0.1.7\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"js-sys\": Label(\"@crates//:js-sys-0.3.82\"),\n \"lsp-server\": Label(\"@crates//:lsp-server-0.8.0\"),\n \"lsp-types\": Label(\"@crates//:lsp-types-0.97.0\"),\n \"serde-wasm-bindgen\": Label(\"@crates//:serde-wasm-bindgen-0.6.5\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n \"line-index\": Label(\"@crates//:line-index-0.1.2\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n}\n\n\n_NORMAL_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n },\n },\n}\n\n\n_NORMAL_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"clap-markdown\": Label(\"@crates//:clap-markdown-0.1.5\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"minijinja\": Label(\"@crates//:minijinja-2.21.0\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"criterion\": Label(\"@crates//:codspeed-criterion-compat-4.4.1\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"serde_with\": Label(\"@crates//:serde_with-3.21.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_NORMAL_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_CONDITIONS = {\n \"aarch64-apple-darwin\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"aarch64-pc-windows-gnullvm\": [],\n \"aarch64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\"],\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(any(target_arch = \\\"x86_64\\\", target_arch = \\\"arm64ec\\\"), target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), not(any(all(target_os = \\\"linux\\\", target_env = \\\"\\\"), getrandom_backend = \\\"custom\\\", getrandom_backend = \\\"linux_raw\\\", getrandom_backend = \\\"rdrand\\\", getrandom_backend = \\\"rndr\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:wasm32-unknown-unknown\",\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", not(target_os = \\\"wasi\\\")))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p2\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p3\\\"))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(target_os = \\\"uefi\\\", getrandom_backend = \\\"efi_rng\\\"))\": [],\n \"cfg(any())\": [],\n \"cfg(any(target_os = \\\"dragonfly\\\", target_os = \\\"freebsd\\\", target_os = \\\"hurd\\\", target_os = \\\"illumos\\\", target_os = \\\"cygwin\\\", all(target_os = \\\"horizon\\\", target_arch = \\\"arm\\\")))\": [],\n \"cfg(any(target_os = \\\"haiku\\\", target_os = \\\"redox\\\", target_os = \\\"nto\\\", target_os = \\\"aix\\\"))\": [],\n \"cfg(any(target_os = \\\"ios\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\", target_os = \\\"tvos\\\"))\": [],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"openbsd\\\", target_os = \\\"vita\\\", target_os = \\\"emscripten\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"cfg(any(unix, target_os = \\\"wasi\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:wasm32-wasip1\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(target_has_atomic = \\\"64\\\"))\": [],\n \"cfg(target_arch = \\\"spirv\\\")\": [],\n \"cfg(target_os = \\\"hermit\\\")\": [],\n \"cfg(target_os = \\\"netbsd\\\")\": [],\n \"cfg(target_os = \\\"solaris\\\")\": [],\n \"cfg(target_os = \\\"vxworks\\\")\": [],\n \"cfg(target_os = \\\"wasi\\\")\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(unix)\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(windows)\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"i686-pc-windows-gnullvm\": [],\n \"wasm32-unknown-unknown\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"wasm32-wasip1\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"x86_64-pc-windows-gnullvm\": [],\n \"x86_64-pc-windows-msvc\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"x86_64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"x86_64-unknown-nixos-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n}\n\n###############################################################################\n\ndef crate_repositories():\n \"\"\"A macro for defining repositories for all generated crates.\n\n Returns:\n A list of repos visible to the module through the module extension.\n \"\"\"\n maybe(\n http_archive,\n name = \"crates__aho-corasick-1.1.4\",\n sha256 = \"ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aho-corasick/1.1.4/download\"],\n strip_prefix = \"aho-corasick-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.aho-corasick-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__allocator-api2-0.2.21\",\n sha256 = \"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/allocator-api2/0.2.21/download\"],\n strip_prefix = \"allocator-api2-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.allocator-api2-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anes-0.1.6\",\n sha256 = \"4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anes/0.1.6/download\"],\n strip_prefix = \"anes-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.anes-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstream-1.0.0\",\n sha256 = \"824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstream/1.0.0/download\"],\n strip_prefix = \"anstream-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstream-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-1.0.14\",\n sha256 = \"940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle/1.0.14/download\"],\n strip_prefix = \"anstyle-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-parse-1.0.0\",\n sha256 = \"52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-parse/1.0.0/download\"],\n strip_prefix = \"anstyle-parse-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-parse-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-query-1.1.5\",\n sha256 = \"40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-query/1.1.5/download\"],\n strip_prefix = \"anstyle-query-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-query-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-wincon-3.0.11\",\n sha256 = \"291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-wincon/3.0.11/download\"],\n strip_prefix = \"anstyle-wincon-3.0.11\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-wincon-3.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anyhow-1.0.102\",\n sha256 = \"7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anyhow/1.0.102/download\"],\n strip_prefix = \"anyhow-1.0.102\",\n build_file = Label(\"@crates//crates:BUILD.anyhow-1.0.102.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__append-only-vec-0.1.8\",\n sha256 = \"2114736faba96bcd79595c700d03183f61357b9fbce14852515e59f3bee4ed4a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/append-only-vec/0.1.8/download\"],\n strip_prefix = \"append-only-vec-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.append-only-vec-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__approx-0.5.1\",\n sha256 = \"cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/approx/0.5.1/download\"],\n strip_prefix = \"approx-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.approx-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__assert_cmd-2.2.2\",\n sha256 = \"2aa3a22042e45de04255c7bf3626e239f450200fd0493c1e382263544b20aea6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/assert_cmd/2.2.2/download\"],\n strip_prefix = \"assert_cmd-2.2.2\",\n build_file = Label(\"@crates//crates:BUILD.assert_cmd-2.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__autocfg-1.5.0\",\n sha256 = \"c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/autocfg/1.5.0/download\"],\n strip_prefix = \"autocfg-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.autocfg-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.22.1\",\n sha256 = \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.22.1/download\"],\n strip_prefix = \"base64-0.22.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.22.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-set-0.8.0\",\n sha256 = \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-set/0.8.0/download\"],\n strip_prefix = \"bit-set-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-set-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-vec-0.8.0\",\n sha256 = \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-vec/0.8.0/download\"],\n strip_prefix = \"bit-vec-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-vec-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-1.3.2\",\n sha256 = \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/1.3.2/download\"],\n strip_prefix = \"bitflags-1.3.2\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-1.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-2.11.0\",\n sha256 = \"843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/2.11.0/download\"],\n strip_prefix = \"bitflags-2.11.0\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-2.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__borsh-1.6.1\",\n sha256 = \"cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/borsh/1.6.1/download\"],\n strip_prefix = \"borsh-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.borsh-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bs58-0.5.1\",\n sha256 = \"bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bs58/0.5.1/download\"],\n strip_prefix = \"bs58-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.bs58-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bstr-1.12.1\",\n sha256 = \"63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bstr/1.12.1/download\"],\n strip_prefix = \"bstr-1.12.1\",\n build_file = Label(\"@crates//crates:BUILD.bstr-1.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bumpalo-3.20.2\",\n sha256 = \"5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bumpalo/3.20.2/download\"],\n strip_prefix = \"bumpalo-3.20.2\",\n build_file = Label(\"@crates//crates:BUILD.bumpalo-3.20.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytes-1.11.1\",\n sha256 = \"1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytes/1.11.1/download\"],\n strip_prefix = \"bytes-1.11.1\",\n build_file = Label(\"@crates//crates:BUILD.bytes-1.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cast-0.3.0\",\n sha256 = \"37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cast/0.3.0/download\"],\n strip_prefix = \"cast-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.cast-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cc-1.2.57\",\n sha256 = \"7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cc/1.2.57/download\"],\n strip_prefix = \"cc-1.2.57\",\n build_file = Label(\"@crates//crates:BUILD.cc-1.2.57.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-if-1.0.4\",\n sha256 = \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-if/1.0.4/download\"],\n strip_prefix = \"cfg-if-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.cfg-if-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.2.1\",\n sha256 = \"613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.2.1/download\"],\n strip_prefix = \"cfg_aliases-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chrono-0.4.44\",\n sha256 = \"c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chrono/0.4.44/download\"],\n strip_prefix = \"chrono-0.4.44\",\n build_file = Label(\"@crates//crates:BUILD.chrono-0.4.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-0.2.2\",\n sha256 = \"42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium/0.2.2/download\"],\n strip_prefix = \"ciborium-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-io-0.2.2\",\n sha256 = \"05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-io/0.2.2/download\"],\n strip_prefix = \"ciborium-io-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-io-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-ll-0.2.2\",\n sha256 = \"57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-ll/0.2.2/download\"],\n strip_prefix = \"ciborium-ll-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-ll-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-4.6.1\",\n sha256 = \"1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap/4.6.1/download\"],\n strip_prefix = \"clap-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-markdown-0.1.5\",\n sha256 = \"d2a2617956a06d4885b490697b5307ebb09fec10b088afc18c81762d848c2339\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap-markdown/0.1.5/download\"],\n strip_prefix = \"clap-markdown-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.clap-markdown-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_builder-4.6.0\",\n sha256 = \"714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_builder/4.6.0/download\"],\n strip_prefix = \"clap_builder-4.6.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_builder-4.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_derive-4.6.1\",\n sha256 = \"f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_derive/4.6.1/download\"],\n strip_prefix = \"clap_derive-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap_derive-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_lex-1.1.0\",\n sha256 = \"c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_lex/1.1.0/download\"],\n strip_prefix = \"clap_lex-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_lex-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-4.4.1\",\n sha256 = \"b684e94583e85a5ca7e1a6454a89d76a5121240f2fb67eb564129d9bafdb9db0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed/4.4.1/download\"],\n strip_prefix = \"codspeed-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-4.4.1\",\n sha256 = \"2e65444156eb73ad7f57618188f8d4a281726d133ef55b96d1dcff89528609ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-walltime-4.4.1\",\n sha256 = \"96389aaa4bbb872ea4924dc0335b2bb181bcf28d6eedbe8fea29afcc5bde36a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat-walltime/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-walltime-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-walltime-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colorchoice-1.0.5\",\n sha256 = \"1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colorchoice/1.0.5/download\"],\n strip_prefix = \"colorchoice-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.colorchoice-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colored-2.2.0\",\n sha256 = \"117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colored/2.2.0/download\"],\n strip_prefix = \"colored-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.colored-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__common-path-1.0.0\",\n sha256 = \"2382f75942f4b3be3690fe4f86365e9c853c1587d6ee58212cebf6e2a9ccd101\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/common-path/1.0.0/download\"],\n strip_prefix = \"common-path-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.common-path-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__configparser-3.2.0\",\n sha256 = \"b46dec724fd22199ebde05033a0cbae453bc3b1ecff11eb6a6bb3eec4b90c6a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/configparser/3.2.0/download\"],\n strip_prefix = \"configparser-3.2.0\",\n build_file = Label(\"@crates//crates:BUILD.configparser-3.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__console_error_panic_hook-0.1.7\",\n sha256 = \"a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/console_error_panic_hook/0.1.7/download\"],\n strip_prefix = \"console_error_panic_hook-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.console_error_panic_hook-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__criterion-plot-0.5.0\",\n sha256 = \"6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/criterion-plot/0.5.0/download\"],\n strip_prefix = \"criterion-plot-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.criterion-plot-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-channel-0.5.15\",\n sha256 = \"82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-channel/0.5.15/download\"],\n strip_prefix = \"crossbeam-channel-0.5.15\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-channel-0.5.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-deque-0.8.6\",\n sha256 = \"9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-deque/0.8.6/download\"],\n strip_prefix = \"crossbeam-deque-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-deque-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-epoch-0.9.18\",\n sha256 = \"5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-epoch/0.9.18/download\"],\n strip_prefix = \"crossbeam-epoch-0.9.18\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-epoch-0.9.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-utils-0.8.21\",\n sha256 = \"d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-utils/0.8.21/download\"],\n strip_prefix = \"crossbeam-utils-0.8.21\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-utils-0.8.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crunchy-0.2.4\",\n sha256 = \"460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crunchy/0.2.4/download\"],\n strip_prefix = \"crunchy-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.crunchy-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.23.0\",\n sha256 = \"25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.23.0/download\"],\n strip_prefix = \"darling-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.23.0\",\n sha256 = \"9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.23.0/download\"],\n strip_prefix = \"darling_core-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.23.0\",\n sha256 = \"ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.23.0/download\"],\n strip_prefix = \"darling_macro-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__deranged-0.5.8\",\n sha256 = \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/deranged/0.5.8/download\"],\n strip_prefix = \"deranged-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.deranged-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__diff-0.1.13\",\n sha256 = \"56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/diff/0.1.13/download\"],\n strip_prefix = \"diff-0.1.13\",\n build_file = Label(\"@crates//crates:BUILD.diff-0.1.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__difflib-0.4.0\",\n sha256 = \"6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/difflib/0.4.0/download\"],\n strip_prefix = \"difflib-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.difflib-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dissimilar-1.0.11\",\n sha256 = \"aeda16ab4059c5fd2a83f2b9c9e9c981327b18aa8e3b313f7e6563799d4f093e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dissimilar/1.0.11/download\"],\n strip_prefix = \"dissimilar-1.0.11\",\n build_file = Label(\"@crates//crates:BUILD.dissimilar-1.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__either-1.15.0\",\n sha256 = \"48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/either/1.15.0/download\"],\n strip_prefix = \"either-1.15.0\",\n build_file = Label(\"@crates//crates:BUILD.either-1.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enum_dispatch-0.3.13\",\n sha256 = \"aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enum_dispatch/0.3.13/download\"],\n strip_prefix = \"enum_dispatch-0.3.13\",\n build_file = Label(\"@crates//crates:BUILD.enum_dispatch-0.3.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__equivalent-1.0.2\",\n sha256 = \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/equivalent/1.0.2/download\"],\n strip_prefix = \"equivalent-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.equivalent-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__errno-0.3.14\",\n sha256 = \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/errno/0.3.14/download\"],\n strip_prefix = \"errno-0.3.14\",\n build_file = Label(\"@crates//crates:BUILD.errno-0.3.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__expect-test-1.5.1\",\n sha256 = \"63af43ff4431e848fb47472a920f14fa71c24de13255a5692e93d4e90302acb0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/expect-test/1.5.1/download\"],\n strip_prefix = \"expect-test-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.expect-test-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.18.0\",\n sha256 = \"e1e1dacd0d2082dfcf1351c4bdd566bbe89a2b263235a2b50058f1e130a47277\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.18.0/download\"],\n strip_prefix = \"fancy-regex-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fastrand-2.3.0\",\n sha256 = \"37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fastrand/2.3.0/download\"],\n strip_prefix = \"fastrand-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.fastrand-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fern-0.7.1\",\n sha256 = \"4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fern/0.7.1/download\"],\n strip_prefix = \"fern-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.fern-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__find-msvc-tools-0.1.9\",\n sha256 = \"5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/find-msvc-tools/0.1.9/download\"],\n strip_prefix = \"find-msvc-tools-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.find-msvc-tools-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-uri-0.1.4\",\n sha256 = \"17c704e9dbe1ddd863da1e6ff3567795087b1eb201ce80d8fa81162e1516500d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-uri/0.1.4/download\"],\n strip_prefix = \"fluent-uri-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.fluent-uri-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.1.5\",\n sha256 = \"d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.1.5/download\"],\n strip_prefix = \"foldhash-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.2.0\",\n sha256 = \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.2.0/download\"],\n strip_prefix = \"foldhash-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.2.17\",\n sha256 = \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.2.17/download\"],\n strip_prefix = \"getrandom-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.4.2\",\n sha256 = \"0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.4.2/download\"],\n strip_prefix = \"getrandom-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__glob-0.3.3\",\n sha256 = \"0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/glob/0.3.3/download\"],\n strip_prefix = \"glob-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.glob-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__globset-0.4.18\",\n sha256 = \"52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/globset/0.4.18/download\"],\n strip_prefix = \"globset-0.4.18\",\n build_file = Label(\"@crates//crates:BUILD.globset-0.4.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__half-2.7.1\",\n sha256 = \"6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/half/2.7.1/download\"],\n strip_prefix = \"half-2.7.1\",\n build_file = Label(\"@crates//crates:BUILD.half-2.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.15.5\",\n sha256 = \"9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.15.5/download\"],\n strip_prefix = \"hashbrown-0.15.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.15.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.17.1\",\n sha256 = \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.17.1/download\"],\n strip_prefix = \"hashbrown-0.17.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.17.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heck-0.5.0\",\n sha256 = \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heck/0.5.0/download\"],\n strip_prefix = \"heck-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.heck-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hermit-abi-0.5.2\",\n sha256 = \"fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hermit-abi/0.5.2/download\"],\n strip_prefix = \"hermit-abi-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.hermit-abi-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hex-0.4.3\",\n sha256 = \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hex/0.4.3/download\"],\n strip_prefix = \"hex-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.hex-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__id-arena-2.3.0\",\n sha256 = \"3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/id-arena/2.3.0/download\"],\n strip_prefix = \"id-arena-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.id-arena-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ident_case-1.0.1\",\n sha256 = \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ident_case/1.0.1/download\"],\n strip_prefix = \"ident_case-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.ident_case-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ignore-0.4.27\",\n sha256 = \"fe112b004901c62c2faa11f4f75e9864e0cc5af8da71c9115d184a3aa888749f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ignore/0.4.27/download\"],\n strip_prefix = \"ignore-0.4.27\",\n build_file = Label(\"@crates//crates:BUILD.ignore-0.4.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indexmap-2.14.0\",\n sha256 = \"d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indexmap/2.14.0/download\"],\n strip_prefix = \"indexmap-2.14.0\",\n build_file = Label(\"@crates//crates:BUILD.indexmap-2.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is-terminal-0.4.17\",\n sha256 = \"3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is-terminal/0.4.17/download\"],\n strip_prefix = \"is-terminal-0.4.17\",\n build_file = Label(\"@crates//crates:BUILD.is-terminal-0.4.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is_terminal_polyfill-1.70.2\",\n sha256 = \"a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is_terminal_polyfill/1.70.2/download\"],\n strip_prefix = \"is_terminal_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.is_terminal_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.10.5\",\n sha256 = \"b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.10.5/download\"],\n strip_prefix = \"itertools-0.10.5\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.10.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.15.0\",\n sha256 = \"8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.15.0/download\"],\n strip_prefix = \"itertools-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itoa-1.0.17\",\n sha256 = \"92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itoa/1.0.17/download\"],\n strip_prefix = \"itoa-1.0.17\",\n build_file = Label(\"@crates//crates:BUILD.itoa-1.0.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__js-sys-0.3.82\",\n sha256 = \"b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/js-sys/0.3.82/download\"],\n strip_prefix = \"js-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.js-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-3.6.0\",\n sha256 = \"6bae91019476d3ec7147de9aa291cadb6d870abf2f3015d2da73a90325ac1496\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex/3.6.0/download\"],\n strip_prefix = \"lazy-regex-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-proc_macros-3.6.0\",\n sha256 = \"4de9c1e1439d8b7b3061b2d209809f447ca33241733d9a3c01eabf2dc8d94358\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex-proc_macros/3.6.0/download\"],\n strip_prefix = \"lazy-regex-proc_macros-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-proc_macros-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy_static-1.5.0\",\n sha256 = \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy_static/1.5.0/download\"],\n strip_prefix = \"lazy_static-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy_static-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__leb128fmt-0.1.0\",\n sha256 = \"09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/leb128fmt/0.1.0/download\"],\n strip_prefix = \"leb128fmt-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.leb128fmt-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libc-0.2.183\",\n sha256 = \"b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libc/0.2.183/download\"],\n strip_prefix = \"libc-0.2.183\",\n build_file = Label(\"@crates//crates:BUILD.libc-0.2.183.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libmimalloc-sys-0.1.49\",\n sha256 = \"6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libmimalloc-sys/0.1.49/download\"],\n strip_prefix = \"libmimalloc-sys-0.1.49\",\n build_file = Label(\"@crates//crates:BUILD.libmimalloc-sys-0.1.49.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__line-index-0.1.2\",\n sha256 = \"3e27e0ed5a392a7f5ba0b3808a2afccff16c64933312c84b57618b49d1209bd2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/line-index/0.1.2/download\"],\n strip_prefix = \"line-index-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.line-index-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.12.1\",\n sha256 = \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.12.1/download\"],\n strip_prefix = \"linux-raw-sys-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__log-0.4.33\",\n sha256 = \"0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/log/0.4.33/download\"],\n strip_prefix = \"log-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.log-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-server-0.8.0\",\n sha256 = \"0ad8be6fe0ca81b8298bfbbe8a77e9fcd8895ad6c84cd7794d5ebadcbb09ae43\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-server/0.8.0/download\"],\n strip_prefix = \"lsp-server-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-server-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-types-0.97.0\",\n sha256 = \"53353550a17c04ac46c585feb189c2db82154fc84b79c7a66c96c2c644f66071\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-types/0.97.0/download\"],\n strip_prefix = \"lsp-types-0.97.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-types-0.97.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memchr-2.8.0\",\n sha256 = \"f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memchr/2.8.0/download\"],\n strip_prefix = \"memchr-2.8.0\",\n build_file = Label(\"@crates//crates:BUILD.memchr-2.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memo-map-0.3.3\",\n sha256 = \"38d1115007560874e373613744c6fba374c17688327a71c1476d1a5954cc857b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memo-map/0.3.3/download\"],\n strip_prefix = \"memo-map-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.memo-map-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__mimalloc-0.1.52\",\n sha256 = \"2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/mimalloc/0.1.52/download\"],\n strip_prefix = \"mimalloc-0.1.52\",\n build_file = Label(\"@crates//crates:BUILD.mimalloc-0.1.52.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__minijinja-2.21.0\",\n sha256 = \"cb3d648e68cea56d9858d535ee28f9538404e2dd8cb08ed0bd05dca379477f39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/minijinja/2.21.0/download\"],\n strip_prefix = \"minijinja-2.21.0\",\n build_file = Label(\"@crates//crates:BUILD.minijinja-2.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.31.2\",\n sha256 = \"5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.31.2/download\"],\n strip_prefix = \"nix-0.31.2\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.31.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nohash-hasher-0.2.0\",\n sha256 = \"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nohash-hasher/0.2.0/download\"],\n strip_prefix = \"nohash-hasher-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.nohash-hasher-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-conv-0.2.0\",\n sha256 = \"cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-conv/0.2.0/download\"],\n strip_prefix = \"num-conv-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.num-conv-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-traits-0.2.19\",\n sha256 = \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-traits/0.2.19/download\"],\n strip_prefix = \"num-traits-0.2.19\",\n build_file = Label(\"@crates//crates:BUILD.num-traits-0.2.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell-1.21.4\",\n sha256 = \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell/1.21.4/download\"],\n strip_prefix = \"once_cell-1.21.4\",\n build_file = Label(\"@crates//crates:BUILD.once_cell-1.21.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell_polyfill-1.70.2\",\n sha256 = \"384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell_polyfill/1.70.2/download\"],\n strip_prefix = \"once_cell_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.once_cell_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__oorandom-11.1.5\",\n sha256 = \"d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/oorandom/11.1.5/download\"],\n strip_prefix = \"oorandom-11.1.5\",\n build_file = Label(\"@crates//crates:BUILD.oorandom-11.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-0.3.7\",\n sha256 = \"5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters/0.3.7/download\"],\n strip_prefix = \"plotters-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-backend-0.3.7\",\n sha256 = \"df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-backend/0.3.7/download\"],\n strip_prefix = \"plotters-backend-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-backend-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-svg-0.3.7\",\n sha256 = \"51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-svg/0.3.7/download\"],\n strip_prefix = \"plotters-svg-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-svg-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-1.13.1\",\n sha256 = \"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic/1.13.1/download\"],\n strip_prefix = \"portable-atomic-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__powerfmt-0.2.0\",\n sha256 = \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/powerfmt/0.2.0/download\"],\n strip_prefix = \"powerfmt-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.powerfmt-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-3.1.4\",\n sha256 = \"ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates/3.1.4/download\"],\n strip_prefix = \"predicates-3.1.4\",\n build_file = Label(\"@crates//crates:BUILD.predicates-3.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-core-1.0.10\",\n sha256 = \"cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-core/1.0.10/download\"],\n strip_prefix = \"predicates-core-1.0.10\",\n build_file = Label(\"@crates//crates:BUILD.predicates-core-1.0.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-tree-1.0.13\",\n sha256 = \"d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-tree/1.0.13/download\"],\n strip_prefix = \"predicates-tree-1.0.13\",\n build_file = Label(\"@crates//crates:BUILD.predicates-tree-1.0.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pretty_assertions-1.4.1\",\n sha256 = \"3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pretty_assertions/1.4.1/download\"],\n strip_prefix = \"pretty_assertions-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.pretty_assertions-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prettyplease-0.2.37\",\n sha256 = \"479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prettyplease/0.2.37/download\"],\n strip_prefix = \"prettyplease-0.2.37\",\n build_file = Label(\"@crates//crates:BUILD.prettyplease-0.2.37.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro2-1.0.106\",\n sha256 = \"8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro2/1.0.106/download\"],\n strip_prefix = \"proc-macro2-1.0.106\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro2-1.0.106.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-0.29.0\",\n sha256 = \"cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3/0.29.0/download\"],\n strip_prefix = \"pyo3-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-build-config-0.29.0\",\n sha256 = \"c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-build-config/0.29.0/download\"],\n strip_prefix = \"pyo3-build-config-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-build-config-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-ffi-0.29.0\",\n sha256 = \"ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-ffi/0.29.0/download\"],\n strip_prefix = \"pyo3-ffi-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-ffi-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-0.29.0\",\n sha256 = \"9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-backend-0.29.0\",\n sha256 = \"4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros-backend/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-backend-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-backend-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quote-1.0.45\",\n sha256 = \"41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quote/1.0.45/download\"],\n strip_prefix = \"quote-1.0.45\",\n build_file = Label(\"@crates//crates:BUILD.quote-1.0.45.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-6.0.0\",\n sha256 = \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/6.0.0/download\"],\n strip_prefix = \"r-efi-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-1.12.0\",\n sha256 = \"fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon/1.12.0/download\"],\n strip_prefix = \"rayon-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-core-1.13.0\",\n sha256 = \"22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon-core/1.13.0/download\"],\n strip_prefix = \"rayon-core-1.13.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-core-1.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-1.12.4\",\n sha256 = \"f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex/1.12.4/download\"],\n strip_prefix = \"regex-1.12.4\",\n build_file = Label(\"@crates//crates:BUILD.regex-1.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-automata-0.4.14\",\n sha256 = \"6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-automata/0.4.14/download\"],\n strip_prefix = \"regex-automata-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.regex-automata-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-syntax-0.8.11\",\n sha256 = \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-syntax/0.8.11/download\"],\n strip_prefix = \"regex-syntax-0.8.11\",\n build_file = Label(\"@crates//crates:BUILD.regex-syntax-0.8.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-1.1.4\",\n sha256 = \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/1.1.4/download\"],\n strip_prefix = \"rustix-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.rustix-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustversion-1.0.22\",\n sha256 = \"b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustversion/1.0.22/download\"],\n strip_prefix = \"rustversion-1.0.22\",\n build_file = Label(\"@crates//crates:BUILD.rustversion-1.0.22.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ryu-1.0.23\",\n sha256 = \"9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ryu/1.0.23/download\"],\n strip_prefix = \"ryu-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.ryu-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__same-file-1.0.6\",\n sha256 = \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/same-file/1.0.6/download\"],\n strip_prefix = \"same-file-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.same-file-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__semver-1.0.27\",\n sha256 = \"d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/semver/1.0.27/download\"],\n strip_prefix = \"semver-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.semver-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-1.0.228\",\n sha256 = \"9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde/1.0.228/download\"],\n strip_prefix = \"serde-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-wasm-bindgen-0.6.5\",\n sha256 = \"8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde-wasm-bindgen/0.6.5/download\"],\n strip_prefix = \"serde-wasm-bindgen-0.6.5\",\n build_file = Label(\"@crates//crates:BUILD.serde-wasm-bindgen-0.6.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_core-1.0.228\",\n sha256 = \"41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_core/1.0.228/download\"],\n strip_prefix = \"serde_core-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_core-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_derive-1.0.228\",\n sha256 = \"d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_derive/1.0.228/download\"],\n strip_prefix = \"serde_derive-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_derive-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_json-1.0.150\",\n sha256 = \"e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_json/1.0.150/download\"],\n strip_prefix = \"serde_json-1.0.150\",\n build_file = Label(\"@crates//crates:BUILD.serde_json-1.0.150.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_repr-0.1.20\",\n sha256 = \"175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_repr/0.1.20/download\"],\n strip_prefix = \"serde_repr-0.1.20\",\n build_file = Label(\"@crates//crates:BUILD.serde_repr-0.1.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_spanned-1.1.1\",\n sha256 = \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_spanned/1.1.1/download\"],\n strip_prefix = \"serde_spanned-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.serde_spanned-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with-3.21.0\",\n sha256 = \"76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with/3.21.0/download\"],\n strip_prefix = \"serde_with-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with_macros-3.21.0\",\n sha256 = \"84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with_macros/3.21.0/download\"],\n strip_prefix = \"serde_with_macros-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with_macros-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_yaml-0.9.34-deprecated\",\n sha256 = \"6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_yaml/0.9.34+deprecated/download\"],\n strip_prefix = \"serde_yaml-0.9.34+deprecated\",\n build_file = Label(\"@crates//crates:BUILD.serde_yaml-0.9.34+deprecated.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-1.3.0\",\n sha256 = \"0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/1.3.0/download\"],\n strip_prefix = \"shlex-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.shlex-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smol_str-0.3.6\",\n sha256 = \"4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smol_str/0.3.6/download\"],\n strip_prefix = \"smol_str-0.3.6\",\n build_file = Label(\"@crates//crates:BUILD.smol_str-0.3.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__statrs-0.18.0\",\n sha256 = \"2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/statrs/0.18.0/download\"],\n strip_prefix = \"statrs-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.statrs-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strsim-0.11.1\",\n sha256 = \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strsim/0.11.1/download\"],\n strip_prefix = \"strsim-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.strsim-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum-0.28.0\",\n sha256 = \"9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum/0.28.0/download\"],\n strip_prefix = \"strum-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum_macros-0.28.0\",\n sha256 = \"ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum_macros/0.28.0/download\"],\n strip_prefix = \"strum_macros-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum_macros-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-2.0.117\",\n sha256 = \"e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/2.0.117/download\"],\n strip_prefix = \"syn-2.0.117\",\n build_file = Label(\"@crates//crates:BUILD.syn-2.0.117.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__target-lexicon-0.13.5\",\n sha256 = \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/target-lexicon/0.13.5/download\"],\n strip_prefix = \"target-lexicon-0.13.5\",\n build_file = Label(\"@crates//crates:BUILD.target-lexicon-0.13.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tempfile-3.27.0\",\n sha256 = \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tempfile/3.27.0/download\"],\n strip_prefix = \"tempfile-3.27.0\",\n build_file = Label(\"@crates//crates:BUILD.tempfile-3.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__termtree-0.5.1\",\n sha256 = \"8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/termtree/0.5.1/download\"],\n strip_prefix = \"termtree-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.termtree-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__text-size-1.1.1\",\n sha256 = \"f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/text-size/1.1.1/download\"],\n strip_prefix = \"text-size-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.text-size-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-2.0.18\",\n sha256 = \"4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/2.0.18/download\"],\n strip_prefix = \"thiserror-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-2.0.18\",\n sha256 = \"ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/2.0.18/download\"],\n strip_prefix = \"thiserror-impl-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-0.3.47\",\n sha256 = \"743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time/0.3.47/download\"],\n strip_prefix = \"time-0.3.47\",\n build_file = Label(\"@crates//crates:BUILD.time-0.3.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-core-0.1.8\",\n sha256 = \"7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-core/0.1.8/download\"],\n strip_prefix = \"time-core-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.time-core-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinytemplate-1.2.1\",\n sha256 = \"be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinytemplate/1.2.1/download\"],\n strip_prefix = \"tinytemplate-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.tinytemplate-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec-1.11.0\",\n sha256 = \"3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec/1.11.0/download\"],\n strip_prefix = \"tinyvec-1.11.0\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec-1.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec_macros-0.1.1\",\n sha256 = \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec_macros/0.1.1/download\"],\n strip_prefix = \"tinyvec_macros-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec_macros-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml-0.9.12-spec-1.1.0\",\n sha256 = \"cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml/0.9.12+spec-1.1.0/download\"],\n strip_prefix = \"toml-0.9.12+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml-0.9.12+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_datetime-0.7.5-spec-1.1.0\",\n sha256 = \"92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_datetime/0.7.5+spec-1.1.0/download\"],\n strip_prefix = \"toml_datetime-0.7.5+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_datetime-0.7.5+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_parser-1.1.2-spec-1.1.0\",\n sha256 = \"a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_parser/1.1.2+spec-1.1.0/download\"],\n strip_prefix = \"toml_parser-1.1.2+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_parser-1.1.2+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_writer-1.1.1-spec-1.1.0\",\n sha256 = \"756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_writer/1.1.1+spec-1.1.0/download\"],\n strip_prefix = \"toml_writer-1.1.1+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_writer-1.1.1+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-ident-1.0.24\",\n sha256 = \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-ident/1.0.24/download\"],\n strip_prefix = \"unicode-ident-1.0.24\",\n build_file = Label(\"@crates//crates:BUILD.unicode-ident-1.0.24.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-xid-0.2.6\",\n sha256 = \"ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-xid/0.2.6/download\"],\n strip_prefix = \"unicode-xid-0.2.6\",\n build_file = Label(\"@crates//crates:BUILD.unicode-xid-0.2.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unsafe-libyaml-0.2.11\",\n sha256 = \"673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unsafe-libyaml/0.2.11/download\"],\n strip_prefix = \"unsafe-libyaml-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.unsafe-libyaml-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8parse-0.2.2\",\n sha256 = \"06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8parse/0.2.2/download\"],\n strip_prefix = \"utf8parse-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.utf8parse-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wait-timeout-0.2.1\",\n sha256 = \"09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wait-timeout/0.2.1/download\"],\n strip_prefix = \"wait-timeout-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.wait-timeout-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__walkdir-2.5.0\",\n sha256 = \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/walkdir/2.5.0/download\"],\n strip_prefix = \"walkdir-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.walkdir-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.11.1-wasi-snapshot-preview1\",\n sha256 = \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.11.1+wasi-snapshot-preview1/download\"],\n strip_prefix = \"wasi-0.11.1+wasi-snapshot-preview1\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.11.1+wasi-snapshot-preview1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip2-1.0.2-wasi-0.2.9\",\n sha256 = \"9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip2/1.0.2+wasi-0.2.9/download\"],\n strip_prefix = \"wasip2-1.0.2+wasi-0.2.9\",\n build_file = Label(\"@crates//crates:BUILD.wasip2-1.0.2+wasi-0.2.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip3-0.4.0-wasi-0.3.0-rc-2026-01-06\",\n sha256 = \"5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip3/0.4.0+wasi-0.3.0-rc-2026-01-06/download\"],\n strip_prefix = \"wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06\",\n build_file = Label(\"@crates//crates:BUILD.wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-0.2.105\",\n sha256 = \"da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-0.2.105\",\n sha256 = \"04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-support-0.2.105\",\n sha256 = \"420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro-support/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-support-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-support-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-shared-0.2.105\",\n sha256 = \"76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-shared/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-shared-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-shared-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-encoder-0.244.0\",\n sha256 = \"990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-encoder/0.244.0/download\"],\n strip_prefix = \"wasm-encoder-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-encoder-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-metadata-0.244.0\",\n sha256 = \"bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-metadata/0.244.0/download\"],\n strip_prefix = \"wasm-metadata-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-metadata-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasmparser-0.244.0\",\n sha256 = \"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasmparser/0.244.0/download\"],\n strip_prefix = \"wasmparser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasmparser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-sys-0.3.82\",\n sha256 = \"3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-sys/0.3.82/download\"],\n strip_prefix = \"web-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.web-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-util-0.1.11\",\n sha256 = \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-util/0.1.11/download\"],\n strip_prefix = \"winapi-util-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.winapi-util-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.2.1\",\n sha256 = \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.2.1/download\"],\n strip_prefix = \"windows-link-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.59.0\",\n sha256 = \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.59.0/download\"],\n strip_prefix = \"windows-sys-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.61.2\",\n sha256 = \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.61.2/download\"],\n strip_prefix = \"windows-sys-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.52.6\",\n sha256 = \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.52.6/download\"],\n strip_prefix = \"windows-targets-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.52.6\",\n sha256 = \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.52.6\",\n sha256 = \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.52.6\",\n sha256 = \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.52.6\",\n sha256 = \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.52.6\",\n sha256 = \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.52.6/download\"],\n strip_prefix = \"windows_i686_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.52.6\",\n sha256 = \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.52.6\",\n sha256 = \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.52.6\",\n sha256 = \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-0.7.15\",\n sha256 = \"df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/0.7.15/download\"],\n strip_prefix = \"winnow-0.7.15\",\n build_file = Label(\"@crates//crates:BUILD.winnow-0.7.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-1.0.3\",\n sha256 = \"0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/1.0.3/download\"],\n strip_prefix = \"winnow-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.winnow-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-0.51.0\",\n sha256 = \"d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-core-0.51.0\",\n sha256 = \"ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-core/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-core-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-core-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-0.51.0\",\n sha256 = \"b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-macro-0.51.0\",\n sha256 = \"0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust-macro/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-macro-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-macro-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-component-0.244.0\",\n sha256 = \"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-component/0.244.0/download\"],\n strip_prefix = \"wit-component-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-component-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-parser-0.244.0\",\n sha256 = \"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-parser/0.244.0/download\"],\n strip_prefix = \"wit-parser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-parser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yansi-1.0.1\",\n sha256 = \"cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yansi/1.0.1/download\"],\n strip_prefix = \"yansi-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.yansi-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-0.8.46\",\n sha256 = \"5c5030500cb2d66bdfbb4ebc9563be6ce7005a4b5d0f26be0c523870fe372ca6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy/0.8.46/download\"],\n strip_prefix = \"zerocopy-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-derive-0.8.46\",\n sha256 = \"a5f86989a046a79640b9d8867c823349a139367bda96549794fcc3313ce91f4e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy-derive/0.8.46/download\"],\n strip_prefix = \"zerocopy-derive-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-derive-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zmij-1.0.21\",\n sha256 = \"b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zmij/1.0.21/download\"],\n strip_prefix = \"zmij-1.0.21\",\n build_file = Label(\"@crates//crates:BUILD.zmij-1.0.21.bazel\"),\n )\n\n return [\n struct(repo=\"crates__anstyle-1.0.14\", is_dev_dep = False),\n struct(repo=\"crates__append-only-vec-0.1.8\", is_dev_dep = False),\n struct(repo=\"crates__clap-4.6.1\", is_dev_dep = False),\n struct(repo=\"crates__common-path-1.0.0\", is_dev_dep = False),\n struct(repo=\"crates__configparser-3.2.0\", is_dev_dep = False),\n struct(repo=\"crates__console_error_panic_hook-0.1.7\", is_dev_dep = False),\n struct(repo=\"crates__enum_dispatch-0.3.13\", is_dev_dep = False),\n struct(repo=\"crates__fancy-regex-0.18.0\", is_dev_dep = False),\n struct(repo=\"crates__fern-0.7.1\", is_dev_dep = False),\n struct(repo=\"crates__getrandom-0.2.17\", is_dev_dep = False),\n struct(repo=\"crates__hashbrown-0.17.1\", is_dev_dep = False),\n struct(repo=\"crates__ignore-0.4.27\", is_dev_dep = False),\n struct(repo=\"crates__indexmap-2.14.0\", is_dev_dep = False),\n struct(repo=\"crates__itertools-0.15.0\", is_dev_dep = False),\n struct(repo=\"crates__js-sys-0.3.82\", is_dev_dep = False),\n struct(repo=\"crates__lazy-regex-3.6.0\", is_dev_dep = False),\n struct(repo=\"crates__line-index-0.1.2\", is_dev_dep = False),\n struct(repo=\"crates__log-0.4.33\", is_dev_dep = False),\n struct(repo=\"crates__lsp-server-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__lsp-types-0.97.0\", is_dev_dep = False),\n struct(repo=\"crates__mimalloc-0.1.52\", is_dev_dep = False),\n struct(repo=\"crates__nohash-hasher-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__pretty_assertions-1.4.1\", is_dev_dep = False),\n struct(repo=\"crates__pyo3-0.29.0\", is_dev_dep = False),\n struct(repo=\"crates__rayon-1.12.0\", is_dev_dep = False),\n struct(repo=\"crates__regex-1.12.4\", is_dev_dep = False),\n struct(repo=\"crates__regex-automata-0.4.14\", is_dev_dep = False),\n struct(repo=\"crates__serde-1.0.228\", is_dev_dep = False),\n struct(repo=\"crates__serde-wasm-bindgen-0.6.5\", is_dev_dep = False),\n struct(repo=\"crates__serde_json-1.0.150\", is_dev_dep = False),\n struct(repo=\"crates__serde_yaml-0.9.34-deprecated\", is_dev_dep = False),\n struct(repo=\"crates__smol_str-0.3.6\", is_dev_dep = False),\n struct(repo=\"crates__strum-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__strum_macros-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__thiserror-2.0.18\", is_dev_dep = False),\n struct(repo=\"crates__toml-0.9.12-spec-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__walkdir-2.5.0\", is_dev_dep = False),\n struct(repo=\"crates__wasm-bindgen-0.2.105\", is_dev_dep = False),\n struct(repo = \"crates__assert_cmd-2.2.2\", is_dev_dep = True),\n struct(repo = \"crates__clap-markdown-0.1.5\", is_dev_dep = True),\n struct(repo = \"crates__codspeed-criterion-compat-4.4.1\", is_dev_dep = True),\n struct(repo = \"crates__expect-test-1.5.1\", is_dev_dep = True),\n struct(repo = \"crates__glob-0.3.3\", is_dev_dep = True),\n struct(repo = \"crates__minijinja-2.21.0\", is_dev_dep = True),\n struct(repo = \"crates__serde_with-3.21.0\", is_dev_dep = True),\n struct(repo = \"crates__tempfile-3.27.0\", is_dev_dep = True),\n ]\n" + "defs.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\"\"\"\n# `crates_repository` API\n\n- [aliases](#aliases)\n- [crate_deps](#crate_deps)\n- [all_crate_deps](#all_crate_deps)\n- [crate_repositories](#crate_repositories)\n\n\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\", \"new_git_repository\")\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:utils.bzl\", \"maybe\")\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\nload(\"@rules_rust//crate_universe/private:local_crate_mirror.bzl\", \"local_crate_mirror\")\n\n###############################################################################\n# MACROS API\n###############################################################################\n\n# An identifier that represent common dependencies (unconditional).\n_COMMON_CONDITION = \"\"\n\ndef _flatten_dependency_maps(all_dependency_maps):\n \"\"\"Flatten a list of dependency maps into one dictionary.\n\n Dependency maps have the following structure:\n\n ```python\n DEPENDENCIES_MAP = {\n # The first key in the map is a Bazel package\n # name of the workspace this file is defined in.\n \"workspace_member_package\": {\n\n # Not all dependencies are supported for all platforms.\n # the condition key is the condition required to be true\n # on the host platform.\n \"condition\": {\n\n # An alias to a crate target. # The label of the crate target the\n # Aliases are only crate names. # package name refers to.\n \"package_name\": \"@full//:label\",\n }\n }\n }\n ```\n\n Args:\n all_dependency_maps (list): A list of dicts as described above\n\n Returns:\n dict: A dictionary as described above\n \"\"\"\n dependencies = {}\n\n for workspace_deps_map in all_dependency_maps:\n for pkg_name, conditional_deps_map in workspace_deps_map.items():\n if pkg_name not in dependencies:\n non_frozen_map = dict()\n for key, values in conditional_deps_map.items():\n non_frozen_map.update({key: dict(values.items())})\n dependencies.setdefault(pkg_name, non_frozen_map)\n continue\n\n for condition, deps_map in conditional_deps_map.items():\n # If the condition has not been recorded, do so and continue\n if condition not in dependencies[pkg_name]:\n dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))\n continue\n\n # Alert on any miss-matched dependencies\n inconsistent_entries = []\n for crate_name, crate_label in deps_map.items():\n existing = dependencies[pkg_name][condition].get(crate_name)\n if existing and existing != crate_label:\n inconsistent_entries.append((crate_name, existing, crate_label))\n dependencies[pkg_name][condition].update({crate_name: crate_label})\n\n return dependencies\n\ndef crate_deps(deps, package_name = None):\n \"\"\"Finds the fully qualified label of the requested crates for the package where this macro is called.\n\n Args:\n deps (list): The desired list of crate targets.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()`.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if not deps:\n return []\n\n if package_name == None:\n package_name = native.package_name()\n\n # Join both sets of dependencies\n dependencies = _flatten_dependency_maps([\n _NORMAL_DEPENDENCIES,\n _NORMAL_DEV_DEPENDENCIES,\n _PROC_MACRO_DEPENDENCIES,\n _PROC_MACRO_DEV_DEPENDENCIES,\n _BUILD_DEPENDENCIES,\n _BUILD_PROC_MACRO_DEPENDENCIES,\n ]).pop(package_name, {})\n\n # Combine all conditional packages so we can easily index over a flat list\n # TODO: Perhaps this should actually return select statements and maintain\n # the conditionals of the dependencies\n flat_deps = {}\n for deps_set in dependencies.values():\n for crate_name, crate_label in deps_set.items():\n flat_deps.update({crate_name: crate_label})\n\n missing_crates = []\n crate_targets = []\n for crate_target in deps:\n if crate_target not in flat_deps:\n missing_crates.append(crate_target)\n else:\n crate_targets.append(flat_deps[crate_target])\n\n if missing_crates:\n fail(\"Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`\".format(\n missing_crates,\n package_name,\n dependencies,\n ))\n\n return crate_targets\n\ndef all_crate_deps(\n normal = False, \n normal_dev = False, \n proc_macro = False, \n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Finds the fully qualified label of all requested direct crate dependencies \\\n for the package where this macro is called.\n\n If no parameters are set, all normal dependencies are returned. Setting any one flag will\n otherwise impact the contents of the returned list.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_dependency_maps = []\n if normal:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n if normal_dev:\n all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)\n if proc_macro:\n all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)\n if proc_macro_dev:\n all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)\n if build:\n all_dependency_maps.append(_BUILD_DEPENDENCIES)\n if build_proc_macro:\n all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)\n\n # Default to always using normal dependencies\n if not all_dependency_maps:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n\n dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)\n\n if not dependencies:\n if dependencies == None:\n fail(\"Tried to get all_crate_deps for package \" + package_name + \" but that package had no Cargo.toml file\")\n else:\n return []\n\n crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())\n for condition, deps in dependencies.items():\n crate_deps += selects.with_or({\n tuple(_CONDITIONS[condition]): deps.values(),\n \"//conditions:default\": [],\n })\n\n return crate_deps\n\ndef aliases(\n normal = False,\n normal_dev = False,\n proc_macro = False,\n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Produces a map of Crate alias names to their original label\n\n If no dependency kinds are specified, `normal` and `proc_macro` are used by default.\n Setting any one flag will otherwise determine the contents of the returned dict.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n dict: The aliases of all associated packages\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_aliases_maps = []\n if normal:\n all_aliases_maps.append(_NORMAL_ALIASES)\n if normal_dev:\n all_aliases_maps.append(_NORMAL_DEV_ALIASES)\n if proc_macro:\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n if proc_macro_dev:\n all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)\n if build:\n all_aliases_maps.append(_BUILD_ALIASES)\n if build_proc_macro:\n all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)\n\n # Default to always using normal aliases\n if not all_aliases_maps:\n all_aliases_maps.append(_NORMAL_ALIASES)\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n\n aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)\n\n if not aliases:\n return dict()\n\n common_items = aliases.pop(_COMMON_CONDITION, {}).items()\n\n # If there are only common items in the dictionary, immediately return them\n if not len(aliases.keys()) == 1:\n return dict(common_items)\n\n # Build a single select statement where each conditional has accounted for the\n # common set of aliases.\n crate_aliases = {\"//conditions:default\": dict(common_items)}\n for condition, deps in aliases.items():\n condition_triples = _CONDITIONS[condition]\n for triple in condition_triples:\n if triple in crate_aliases:\n crate_aliases[triple].update(deps)\n else:\n crate_aliases.update({triple: dict(deps.items() + common_items)})\n\n return select(crate_aliases)\n\n###############################################################################\n# WORKSPACE MEMBER DEPS AND ALIASES\n###############################################################################\n\n_NORMAL_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"append-only-vec\": Label(\"@crates//:append-only-vec-0.1.8\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n \"mimalloc\": Label(\"@crates//:mimalloc-0.1.52\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"anstyle\": Label(\"@crates//:anstyle-1.0.14\"),\n \"clap\": Label(\"@crates//:clap-4.6.1\"),\n \"fern\": Label(\"@crates//:fern-0.7.1\"),\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"common-path\": Label(\"@crates//:common-path-1.0.0\"),\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"lazy-regex\": Label(\"@crates//:lazy-regex-3.6.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n \"regex\": Label(\"@crates//:regex-1.12.4\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"toml\": Label(\"@crates//:toml-0.9.12+spec-1.1.0\"),\n \"walkdir\": Label(\"@crates//:walkdir-2.5.0\"),\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n \"getrandom\": Label(\"@crates//:getrandom-0.2.17\"),\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"regex-automata\": Label(\"@crates//:regex-automata-0.4.14\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"thiserror\": Label(\"@crates//:thiserror-2.0.18\"),\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n \"console_error_panic_hook\": Label(\"@crates//:console_error_panic_hook-0.1.7\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"js-sys\": Label(\"@crates//:js-sys-0.3.82\"),\n \"lsp-server\": Label(\"@crates//:lsp-server-0.8.0\"),\n \"lsp-types\": Label(\"@crates//:lsp-types-0.97.0\"),\n \"serde-wasm-bindgen\": Label(\"@crates//:serde-wasm-bindgen-0.6.5\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n \"line-index\": Label(\"@crates//:line-index-0.1.2\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n}\n\n\n_NORMAL_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n },\n },\n}\n\n\n_NORMAL_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"clap-markdown\": Label(\"@crates//:clap-markdown-0.1.5\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"minijinja\": Label(\"@crates//:minijinja-2.21.0\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"criterion\": Label(\"@crates//:codspeed-criterion-compat-4.4.1\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"serde_with\": Label(\"@crates//:serde_with-3.21.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_NORMAL_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_CONDITIONS = {\n \"aarch64-apple-darwin\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"aarch64-pc-windows-gnullvm\": [],\n \"aarch64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\"],\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(any(target_arch = \\\"x86_64\\\", target_arch = \\\"arm64ec\\\"), target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), not(any(all(target_os = \\\"linux\\\", target_env = \\\"\\\"), getrandom_backend = \\\"custom\\\", getrandom_backend = \\\"linux_raw\\\", getrandom_backend = \\\"rdrand\\\", getrandom_backend = \\\"rndr\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:wasm32-unknown-unknown\",\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", not(target_os = \\\"wasi\\\")))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p2\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p3\\\"))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(target_os = \\\"uefi\\\", getrandom_backend = \\\"efi_rng\\\"))\": [],\n \"cfg(any())\": [],\n \"cfg(any(target_os = \\\"dragonfly\\\", target_os = \\\"freebsd\\\", target_os = \\\"hurd\\\", target_os = \\\"illumos\\\", target_os = \\\"cygwin\\\", all(target_os = \\\"horizon\\\", target_arch = \\\"arm\\\")))\": [],\n \"cfg(any(target_os = \\\"haiku\\\", target_os = \\\"redox\\\", target_os = \\\"nto\\\", target_os = \\\"aix\\\"))\": [],\n \"cfg(any(target_os = \\\"ios\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\", target_os = \\\"tvos\\\"))\": [],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"openbsd\\\", target_os = \\\"vita\\\", target_os = \\\"emscripten\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"cfg(any(unix, target_os = \\\"wasi\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:wasm32-wasip1\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(target_has_atomic = \\\"64\\\"))\": [],\n \"cfg(target_arch = \\\"spirv\\\")\": [],\n \"cfg(target_os = \\\"hermit\\\")\": [],\n \"cfg(target_os = \\\"netbsd\\\")\": [],\n \"cfg(target_os = \\\"solaris\\\")\": [],\n \"cfg(target_os = \\\"vxworks\\\")\": [],\n \"cfg(target_os = \\\"wasi\\\")\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(unix)\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(windows)\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"i686-pc-windows-gnullvm\": [],\n \"wasm32-unknown-unknown\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"wasm32-wasip1\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"x86_64-pc-windows-gnullvm\": [],\n \"x86_64-pc-windows-msvc\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"x86_64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"x86_64-unknown-nixos-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n}\n\n###############################################################################\n\ndef crate_repositories():\n \"\"\"A macro for defining repositories for all generated crates.\n\n Returns:\n A list of repos visible to the module through the module extension.\n \"\"\"\n maybe(\n http_archive,\n name = \"crates__aho-corasick-1.1.4\",\n sha256 = \"ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aho-corasick/1.1.4/download\"],\n strip_prefix = \"aho-corasick-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.aho-corasick-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__allocator-api2-0.2.21\",\n sha256 = \"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/allocator-api2/0.2.21/download\"],\n strip_prefix = \"allocator-api2-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.allocator-api2-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anes-0.1.6\",\n sha256 = \"4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anes/0.1.6/download\"],\n strip_prefix = \"anes-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.anes-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstream-1.0.0\",\n sha256 = \"824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstream/1.0.0/download\"],\n strip_prefix = \"anstream-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstream-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-1.0.14\",\n sha256 = \"940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle/1.0.14/download\"],\n strip_prefix = \"anstyle-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-parse-1.0.0\",\n sha256 = \"52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-parse/1.0.0/download\"],\n strip_prefix = \"anstyle-parse-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-parse-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-query-1.1.5\",\n sha256 = \"40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-query/1.1.5/download\"],\n strip_prefix = \"anstyle-query-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-query-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-wincon-3.0.11\",\n sha256 = \"291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-wincon/3.0.11/download\"],\n strip_prefix = \"anstyle-wincon-3.0.11\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-wincon-3.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anyhow-1.0.102\",\n sha256 = \"7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anyhow/1.0.102/download\"],\n strip_prefix = \"anyhow-1.0.102\",\n build_file = Label(\"@crates//crates:BUILD.anyhow-1.0.102.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__append-only-vec-0.1.8\",\n sha256 = \"2114736faba96bcd79595c700d03183f61357b9fbce14852515e59f3bee4ed4a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/append-only-vec/0.1.8/download\"],\n strip_prefix = \"append-only-vec-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.append-only-vec-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__approx-0.5.1\",\n sha256 = \"cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/approx/0.5.1/download\"],\n strip_prefix = \"approx-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.approx-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__assert_cmd-2.2.2\",\n sha256 = \"2aa3a22042e45de04255c7bf3626e239f450200fd0493c1e382263544b20aea6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/assert_cmd/2.2.2/download\"],\n strip_prefix = \"assert_cmd-2.2.2\",\n build_file = Label(\"@crates//crates:BUILD.assert_cmd-2.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__autocfg-1.5.0\",\n sha256 = \"c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/autocfg/1.5.0/download\"],\n strip_prefix = \"autocfg-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.autocfg-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.22.1\",\n sha256 = \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.22.1/download\"],\n strip_prefix = \"base64-0.22.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.22.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-set-0.8.0\",\n sha256 = \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-set/0.8.0/download\"],\n strip_prefix = \"bit-set-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-set-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-vec-0.8.0\",\n sha256 = \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-vec/0.8.0/download\"],\n strip_prefix = \"bit-vec-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-vec-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-1.3.2\",\n sha256 = \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/1.3.2/download\"],\n strip_prefix = \"bitflags-1.3.2\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-1.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-2.11.0\",\n sha256 = \"843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/2.11.0/download\"],\n strip_prefix = \"bitflags-2.11.0\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-2.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__borsh-1.6.1\",\n sha256 = \"cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/borsh/1.6.1/download\"],\n strip_prefix = \"borsh-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.borsh-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bs58-0.5.1\",\n sha256 = \"bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bs58/0.5.1/download\"],\n strip_prefix = \"bs58-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.bs58-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bstr-1.12.1\",\n sha256 = \"63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bstr/1.12.1/download\"],\n strip_prefix = \"bstr-1.12.1\",\n build_file = Label(\"@crates//crates:BUILD.bstr-1.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bumpalo-3.20.2\",\n sha256 = \"5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bumpalo/3.20.2/download\"],\n strip_prefix = \"bumpalo-3.20.2\",\n build_file = Label(\"@crates//crates:BUILD.bumpalo-3.20.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytes-1.11.1\",\n sha256 = \"1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytes/1.11.1/download\"],\n strip_prefix = \"bytes-1.11.1\",\n build_file = Label(\"@crates//crates:BUILD.bytes-1.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cast-0.3.0\",\n sha256 = \"37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cast/0.3.0/download\"],\n strip_prefix = \"cast-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.cast-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cc-1.2.57\",\n sha256 = \"7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cc/1.2.57/download\"],\n strip_prefix = \"cc-1.2.57\",\n build_file = Label(\"@crates//crates:BUILD.cc-1.2.57.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-if-1.0.4\",\n sha256 = \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-if/1.0.4/download\"],\n strip_prefix = \"cfg-if-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.cfg-if-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.2.1\",\n sha256 = \"613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.2.1/download\"],\n strip_prefix = \"cfg_aliases-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chrono-0.4.44\",\n sha256 = \"c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chrono/0.4.44/download\"],\n strip_prefix = \"chrono-0.4.44\",\n build_file = Label(\"@crates//crates:BUILD.chrono-0.4.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-0.2.2\",\n sha256 = \"42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium/0.2.2/download\"],\n strip_prefix = \"ciborium-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-io-0.2.2\",\n sha256 = \"05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-io/0.2.2/download\"],\n strip_prefix = \"ciborium-io-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-io-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-ll-0.2.2\",\n sha256 = \"57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-ll/0.2.2/download\"],\n strip_prefix = \"ciborium-ll-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-ll-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-4.6.1\",\n sha256 = \"1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap/4.6.1/download\"],\n strip_prefix = \"clap-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-markdown-0.1.5\",\n sha256 = \"d2a2617956a06d4885b490697b5307ebb09fec10b088afc18c81762d848c2339\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap-markdown/0.1.5/download\"],\n strip_prefix = \"clap-markdown-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.clap-markdown-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_builder-4.6.0\",\n sha256 = \"714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_builder/4.6.0/download\"],\n strip_prefix = \"clap_builder-4.6.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_builder-4.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_derive-4.6.1\",\n sha256 = \"f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_derive/4.6.1/download\"],\n strip_prefix = \"clap_derive-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap_derive-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_lex-1.1.0\",\n sha256 = \"c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_lex/1.1.0/download\"],\n strip_prefix = \"clap_lex-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_lex-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-4.4.1\",\n sha256 = \"b684e94583e85a5ca7e1a6454a89d76a5121240f2fb67eb564129d9bafdb9db0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed/4.4.1/download\"],\n strip_prefix = \"codspeed-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-4.4.1\",\n sha256 = \"2e65444156eb73ad7f57618188f8d4a281726d133ef55b96d1dcff89528609ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-walltime-4.4.1\",\n sha256 = \"96389aaa4bbb872ea4924dc0335b2bb181bcf28d6eedbe8fea29afcc5bde36a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat-walltime/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-walltime-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-walltime-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colorchoice-1.0.5\",\n sha256 = \"1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colorchoice/1.0.5/download\"],\n strip_prefix = \"colorchoice-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.colorchoice-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colored-2.2.0\",\n sha256 = \"117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colored/2.2.0/download\"],\n strip_prefix = \"colored-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.colored-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__common-path-1.0.0\",\n sha256 = \"2382f75942f4b3be3690fe4f86365e9c853c1587d6ee58212cebf6e2a9ccd101\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/common-path/1.0.0/download\"],\n strip_prefix = \"common-path-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.common-path-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__configparser-3.2.0\",\n sha256 = \"b46dec724fd22199ebde05033a0cbae453bc3b1ecff11eb6a6bb3eec4b90c6a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/configparser/3.2.0/download\"],\n strip_prefix = \"configparser-3.2.0\",\n build_file = Label(\"@crates//crates:BUILD.configparser-3.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__console_error_panic_hook-0.1.7\",\n sha256 = \"a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/console_error_panic_hook/0.1.7/download\"],\n strip_prefix = \"console_error_panic_hook-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.console_error_panic_hook-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__criterion-plot-0.5.0\",\n sha256 = \"6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/criterion-plot/0.5.0/download\"],\n strip_prefix = \"criterion-plot-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.criterion-plot-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-channel-0.5.15\",\n sha256 = \"82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-channel/0.5.15/download\"],\n strip_prefix = \"crossbeam-channel-0.5.15\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-channel-0.5.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-deque-0.8.6\",\n sha256 = \"9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-deque/0.8.6/download\"],\n strip_prefix = \"crossbeam-deque-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-deque-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-epoch-0.9.18\",\n sha256 = \"5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-epoch/0.9.18/download\"],\n strip_prefix = \"crossbeam-epoch-0.9.18\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-epoch-0.9.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-utils-0.8.21\",\n sha256 = \"d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-utils/0.8.21/download\"],\n strip_prefix = \"crossbeam-utils-0.8.21\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-utils-0.8.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crunchy-0.2.4\",\n sha256 = \"460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crunchy/0.2.4/download\"],\n strip_prefix = \"crunchy-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.crunchy-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.23.0\",\n sha256 = \"25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.23.0/download\"],\n strip_prefix = \"darling-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.23.0\",\n sha256 = \"9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.23.0/download\"],\n strip_prefix = \"darling_core-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.23.0\",\n sha256 = \"ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.23.0/download\"],\n strip_prefix = \"darling_macro-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__deranged-0.5.8\",\n sha256 = \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/deranged/0.5.8/download\"],\n strip_prefix = \"deranged-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.deranged-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__diff-0.1.13\",\n sha256 = \"56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/diff/0.1.13/download\"],\n strip_prefix = \"diff-0.1.13\",\n build_file = Label(\"@crates//crates:BUILD.diff-0.1.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__difflib-0.4.0\",\n sha256 = \"6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/difflib/0.4.0/download\"],\n strip_prefix = \"difflib-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.difflib-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dissimilar-1.0.11\",\n sha256 = \"aeda16ab4059c5fd2a83f2b9c9e9c981327b18aa8e3b313f7e6563799d4f093e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dissimilar/1.0.11/download\"],\n strip_prefix = \"dissimilar-1.0.11\",\n build_file = Label(\"@crates//crates:BUILD.dissimilar-1.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__either-1.15.0\",\n sha256 = \"48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/either/1.15.0/download\"],\n strip_prefix = \"either-1.15.0\",\n build_file = Label(\"@crates//crates:BUILD.either-1.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enum_dispatch-0.3.13\",\n sha256 = \"aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enum_dispatch/0.3.13/download\"],\n strip_prefix = \"enum_dispatch-0.3.13\",\n build_file = Label(\"@crates//crates:BUILD.enum_dispatch-0.3.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__equivalent-1.0.2\",\n sha256 = \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/equivalent/1.0.2/download\"],\n strip_prefix = \"equivalent-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.equivalent-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__errno-0.3.14\",\n sha256 = \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/errno/0.3.14/download\"],\n strip_prefix = \"errno-0.3.14\",\n build_file = Label(\"@crates//crates:BUILD.errno-0.3.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__expect-test-1.5.1\",\n sha256 = \"63af43ff4431e848fb47472a920f14fa71c24de13255a5692e93d4e90302acb0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/expect-test/1.5.1/download\"],\n strip_prefix = \"expect-test-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.expect-test-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.18.0\",\n sha256 = \"e1e1dacd0d2082dfcf1351c4bdd566bbe89a2b263235a2b50058f1e130a47277\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.18.0/download\"],\n strip_prefix = \"fancy-regex-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fastrand-2.3.0\",\n sha256 = \"37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fastrand/2.3.0/download\"],\n strip_prefix = \"fastrand-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.fastrand-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fern-0.7.1\",\n sha256 = \"4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fern/0.7.1/download\"],\n strip_prefix = \"fern-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.fern-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__find-msvc-tools-0.1.9\",\n sha256 = \"5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/find-msvc-tools/0.1.9/download\"],\n strip_prefix = \"find-msvc-tools-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.find-msvc-tools-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-uri-0.1.4\",\n sha256 = \"17c704e9dbe1ddd863da1e6ff3567795087b1eb201ce80d8fa81162e1516500d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-uri/0.1.4/download\"],\n strip_prefix = \"fluent-uri-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.fluent-uri-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.1.5\",\n sha256 = \"d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.1.5/download\"],\n strip_prefix = \"foldhash-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.2.0\",\n sha256 = \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.2.0/download\"],\n strip_prefix = \"foldhash-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.2.17\",\n sha256 = \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.2.17/download\"],\n strip_prefix = \"getrandom-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.4.2\",\n sha256 = \"0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.4.2/download\"],\n strip_prefix = \"getrandom-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__glob-0.3.3\",\n sha256 = \"0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/glob/0.3.3/download\"],\n strip_prefix = \"glob-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.glob-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__globset-0.4.18\",\n sha256 = \"52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/globset/0.4.18/download\"],\n strip_prefix = \"globset-0.4.18\",\n build_file = Label(\"@crates//crates:BUILD.globset-0.4.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__half-2.7.1\",\n sha256 = \"6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/half/2.7.1/download\"],\n strip_prefix = \"half-2.7.1\",\n build_file = Label(\"@crates//crates:BUILD.half-2.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.15.5\",\n sha256 = \"9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.15.5/download\"],\n strip_prefix = \"hashbrown-0.15.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.15.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.17.1\",\n sha256 = \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.17.1/download\"],\n strip_prefix = \"hashbrown-0.17.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.17.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heck-0.5.0\",\n sha256 = \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heck/0.5.0/download\"],\n strip_prefix = \"heck-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.heck-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hermit-abi-0.5.2\",\n sha256 = \"fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hermit-abi/0.5.2/download\"],\n strip_prefix = \"hermit-abi-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.hermit-abi-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hex-0.4.3\",\n sha256 = \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hex/0.4.3/download\"],\n strip_prefix = \"hex-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.hex-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__id-arena-2.3.0\",\n sha256 = \"3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/id-arena/2.3.0/download\"],\n strip_prefix = \"id-arena-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.id-arena-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ident_case-1.0.1\",\n sha256 = \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ident_case/1.0.1/download\"],\n strip_prefix = \"ident_case-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.ident_case-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ignore-0.4.27\",\n sha256 = \"fe112b004901c62c2faa11f4f75e9864e0cc5af8da71c9115d184a3aa888749f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ignore/0.4.27/download\"],\n strip_prefix = \"ignore-0.4.27\",\n build_file = Label(\"@crates//crates:BUILD.ignore-0.4.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indexmap-2.14.0\",\n sha256 = \"d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indexmap/2.14.0/download\"],\n strip_prefix = \"indexmap-2.14.0\",\n build_file = Label(\"@crates//crates:BUILD.indexmap-2.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is-terminal-0.4.17\",\n sha256 = \"3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is-terminal/0.4.17/download\"],\n strip_prefix = \"is-terminal-0.4.17\",\n build_file = Label(\"@crates//crates:BUILD.is-terminal-0.4.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is_terminal_polyfill-1.70.2\",\n sha256 = \"a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is_terminal_polyfill/1.70.2/download\"],\n strip_prefix = \"is_terminal_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.is_terminal_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.10.5\",\n sha256 = \"b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.10.5/download\"],\n strip_prefix = \"itertools-0.10.5\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.10.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.15.0\",\n sha256 = \"8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.15.0/download\"],\n strip_prefix = \"itertools-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itoa-1.0.17\",\n sha256 = \"92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itoa/1.0.17/download\"],\n strip_prefix = \"itoa-1.0.17\",\n build_file = Label(\"@crates//crates:BUILD.itoa-1.0.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__js-sys-0.3.82\",\n sha256 = \"b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/js-sys/0.3.82/download\"],\n strip_prefix = \"js-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.js-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-3.6.0\",\n sha256 = \"6bae91019476d3ec7147de9aa291cadb6d870abf2f3015d2da73a90325ac1496\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex/3.6.0/download\"],\n strip_prefix = \"lazy-regex-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-proc_macros-3.6.0\",\n sha256 = \"4de9c1e1439d8b7b3061b2d209809f447ca33241733d9a3c01eabf2dc8d94358\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex-proc_macros/3.6.0/download\"],\n strip_prefix = \"lazy-regex-proc_macros-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-proc_macros-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy_static-1.5.0\",\n sha256 = \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy_static/1.5.0/download\"],\n strip_prefix = \"lazy_static-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy_static-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__leb128fmt-0.1.0\",\n sha256 = \"09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/leb128fmt/0.1.0/download\"],\n strip_prefix = \"leb128fmt-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.leb128fmt-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libc-0.2.183\",\n sha256 = \"b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libc/0.2.183/download\"],\n strip_prefix = \"libc-0.2.183\",\n build_file = Label(\"@crates//crates:BUILD.libc-0.2.183.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libmimalloc-sys-0.1.49\",\n sha256 = \"6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libmimalloc-sys/0.1.49/download\"],\n strip_prefix = \"libmimalloc-sys-0.1.49\",\n build_file = Label(\"@crates//crates:BUILD.libmimalloc-sys-0.1.49.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__line-index-0.1.2\",\n sha256 = \"3e27e0ed5a392a7f5ba0b3808a2afccff16c64933312c84b57618b49d1209bd2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/line-index/0.1.2/download\"],\n strip_prefix = \"line-index-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.line-index-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.12.1\",\n sha256 = \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.12.1/download\"],\n strip_prefix = \"linux-raw-sys-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__log-0.4.33\",\n sha256 = \"0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/log/0.4.33/download\"],\n strip_prefix = \"log-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.log-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-server-0.8.0\",\n sha256 = \"0ad8be6fe0ca81b8298bfbbe8a77e9fcd8895ad6c84cd7794d5ebadcbb09ae43\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-server/0.8.0/download\"],\n strip_prefix = \"lsp-server-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-server-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-types-0.97.0\",\n sha256 = \"53353550a17c04ac46c585feb189c2db82154fc84b79c7a66c96c2c644f66071\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-types/0.97.0/download\"],\n strip_prefix = \"lsp-types-0.97.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-types-0.97.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memchr-2.8.0\",\n sha256 = \"f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memchr/2.8.0/download\"],\n strip_prefix = \"memchr-2.8.0\",\n build_file = Label(\"@crates//crates:BUILD.memchr-2.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memo-map-0.3.3\",\n sha256 = \"38d1115007560874e373613744c6fba374c17688327a71c1476d1a5954cc857b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memo-map/0.3.3/download\"],\n strip_prefix = \"memo-map-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.memo-map-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__mimalloc-0.1.52\",\n sha256 = \"2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/mimalloc/0.1.52/download\"],\n strip_prefix = \"mimalloc-0.1.52\",\n build_file = Label(\"@crates//crates:BUILD.mimalloc-0.1.52.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__minijinja-2.21.0\",\n sha256 = \"cb3d648e68cea56d9858d535ee28f9538404e2dd8cb08ed0bd05dca379477f39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/minijinja/2.21.0/download\"],\n strip_prefix = \"minijinja-2.21.0\",\n build_file = Label(\"@crates//crates:BUILD.minijinja-2.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.31.2\",\n sha256 = \"5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.31.2/download\"],\n strip_prefix = \"nix-0.31.2\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.31.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nohash-hasher-0.2.0\",\n sha256 = \"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nohash-hasher/0.2.0/download\"],\n strip_prefix = \"nohash-hasher-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.nohash-hasher-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-conv-0.2.0\",\n sha256 = \"cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-conv/0.2.0/download\"],\n strip_prefix = \"num-conv-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.num-conv-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-traits-0.2.19\",\n sha256 = \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-traits/0.2.19/download\"],\n strip_prefix = \"num-traits-0.2.19\",\n build_file = Label(\"@crates//crates:BUILD.num-traits-0.2.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell-1.21.4\",\n sha256 = \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell/1.21.4/download\"],\n strip_prefix = \"once_cell-1.21.4\",\n build_file = Label(\"@crates//crates:BUILD.once_cell-1.21.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell_polyfill-1.70.2\",\n sha256 = \"384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell_polyfill/1.70.2/download\"],\n strip_prefix = \"once_cell_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.once_cell_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__oorandom-11.1.5\",\n sha256 = \"d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/oorandom/11.1.5/download\"],\n strip_prefix = \"oorandom-11.1.5\",\n build_file = Label(\"@crates//crates:BUILD.oorandom-11.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-0.3.7\",\n sha256 = \"5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters/0.3.7/download\"],\n strip_prefix = \"plotters-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-backend-0.3.7\",\n sha256 = \"df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-backend/0.3.7/download\"],\n strip_prefix = \"plotters-backend-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-backend-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-svg-0.3.7\",\n sha256 = \"51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-svg/0.3.7/download\"],\n strip_prefix = \"plotters-svg-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-svg-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-1.13.1\",\n sha256 = \"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic/1.13.1/download\"],\n strip_prefix = \"portable-atomic-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__powerfmt-0.2.0\",\n sha256 = \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/powerfmt/0.2.0/download\"],\n strip_prefix = \"powerfmt-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.powerfmt-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-3.1.4\",\n sha256 = \"ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates/3.1.4/download\"],\n strip_prefix = \"predicates-3.1.4\",\n build_file = Label(\"@crates//crates:BUILD.predicates-3.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-core-1.0.10\",\n sha256 = \"cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-core/1.0.10/download\"],\n strip_prefix = \"predicates-core-1.0.10\",\n build_file = Label(\"@crates//crates:BUILD.predicates-core-1.0.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-tree-1.0.13\",\n sha256 = \"d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-tree/1.0.13/download\"],\n strip_prefix = \"predicates-tree-1.0.13\",\n build_file = Label(\"@crates//crates:BUILD.predicates-tree-1.0.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pretty_assertions-1.4.1\",\n sha256 = \"3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pretty_assertions/1.4.1/download\"],\n strip_prefix = \"pretty_assertions-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.pretty_assertions-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prettyplease-0.2.37\",\n sha256 = \"479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prettyplease/0.2.37/download\"],\n strip_prefix = \"prettyplease-0.2.37\",\n build_file = Label(\"@crates//crates:BUILD.prettyplease-0.2.37.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro2-1.0.106\",\n sha256 = \"8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro2/1.0.106/download\"],\n strip_prefix = \"proc-macro2-1.0.106\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro2-1.0.106.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-0.29.0\",\n sha256 = \"cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3/0.29.0/download\"],\n strip_prefix = \"pyo3-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-build-config-0.29.0\",\n sha256 = \"c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-build-config/0.29.0/download\"],\n strip_prefix = \"pyo3-build-config-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-build-config-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-ffi-0.29.0\",\n sha256 = \"ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-ffi/0.29.0/download\"],\n strip_prefix = \"pyo3-ffi-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-ffi-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-0.29.0\",\n sha256 = \"9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-backend-0.29.0\",\n sha256 = \"4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros-backend/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-backend-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-backend-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quote-1.0.45\",\n sha256 = \"41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quote/1.0.45/download\"],\n strip_prefix = \"quote-1.0.45\",\n build_file = Label(\"@crates//crates:BUILD.quote-1.0.45.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-6.0.0\",\n sha256 = \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/6.0.0/download\"],\n strip_prefix = \"r-efi-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-1.12.0\",\n sha256 = \"fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon/1.12.0/download\"],\n strip_prefix = \"rayon-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-core-1.13.0\",\n sha256 = \"22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon-core/1.13.0/download\"],\n strip_prefix = \"rayon-core-1.13.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-core-1.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-1.12.4\",\n sha256 = \"f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex/1.12.4/download\"],\n strip_prefix = \"regex-1.12.4\",\n build_file = Label(\"@crates//crates:BUILD.regex-1.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-automata-0.4.14\",\n sha256 = \"6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-automata/0.4.14/download\"],\n strip_prefix = \"regex-automata-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.regex-automata-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-syntax-0.8.11\",\n sha256 = \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-syntax/0.8.11/download\"],\n strip_prefix = \"regex-syntax-0.8.11\",\n build_file = Label(\"@crates//crates:BUILD.regex-syntax-0.8.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-1.1.4\",\n sha256 = \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/1.1.4/download\"],\n strip_prefix = \"rustix-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.rustix-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustversion-1.0.22\",\n sha256 = \"b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustversion/1.0.22/download\"],\n strip_prefix = \"rustversion-1.0.22\",\n build_file = Label(\"@crates//crates:BUILD.rustversion-1.0.22.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ryu-1.0.23\",\n sha256 = \"9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ryu/1.0.23/download\"],\n strip_prefix = \"ryu-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.ryu-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__same-file-1.0.6\",\n sha256 = \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/same-file/1.0.6/download\"],\n strip_prefix = \"same-file-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.same-file-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__semver-1.0.27\",\n sha256 = \"d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/semver/1.0.27/download\"],\n strip_prefix = \"semver-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.semver-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-1.0.228\",\n sha256 = \"9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde/1.0.228/download\"],\n strip_prefix = \"serde-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-wasm-bindgen-0.6.5\",\n sha256 = \"8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde-wasm-bindgen/0.6.5/download\"],\n strip_prefix = \"serde-wasm-bindgen-0.6.5\",\n build_file = Label(\"@crates//crates:BUILD.serde-wasm-bindgen-0.6.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_core-1.0.228\",\n sha256 = \"41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_core/1.0.228/download\"],\n strip_prefix = \"serde_core-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_core-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_derive-1.0.228\",\n sha256 = \"d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_derive/1.0.228/download\"],\n strip_prefix = \"serde_derive-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_derive-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_json-1.0.150\",\n sha256 = \"e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_json/1.0.150/download\"],\n strip_prefix = \"serde_json-1.0.150\",\n build_file = Label(\"@crates//crates:BUILD.serde_json-1.0.150.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_repr-0.1.20\",\n sha256 = \"175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_repr/0.1.20/download\"],\n strip_prefix = \"serde_repr-0.1.20\",\n build_file = Label(\"@crates//crates:BUILD.serde_repr-0.1.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_spanned-1.1.1\",\n sha256 = \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_spanned/1.1.1/download\"],\n strip_prefix = \"serde_spanned-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.serde_spanned-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with-3.21.0\",\n sha256 = \"76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with/3.21.0/download\"],\n strip_prefix = \"serde_with-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with_macros-3.21.0\",\n sha256 = \"84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with_macros/3.21.0/download\"],\n strip_prefix = \"serde_with_macros-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with_macros-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_yaml-0.9.34-deprecated\",\n sha256 = \"6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_yaml/0.9.34+deprecated/download\"],\n strip_prefix = \"serde_yaml-0.9.34+deprecated\",\n build_file = Label(\"@crates//crates:BUILD.serde_yaml-0.9.34+deprecated.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-1.3.0\",\n sha256 = \"0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/1.3.0/download\"],\n strip_prefix = \"shlex-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.shlex-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smol_str-0.3.6\",\n sha256 = \"4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smol_str/0.3.6/download\"],\n strip_prefix = \"smol_str-0.3.6\",\n build_file = Label(\"@crates//crates:BUILD.smol_str-0.3.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__statrs-0.18.0\",\n sha256 = \"2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/statrs/0.18.0/download\"],\n strip_prefix = \"statrs-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.statrs-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strsim-0.11.1\",\n sha256 = \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strsim/0.11.1/download\"],\n strip_prefix = \"strsim-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.strsim-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum-0.28.0\",\n sha256 = \"9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum/0.28.0/download\"],\n strip_prefix = \"strum-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum_macros-0.28.0\",\n sha256 = \"ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum_macros/0.28.0/download\"],\n strip_prefix = \"strum_macros-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum_macros-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-2.0.117\",\n sha256 = \"e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/2.0.117/download\"],\n strip_prefix = \"syn-2.0.117\",\n build_file = Label(\"@crates//crates:BUILD.syn-2.0.117.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__target-lexicon-0.13.5\",\n sha256 = \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/target-lexicon/0.13.5/download\"],\n strip_prefix = \"target-lexicon-0.13.5\",\n build_file = Label(\"@crates//crates:BUILD.target-lexicon-0.13.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tempfile-3.27.0\",\n sha256 = \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tempfile/3.27.0/download\"],\n strip_prefix = \"tempfile-3.27.0\",\n build_file = Label(\"@crates//crates:BUILD.tempfile-3.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__termtree-0.5.1\",\n sha256 = \"8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/termtree/0.5.1/download\"],\n strip_prefix = \"termtree-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.termtree-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__text-size-1.1.1\",\n sha256 = \"f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/text-size/1.1.1/download\"],\n strip_prefix = \"text-size-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.text-size-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-2.0.18\",\n sha256 = \"4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/2.0.18/download\"],\n strip_prefix = \"thiserror-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-2.0.18\",\n sha256 = \"ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/2.0.18/download\"],\n strip_prefix = \"thiserror-impl-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-0.3.47\",\n sha256 = \"743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time/0.3.47/download\"],\n strip_prefix = \"time-0.3.47\",\n build_file = Label(\"@crates//crates:BUILD.time-0.3.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-core-0.1.8\",\n sha256 = \"7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-core/0.1.8/download\"],\n strip_prefix = \"time-core-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.time-core-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinytemplate-1.2.1\",\n sha256 = \"be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinytemplate/1.2.1/download\"],\n strip_prefix = \"tinytemplate-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.tinytemplate-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec-1.11.0\",\n sha256 = \"3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec/1.11.0/download\"],\n strip_prefix = \"tinyvec-1.11.0\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec-1.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec_macros-0.1.1\",\n sha256 = \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec_macros/0.1.1/download\"],\n strip_prefix = \"tinyvec_macros-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec_macros-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml-0.9.12-spec-1.1.0\",\n sha256 = \"cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml/0.9.12+spec-1.1.0/download\"],\n strip_prefix = \"toml-0.9.12+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml-0.9.12+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_datetime-0.7.5-spec-1.1.0\",\n sha256 = \"92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_datetime/0.7.5+spec-1.1.0/download\"],\n strip_prefix = \"toml_datetime-0.7.5+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_datetime-0.7.5+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_parser-1.1.2-spec-1.1.0\",\n sha256 = \"a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_parser/1.1.2+spec-1.1.0/download\"],\n strip_prefix = \"toml_parser-1.1.2+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_parser-1.1.2+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_writer-1.1.1-spec-1.1.0\",\n sha256 = \"756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_writer/1.1.1+spec-1.1.0/download\"],\n strip_prefix = \"toml_writer-1.1.1+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_writer-1.1.1+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-ident-1.0.24\",\n sha256 = \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-ident/1.0.24/download\"],\n strip_prefix = \"unicode-ident-1.0.24\",\n build_file = Label(\"@crates//crates:BUILD.unicode-ident-1.0.24.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-xid-0.2.6\",\n sha256 = \"ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-xid/0.2.6/download\"],\n strip_prefix = \"unicode-xid-0.2.6\",\n build_file = Label(\"@crates//crates:BUILD.unicode-xid-0.2.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unsafe-libyaml-0.2.11\",\n sha256 = \"673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unsafe-libyaml/0.2.11/download\"],\n strip_prefix = \"unsafe-libyaml-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.unsafe-libyaml-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8parse-0.2.2\",\n sha256 = \"06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8parse/0.2.2/download\"],\n strip_prefix = \"utf8parse-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.utf8parse-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wait-timeout-0.2.1\",\n sha256 = \"09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wait-timeout/0.2.1/download\"],\n strip_prefix = \"wait-timeout-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.wait-timeout-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__walkdir-2.5.0\",\n sha256 = \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/walkdir/2.5.0/download\"],\n strip_prefix = \"walkdir-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.walkdir-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.11.1-wasi-snapshot-preview1\",\n sha256 = \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.11.1+wasi-snapshot-preview1/download\"],\n strip_prefix = \"wasi-0.11.1+wasi-snapshot-preview1\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.11.1+wasi-snapshot-preview1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip2-1.0.2-wasi-0.2.9\",\n sha256 = \"9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip2/1.0.2+wasi-0.2.9/download\"],\n strip_prefix = \"wasip2-1.0.2+wasi-0.2.9\",\n build_file = Label(\"@crates//crates:BUILD.wasip2-1.0.2+wasi-0.2.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip3-0.4.0-wasi-0.3.0-rc-2026-01-06\",\n sha256 = \"5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip3/0.4.0+wasi-0.3.0-rc-2026-01-06/download\"],\n strip_prefix = \"wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06\",\n build_file = Label(\"@crates//crates:BUILD.wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-0.2.105\",\n sha256 = \"da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-0.2.105\",\n sha256 = \"04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-support-0.2.105\",\n sha256 = \"420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro-support/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-support-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-support-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-shared-0.2.105\",\n sha256 = \"76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-shared/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-shared-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-shared-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-encoder-0.244.0\",\n sha256 = \"990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-encoder/0.244.0/download\"],\n strip_prefix = \"wasm-encoder-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-encoder-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-metadata-0.244.0\",\n sha256 = \"bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-metadata/0.244.0/download\"],\n strip_prefix = \"wasm-metadata-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-metadata-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasmparser-0.244.0\",\n sha256 = \"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasmparser/0.244.0/download\"],\n strip_prefix = \"wasmparser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasmparser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-sys-0.3.82\",\n sha256 = \"3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-sys/0.3.82/download\"],\n strip_prefix = \"web-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.web-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-util-0.1.11\",\n sha256 = \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-util/0.1.11/download\"],\n strip_prefix = \"winapi-util-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.winapi-util-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.2.1\",\n sha256 = \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.2.1/download\"],\n strip_prefix = \"windows-link-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.59.0\",\n sha256 = \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.59.0/download\"],\n strip_prefix = \"windows-sys-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.61.2\",\n sha256 = \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.61.2/download\"],\n strip_prefix = \"windows-sys-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.52.6\",\n sha256 = \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.52.6/download\"],\n strip_prefix = \"windows-targets-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.52.6\",\n sha256 = \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.52.6\",\n sha256 = \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.52.6\",\n sha256 = \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.52.6\",\n sha256 = \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.52.6\",\n sha256 = \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.52.6/download\"],\n strip_prefix = \"windows_i686_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.52.6\",\n sha256 = \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.52.6\",\n sha256 = \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.52.6\",\n sha256 = \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-0.7.15\",\n sha256 = \"df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/0.7.15/download\"],\n strip_prefix = \"winnow-0.7.15\",\n build_file = Label(\"@crates//crates:BUILD.winnow-0.7.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-1.0.3\",\n sha256 = \"0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/1.0.3/download\"],\n strip_prefix = \"winnow-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.winnow-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-0.51.0\",\n sha256 = \"d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-core-0.51.0\",\n sha256 = \"ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-core/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-core-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-core-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-0.51.0\",\n sha256 = \"b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-macro-0.51.0\",\n sha256 = \"0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust-macro/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-macro-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-macro-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-component-0.244.0\",\n sha256 = \"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-component/0.244.0/download\"],\n strip_prefix = \"wit-component-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-component-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-parser-0.244.0\",\n sha256 = \"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-parser/0.244.0/download\"],\n strip_prefix = \"wit-parser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-parser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yansi-1.0.1\",\n sha256 = \"cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yansi/1.0.1/download\"],\n strip_prefix = \"yansi-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.yansi-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-0.8.46\",\n sha256 = \"5c5030500cb2d66bdfbb4ebc9563be6ce7005a4b5d0f26be0c523870fe372ca6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy/0.8.46/download\"],\n strip_prefix = \"zerocopy-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-derive-0.8.46\",\n sha256 = \"a5f86989a046a79640b9d8867c823349a139367bda96549794fcc3313ce91f4e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy-derive/0.8.46/download\"],\n strip_prefix = \"zerocopy-derive-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-derive-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zmij-1.0.21\",\n sha256 = \"b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zmij/1.0.21/download\"],\n strip_prefix = \"zmij-1.0.21\",\n build_file = Label(\"@crates//crates:BUILD.zmij-1.0.21.bazel\"),\n )\n\n return [\n struct(repo=\"crates__anstyle-1.0.14\", is_dev_dep = False),\n struct(repo=\"crates__append-only-vec-0.1.8\", is_dev_dep = False),\n struct(repo=\"crates__clap-4.6.1\", is_dev_dep = False),\n struct(repo=\"crates__common-path-1.0.0\", is_dev_dep = False),\n struct(repo=\"crates__configparser-3.2.0\", is_dev_dep = False),\n struct(repo=\"crates__console_error_panic_hook-0.1.7\", is_dev_dep = False),\n struct(repo=\"crates__enum_dispatch-0.3.13\", is_dev_dep = False),\n struct(repo=\"crates__fancy-regex-0.18.0\", is_dev_dep = False),\n struct(repo=\"crates__fern-0.7.1\", is_dev_dep = False),\n struct(repo=\"crates__getrandom-0.2.17\", is_dev_dep = False),\n struct(repo=\"crates__hashbrown-0.17.1\", is_dev_dep = False),\n struct(repo=\"crates__ignore-0.4.27\", is_dev_dep = False),\n struct(repo=\"crates__indexmap-2.14.0\", is_dev_dep = False),\n struct(repo=\"crates__itertools-0.15.0\", is_dev_dep = False),\n struct(repo=\"crates__js-sys-0.3.82\", is_dev_dep = False),\n struct(repo=\"crates__lazy-regex-3.6.0\", is_dev_dep = False),\n struct(repo=\"crates__line-index-0.1.2\", is_dev_dep = False),\n struct(repo=\"crates__log-0.4.33\", is_dev_dep = False),\n struct(repo=\"crates__lsp-server-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__lsp-types-0.97.0\", is_dev_dep = False),\n struct(repo=\"crates__mimalloc-0.1.52\", is_dev_dep = False),\n struct(repo=\"crates__nohash-hasher-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__pretty_assertions-1.4.1\", is_dev_dep = False),\n struct(repo=\"crates__pyo3-0.29.0\", is_dev_dep = False),\n struct(repo=\"crates__rayon-1.12.0\", is_dev_dep = False),\n struct(repo=\"crates__regex-1.12.4\", is_dev_dep = False),\n struct(repo=\"crates__regex-automata-0.4.14\", is_dev_dep = False),\n struct(repo=\"crates__serde-1.0.228\", is_dev_dep = False),\n struct(repo=\"crates__serde-wasm-bindgen-0.6.5\", is_dev_dep = False),\n struct(repo=\"crates__serde_json-1.0.150\", is_dev_dep = False),\n struct(repo=\"crates__serde_yaml-0.9.34-deprecated\", is_dev_dep = False),\n struct(repo=\"crates__smol_str-0.3.6\", is_dev_dep = False),\n struct(repo=\"crates__strum-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__strum_macros-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__thiserror-2.0.18\", is_dev_dep = False),\n struct(repo=\"crates__toml-0.9.12-spec-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__walkdir-2.5.0\", is_dev_dep = False),\n struct(repo=\"crates__wasm-bindgen-0.2.105\", is_dev_dep = False),\n struct(repo = \"crates__assert_cmd-2.2.2\", is_dev_dep = True),\n struct(repo = \"crates__clap-markdown-0.1.5\", is_dev_dep = True),\n struct(repo = \"crates__codspeed-criterion-compat-4.4.1\", is_dev_dep = True),\n struct(repo = \"crates__expect-test-1.5.1\", is_dev_dep = True),\n struct(repo = \"crates__glob-0.3.3\", is_dev_dep = True),\n struct(repo = \"crates__minijinja-2.21.0\", is_dev_dep = True),\n struct(repo = \"crates__serde_with-3.21.0\", is_dev_dep = True),\n struct(repo = \"crates__tempfile-3.27.0\", is_dev_dep = True),\n ]\n" } } }, diff --git a/crates/cli-lib/Cargo.toml b/crates/cli-lib/Cargo.toml index f20dabc21..e4322d222 100644 --- a/crates/cli-lib/Cargo.toml +++ b/crates/cli-lib/Cargo.toml @@ -32,6 +32,7 @@ strum.workspace = true strum_macros.workspace = true fern = "0.7" log.workspace = true +ignore = "0.4.26" anstyle = "1.0" clap = { version = "4.6.1", features = ["derive"] } pyo3 = { version = "0.29.0", optional = true } diff --git a/crates/cli-lib/src/formatters.rs b/crates/cli-lib/src/formatters.rs index 8a90c1f0b..c4df53eb1 100644 --- a/crates/cli-lib/src/formatters.rs +++ b/crates/cli-lib/src/formatters.rs @@ -206,20 +206,6 @@ impl OutputStreamFormatter { } } -/// A formatter that produces no output at all. -/// -/// Mirrors SQLFluff's `none` format type, which is used mostly for testing. -#[derive(Default)] -pub(crate) struct NullFormatter; - -impl Formatter for NullFormatter { - fn dispatch_file_violations(&self, _linted_file: &LintedFile) {} - - fn dispatch_file_skip(&self, _fname: &str, _reason: &str) {} - - fn completion_message(&self, _count: usize) {} -} - #[derive(Clone, Copy)] pub(crate) enum Status { Pass, diff --git a/crates/cli-lib/src/ignore.rs b/crates/cli-lib/src/ignore.rs new file mode 100644 index 000000000..856e1b6b3 --- /dev/null +++ b/crates/cli-lib/src/ignore.rs @@ -0,0 +1,50 @@ +use ignore::gitignore::Gitignore; +use std::path::Path; + +/// The name of the ignore file that sqruff will look for in the root of the project and use to +/// determine which files to ignore. +const IGNORE_FILE_NAME: &str = ".sqruffignore"; + +pub(crate) struct IgnoreFile { + ignore: Gitignore, +} + +impl IgnoreFile { + /// Create a new instance of `IgnoreFile` from the root of the project. + pub(crate) fn new_from_root(root: &Path) -> Result { + let ignore_file = root.join(IGNORE_FILE_NAME); + if ignore_file.exists() { + let ignore = Gitignore::new(ignore_file); + match ignore { + (ignore, None) => Ok(IgnoreFile { ignore }), + (_, Some(err)) => Err(err.to_string()), + } + } else { + Ok(IgnoreFile { + ignore: Gitignore::empty(), + }) + } + } + + /// Check if the given path should be ignored. + pub(crate) fn is_ignored(&self, path: &Path) -> bool { + let is_dir = path.is_dir(); + let match_result = self.ignore.matched(path, is_dir); + let is_ignored = match_result.is_ignore(); + + if is_ignored { + let path_type = if is_dir { "directory" } else { "file" }; + log::debug!( + "Ignoring {} '{}' due to ignore pattern", + path_type, + path.display() + ); + + if let Some(pattern) = match_result.inner() { + log::debug!("Matched ignore pattern: '{}'", pattern.original()); + } + } + + is_ignored + } +} diff --git a/crates/cli-lib/src/reporters.rs b/crates/cli-lib/src/reporters.rs index 0c17f7048..c64eb0243 100644 --- a/crates/cli-lib/src/reporters.rs +++ b/crates/cli-lib/src/reporters.rs @@ -16,6 +16,7 @@ pub(crate) enum Reporter { Human(HumanReporter), Json(JsonReporter), Github(GithubReporter), + None, } impl Reporter { @@ -24,6 +25,7 @@ impl Reporter { Format::Human => Self::Human(HumanReporter::new(config)), Format::GithubAnnotationNative => Self::Github(GithubReporter::new()), Format::Json => Self::Json(JsonReporter::default()), + Format::None => Self::None, } } @@ -32,6 +34,7 @@ impl Reporter { Self::Human(r) => r.emit(report), Self::Json(r) => r.emit(report), Self::Github(r) => r.emit(report), + Self::None => Ok(()), } } @@ -40,6 +43,7 @@ impl Reporter { Self::Human(r) => r.emit_diagnostics(report), Self::Json(r) => r.emit(report), Self::Github(r) => r.emit(report), + Self::None => Ok(()), } } } From 9075eefdbad963d0f9bf899b55777b64b3d3cee2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 8 Jul 2026 16:01:49 +0000 Subject: [PATCH 9/9] chore: auto-fix formatting --- MODULE.bazel.lock | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index cccab3162..088d2901b 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -2708,7 +2708,7 @@ "REPO_MAPPING:rules_rust+,rules_rust rules_rust+", "FILE:@@//Cargo.lock 6129983b8503de4b1a52965b3d53aec9803e51b715c5968bf4e5048d6ee6b7fe", "FILE:@@//Cargo.toml 8fbb9d9ad8bd861d59b023729fe884865690704382155a6e2bf0cb01c97c6c16", - "FILE:@@//crates/cli/Cargo.toml 69789bdb7a1ada8e986afa284402986c9a6e64055744c4af2f209941e1525a27", + "FILE:@@//crates/cli/Cargo.toml dc355023927e45c3be43a0778ab7ca343f761603931bf6fe43a8b1dba65ea022", "FILE:@@//crates/cli-lib/Cargo.toml 48ac2d77c8ce62c2d18732ec0bd4d3ef17041cdad18bfb27b0006b60e4cab1d6", "FILE:@@//crates/cli-python/Cargo.toml 1be309c34494f9590292f3eb091b24f009ca2619da98ce711968ff43b4947b71", "FILE:@@//crates/lib/Cargo.toml 6e6ee84636278cdbcc21490f7f89e68eb95eacd587448c209463de43df3de937", @@ -2716,7 +2716,7 @@ "FILE:@@//crates/lib-dialects/Cargo.toml 65f14eef0fd90412fdb48dbcd7ad7060aec5891bad7cd200d8e241ff19d544a9", "FILE:@@//crates/lib-wasm/Cargo.toml dcafc87d240f6567664317913da006a8e786a195a1c0d7e93263b6ef7fa10874", "FILE:@@//crates/lineage/Cargo.toml d26ee434e736f8dd310937ca3dad5a5090d207ecf3e553dd627b4bdc576d82bb", - "FILE:@@//crates/lsp/Cargo.toml 778e793284fd699e5170e18ecd56ab246a82ae6dfd3229a36cdd10a83fced904", + "FILE:@@//crates/lsp/Cargo.toml aa348521db3218232e627bf659d91250eba89415da59fb999665ddd4df974e9a", "FILE:@@//crates/sqlinference/Cargo.toml 019ec868ee5b87094d99a7cc47cd51950d75095d7025e05133ed1b69dbea0809" ], "generatedRepoSpecs": { @@ -2726,7 +2726,7 @@ "contents": { "BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nexports_files(\n [\n \"cargo-bazel.json\",\n \"crates.bzl\",\n \"defs.bzl\",\n ] + glob(\n allow_empty = True,\n include = [\"*.bazel\"],\n ),\n)\n\nfilegroup(\n name = \"srcs\",\n srcs = glob(\n allow_empty = True,\n include = [\n \"*.bazel\",\n \"*.bzl\",\n ],\n ),\n)\n\n# Workspace Member Dependencies\nalias(\n name = \"anstyle-1.0.14\",\n actual = \"@crates__anstyle-1.0.14//:anstyle\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"anstyle\",\n actual = \"@crates__anstyle-1.0.14//:anstyle\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"append-only-vec-0.1.8\",\n actual = \"@crates__append-only-vec-0.1.8//:append_only_vec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"append-only-vec\",\n actual = \"@crates__append-only-vec-0.1.8//:append_only_vec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"assert_cmd-2.2.2\",\n actual = \"@crates__assert_cmd-2.2.2//:assert_cmd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"assert_cmd\",\n actual = \"@crates__assert_cmd-2.2.2//:assert_cmd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-4.6.1\",\n actual = \"@crates__clap-4.6.1//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap\",\n actual = \"@crates__clap-4.6.1//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-markdown-0.1.5\",\n actual = \"@crates__clap-markdown-0.1.5//:clap_markdown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-markdown\",\n actual = \"@crates__clap-markdown-0.1.5//:clap_markdown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"codspeed-criterion-compat-4.4.1\",\n actual = \"@crates__codspeed-criterion-compat-4.4.1//:codspeed_criterion_compat\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"criterion-4.4.1\",\n actual = \"@crates__codspeed-criterion-compat-4.4.1//:codspeed_criterion_compat\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"criterion\",\n actual = \"@crates__codspeed-criterion-compat-4.4.1//:codspeed_criterion_compat\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"common-path-1.0.0\",\n actual = \"@crates__common-path-1.0.0//:common_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"common-path\",\n actual = \"@crates__common-path-1.0.0//:common_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"configparser-3.2.0\",\n actual = \"@crates__configparser-3.2.0//:configparser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"configparser\",\n actual = \"@crates__configparser-3.2.0//:configparser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"console_error_panic_hook-0.1.7\",\n actual = \"@crates__console_error_panic_hook-0.1.7//:console_error_panic_hook\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"console_error_panic_hook\",\n actual = \"@crates__console_error_panic_hook-0.1.7//:console_error_panic_hook\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enum_dispatch-0.3.13\",\n actual = \"@crates__enum_dispatch-0.3.13//:enum_dispatch\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enum_dispatch\",\n actual = \"@crates__enum_dispatch-0.3.13//:enum_dispatch\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"expect-test-1.5.1\",\n actual = \"@crates__expect-test-1.5.1//:expect_test\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"expect-test\",\n actual = \"@crates__expect-test-1.5.1//:expect_test\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex-0.18.0\",\n actual = \"@crates__fancy-regex-0.18.0//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex\",\n actual = \"@crates__fancy-regex-0.18.0//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fern-0.7.1\",\n actual = \"@crates__fern-0.7.1//:fern\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fern\",\n actual = \"@crates__fern-0.7.1//:fern\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom-0.2.17\",\n actual = \"@crates__getrandom-0.2.17//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom\",\n actual = \"@crates__getrandom-0.2.17//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob-0.3.3\",\n actual = \"@crates__glob-0.3.3//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob\",\n actual = \"@crates__glob-0.3.3//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hashbrown-0.17.1\",\n actual = \"@crates__hashbrown-0.17.1//:hashbrown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hashbrown\",\n actual = \"@crates__hashbrown-0.17.1//:hashbrown\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore-0.4.27\",\n actual = \"@crates__ignore-0.4.27//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore\",\n actual = \"@crates__ignore-0.4.27//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indexmap-2.14.0\",\n actual = \"@crates__indexmap-2.14.0//:indexmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indexmap\",\n actual = \"@crates__indexmap-2.14.0//:indexmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools-0.15.0\",\n actual = \"@crates__itertools-0.15.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools\",\n actual = \"@crates__itertools-0.15.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"js-sys-0.3.82\",\n actual = \"@crates__js-sys-0.3.82//:js_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"js-sys\",\n actual = \"@crates__js-sys-0.3.82//:js_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lazy-regex-3.6.0\",\n actual = \"@crates__lazy-regex-3.6.0//:lazy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lazy-regex\",\n actual = \"@crates__lazy-regex-3.6.0//:lazy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"line-index-0.1.2\",\n actual = \"@crates__line-index-0.1.2//:line_index\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"line-index\",\n actual = \"@crates__line-index-0.1.2//:line_index\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"log-0.4.33\",\n actual = \"@crates__log-0.4.33//:log\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"log\",\n actual = \"@crates__log-0.4.33//:log\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-server-0.8.0\",\n actual = \"@crates__lsp-server-0.8.0//:lsp_server\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-server\",\n actual = \"@crates__lsp-server-0.8.0//:lsp_server\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-types-0.97.0\",\n actual = \"@crates__lsp-types-0.97.0//:lsp_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lsp-types\",\n actual = \"@crates__lsp-types-0.97.0//:lsp_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"mimalloc-0.1.52\",\n actual = \"@crates__mimalloc-0.1.52//:mimalloc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"mimalloc\",\n actual = \"@crates__mimalloc-0.1.52//:mimalloc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"minijinja-2.21.0\",\n actual = \"@crates__minijinja-2.21.0//:minijinja\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"minijinja\",\n actual = \"@crates__minijinja-2.21.0//:minijinja\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nohash-hasher-0.2.0\",\n actual = \"@crates__nohash-hasher-0.2.0//:nohash_hasher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nohash-hasher\",\n actual = \"@crates__nohash-hasher-0.2.0//:nohash_hasher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions-1.4.1\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pyo3-0.29.0\",\n actual = \"@crates__pyo3-0.29.0//:pyo3\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pyo3\",\n actual = \"@crates__pyo3-0.29.0//:pyo3\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon-1.12.0\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-1.12.4\",\n actual = \"@crates__regex-1.12.4//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex\",\n actual = \"@crates__regex-1.12.4//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-automata-0.4.14\",\n actual = \"@crates__regex-automata-0.4.14//:regex_automata\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-automata\",\n actual = \"@crates__regex-automata-0.4.14//:regex_automata\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-1.0.228\",\n actual = \"@crates__serde-1.0.228//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde\",\n actual = \"@crates__serde-1.0.228//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-wasm-bindgen-0.6.5\",\n actual = \"@crates__serde-wasm-bindgen-0.6.5//:serde_wasm_bindgen\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-wasm-bindgen\",\n actual = \"@crates__serde-wasm-bindgen-0.6.5//:serde_wasm_bindgen\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json-1.0.150\",\n actual = \"@crates__serde_json-1.0.150//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json\",\n actual = \"@crates__serde_json-1.0.150//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_with-3.21.0\",\n actual = \"@crates__serde_with-3.21.0//:serde_with\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_with\",\n actual = \"@crates__serde_with-3.21.0//:serde_with\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_yaml-0.9.34+deprecated\",\n actual = \"@crates__serde_yaml-0.9.34-deprecated//:serde_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_yaml\",\n actual = \"@crates__serde_yaml-0.9.34-deprecated//:serde_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smol_str-0.3.6\",\n actual = \"@crates__smol_str-0.3.6//:smol_str\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smol_str\",\n actual = \"@crates__smol_str-0.3.6//:smol_str\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum-0.28.0\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros-0.28.0\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile-3.27.0\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror-2.0.18\",\n actual = \"@crates__thiserror-2.0.18//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror\",\n actual = \"@crates__thiserror-2.0.18//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml-0.9.12+spec-1.1.0\",\n actual = \"@crates__toml-0.9.12-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml\",\n actual = \"@crates__toml-0.9.12-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"walkdir-2.5.0\",\n actual = \"@crates__walkdir-2.5.0//:walkdir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"walkdir\",\n actual = \"@crates__walkdir-2.5.0//:walkdir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"wasm-bindgen-0.2.105\",\n actual = \"@crates__wasm-bindgen-0.2.105//:wasm_bindgen\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"wasm-bindgen\",\n actual = \"@crates__wasm-bindgen-0.2.105//:wasm_bindgen\",\n tags = [\"manual\"],\n)\n", "alias_rules.bzl": "\"\"\"Alias that transitions its target to `compilation_mode=opt`. Use `transition_alias=\"opt\"` to enable.\"\"\"\n\nload(\"@rules_cc//cc:defs.bzl\", \"CcInfo\")\nload(\"@rules_rust//rust:rust_common.bzl\", \"COMMON_PROVIDERS\")\n\ndef _transition_alias_impl(ctx):\n # `ctx.attr.actual` is a list of 1 item due to the transition\n providers = [ctx.attr.actual[0][provider] for provider in COMMON_PROVIDERS]\n if CcInfo in ctx.attr.actual[0]:\n providers.append(ctx.attr.actual[0][CcInfo])\n return providers\n\ndef _change_compilation_mode(compilation_mode):\n def _change_compilation_mode_impl(_settings, _attr):\n return {\n \"//command_line_option:compilation_mode\": compilation_mode,\n }\n\n return transition(\n implementation = _change_compilation_mode_impl,\n inputs = [],\n outputs = [\n \"//command_line_option:compilation_mode\",\n ],\n )\n\ndef _transition_alias_rule(compilation_mode):\n return rule(\n implementation = _transition_alias_impl,\n provides = COMMON_PROVIDERS,\n attrs = {\n \"actual\": attr.label(\n mandatory = True,\n doc = \"`rust_library()` target to transition to `compilation_mode=opt`.\",\n providers = COMMON_PROVIDERS,\n cfg = _change_compilation_mode(compilation_mode),\n ),\n \"_allowlist_function_transition\": attr.label(\n default = \"@bazel_tools//tools/allowlists/function_transition_allowlist\",\n ),\n },\n doc = \"Transitions a Rust library crate to the `compilation_mode=opt`.\",\n )\n\ntransition_alias_dbg = _transition_alias_rule(\"dbg\")\ntransition_alias_fastbuild = _transition_alias_rule(\"fastbuild\")\ntransition_alias_opt = _transition_alias_rule(\"opt\")\n", - "defs.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\"\"\"\n# `crates_repository` API\n\n- [aliases](#aliases)\n- [crate_deps](#crate_deps)\n- [all_crate_deps](#all_crate_deps)\n- [crate_repositories](#crate_repositories)\n\n\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\", \"new_git_repository\")\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:utils.bzl\", \"maybe\")\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\nload(\"@rules_rust//crate_universe/private:local_crate_mirror.bzl\", \"local_crate_mirror\")\n\n###############################################################################\n# MACROS API\n###############################################################################\n\n# An identifier that represent common dependencies (unconditional).\n_COMMON_CONDITION = \"\"\n\ndef _flatten_dependency_maps(all_dependency_maps):\n \"\"\"Flatten a list of dependency maps into one dictionary.\n\n Dependency maps have the following structure:\n\n ```python\n DEPENDENCIES_MAP = {\n # The first key in the map is a Bazel package\n # name of the workspace this file is defined in.\n \"workspace_member_package\": {\n\n # Not all dependencies are supported for all platforms.\n # the condition key is the condition required to be true\n # on the host platform.\n \"condition\": {\n\n # An alias to a crate target. # The label of the crate target the\n # Aliases are only crate names. # package name refers to.\n \"package_name\": \"@full//:label\",\n }\n }\n }\n ```\n\n Args:\n all_dependency_maps (list): A list of dicts as described above\n\n Returns:\n dict: A dictionary as described above\n \"\"\"\n dependencies = {}\n\n for workspace_deps_map in all_dependency_maps:\n for pkg_name, conditional_deps_map in workspace_deps_map.items():\n if pkg_name not in dependencies:\n non_frozen_map = dict()\n for key, values in conditional_deps_map.items():\n non_frozen_map.update({key: dict(values.items())})\n dependencies.setdefault(pkg_name, non_frozen_map)\n continue\n\n for condition, deps_map in conditional_deps_map.items():\n # If the condition has not been recorded, do so and continue\n if condition not in dependencies[pkg_name]:\n dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))\n continue\n\n # Alert on any miss-matched dependencies\n inconsistent_entries = []\n for crate_name, crate_label in deps_map.items():\n existing = dependencies[pkg_name][condition].get(crate_name)\n if existing and existing != crate_label:\n inconsistent_entries.append((crate_name, existing, crate_label))\n dependencies[pkg_name][condition].update({crate_name: crate_label})\n\n return dependencies\n\ndef crate_deps(deps, package_name = None):\n \"\"\"Finds the fully qualified label of the requested crates for the package where this macro is called.\n\n Args:\n deps (list): The desired list of crate targets.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()`.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if not deps:\n return []\n\n if package_name == None:\n package_name = native.package_name()\n\n # Join both sets of dependencies\n dependencies = _flatten_dependency_maps([\n _NORMAL_DEPENDENCIES,\n _NORMAL_DEV_DEPENDENCIES,\n _PROC_MACRO_DEPENDENCIES,\n _PROC_MACRO_DEV_DEPENDENCIES,\n _BUILD_DEPENDENCIES,\n _BUILD_PROC_MACRO_DEPENDENCIES,\n ]).pop(package_name, {})\n\n # Combine all conditional packages so we can easily index over a flat list\n # TODO: Perhaps this should actually return select statements and maintain\n # the conditionals of the dependencies\n flat_deps = {}\n for deps_set in dependencies.values():\n for crate_name, crate_label in deps_set.items():\n flat_deps.update({crate_name: crate_label})\n\n missing_crates = []\n crate_targets = []\n for crate_target in deps:\n if crate_target not in flat_deps:\n missing_crates.append(crate_target)\n else:\n crate_targets.append(flat_deps[crate_target])\n\n if missing_crates:\n fail(\"Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`\".format(\n missing_crates,\n package_name,\n dependencies,\n ))\n\n return crate_targets\n\ndef all_crate_deps(\n normal = False, \n normal_dev = False, \n proc_macro = False, \n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Finds the fully qualified label of all requested direct crate dependencies \\\n for the package where this macro is called.\n\n If no parameters are set, all normal dependencies are returned. Setting any one flag will\n otherwise impact the contents of the returned list.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_dependency_maps = []\n if normal:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n if normal_dev:\n all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)\n if proc_macro:\n all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)\n if proc_macro_dev:\n all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)\n if build:\n all_dependency_maps.append(_BUILD_DEPENDENCIES)\n if build_proc_macro:\n all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)\n\n # Default to always using normal dependencies\n if not all_dependency_maps:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n\n dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)\n\n if not dependencies:\n if dependencies == None:\n fail(\"Tried to get all_crate_deps for package \" + package_name + \" but that package had no Cargo.toml file\")\n else:\n return []\n\n crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())\n for condition, deps in dependencies.items():\n crate_deps += selects.with_or({\n tuple(_CONDITIONS[condition]): deps.values(),\n \"//conditions:default\": [],\n })\n\n return crate_deps\n\ndef aliases(\n normal = False,\n normal_dev = False,\n proc_macro = False,\n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Produces a map of Crate alias names to their original label\n\n If no dependency kinds are specified, `normal` and `proc_macro` are used by default.\n Setting any one flag will otherwise determine the contents of the returned dict.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n dict: The aliases of all associated packages\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_aliases_maps = []\n if normal:\n all_aliases_maps.append(_NORMAL_ALIASES)\n if normal_dev:\n all_aliases_maps.append(_NORMAL_DEV_ALIASES)\n if proc_macro:\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n if proc_macro_dev:\n all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)\n if build:\n all_aliases_maps.append(_BUILD_ALIASES)\n if build_proc_macro:\n all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)\n\n # Default to always using normal aliases\n if not all_aliases_maps:\n all_aliases_maps.append(_NORMAL_ALIASES)\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n\n aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)\n\n if not aliases:\n return dict()\n\n common_items = aliases.pop(_COMMON_CONDITION, {}).items()\n\n # If there are only common items in the dictionary, immediately return them\n if not len(aliases.keys()) == 1:\n return dict(common_items)\n\n # Build a single select statement where each conditional has accounted for the\n # common set of aliases.\n crate_aliases = {\"//conditions:default\": dict(common_items)}\n for condition, deps in aliases.items():\n condition_triples = _CONDITIONS[condition]\n for triple in condition_triples:\n if triple in crate_aliases:\n crate_aliases[triple].update(deps)\n else:\n crate_aliases.update({triple: dict(deps.items() + common_items)})\n\n return select(crate_aliases)\n\n###############################################################################\n# WORKSPACE MEMBER DEPS AND ALIASES\n###############################################################################\n\n_NORMAL_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"append-only-vec\": Label(\"@crates//:append-only-vec-0.1.8\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n \"mimalloc\": Label(\"@crates//:mimalloc-0.1.52\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"anstyle\": Label(\"@crates//:anstyle-1.0.14\"),\n \"clap\": Label(\"@crates//:clap-4.6.1\"),\n \"fern\": Label(\"@crates//:fern-0.7.1\"),\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"common-path\": Label(\"@crates//:common-path-1.0.0\"),\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"lazy-regex\": Label(\"@crates//:lazy-regex-3.6.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n \"regex\": Label(\"@crates//:regex-1.12.4\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"toml\": Label(\"@crates//:toml-0.9.12+spec-1.1.0\"),\n \"walkdir\": Label(\"@crates//:walkdir-2.5.0\"),\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n \"getrandom\": Label(\"@crates//:getrandom-0.2.17\"),\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"regex-automata\": Label(\"@crates//:regex-automata-0.4.14\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"thiserror\": Label(\"@crates//:thiserror-2.0.18\"),\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n \"console_error_panic_hook\": Label(\"@crates//:console_error_panic_hook-0.1.7\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"js-sys\": Label(\"@crates//:js-sys-0.3.82\"),\n \"lsp-server\": Label(\"@crates//:lsp-server-0.8.0\"),\n \"lsp-types\": Label(\"@crates//:lsp-types-0.97.0\"),\n \"serde-wasm-bindgen\": Label(\"@crates//:serde-wasm-bindgen-0.6.5\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n \"line-index\": Label(\"@crates//:line-index-0.1.2\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n}\n\n\n_NORMAL_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n },\n },\n}\n\n\n_NORMAL_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"clap-markdown\": Label(\"@crates//:clap-markdown-0.1.5\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"minijinja\": Label(\"@crates//:minijinja-2.21.0\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"criterion\": Label(\"@crates//:codspeed-criterion-compat-4.4.1\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"serde_with\": Label(\"@crates//:serde_with-3.21.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_NORMAL_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_CONDITIONS = {\n \"aarch64-apple-darwin\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"aarch64-pc-windows-gnullvm\": [],\n \"aarch64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\"],\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(any(target_arch = \\\"x86_64\\\", target_arch = \\\"arm64ec\\\"), target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), not(any(all(target_os = \\\"linux\\\", target_env = \\\"\\\"), getrandom_backend = \\\"custom\\\", getrandom_backend = \\\"linux_raw\\\", getrandom_backend = \\\"rdrand\\\", getrandom_backend = \\\"rndr\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:wasm32-unknown-unknown\",\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", not(target_os = \\\"wasi\\\")))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p2\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p3\\\"))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(target_os = \\\"uefi\\\", getrandom_backend = \\\"efi_rng\\\"))\": [],\n \"cfg(any())\": [],\n \"cfg(any(target_os = \\\"dragonfly\\\", target_os = \\\"freebsd\\\", target_os = \\\"hurd\\\", target_os = \\\"illumos\\\", target_os = \\\"cygwin\\\", all(target_os = \\\"horizon\\\", target_arch = \\\"arm\\\")))\": [],\n \"cfg(any(target_os = \\\"haiku\\\", target_os = \\\"redox\\\", target_os = \\\"nto\\\", target_os = \\\"aix\\\"))\": [],\n \"cfg(any(target_os = \\\"ios\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\", target_os = \\\"tvos\\\"))\": [],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"openbsd\\\", target_os = \\\"vita\\\", target_os = \\\"emscripten\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"cfg(any(unix, target_os = \\\"wasi\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:wasm32-wasip1\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(target_has_atomic = \\\"64\\\"))\": [],\n \"cfg(target_arch = \\\"spirv\\\")\": [],\n \"cfg(target_os = \\\"hermit\\\")\": [],\n \"cfg(target_os = \\\"netbsd\\\")\": [],\n \"cfg(target_os = \\\"solaris\\\")\": [],\n \"cfg(target_os = \\\"vxworks\\\")\": [],\n \"cfg(target_os = \\\"wasi\\\")\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(unix)\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(windows)\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"i686-pc-windows-gnullvm\": [],\n \"wasm32-unknown-unknown\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"wasm32-wasip1\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"x86_64-pc-windows-gnullvm\": [],\n \"x86_64-pc-windows-msvc\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"x86_64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"x86_64-unknown-nixos-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n}\n\n###############################################################################\n\ndef crate_repositories():\n \"\"\"A macro for defining repositories for all generated crates.\n\n Returns:\n A list of repos visible to the module through the module extension.\n \"\"\"\n maybe(\n http_archive,\n name = \"crates__aho-corasick-1.1.4\",\n sha256 = \"ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aho-corasick/1.1.4/download\"],\n strip_prefix = \"aho-corasick-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.aho-corasick-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__allocator-api2-0.2.21\",\n sha256 = \"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/allocator-api2/0.2.21/download\"],\n strip_prefix = \"allocator-api2-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.allocator-api2-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anes-0.1.6\",\n sha256 = \"4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anes/0.1.6/download\"],\n strip_prefix = \"anes-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.anes-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstream-1.0.0\",\n sha256 = \"824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstream/1.0.0/download\"],\n strip_prefix = \"anstream-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstream-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-1.0.14\",\n sha256 = \"940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle/1.0.14/download\"],\n strip_prefix = \"anstyle-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-parse-1.0.0\",\n sha256 = \"52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-parse/1.0.0/download\"],\n strip_prefix = \"anstyle-parse-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-parse-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-query-1.1.5\",\n sha256 = \"40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-query/1.1.5/download\"],\n strip_prefix = \"anstyle-query-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-query-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-wincon-3.0.11\",\n sha256 = \"291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-wincon/3.0.11/download\"],\n strip_prefix = \"anstyle-wincon-3.0.11\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-wincon-3.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anyhow-1.0.102\",\n sha256 = \"7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anyhow/1.0.102/download\"],\n strip_prefix = \"anyhow-1.0.102\",\n build_file = Label(\"@crates//crates:BUILD.anyhow-1.0.102.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__append-only-vec-0.1.8\",\n sha256 = \"2114736faba96bcd79595c700d03183f61357b9fbce14852515e59f3bee4ed4a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/append-only-vec/0.1.8/download\"],\n strip_prefix = \"append-only-vec-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.append-only-vec-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__approx-0.5.1\",\n sha256 = \"cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/approx/0.5.1/download\"],\n strip_prefix = \"approx-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.approx-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__assert_cmd-2.2.2\",\n sha256 = \"2aa3a22042e45de04255c7bf3626e239f450200fd0493c1e382263544b20aea6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/assert_cmd/2.2.2/download\"],\n strip_prefix = \"assert_cmd-2.2.2\",\n build_file = Label(\"@crates//crates:BUILD.assert_cmd-2.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__autocfg-1.5.0\",\n sha256 = \"c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/autocfg/1.5.0/download\"],\n strip_prefix = \"autocfg-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.autocfg-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.22.1\",\n sha256 = \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.22.1/download\"],\n strip_prefix = \"base64-0.22.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.22.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-set-0.8.0\",\n sha256 = \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-set/0.8.0/download\"],\n strip_prefix = \"bit-set-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-set-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-vec-0.8.0\",\n sha256 = \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-vec/0.8.0/download\"],\n strip_prefix = \"bit-vec-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-vec-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-1.3.2\",\n sha256 = \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/1.3.2/download\"],\n strip_prefix = \"bitflags-1.3.2\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-1.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-2.11.0\",\n sha256 = \"843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/2.11.0/download\"],\n strip_prefix = \"bitflags-2.11.0\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-2.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__borsh-1.6.1\",\n sha256 = \"cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/borsh/1.6.1/download\"],\n strip_prefix = \"borsh-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.borsh-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bs58-0.5.1\",\n sha256 = \"bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bs58/0.5.1/download\"],\n strip_prefix = \"bs58-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.bs58-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bstr-1.12.1\",\n sha256 = \"63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bstr/1.12.1/download\"],\n strip_prefix = \"bstr-1.12.1\",\n build_file = Label(\"@crates//crates:BUILD.bstr-1.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bumpalo-3.20.2\",\n sha256 = \"5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bumpalo/3.20.2/download\"],\n strip_prefix = \"bumpalo-3.20.2\",\n build_file = Label(\"@crates//crates:BUILD.bumpalo-3.20.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytes-1.11.1\",\n sha256 = \"1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytes/1.11.1/download\"],\n strip_prefix = \"bytes-1.11.1\",\n build_file = Label(\"@crates//crates:BUILD.bytes-1.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cast-0.3.0\",\n sha256 = \"37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cast/0.3.0/download\"],\n strip_prefix = \"cast-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.cast-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cc-1.2.57\",\n sha256 = \"7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cc/1.2.57/download\"],\n strip_prefix = \"cc-1.2.57\",\n build_file = Label(\"@crates//crates:BUILD.cc-1.2.57.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-if-1.0.4\",\n sha256 = \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-if/1.0.4/download\"],\n strip_prefix = \"cfg-if-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.cfg-if-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.2.1\",\n sha256 = \"613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.2.1/download\"],\n strip_prefix = \"cfg_aliases-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chrono-0.4.44\",\n sha256 = \"c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chrono/0.4.44/download\"],\n strip_prefix = \"chrono-0.4.44\",\n build_file = Label(\"@crates//crates:BUILD.chrono-0.4.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-0.2.2\",\n sha256 = \"42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium/0.2.2/download\"],\n strip_prefix = \"ciborium-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-io-0.2.2\",\n sha256 = \"05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-io/0.2.2/download\"],\n strip_prefix = \"ciborium-io-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-io-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-ll-0.2.2\",\n sha256 = \"57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-ll/0.2.2/download\"],\n strip_prefix = \"ciborium-ll-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-ll-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-4.6.1\",\n sha256 = \"1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap/4.6.1/download\"],\n strip_prefix = \"clap-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-markdown-0.1.5\",\n sha256 = \"d2a2617956a06d4885b490697b5307ebb09fec10b088afc18c81762d848c2339\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap-markdown/0.1.5/download\"],\n strip_prefix = \"clap-markdown-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.clap-markdown-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_builder-4.6.0\",\n sha256 = \"714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_builder/4.6.0/download\"],\n strip_prefix = \"clap_builder-4.6.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_builder-4.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_derive-4.6.1\",\n sha256 = \"f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_derive/4.6.1/download\"],\n strip_prefix = \"clap_derive-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap_derive-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_lex-1.1.0\",\n sha256 = \"c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_lex/1.1.0/download\"],\n strip_prefix = \"clap_lex-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_lex-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-4.4.1\",\n sha256 = \"b684e94583e85a5ca7e1a6454a89d76a5121240f2fb67eb564129d9bafdb9db0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed/4.4.1/download\"],\n strip_prefix = \"codspeed-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-4.4.1\",\n sha256 = \"2e65444156eb73ad7f57618188f8d4a281726d133ef55b96d1dcff89528609ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-walltime-4.4.1\",\n sha256 = \"96389aaa4bbb872ea4924dc0335b2bb181bcf28d6eedbe8fea29afcc5bde36a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat-walltime/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-walltime-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-walltime-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colorchoice-1.0.5\",\n sha256 = \"1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colorchoice/1.0.5/download\"],\n strip_prefix = \"colorchoice-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.colorchoice-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colored-2.2.0\",\n sha256 = \"117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colored/2.2.0/download\"],\n strip_prefix = \"colored-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.colored-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__common-path-1.0.0\",\n sha256 = \"2382f75942f4b3be3690fe4f86365e9c853c1587d6ee58212cebf6e2a9ccd101\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/common-path/1.0.0/download\"],\n strip_prefix = \"common-path-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.common-path-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__configparser-3.2.0\",\n sha256 = \"b46dec724fd22199ebde05033a0cbae453bc3b1ecff11eb6a6bb3eec4b90c6a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/configparser/3.2.0/download\"],\n strip_prefix = \"configparser-3.2.0\",\n build_file = Label(\"@crates//crates:BUILD.configparser-3.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__console_error_panic_hook-0.1.7\",\n sha256 = \"a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/console_error_panic_hook/0.1.7/download\"],\n strip_prefix = \"console_error_panic_hook-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.console_error_panic_hook-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__criterion-plot-0.5.0\",\n sha256 = \"6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/criterion-plot/0.5.0/download\"],\n strip_prefix = \"criterion-plot-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.criterion-plot-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-channel-0.5.15\",\n sha256 = \"82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-channel/0.5.15/download\"],\n strip_prefix = \"crossbeam-channel-0.5.15\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-channel-0.5.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-deque-0.8.6\",\n sha256 = \"9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-deque/0.8.6/download\"],\n strip_prefix = \"crossbeam-deque-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-deque-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-epoch-0.9.18\",\n sha256 = \"5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-epoch/0.9.18/download\"],\n strip_prefix = \"crossbeam-epoch-0.9.18\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-epoch-0.9.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-utils-0.8.21\",\n sha256 = \"d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-utils/0.8.21/download\"],\n strip_prefix = \"crossbeam-utils-0.8.21\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-utils-0.8.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crunchy-0.2.4\",\n sha256 = \"460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crunchy/0.2.4/download\"],\n strip_prefix = \"crunchy-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.crunchy-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.23.0\",\n sha256 = \"25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.23.0/download\"],\n strip_prefix = \"darling-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.23.0\",\n sha256 = \"9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.23.0/download\"],\n strip_prefix = \"darling_core-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.23.0\",\n sha256 = \"ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.23.0/download\"],\n strip_prefix = \"darling_macro-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__deranged-0.5.8\",\n sha256 = \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/deranged/0.5.8/download\"],\n strip_prefix = \"deranged-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.deranged-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__diff-0.1.13\",\n sha256 = \"56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/diff/0.1.13/download\"],\n strip_prefix = \"diff-0.1.13\",\n build_file = Label(\"@crates//crates:BUILD.diff-0.1.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__difflib-0.4.0\",\n sha256 = \"6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/difflib/0.4.0/download\"],\n strip_prefix = \"difflib-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.difflib-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dissimilar-1.0.11\",\n sha256 = \"aeda16ab4059c5fd2a83f2b9c9e9c981327b18aa8e3b313f7e6563799d4f093e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dissimilar/1.0.11/download\"],\n strip_prefix = \"dissimilar-1.0.11\",\n build_file = Label(\"@crates//crates:BUILD.dissimilar-1.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__either-1.15.0\",\n sha256 = \"48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/either/1.15.0/download\"],\n strip_prefix = \"either-1.15.0\",\n build_file = Label(\"@crates//crates:BUILD.either-1.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enum_dispatch-0.3.13\",\n sha256 = \"aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enum_dispatch/0.3.13/download\"],\n strip_prefix = \"enum_dispatch-0.3.13\",\n build_file = Label(\"@crates//crates:BUILD.enum_dispatch-0.3.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__equivalent-1.0.2\",\n sha256 = \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/equivalent/1.0.2/download\"],\n strip_prefix = \"equivalent-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.equivalent-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__errno-0.3.14\",\n sha256 = \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/errno/0.3.14/download\"],\n strip_prefix = \"errno-0.3.14\",\n build_file = Label(\"@crates//crates:BUILD.errno-0.3.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__expect-test-1.5.1\",\n sha256 = \"63af43ff4431e848fb47472a920f14fa71c24de13255a5692e93d4e90302acb0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/expect-test/1.5.1/download\"],\n strip_prefix = \"expect-test-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.expect-test-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.18.0\",\n sha256 = \"e1e1dacd0d2082dfcf1351c4bdd566bbe89a2b263235a2b50058f1e130a47277\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.18.0/download\"],\n strip_prefix = \"fancy-regex-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fastrand-2.3.0\",\n sha256 = \"37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fastrand/2.3.0/download\"],\n strip_prefix = \"fastrand-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.fastrand-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fern-0.7.1\",\n sha256 = \"4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fern/0.7.1/download\"],\n strip_prefix = \"fern-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.fern-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__find-msvc-tools-0.1.9\",\n sha256 = \"5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/find-msvc-tools/0.1.9/download\"],\n strip_prefix = \"find-msvc-tools-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.find-msvc-tools-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-uri-0.1.4\",\n sha256 = \"17c704e9dbe1ddd863da1e6ff3567795087b1eb201ce80d8fa81162e1516500d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-uri/0.1.4/download\"],\n strip_prefix = \"fluent-uri-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.fluent-uri-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.1.5\",\n sha256 = \"d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.1.5/download\"],\n strip_prefix = \"foldhash-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.2.0\",\n sha256 = \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.2.0/download\"],\n strip_prefix = \"foldhash-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.2.17\",\n sha256 = \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.2.17/download\"],\n strip_prefix = \"getrandom-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.4.2\",\n sha256 = \"0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.4.2/download\"],\n strip_prefix = \"getrandom-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__glob-0.3.3\",\n sha256 = \"0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/glob/0.3.3/download\"],\n strip_prefix = \"glob-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.glob-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__globset-0.4.18\",\n sha256 = \"52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/globset/0.4.18/download\"],\n strip_prefix = \"globset-0.4.18\",\n build_file = Label(\"@crates//crates:BUILD.globset-0.4.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__half-2.7.1\",\n sha256 = \"6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/half/2.7.1/download\"],\n strip_prefix = \"half-2.7.1\",\n build_file = Label(\"@crates//crates:BUILD.half-2.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.15.5\",\n sha256 = \"9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.15.5/download\"],\n strip_prefix = \"hashbrown-0.15.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.15.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.17.1\",\n sha256 = \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.17.1/download\"],\n strip_prefix = \"hashbrown-0.17.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.17.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heck-0.5.0\",\n sha256 = \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heck/0.5.0/download\"],\n strip_prefix = \"heck-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.heck-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hermit-abi-0.5.2\",\n sha256 = \"fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hermit-abi/0.5.2/download\"],\n strip_prefix = \"hermit-abi-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.hermit-abi-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hex-0.4.3\",\n sha256 = \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hex/0.4.3/download\"],\n strip_prefix = \"hex-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.hex-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__id-arena-2.3.0\",\n sha256 = \"3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/id-arena/2.3.0/download\"],\n strip_prefix = \"id-arena-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.id-arena-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ident_case-1.0.1\",\n sha256 = \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ident_case/1.0.1/download\"],\n strip_prefix = \"ident_case-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.ident_case-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ignore-0.4.27\",\n sha256 = \"fe112b004901c62c2faa11f4f75e9864e0cc5af8da71c9115d184a3aa888749f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ignore/0.4.27/download\"],\n strip_prefix = \"ignore-0.4.27\",\n build_file = Label(\"@crates//crates:BUILD.ignore-0.4.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indexmap-2.14.0\",\n sha256 = \"d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indexmap/2.14.0/download\"],\n strip_prefix = \"indexmap-2.14.0\",\n build_file = Label(\"@crates//crates:BUILD.indexmap-2.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is-terminal-0.4.17\",\n sha256 = \"3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is-terminal/0.4.17/download\"],\n strip_prefix = \"is-terminal-0.4.17\",\n build_file = Label(\"@crates//crates:BUILD.is-terminal-0.4.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is_terminal_polyfill-1.70.2\",\n sha256 = \"a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is_terminal_polyfill/1.70.2/download\"],\n strip_prefix = \"is_terminal_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.is_terminal_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.10.5\",\n sha256 = \"b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.10.5/download\"],\n strip_prefix = \"itertools-0.10.5\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.10.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.15.0\",\n sha256 = \"8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.15.0/download\"],\n strip_prefix = \"itertools-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itoa-1.0.17\",\n sha256 = \"92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itoa/1.0.17/download\"],\n strip_prefix = \"itoa-1.0.17\",\n build_file = Label(\"@crates//crates:BUILD.itoa-1.0.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__js-sys-0.3.82\",\n sha256 = \"b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/js-sys/0.3.82/download\"],\n strip_prefix = \"js-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.js-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-3.6.0\",\n sha256 = \"6bae91019476d3ec7147de9aa291cadb6d870abf2f3015d2da73a90325ac1496\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex/3.6.0/download\"],\n strip_prefix = \"lazy-regex-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-proc_macros-3.6.0\",\n sha256 = \"4de9c1e1439d8b7b3061b2d209809f447ca33241733d9a3c01eabf2dc8d94358\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex-proc_macros/3.6.0/download\"],\n strip_prefix = \"lazy-regex-proc_macros-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-proc_macros-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy_static-1.5.0\",\n sha256 = \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy_static/1.5.0/download\"],\n strip_prefix = \"lazy_static-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy_static-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__leb128fmt-0.1.0\",\n sha256 = \"09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/leb128fmt/0.1.0/download\"],\n strip_prefix = \"leb128fmt-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.leb128fmt-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libc-0.2.183\",\n sha256 = \"b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libc/0.2.183/download\"],\n strip_prefix = \"libc-0.2.183\",\n build_file = Label(\"@crates//crates:BUILD.libc-0.2.183.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libmimalloc-sys-0.1.49\",\n sha256 = \"6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libmimalloc-sys/0.1.49/download\"],\n strip_prefix = \"libmimalloc-sys-0.1.49\",\n build_file = Label(\"@crates//crates:BUILD.libmimalloc-sys-0.1.49.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__line-index-0.1.2\",\n sha256 = \"3e27e0ed5a392a7f5ba0b3808a2afccff16c64933312c84b57618b49d1209bd2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/line-index/0.1.2/download\"],\n strip_prefix = \"line-index-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.line-index-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.12.1\",\n sha256 = \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.12.1/download\"],\n strip_prefix = \"linux-raw-sys-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__log-0.4.33\",\n sha256 = \"0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/log/0.4.33/download\"],\n strip_prefix = \"log-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.log-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-server-0.8.0\",\n sha256 = \"0ad8be6fe0ca81b8298bfbbe8a77e9fcd8895ad6c84cd7794d5ebadcbb09ae43\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-server/0.8.0/download\"],\n strip_prefix = \"lsp-server-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-server-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-types-0.97.0\",\n sha256 = \"53353550a17c04ac46c585feb189c2db82154fc84b79c7a66c96c2c644f66071\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-types/0.97.0/download\"],\n strip_prefix = \"lsp-types-0.97.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-types-0.97.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memchr-2.8.0\",\n sha256 = \"f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memchr/2.8.0/download\"],\n strip_prefix = \"memchr-2.8.0\",\n build_file = Label(\"@crates//crates:BUILD.memchr-2.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memo-map-0.3.3\",\n sha256 = \"38d1115007560874e373613744c6fba374c17688327a71c1476d1a5954cc857b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memo-map/0.3.3/download\"],\n strip_prefix = \"memo-map-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.memo-map-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__mimalloc-0.1.52\",\n sha256 = \"2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/mimalloc/0.1.52/download\"],\n strip_prefix = \"mimalloc-0.1.52\",\n build_file = Label(\"@crates//crates:BUILD.mimalloc-0.1.52.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__minijinja-2.21.0\",\n sha256 = \"cb3d648e68cea56d9858d535ee28f9538404e2dd8cb08ed0bd05dca379477f39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/minijinja/2.21.0/download\"],\n strip_prefix = \"minijinja-2.21.0\",\n build_file = Label(\"@crates//crates:BUILD.minijinja-2.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.31.2\",\n sha256 = \"5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.31.2/download\"],\n strip_prefix = \"nix-0.31.2\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.31.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nohash-hasher-0.2.0\",\n sha256 = \"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nohash-hasher/0.2.0/download\"],\n strip_prefix = \"nohash-hasher-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.nohash-hasher-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-conv-0.2.0\",\n sha256 = \"cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-conv/0.2.0/download\"],\n strip_prefix = \"num-conv-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.num-conv-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-traits-0.2.19\",\n sha256 = \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-traits/0.2.19/download\"],\n strip_prefix = \"num-traits-0.2.19\",\n build_file = Label(\"@crates//crates:BUILD.num-traits-0.2.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell-1.21.4\",\n sha256 = \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell/1.21.4/download\"],\n strip_prefix = \"once_cell-1.21.4\",\n build_file = Label(\"@crates//crates:BUILD.once_cell-1.21.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell_polyfill-1.70.2\",\n sha256 = \"384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell_polyfill/1.70.2/download\"],\n strip_prefix = \"once_cell_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.once_cell_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__oorandom-11.1.5\",\n sha256 = \"d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/oorandom/11.1.5/download\"],\n strip_prefix = \"oorandom-11.1.5\",\n build_file = Label(\"@crates//crates:BUILD.oorandom-11.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-0.3.7\",\n sha256 = \"5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters/0.3.7/download\"],\n strip_prefix = \"plotters-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-backend-0.3.7\",\n sha256 = \"df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-backend/0.3.7/download\"],\n strip_prefix = \"plotters-backend-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-backend-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-svg-0.3.7\",\n sha256 = \"51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-svg/0.3.7/download\"],\n strip_prefix = \"plotters-svg-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-svg-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-1.13.1\",\n sha256 = \"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic/1.13.1/download\"],\n strip_prefix = \"portable-atomic-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__powerfmt-0.2.0\",\n sha256 = \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/powerfmt/0.2.0/download\"],\n strip_prefix = \"powerfmt-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.powerfmt-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-3.1.4\",\n sha256 = \"ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates/3.1.4/download\"],\n strip_prefix = \"predicates-3.1.4\",\n build_file = Label(\"@crates//crates:BUILD.predicates-3.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-core-1.0.10\",\n sha256 = \"cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-core/1.0.10/download\"],\n strip_prefix = \"predicates-core-1.0.10\",\n build_file = Label(\"@crates//crates:BUILD.predicates-core-1.0.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-tree-1.0.13\",\n sha256 = \"d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-tree/1.0.13/download\"],\n strip_prefix = \"predicates-tree-1.0.13\",\n build_file = Label(\"@crates//crates:BUILD.predicates-tree-1.0.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pretty_assertions-1.4.1\",\n sha256 = \"3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pretty_assertions/1.4.1/download\"],\n strip_prefix = \"pretty_assertions-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.pretty_assertions-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prettyplease-0.2.37\",\n sha256 = \"479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prettyplease/0.2.37/download\"],\n strip_prefix = \"prettyplease-0.2.37\",\n build_file = Label(\"@crates//crates:BUILD.prettyplease-0.2.37.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro2-1.0.106\",\n sha256 = \"8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro2/1.0.106/download\"],\n strip_prefix = \"proc-macro2-1.0.106\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro2-1.0.106.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-0.29.0\",\n sha256 = \"cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3/0.29.0/download\"],\n strip_prefix = \"pyo3-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-build-config-0.29.0\",\n sha256 = \"c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-build-config/0.29.0/download\"],\n strip_prefix = \"pyo3-build-config-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-build-config-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-ffi-0.29.0\",\n sha256 = \"ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-ffi/0.29.0/download\"],\n strip_prefix = \"pyo3-ffi-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-ffi-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-0.29.0\",\n sha256 = \"9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-backend-0.29.0\",\n sha256 = \"4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros-backend/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-backend-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-backend-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quote-1.0.45\",\n sha256 = \"41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quote/1.0.45/download\"],\n strip_prefix = \"quote-1.0.45\",\n build_file = Label(\"@crates//crates:BUILD.quote-1.0.45.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-6.0.0\",\n sha256 = \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/6.0.0/download\"],\n strip_prefix = \"r-efi-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-1.12.0\",\n sha256 = \"fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon/1.12.0/download\"],\n strip_prefix = \"rayon-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-core-1.13.0\",\n sha256 = \"22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon-core/1.13.0/download\"],\n strip_prefix = \"rayon-core-1.13.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-core-1.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-1.12.4\",\n sha256 = \"f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex/1.12.4/download\"],\n strip_prefix = \"regex-1.12.4\",\n build_file = Label(\"@crates//crates:BUILD.regex-1.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-automata-0.4.14\",\n sha256 = \"6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-automata/0.4.14/download\"],\n strip_prefix = \"regex-automata-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.regex-automata-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-syntax-0.8.11\",\n sha256 = \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-syntax/0.8.11/download\"],\n strip_prefix = \"regex-syntax-0.8.11\",\n build_file = Label(\"@crates//crates:BUILD.regex-syntax-0.8.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-1.1.4\",\n sha256 = \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/1.1.4/download\"],\n strip_prefix = \"rustix-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.rustix-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustversion-1.0.22\",\n sha256 = \"b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustversion/1.0.22/download\"],\n strip_prefix = \"rustversion-1.0.22\",\n build_file = Label(\"@crates//crates:BUILD.rustversion-1.0.22.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ryu-1.0.23\",\n sha256 = \"9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ryu/1.0.23/download\"],\n strip_prefix = \"ryu-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.ryu-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__same-file-1.0.6\",\n sha256 = \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/same-file/1.0.6/download\"],\n strip_prefix = \"same-file-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.same-file-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__semver-1.0.27\",\n sha256 = \"d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/semver/1.0.27/download\"],\n strip_prefix = \"semver-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.semver-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-1.0.228\",\n sha256 = \"9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde/1.0.228/download\"],\n strip_prefix = \"serde-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-wasm-bindgen-0.6.5\",\n sha256 = \"8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde-wasm-bindgen/0.6.5/download\"],\n strip_prefix = \"serde-wasm-bindgen-0.6.5\",\n build_file = Label(\"@crates//crates:BUILD.serde-wasm-bindgen-0.6.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_core-1.0.228\",\n sha256 = \"41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_core/1.0.228/download\"],\n strip_prefix = \"serde_core-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_core-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_derive-1.0.228\",\n sha256 = \"d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_derive/1.0.228/download\"],\n strip_prefix = \"serde_derive-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_derive-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_json-1.0.150\",\n sha256 = \"e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_json/1.0.150/download\"],\n strip_prefix = \"serde_json-1.0.150\",\n build_file = Label(\"@crates//crates:BUILD.serde_json-1.0.150.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_repr-0.1.20\",\n sha256 = \"175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_repr/0.1.20/download\"],\n strip_prefix = \"serde_repr-0.1.20\",\n build_file = Label(\"@crates//crates:BUILD.serde_repr-0.1.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_spanned-1.1.1\",\n sha256 = \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_spanned/1.1.1/download\"],\n strip_prefix = \"serde_spanned-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.serde_spanned-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with-3.21.0\",\n sha256 = \"76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with/3.21.0/download\"],\n strip_prefix = \"serde_with-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with_macros-3.21.0\",\n sha256 = \"84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with_macros/3.21.0/download\"],\n strip_prefix = \"serde_with_macros-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with_macros-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_yaml-0.9.34-deprecated\",\n sha256 = \"6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_yaml/0.9.34+deprecated/download\"],\n strip_prefix = \"serde_yaml-0.9.34+deprecated\",\n build_file = Label(\"@crates//crates:BUILD.serde_yaml-0.9.34+deprecated.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-1.3.0\",\n sha256 = \"0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/1.3.0/download\"],\n strip_prefix = \"shlex-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.shlex-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smol_str-0.3.6\",\n sha256 = \"4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smol_str/0.3.6/download\"],\n strip_prefix = \"smol_str-0.3.6\",\n build_file = Label(\"@crates//crates:BUILD.smol_str-0.3.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__statrs-0.18.0\",\n sha256 = \"2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/statrs/0.18.0/download\"],\n strip_prefix = \"statrs-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.statrs-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strsim-0.11.1\",\n sha256 = \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strsim/0.11.1/download\"],\n strip_prefix = \"strsim-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.strsim-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum-0.28.0\",\n sha256 = \"9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum/0.28.0/download\"],\n strip_prefix = \"strum-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum_macros-0.28.0\",\n sha256 = \"ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum_macros/0.28.0/download\"],\n strip_prefix = \"strum_macros-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum_macros-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-2.0.117\",\n sha256 = \"e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/2.0.117/download\"],\n strip_prefix = \"syn-2.0.117\",\n build_file = Label(\"@crates//crates:BUILD.syn-2.0.117.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__target-lexicon-0.13.5\",\n sha256 = \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/target-lexicon/0.13.5/download\"],\n strip_prefix = \"target-lexicon-0.13.5\",\n build_file = Label(\"@crates//crates:BUILD.target-lexicon-0.13.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tempfile-3.27.0\",\n sha256 = \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tempfile/3.27.0/download\"],\n strip_prefix = \"tempfile-3.27.0\",\n build_file = Label(\"@crates//crates:BUILD.tempfile-3.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__termtree-0.5.1\",\n sha256 = \"8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/termtree/0.5.1/download\"],\n strip_prefix = \"termtree-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.termtree-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__text-size-1.1.1\",\n sha256 = \"f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/text-size/1.1.1/download\"],\n strip_prefix = \"text-size-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.text-size-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-2.0.18\",\n sha256 = \"4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/2.0.18/download\"],\n strip_prefix = \"thiserror-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-2.0.18\",\n sha256 = \"ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/2.0.18/download\"],\n strip_prefix = \"thiserror-impl-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-0.3.47\",\n sha256 = \"743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time/0.3.47/download\"],\n strip_prefix = \"time-0.3.47\",\n build_file = Label(\"@crates//crates:BUILD.time-0.3.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-core-0.1.8\",\n sha256 = \"7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-core/0.1.8/download\"],\n strip_prefix = \"time-core-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.time-core-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinytemplate-1.2.1\",\n sha256 = \"be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinytemplate/1.2.1/download\"],\n strip_prefix = \"tinytemplate-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.tinytemplate-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec-1.11.0\",\n sha256 = \"3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec/1.11.0/download\"],\n strip_prefix = \"tinyvec-1.11.0\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec-1.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec_macros-0.1.1\",\n sha256 = \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec_macros/0.1.1/download\"],\n strip_prefix = \"tinyvec_macros-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec_macros-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml-0.9.12-spec-1.1.0\",\n sha256 = \"cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml/0.9.12+spec-1.1.0/download\"],\n strip_prefix = \"toml-0.9.12+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml-0.9.12+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_datetime-0.7.5-spec-1.1.0\",\n sha256 = \"92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_datetime/0.7.5+spec-1.1.0/download\"],\n strip_prefix = \"toml_datetime-0.7.5+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_datetime-0.7.5+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_parser-1.1.2-spec-1.1.0\",\n sha256 = \"a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_parser/1.1.2+spec-1.1.0/download\"],\n strip_prefix = \"toml_parser-1.1.2+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_parser-1.1.2+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_writer-1.1.1-spec-1.1.0\",\n sha256 = \"756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_writer/1.1.1+spec-1.1.0/download\"],\n strip_prefix = \"toml_writer-1.1.1+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_writer-1.1.1+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-ident-1.0.24\",\n sha256 = \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-ident/1.0.24/download\"],\n strip_prefix = \"unicode-ident-1.0.24\",\n build_file = Label(\"@crates//crates:BUILD.unicode-ident-1.0.24.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-xid-0.2.6\",\n sha256 = \"ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-xid/0.2.6/download\"],\n strip_prefix = \"unicode-xid-0.2.6\",\n build_file = Label(\"@crates//crates:BUILD.unicode-xid-0.2.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unsafe-libyaml-0.2.11\",\n sha256 = \"673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unsafe-libyaml/0.2.11/download\"],\n strip_prefix = \"unsafe-libyaml-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.unsafe-libyaml-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8parse-0.2.2\",\n sha256 = \"06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8parse/0.2.2/download\"],\n strip_prefix = \"utf8parse-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.utf8parse-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wait-timeout-0.2.1\",\n sha256 = \"09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wait-timeout/0.2.1/download\"],\n strip_prefix = \"wait-timeout-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.wait-timeout-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__walkdir-2.5.0\",\n sha256 = \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/walkdir/2.5.0/download\"],\n strip_prefix = \"walkdir-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.walkdir-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.11.1-wasi-snapshot-preview1\",\n sha256 = \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.11.1+wasi-snapshot-preview1/download\"],\n strip_prefix = \"wasi-0.11.1+wasi-snapshot-preview1\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.11.1+wasi-snapshot-preview1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip2-1.0.2-wasi-0.2.9\",\n sha256 = \"9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip2/1.0.2+wasi-0.2.9/download\"],\n strip_prefix = \"wasip2-1.0.2+wasi-0.2.9\",\n build_file = Label(\"@crates//crates:BUILD.wasip2-1.0.2+wasi-0.2.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip3-0.4.0-wasi-0.3.0-rc-2026-01-06\",\n sha256 = \"5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip3/0.4.0+wasi-0.3.0-rc-2026-01-06/download\"],\n strip_prefix = \"wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06\",\n build_file = Label(\"@crates//crates:BUILD.wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-0.2.105\",\n sha256 = \"da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-0.2.105\",\n sha256 = \"04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-support-0.2.105\",\n sha256 = \"420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro-support/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-support-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-support-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-shared-0.2.105\",\n sha256 = \"76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-shared/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-shared-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-shared-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-encoder-0.244.0\",\n sha256 = \"990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-encoder/0.244.0/download\"],\n strip_prefix = \"wasm-encoder-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-encoder-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-metadata-0.244.0\",\n sha256 = \"bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-metadata/0.244.0/download\"],\n strip_prefix = \"wasm-metadata-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-metadata-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasmparser-0.244.0\",\n sha256 = \"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasmparser/0.244.0/download\"],\n strip_prefix = \"wasmparser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasmparser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-sys-0.3.82\",\n sha256 = \"3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-sys/0.3.82/download\"],\n strip_prefix = \"web-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.web-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-util-0.1.11\",\n sha256 = \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-util/0.1.11/download\"],\n strip_prefix = \"winapi-util-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.winapi-util-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.2.1\",\n sha256 = \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.2.1/download\"],\n strip_prefix = \"windows-link-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.59.0\",\n sha256 = \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.59.0/download\"],\n strip_prefix = \"windows-sys-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.61.2\",\n sha256 = \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.61.2/download\"],\n strip_prefix = \"windows-sys-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.52.6\",\n sha256 = \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.52.6/download\"],\n strip_prefix = \"windows-targets-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.52.6\",\n sha256 = \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.52.6\",\n sha256 = \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.52.6\",\n sha256 = \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.52.6\",\n sha256 = \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.52.6\",\n sha256 = \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.52.6/download\"],\n strip_prefix = \"windows_i686_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.52.6\",\n sha256 = \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.52.6\",\n sha256 = \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.52.6\",\n sha256 = \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-0.7.15\",\n sha256 = \"df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/0.7.15/download\"],\n strip_prefix = \"winnow-0.7.15\",\n build_file = Label(\"@crates//crates:BUILD.winnow-0.7.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-1.0.3\",\n sha256 = \"0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/1.0.3/download\"],\n strip_prefix = \"winnow-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.winnow-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-0.51.0\",\n sha256 = \"d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-core-0.51.0\",\n sha256 = \"ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-core/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-core-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-core-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-0.51.0\",\n sha256 = \"b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-macro-0.51.0\",\n sha256 = \"0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust-macro/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-macro-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-macro-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-component-0.244.0\",\n sha256 = \"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-component/0.244.0/download\"],\n strip_prefix = \"wit-component-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-component-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-parser-0.244.0\",\n sha256 = \"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-parser/0.244.0/download\"],\n strip_prefix = \"wit-parser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-parser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yansi-1.0.1\",\n sha256 = \"cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yansi/1.0.1/download\"],\n strip_prefix = \"yansi-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.yansi-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-0.8.46\",\n sha256 = \"5c5030500cb2d66bdfbb4ebc9563be6ce7005a4b5d0f26be0c523870fe372ca6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy/0.8.46/download\"],\n strip_prefix = \"zerocopy-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-derive-0.8.46\",\n sha256 = \"a5f86989a046a79640b9d8867c823349a139367bda96549794fcc3313ce91f4e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy-derive/0.8.46/download\"],\n strip_prefix = \"zerocopy-derive-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-derive-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zmij-1.0.21\",\n sha256 = \"b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zmij/1.0.21/download\"],\n strip_prefix = \"zmij-1.0.21\",\n build_file = Label(\"@crates//crates:BUILD.zmij-1.0.21.bazel\"),\n )\n\n return [\n struct(repo=\"crates__anstyle-1.0.14\", is_dev_dep = False),\n struct(repo=\"crates__append-only-vec-0.1.8\", is_dev_dep = False),\n struct(repo=\"crates__clap-4.6.1\", is_dev_dep = False),\n struct(repo=\"crates__common-path-1.0.0\", is_dev_dep = False),\n struct(repo=\"crates__configparser-3.2.0\", is_dev_dep = False),\n struct(repo=\"crates__console_error_panic_hook-0.1.7\", is_dev_dep = False),\n struct(repo=\"crates__enum_dispatch-0.3.13\", is_dev_dep = False),\n struct(repo=\"crates__fancy-regex-0.18.0\", is_dev_dep = False),\n struct(repo=\"crates__fern-0.7.1\", is_dev_dep = False),\n struct(repo=\"crates__getrandom-0.2.17\", is_dev_dep = False),\n struct(repo=\"crates__hashbrown-0.17.1\", is_dev_dep = False),\n struct(repo=\"crates__ignore-0.4.27\", is_dev_dep = False),\n struct(repo=\"crates__indexmap-2.14.0\", is_dev_dep = False),\n struct(repo=\"crates__itertools-0.15.0\", is_dev_dep = False),\n struct(repo=\"crates__js-sys-0.3.82\", is_dev_dep = False),\n struct(repo=\"crates__lazy-regex-3.6.0\", is_dev_dep = False),\n struct(repo=\"crates__line-index-0.1.2\", is_dev_dep = False),\n struct(repo=\"crates__log-0.4.33\", is_dev_dep = False),\n struct(repo=\"crates__lsp-server-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__lsp-types-0.97.0\", is_dev_dep = False),\n struct(repo=\"crates__mimalloc-0.1.52\", is_dev_dep = False),\n struct(repo=\"crates__nohash-hasher-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__pretty_assertions-1.4.1\", is_dev_dep = False),\n struct(repo=\"crates__pyo3-0.29.0\", is_dev_dep = False),\n struct(repo=\"crates__rayon-1.12.0\", is_dev_dep = False),\n struct(repo=\"crates__regex-1.12.4\", is_dev_dep = False),\n struct(repo=\"crates__regex-automata-0.4.14\", is_dev_dep = False),\n struct(repo=\"crates__serde-1.0.228\", is_dev_dep = False),\n struct(repo=\"crates__serde-wasm-bindgen-0.6.5\", is_dev_dep = False),\n struct(repo=\"crates__serde_json-1.0.150\", is_dev_dep = False),\n struct(repo=\"crates__serde_yaml-0.9.34-deprecated\", is_dev_dep = False),\n struct(repo=\"crates__smol_str-0.3.6\", is_dev_dep = False),\n struct(repo=\"crates__strum-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__strum_macros-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__thiserror-2.0.18\", is_dev_dep = False),\n struct(repo=\"crates__toml-0.9.12-spec-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__walkdir-2.5.0\", is_dev_dep = False),\n struct(repo=\"crates__wasm-bindgen-0.2.105\", is_dev_dep = False),\n struct(repo = \"crates__assert_cmd-2.2.2\", is_dev_dep = True),\n struct(repo = \"crates__clap-markdown-0.1.5\", is_dev_dep = True),\n struct(repo = \"crates__codspeed-criterion-compat-4.4.1\", is_dev_dep = True),\n struct(repo = \"crates__expect-test-1.5.1\", is_dev_dep = True),\n struct(repo = \"crates__glob-0.3.3\", is_dev_dep = True),\n struct(repo = \"crates__minijinja-2.21.0\", is_dev_dep = True),\n struct(repo = \"crates__serde_with-3.21.0\", is_dev_dep = True),\n struct(repo = \"crates__tempfile-3.27.0\", is_dev_dep = True),\n ]\n" + "defs.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\"\"\"\n# `crates_repository` API\n\n- [aliases](#aliases)\n- [crate_deps](#crate_deps)\n- [all_crate_deps](#all_crate_deps)\n- [crate_repositories](#crate_repositories)\n\n\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\", \"new_git_repository\")\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:utils.bzl\", \"maybe\")\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\nload(\"@rules_rust//crate_universe/private:local_crate_mirror.bzl\", \"local_crate_mirror\")\n\n###############################################################################\n# MACROS API\n###############################################################################\n\n# An identifier that represent common dependencies (unconditional).\n_COMMON_CONDITION = \"\"\n\ndef _flatten_dependency_maps(all_dependency_maps):\n \"\"\"Flatten a list of dependency maps into one dictionary.\n\n Dependency maps have the following structure:\n\n ```python\n DEPENDENCIES_MAP = {\n # The first key in the map is a Bazel package\n # name of the workspace this file is defined in.\n \"workspace_member_package\": {\n\n # Not all dependencies are supported for all platforms.\n # the condition key is the condition required to be true\n # on the host platform.\n \"condition\": {\n\n # An alias to a crate target. # The label of the crate target the\n # Aliases are only crate names. # package name refers to.\n \"package_name\": \"@full//:label\",\n }\n }\n }\n ```\n\n Args:\n all_dependency_maps (list): A list of dicts as described above\n\n Returns:\n dict: A dictionary as described above\n \"\"\"\n dependencies = {}\n\n for workspace_deps_map in all_dependency_maps:\n for pkg_name, conditional_deps_map in workspace_deps_map.items():\n if pkg_name not in dependencies:\n non_frozen_map = dict()\n for key, values in conditional_deps_map.items():\n non_frozen_map.update({key: dict(values.items())})\n dependencies.setdefault(pkg_name, non_frozen_map)\n continue\n\n for condition, deps_map in conditional_deps_map.items():\n # If the condition has not been recorded, do so and continue\n if condition not in dependencies[pkg_name]:\n dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))\n continue\n\n # Alert on any miss-matched dependencies\n inconsistent_entries = []\n for crate_name, crate_label in deps_map.items():\n existing = dependencies[pkg_name][condition].get(crate_name)\n if existing and existing != crate_label:\n inconsistent_entries.append((crate_name, existing, crate_label))\n dependencies[pkg_name][condition].update({crate_name: crate_label})\n\n return dependencies\n\ndef crate_deps(deps, package_name = None):\n \"\"\"Finds the fully qualified label of the requested crates for the package where this macro is called.\n\n Args:\n deps (list): The desired list of crate targets.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()`.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if not deps:\n return []\n\n if package_name == None:\n package_name = native.package_name()\n\n # Join both sets of dependencies\n dependencies = _flatten_dependency_maps([\n _NORMAL_DEPENDENCIES,\n _NORMAL_DEV_DEPENDENCIES,\n _PROC_MACRO_DEPENDENCIES,\n _PROC_MACRO_DEV_DEPENDENCIES,\n _BUILD_DEPENDENCIES,\n _BUILD_PROC_MACRO_DEPENDENCIES,\n ]).pop(package_name, {})\n\n # Combine all conditional packages so we can easily index over a flat list\n # TODO: Perhaps this should actually return select statements and maintain\n # the conditionals of the dependencies\n flat_deps = {}\n for deps_set in dependencies.values():\n for crate_name, crate_label in deps_set.items():\n flat_deps.update({crate_name: crate_label})\n\n missing_crates = []\n crate_targets = []\n for crate_target in deps:\n if crate_target not in flat_deps:\n missing_crates.append(crate_target)\n else:\n crate_targets.append(flat_deps[crate_target])\n\n if missing_crates:\n fail(\"Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`\".format(\n missing_crates,\n package_name,\n dependencies,\n ))\n\n return crate_targets\n\ndef all_crate_deps(\n normal = False, \n normal_dev = False, \n proc_macro = False, \n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Finds the fully qualified label of all requested direct crate dependencies \\\n for the package where this macro is called.\n\n If no parameters are set, all normal dependencies are returned. Setting any one flag will\n otherwise impact the contents of the returned list.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_dependency_maps = []\n if normal:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n if normal_dev:\n all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)\n if proc_macro:\n all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)\n if proc_macro_dev:\n all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)\n if build:\n all_dependency_maps.append(_BUILD_DEPENDENCIES)\n if build_proc_macro:\n all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)\n\n # Default to always using normal dependencies\n if not all_dependency_maps:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n\n dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)\n\n if not dependencies:\n if dependencies == None:\n fail(\"Tried to get all_crate_deps for package \" + package_name + \" but that package had no Cargo.toml file\")\n else:\n return []\n\n crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())\n for condition, deps in dependencies.items():\n crate_deps += selects.with_or({\n tuple(_CONDITIONS[condition]): deps.values(),\n \"//conditions:default\": [],\n })\n\n return crate_deps\n\ndef aliases(\n normal = False,\n normal_dev = False,\n proc_macro = False,\n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Produces a map of Crate alias names to their original label\n\n If no dependency kinds are specified, `normal` and `proc_macro` are used by default.\n Setting any one flag will otherwise determine the contents of the returned dict.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n dict: The aliases of all associated packages\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_aliases_maps = []\n if normal:\n all_aliases_maps.append(_NORMAL_ALIASES)\n if normal_dev:\n all_aliases_maps.append(_NORMAL_DEV_ALIASES)\n if proc_macro:\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n if proc_macro_dev:\n all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)\n if build:\n all_aliases_maps.append(_BUILD_ALIASES)\n if build_proc_macro:\n all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)\n\n # Default to always using normal aliases\n if not all_aliases_maps:\n all_aliases_maps.append(_NORMAL_ALIASES)\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n\n aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)\n\n if not aliases:\n return dict()\n\n common_items = aliases.pop(_COMMON_CONDITION, {}).items()\n\n # If there are only common items in the dictionary, immediately return them\n if not len(aliases.keys()) == 1:\n return dict(common_items)\n\n # Build a single select statement where each conditional has accounted for the\n # common set of aliases.\n crate_aliases = {\"//conditions:default\": dict(common_items)}\n for condition, deps in aliases.items():\n condition_triples = _CONDITIONS[condition]\n for triple in condition_triples:\n if triple in crate_aliases:\n crate_aliases[triple].update(deps)\n else:\n crate_aliases.update({triple: dict(deps.items() + common_items)})\n\n return select(crate_aliases)\n\n###############################################################################\n# WORKSPACE MEMBER DEPS AND ALIASES\n###############################################################################\n\n_NORMAL_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"append-only-vec\": Label(\"@crates//:append-only-vec-0.1.8\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n \"mimalloc\": Label(\"@crates//:mimalloc-0.1.52\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"anstyle\": Label(\"@crates//:anstyle-1.0.14\"),\n \"clap\": Label(\"@crates//:clap-4.6.1\"),\n \"fern\": Label(\"@crates//:fern-0.7.1\"),\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"common-path\": Label(\"@crates//:common-path-1.0.0\"),\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"lazy-regex\": Label(\"@crates//:lazy-regex-3.6.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"pyo3\": Label(\"@crates//:pyo3-0.29.0\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n \"regex\": Label(\"@crates//:regex-1.12.4\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"toml\": Label(\"@crates//:toml-0.9.12+spec-1.1.0\"),\n \"walkdir\": Label(\"@crates//:walkdir-2.5.0\"),\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n \"getrandom\": Label(\"@crates//:getrandom-0.2.17\"),\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"indexmap\": Label(\"@crates//:indexmap-2.14.0\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"log\": Label(\"@crates//:log-0.4.33\"),\n \"nohash-hasher\": Label(\"@crates//:nohash-hasher-0.2.0\"),\n \"pretty_assertions\": Label(\"@crates//:pretty_assertions-1.4.1\"),\n \"regex-automata\": Label(\"@crates//:regex-automata-0.4.14\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"smol_str\": Label(\"@crates//:smol_str-0.3.6\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n \"thiserror\": Label(\"@crates//:thiserror-2.0.18\"),\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"itertools\": Label(\"@crates//:itertools-0.15.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n \"console_error_panic_hook\": Label(\"@crates//:console_error_panic_hook-0.1.7\"),\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n \"ignore\": Label(\"@crates//:ignore-0.4.27\"),\n \"js-sys\": Label(\"@crates//:js-sys-0.3.82\"),\n \"lsp-server\": Label(\"@crates//:lsp-server-0.8.0\"),\n \"lsp-types\": Label(\"@crates//:lsp-types-0.97.0\"),\n \"serde-wasm-bindgen\": Label(\"@crates//:serde-wasm-bindgen-0.6.5\"),\n \"serde_json\": Label(\"@crates//:serde_json-1.0.150\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n \"hashbrown\": Label(\"@crates//:hashbrown-0.17.1\"),\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n \"line-index\": Label(\"@crates//:line-index-0.1.2\"),\n \"serde\": Label(\"@crates//:serde-1.0.228\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n \"wasm-bindgen\": Label(\"@crates//:wasm-bindgen-0.2.105\"),\n },\n },\n}\n\n\n_NORMAL_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n \"x86_64-pc-windows-msvc\": {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n },\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": {\n },\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": {\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/sqlinference\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib-wasm\": {\n _COMMON_CONDITION: {\n },\n },\n}\n\n\n_NORMAL_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n \"strum\": Label(\"@crates//:strum-0.28.0\"),\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"clap-markdown\": Label(\"@crates//:clap-markdown-0.1.5\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"fancy-regex\": Label(\"@crates//:fancy-regex-0.18.0\"),\n \"minijinja\": Label(\"@crates//:minijinja-2.21.0\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n \"assert_cmd\": Label(\"@crates//:assert_cmd-2.2.2\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"tempfile\": Label(\"@crates//:tempfile-3.27.0\"),\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"criterion\": Label(\"@crates//:codspeed-criterion-compat-4.4.1\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"serde_with\": Label(\"@crates//:serde_with-3.21.0\"),\n \"serde_yaml\": Label(\"@crates//:serde_yaml-0.9.34+deprecated\"),\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n \"configparser\": Label(\"@crates//:configparser-3.2.0\"),\n \"expect-test\": Label(\"@crates//:expect-test-1.5.1\"),\n \"glob\": Label(\"@crates//:glob-0.3.3\"),\n \"rayon\": Label(\"@crates//:rayon-1.12.0\"),\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_NORMAL_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-core\": {\n _COMMON_CONDITION: {\n \"enum_dispatch\": Label(\"@crates//:enum_dispatch-0.3.13\"),\n \"strum_macros\": Label(\"@crates//:strum_macros-0.28.0\"),\n },\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_PROC_MACRO_DEV_ALIASES = {\n \"crates/lineage\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-lib\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/cli-python\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lib\": {\n _COMMON_CONDITION: {\n Label(\"@crates//:codspeed-criterion-compat-4.4.1\"): \"criterion\",\n },\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_DEPENDENCIES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_ALIASES = {\n \"crates/lineage\": {\n },\n \"crates/cli\": {\n },\n \"crates/cli-lib\": {\n },\n \"crates/cli-python\": {\n },\n \"crates/lib\": {\n },\n \"crates/lib-core\": {\n },\n \"crates/lib-dialects\": {\n },\n \"crates/lsp\": {\n },\n \"crates/sqlinference\": {\n },\n \"crates/lib-wasm\": {\n },\n}\n\n\n_CONDITIONS = {\n \"aarch64-apple-darwin\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"aarch64-pc-windows-gnullvm\": [],\n \"aarch64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\"],\n \"cfg(all(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\"), target_os = \\\"unknown\\\"))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(any(target_arch = \\\"x86_64\\\", target_arch = \\\"arm64ec\\\"), target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), not(any(all(target_os = \\\"linux\\\", target_env = \\\"\\\"), getrandom_backend = \\\"custom\\\", getrandom_backend = \\\"linux_raw\\\", getrandom_backend = \\\"rdrand\\\", getrandom_backend = \\\"rndr\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:wasm32-unknown-unknown\",\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", not(target_os = \\\"wasi\\\")))\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p2\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p3\\\"))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(all(target_os = \\\"uefi\\\", getrandom_backend = \\\"efi_rng\\\"))\": [],\n \"cfg(any())\": [],\n \"cfg(any(target_os = \\\"dragonfly\\\", target_os = \\\"freebsd\\\", target_os = \\\"hurd\\\", target_os = \\\"illumos\\\", target_os = \\\"cygwin\\\", all(target_os = \\\"horizon\\\", target_arch = \\\"arm\\\")))\": [],\n \"cfg(any(target_os = \\\"haiku\\\", target_os = \\\"redox\\\", target_os = \\\"nto\\\", target_os = \\\"aix\\\"))\": [],\n \"cfg(any(target_os = \\\"ios\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\", target_os = \\\"tvos\\\"))\": [],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"openbsd\\\", target_os = \\\"vita\\\", target_os = \\\"emscripten\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\"],\n \"cfg(any(unix, target_os = \\\"wasi\\\"))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:wasm32-wasip1\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(any(target_arch = \\\"wasm32\\\", target_arch = \\\"wasm64\\\")))\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(not(target_has_atomic = \\\"64\\\"))\": [],\n \"cfg(target_arch = \\\"spirv\\\")\": [],\n \"cfg(target_os = \\\"hermit\\\")\": [],\n \"cfg(target_os = \\\"netbsd\\\")\": [],\n \"cfg(target_os = \\\"solaris\\\")\": [],\n \"cfg(target_os = \\\"vxworks\\\")\": [],\n \"cfg(target_os = \\\"wasi\\\")\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"cfg(unix)\": [\"@rules_rust//rust/platform:aarch64-apple-darwin\",\"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"cfg(windows)\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"i686-pc-windows-gnullvm\": [],\n \"wasm32-unknown-unknown\": [\"@rules_rust//rust/platform:wasm32-unknown-unknown\"],\n \"wasm32-wasip1\": [\"@rules_rust//rust/platform:wasm32-wasip1\"],\n \"x86_64-pc-windows-gnullvm\": [],\n \"x86_64-pc-windows-msvc\": [\"@rules_rust//rust/platform:x86_64-pc-windows-msvc\"],\n \"x86_64-unknown-linux-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\",\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n \"x86_64-unknown-nixos-gnu\": [\"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\"],\n}\n\n###############################################################################\n\ndef crate_repositories():\n \"\"\"A macro for defining repositories for all generated crates.\n\n Returns:\n A list of repos visible to the module through the module extension.\n \"\"\"\n maybe(\n http_archive,\n name = \"crates__aho-corasick-1.1.4\",\n sha256 = \"ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aho-corasick/1.1.4/download\"],\n strip_prefix = \"aho-corasick-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.aho-corasick-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__allocator-api2-0.2.21\",\n sha256 = \"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/allocator-api2/0.2.21/download\"],\n strip_prefix = \"allocator-api2-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.allocator-api2-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anes-0.1.6\",\n sha256 = \"4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anes/0.1.6/download\"],\n strip_prefix = \"anes-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.anes-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstream-1.0.0\",\n sha256 = \"824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstream/1.0.0/download\"],\n strip_prefix = \"anstream-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstream-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-1.0.14\",\n sha256 = \"940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle/1.0.14/download\"],\n strip_prefix = \"anstyle-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-parse-1.0.0\",\n sha256 = \"52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-parse/1.0.0/download\"],\n strip_prefix = \"anstyle-parse-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-parse-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-query-1.1.5\",\n sha256 = \"40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-query/1.1.5/download\"],\n strip_prefix = \"anstyle-query-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-query-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-wincon-3.0.11\",\n sha256 = \"291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-wincon/3.0.11/download\"],\n strip_prefix = \"anstyle-wincon-3.0.11\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-wincon-3.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anyhow-1.0.102\",\n sha256 = \"7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anyhow/1.0.102/download\"],\n strip_prefix = \"anyhow-1.0.102\",\n build_file = Label(\"@crates//crates:BUILD.anyhow-1.0.102.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__append-only-vec-0.1.8\",\n sha256 = \"2114736faba96bcd79595c700d03183f61357b9fbce14852515e59f3bee4ed4a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/append-only-vec/0.1.8/download\"],\n strip_prefix = \"append-only-vec-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.append-only-vec-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__approx-0.5.1\",\n sha256 = \"cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/approx/0.5.1/download\"],\n strip_prefix = \"approx-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.approx-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__assert_cmd-2.2.2\",\n sha256 = \"2aa3a22042e45de04255c7bf3626e239f450200fd0493c1e382263544b20aea6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/assert_cmd/2.2.2/download\"],\n strip_prefix = \"assert_cmd-2.2.2\",\n build_file = Label(\"@crates//crates:BUILD.assert_cmd-2.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__autocfg-1.5.0\",\n sha256 = \"c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/autocfg/1.5.0/download\"],\n strip_prefix = \"autocfg-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.autocfg-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.22.1\",\n sha256 = \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.22.1/download\"],\n strip_prefix = \"base64-0.22.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.22.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-set-0.8.0\",\n sha256 = \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-set/0.8.0/download\"],\n strip_prefix = \"bit-set-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-set-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-vec-0.8.0\",\n sha256 = \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-vec/0.8.0/download\"],\n strip_prefix = \"bit-vec-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-vec-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-1.3.2\",\n sha256 = \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/1.3.2/download\"],\n strip_prefix = \"bitflags-1.3.2\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-1.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-2.11.0\",\n sha256 = \"843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/2.11.0/download\"],\n strip_prefix = \"bitflags-2.11.0\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-2.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__borsh-1.6.1\",\n sha256 = \"cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/borsh/1.6.1/download\"],\n strip_prefix = \"borsh-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.borsh-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bs58-0.5.1\",\n sha256 = \"bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bs58/0.5.1/download\"],\n strip_prefix = \"bs58-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.bs58-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bstr-1.12.1\",\n sha256 = \"63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bstr/1.12.1/download\"],\n strip_prefix = \"bstr-1.12.1\",\n build_file = Label(\"@crates//crates:BUILD.bstr-1.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bumpalo-3.20.2\",\n sha256 = \"5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bumpalo/3.20.2/download\"],\n strip_prefix = \"bumpalo-3.20.2\",\n build_file = Label(\"@crates//crates:BUILD.bumpalo-3.20.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytes-1.11.1\",\n sha256 = \"1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytes/1.11.1/download\"],\n strip_prefix = \"bytes-1.11.1\",\n build_file = Label(\"@crates//crates:BUILD.bytes-1.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cast-0.3.0\",\n sha256 = \"37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cast/0.3.0/download\"],\n strip_prefix = \"cast-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.cast-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cc-1.2.57\",\n sha256 = \"7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cc/1.2.57/download\"],\n strip_prefix = \"cc-1.2.57\",\n build_file = Label(\"@crates//crates:BUILD.cc-1.2.57.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-if-1.0.4\",\n sha256 = \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-if/1.0.4/download\"],\n strip_prefix = \"cfg-if-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.cfg-if-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.2.1\",\n sha256 = \"613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.2.1/download\"],\n strip_prefix = \"cfg_aliases-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chrono-0.4.44\",\n sha256 = \"c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chrono/0.4.44/download\"],\n strip_prefix = \"chrono-0.4.44\",\n build_file = Label(\"@crates//crates:BUILD.chrono-0.4.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-0.2.2\",\n sha256 = \"42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium/0.2.2/download\"],\n strip_prefix = \"ciborium-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-io-0.2.2\",\n sha256 = \"05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-io/0.2.2/download\"],\n strip_prefix = \"ciborium-io-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-io-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ciborium-ll-0.2.2\",\n sha256 = \"57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ciborium-ll/0.2.2/download\"],\n strip_prefix = \"ciborium-ll-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.ciborium-ll-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-4.6.1\",\n sha256 = \"1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap/4.6.1/download\"],\n strip_prefix = \"clap-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-markdown-0.1.5\",\n sha256 = \"d2a2617956a06d4885b490697b5307ebb09fec10b088afc18c81762d848c2339\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap-markdown/0.1.5/download\"],\n strip_prefix = \"clap-markdown-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.clap-markdown-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_builder-4.6.0\",\n sha256 = \"714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_builder/4.6.0/download\"],\n strip_prefix = \"clap_builder-4.6.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_builder-4.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_derive-4.6.1\",\n sha256 = \"f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_derive/4.6.1/download\"],\n strip_prefix = \"clap_derive-4.6.1\",\n build_file = Label(\"@crates//crates:BUILD.clap_derive-4.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_lex-1.1.0\",\n sha256 = \"c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_lex/1.1.0/download\"],\n strip_prefix = \"clap_lex-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_lex-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-4.4.1\",\n sha256 = \"b684e94583e85a5ca7e1a6454a89d76a5121240f2fb67eb564129d9bafdb9db0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed/4.4.1/download\"],\n strip_prefix = \"codspeed-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-4.4.1\",\n sha256 = \"2e65444156eb73ad7f57618188f8d4a281726d133ef55b96d1dcff89528609ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codspeed-criterion-compat-walltime-4.4.1\",\n sha256 = \"96389aaa4bbb872ea4924dc0335b2bb181bcf28d6eedbe8fea29afcc5bde36a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codspeed-criterion-compat-walltime/4.4.1/download\"],\n strip_prefix = \"codspeed-criterion-compat-walltime-4.4.1\",\n build_file = Label(\"@crates//crates:BUILD.codspeed-criterion-compat-walltime-4.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colorchoice-1.0.5\",\n sha256 = \"1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colorchoice/1.0.5/download\"],\n strip_prefix = \"colorchoice-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.colorchoice-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colored-2.2.0\",\n sha256 = \"117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colored/2.2.0/download\"],\n strip_prefix = \"colored-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.colored-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__common-path-1.0.0\",\n sha256 = \"2382f75942f4b3be3690fe4f86365e9c853c1587d6ee58212cebf6e2a9ccd101\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/common-path/1.0.0/download\"],\n strip_prefix = \"common-path-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.common-path-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__configparser-3.2.0\",\n sha256 = \"b46dec724fd22199ebde05033a0cbae453bc3b1ecff11eb6a6bb3eec4b90c6a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/configparser/3.2.0/download\"],\n strip_prefix = \"configparser-3.2.0\",\n build_file = Label(\"@crates//crates:BUILD.configparser-3.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__console_error_panic_hook-0.1.7\",\n sha256 = \"a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/console_error_panic_hook/0.1.7/download\"],\n strip_prefix = \"console_error_panic_hook-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.console_error_panic_hook-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__criterion-plot-0.5.0\",\n sha256 = \"6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/criterion-plot/0.5.0/download\"],\n strip_prefix = \"criterion-plot-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.criterion-plot-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-channel-0.5.15\",\n sha256 = \"82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-channel/0.5.15/download\"],\n strip_prefix = \"crossbeam-channel-0.5.15\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-channel-0.5.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-deque-0.8.6\",\n sha256 = \"9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-deque/0.8.6/download\"],\n strip_prefix = \"crossbeam-deque-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-deque-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-epoch-0.9.18\",\n sha256 = \"5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-epoch/0.9.18/download\"],\n strip_prefix = \"crossbeam-epoch-0.9.18\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-epoch-0.9.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-utils-0.8.21\",\n sha256 = \"d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-utils/0.8.21/download\"],\n strip_prefix = \"crossbeam-utils-0.8.21\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-utils-0.8.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crunchy-0.2.4\",\n sha256 = \"460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crunchy/0.2.4/download\"],\n strip_prefix = \"crunchy-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.crunchy-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.23.0\",\n sha256 = \"25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.23.0/download\"],\n strip_prefix = \"darling-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.23.0\",\n sha256 = \"9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.23.0/download\"],\n strip_prefix = \"darling_core-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.23.0\",\n sha256 = \"ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.23.0/download\"],\n strip_prefix = \"darling_macro-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__deranged-0.5.8\",\n sha256 = \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/deranged/0.5.8/download\"],\n strip_prefix = \"deranged-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.deranged-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__diff-0.1.13\",\n sha256 = \"56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/diff/0.1.13/download\"],\n strip_prefix = \"diff-0.1.13\",\n build_file = Label(\"@crates//crates:BUILD.diff-0.1.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__difflib-0.4.0\",\n sha256 = \"6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/difflib/0.4.0/download\"],\n strip_prefix = \"difflib-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.difflib-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dissimilar-1.0.11\",\n sha256 = \"aeda16ab4059c5fd2a83f2b9c9e9c981327b18aa8e3b313f7e6563799d4f093e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dissimilar/1.0.11/download\"],\n strip_prefix = \"dissimilar-1.0.11\",\n build_file = Label(\"@crates//crates:BUILD.dissimilar-1.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__either-1.15.0\",\n sha256 = \"48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/either/1.15.0/download\"],\n strip_prefix = \"either-1.15.0\",\n build_file = Label(\"@crates//crates:BUILD.either-1.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enum_dispatch-0.3.13\",\n sha256 = \"aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enum_dispatch/0.3.13/download\"],\n strip_prefix = \"enum_dispatch-0.3.13\",\n build_file = Label(\"@crates//crates:BUILD.enum_dispatch-0.3.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__equivalent-1.0.2\",\n sha256 = \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/equivalent/1.0.2/download\"],\n strip_prefix = \"equivalent-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.equivalent-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__errno-0.3.14\",\n sha256 = \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/errno/0.3.14/download\"],\n strip_prefix = \"errno-0.3.14\",\n build_file = Label(\"@crates//crates:BUILD.errno-0.3.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__expect-test-1.5.1\",\n sha256 = \"63af43ff4431e848fb47472a920f14fa71c24de13255a5692e93d4e90302acb0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/expect-test/1.5.1/download\"],\n strip_prefix = \"expect-test-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.expect-test-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.18.0\",\n sha256 = \"e1e1dacd0d2082dfcf1351c4bdd566bbe89a2b263235a2b50058f1e130a47277\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.18.0/download\"],\n strip_prefix = \"fancy-regex-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fastrand-2.3.0\",\n sha256 = \"37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fastrand/2.3.0/download\"],\n strip_prefix = \"fastrand-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.fastrand-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fern-0.7.1\",\n sha256 = \"4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fern/0.7.1/download\"],\n strip_prefix = \"fern-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.fern-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__find-msvc-tools-0.1.9\",\n sha256 = \"5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/find-msvc-tools/0.1.9/download\"],\n strip_prefix = \"find-msvc-tools-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.find-msvc-tools-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-uri-0.1.4\",\n sha256 = \"17c704e9dbe1ddd863da1e6ff3567795087b1eb201ce80d8fa81162e1516500d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-uri/0.1.4/download\"],\n strip_prefix = \"fluent-uri-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.fluent-uri-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.1.5\",\n sha256 = \"d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.1.5/download\"],\n strip_prefix = \"foldhash-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.2.0\",\n sha256 = \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.2.0/download\"],\n strip_prefix = \"foldhash-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.2.17\",\n sha256 = \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.2.17/download\"],\n strip_prefix = \"getrandom-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.4.2\",\n sha256 = \"0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.4.2/download\"],\n strip_prefix = \"getrandom-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__glob-0.3.3\",\n sha256 = \"0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/glob/0.3.3/download\"],\n strip_prefix = \"glob-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.glob-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__globset-0.4.18\",\n sha256 = \"52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/globset/0.4.18/download\"],\n strip_prefix = \"globset-0.4.18\",\n build_file = Label(\"@crates//crates:BUILD.globset-0.4.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__half-2.7.1\",\n sha256 = \"6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/half/2.7.1/download\"],\n strip_prefix = \"half-2.7.1\",\n build_file = Label(\"@crates//crates:BUILD.half-2.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.15.5\",\n sha256 = \"9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.15.5/download\"],\n strip_prefix = \"hashbrown-0.15.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.15.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.17.1\",\n sha256 = \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.17.1/download\"],\n strip_prefix = \"hashbrown-0.17.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.17.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heck-0.5.0\",\n sha256 = \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heck/0.5.0/download\"],\n strip_prefix = \"heck-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.heck-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hermit-abi-0.5.2\",\n sha256 = \"fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hermit-abi/0.5.2/download\"],\n strip_prefix = \"hermit-abi-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.hermit-abi-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hex-0.4.3\",\n sha256 = \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hex/0.4.3/download\"],\n strip_prefix = \"hex-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.hex-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__id-arena-2.3.0\",\n sha256 = \"3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/id-arena/2.3.0/download\"],\n strip_prefix = \"id-arena-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.id-arena-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ident_case-1.0.1\",\n sha256 = \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ident_case/1.0.1/download\"],\n strip_prefix = \"ident_case-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.ident_case-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ignore-0.4.27\",\n sha256 = \"fe112b004901c62c2faa11f4f75e9864e0cc5af8da71c9115d184a3aa888749f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ignore/0.4.27/download\"],\n strip_prefix = \"ignore-0.4.27\",\n build_file = Label(\"@crates//crates:BUILD.ignore-0.4.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indexmap-2.14.0\",\n sha256 = \"d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indexmap/2.14.0/download\"],\n strip_prefix = \"indexmap-2.14.0\",\n build_file = Label(\"@crates//crates:BUILD.indexmap-2.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is-terminal-0.4.17\",\n sha256 = \"3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is-terminal/0.4.17/download\"],\n strip_prefix = \"is-terminal-0.4.17\",\n build_file = Label(\"@crates//crates:BUILD.is-terminal-0.4.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is_terminal_polyfill-1.70.2\",\n sha256 = \"a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is_terminal_polyfill/1.70.2/download\"],\n strip_prefix = \"is_terminal_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.is_terminal_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.10.5\",\n sha256 = \"b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.10.5/download\"],\n strip_prefix = \"itertools-0.10.5\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.10.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.15.0\",\n sha256 = \"8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.15.0/download\"],\n strip_prefix = \"itertools-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itoa-1.0.17\",\n sha256 = \"92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itoa/1.0.17/download\"],\n strip_prefix = \"itoa-1.0.17\",\n build_file = Label(\"@crates//crates:BUILD.itoa-1.0.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__js-sys-0.3.82\",\n sha256 = \"b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/js-sys/0.3.82/download\"],\n strip_prefix = \"js-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.js-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-3.6.0\",\n sha256 = \"6bae91019476d3ec7147de9aa291cadb6d870abf2f3015d2da73a90325ac1496\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex/3.6.0/download\"],\n strip_prefix = \"lazy-regex-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy-regex-proc_macros-3.6.0\",\n sha256 = \"4de9c1e1439d8b7b3061b2d209809f447ca33241733d9a3c01eabf2dc8d94358\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy-regex-proc_macros/3.6.0/download\"],\n strip_prefix = \"lazy-regex-proc_macros-3.6.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy-regex-proc_macros-3.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy_static-1.5.0\",\n sha256 = \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy_static/1.5.0/download\"],\n strip_prefix = \"lazy_static-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy_static-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__leb128fmt-0.1.0\",\n sha256 = \"09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/leb128fmt/0.1.0/download\"],\n strip_prefix = \"leb128fmt-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.leb128fmt-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libc-0.2.183\",\n sha256 = \"b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libc/0.2.183/download\"],\n strip_prefix = \"libc-0.2.183\",\n build_file = Label(\"@crates//crates:BUILD.libc-0.2.183.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libmimalloc-sys-0.1.49\",\n sha256 = \"6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libmimalloc-sys/0.1.49/download\"],\n strip_prefix = \"libmimalloc-sys-0.1.49\",\n build_file = Label(\"@crates//crates:BUILD.libmimalloc-sys-0.1.49.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__line-index-0.1.2\",\n sha256 = \"3e27e0ed5a392a7f5ba0b3808a2afccff16c64933312c84b57618b49d1209bd2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/line-index/0.1.2/download\"],\n strip_prefix = \"line-index-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.line-index-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.12.1\",\n sha256 = \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.12.1/download\"],\n strip_prefix = \"linux-raw-sys-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__log-0.4.33\",\n sha256 = \"0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/log/0.4.33/download\"],\n strip_prefix = \"log-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.log-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-server-0.8.0\",\n sha256 = \"0ad8be6fe0ca81b8298bfbbe8a77e9fcd8895ad6c84cd7794d5ebadcbb09ae43\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-server/0.8.0/download\"],\n strip_prefix = \"lsp-server-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-server-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lsp-types-0.97.0\",\n sha256 = \"53353550a17c04ac46c585feb189c2db82154fc84b79c7a66c96c2c644f66071\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lsp-types/0.97.0/download\"],\n strip_prefix = \"lsp-types-0.97.0\",\n build_file = Label(\"@crates//crates:BUILD.lsp-types-0.97.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memchr-2.8.0\",\n sha256 = \"f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memchr/2.8.0/download\"],\n strip_prefix = \"memchr-2.8.0\",\n build_file = Label(\"@crates//crates:BUILD.memchr-2.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memo-map-0.3.3\",\n sha256 = \"38d1115007560874e373613744c6fba374c17688327a71c1476d1a5954cc857b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memo-map/0.3.3/download\"],\n strip_prefix = \"memo-map-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.memo-map-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__mimalloc-0.1.52\",\n sha256 = \"2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/mimalloc/0.1.52/download\"],\n strip_prefix = \"mimalloc-0.1.52\",\n build_file = Label(\"@crates//crates:BUILD.mimalloc-0.1.52.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__minijinja-2.21.0\",\n sha256 = \"cb3d648e68cea56d9858d535ee28f9538404e2dd8cb08ed0bd05dca379477f39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/minijinja/2.21.0/download\"],\n strip_prefix = \"minijinja-2.21.0\",\n build_file = Label(\"@crates//crates:BUILD.minijinja-2.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.31.2\",\n sha256 = \"5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.31.2/download\"],\n strip_prefix = \"nix-0.31.2\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.31.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nohash-hasher-0.2.0\",\n sha256 = \"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nohash-hasher/0.2.0/download\"],\n strip_prefix = \"nohash-hasher-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.nohash-hasher-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-conv-0.2.0\",\n sha256 = \"cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-conv/0.2.0/download\"],\n strip_prefix = \"num-conv-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.num-conv-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-traits-0.2.19\",\n sha256 = \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-traits/0.2.19/download\"],\n strip_prefix = \"num-traits-0.2.19\",\n build_file = Label(\"@crates//crates:BUILD.num-traits-0.2.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell-1.21.4\",\n sha256 = \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell/1.21.4/download\"],\n strip_prefix = \"once_cell-1.21.4\",\n build_file = Label(\"@crates//crates:BUILD.once_cell-1.21.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell_polyfill-1.70.2\",\n sha256 = \"384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell_polyfill/1.70.2/download\"],\n strip_prefix = \"once_cell_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.once_cell_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__oorandom-11.1.5\",\n sha256 = \"d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/oorandom/11.1.5/download\"],\n strip_prefix = \"oorandom-11.1.5\",\n build_file = Label(\"@crates//crates:BUILD.oorandom-11.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-0.3.7\",\n sha256 = \"5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters/0.3.7/download\"],\n strip_prefix = \"plotters-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-backend-0.3.7\",\n sha256 = \"df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-backend/0.3.7/download\"],\n strip_prefix = \"plotters-backend-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-backend-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__plotters-svg-0.3.7\",\n sha256 = \"51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/plotters-svg/0.3.7/download\"],\n strip_prefix = \"plotters-svg-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.plotters-svg-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-1.13.1\",\n sha256 = \"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic/1.13.1/download\"],\n strip_prefix = \"portable-atomic-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__powerfmt-0.2.0\",\n sha256 = \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/powerfmt/0.2.0/download\"],\n strip_prefix = \"powerfmt-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.powerfmt-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-3.1.4\",\n sha256 = \"ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates/3.1.4/download\"],\n strip_prefix = \"predicates-3.1.4\",\n build_file = Label(\"@crates//crates:BUILD.predicates-3.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-core-1.0.10\",\n sha256 = \"cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-core/1.0.10/download\"],\n strip_prefix = \"predicates-core-1.0.10\",\n build_file = Label(\"@crates//crates:BUILD.predicates-core-1.0.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__predicates-tree-1.0.13\",\n sha256 = \"d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/predicates-tree/1.0.13/download\"],\n strip_prefix = \"predicates-tree-1.0.13\",\n build_file = Label(\"@crates//crates:BUILD.predicates-tree-1.0.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pretty_assertions-1.4.1\",\n sha256 = \"3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pretty_assertions/1.4.1/download\"],\n strip_prefix = \"pretty_assertions-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.pretty_assertions-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prettyplease-0.2.37\",\n sha256 = \"479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prettyplease/0.2.37/download\"],\n strip_prefix = \"prettyplease-0.2.37\",\n build_file = Label(\"@crates//crates:BUILD.prettyplease-0.2.37.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro2-1.0.106\",\n sha256 = \"8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro2/1.0.106/download\"],\n strip_prefix = \"proc-macro2-1.0.106\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro2-1.0.106.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-0.29.0\",\n sha256 = \"cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3/0.29.0/download\"],\n strip_prefix = \"pyo3-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-build-config-0.29.0\",\n sha256 = \"c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-build-config/0.29.0/download\"],\n strip_prefix = \"pyo3-build-config-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-build-config-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-ffi-0.29.0\",\n sha256 = \"ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-ffi/0.29.0/download\"],\n strip_prefix = \"pyo3-ffi-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-ffi-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-0.29.0\",\n sha256 = \"9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pyo3-macros-backend-0.29.0\",\n sha256 = \"4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pyo3-macros-backend/0.29.0/download\"],\n strip_prefix = \"pyo3-macros-backend-0.29.0\",\n build_file = Label(\"@crates//crates:BUILD.pyo3-macros-backend-0.29.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quote-1.0.45\",\n sha256 = \"41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quote/1.0.45/download\"],\n strip_prefix = \"quote-1.0.45\",\n build_file = Label(\"@crates//crates:BUILD.quote-1.0.45.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-6.0.0\",\n sha256 = \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/6.0.0/download\"],\n strip_prefix = \"r-efi-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-1.12.0\",\n sha256 = \"fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon/1.12.0/download\"],\n strip_prefix = \"rayon-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-core-1.13.0\",\n sha256 = \"22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon-core/1.13.0/download\"],\n strip_prefix = \"rayon-core-1.13.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-core-1.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-1.12.4\",\n sha256 = \"f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex/1.12.4/download\"],\n strip_prefix = \"regex-1.12.4\",\n build_file = Label(\"@crates//crates:BUILD.regex-1.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-automata-0.4.14\",\n sha256 = \"6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-automata/0.4.14/download\"],\n strip_prefix = \"regex-automata-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.regex-automata-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-syntax-0.8.11\",\n sha256 = \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-syntax/0.8.11/download\"],\n strip_prefix = \"regex-syntax-0.8.11\",\n build_file = Label(\"@crates//crates:BUILD.regex-syntax-0.8.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-1.1.4\",\n sha256 = \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/1.1.4/download\"],\n strip_prefix = \"rustix-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.rustix-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustversion-1.0.22\",\n sha256 = \"b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustversion/1.0.22/download\"],\n strip_prefix = \"rustversion-1.0.22\",\n build_file = Label(\"@crates//crates:BUILD.rustversion-1.0.22.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ryu-1.0.23\",\n sha256 = \"9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ryu/1.0.23/download\"],\n strip_prefix = \"ryu-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.ryu-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__same-file-1.0.6\",\n sha256 = \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/same-file/1.0.6/download\"],\n strip_prefix = \"same-file-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.same-file-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__semver-1.0.27\",\n sha256 = \"d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/semver/1.0.27/download\"],\n strip_prefix = \"semver-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.semver-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-1.0.228\",\n sha256 = \"9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde/1.0.228/download\"],\n strip_prefix = \"serde-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-wasm-bindgen-0.6.5\",\n sha256 = \"8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde-wasm-bindgen/0.6.5/download\"],\n strip_prefix = \"serde-wasm-bindgen-0.6.5\",\n build_file = Label(\"@crates//crates:BUILD.serde-wasm-bindgen-0.6.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_core-1.0.228\",\n sha256 = \"41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_core/1.0.228/download\"],\n strip_prefix = \"serde_core-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_core-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_derive-1.0.228\",\n sha256 = \"d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_derive/1.0.228/download\"],\n strip_prefix = \"serde_derive-1.0.228\",\n build_file = Label(\"@crates//crates:BUILD.serde_derive-1.0.228.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_json-1.0.150\",\n sha256 = \"e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_json/1.0.150/download\"],\n strip_prefix = \"serde_json-1.0.150\",\n build_file = Label(\"@crates//crates:BUILD.serde_json-1.0.150.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_repr-0.1.20\",\n sha256 = \"175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_repr/0.1.20/download\"],\n strip_prefix = \"serde_repr-0.1.20\",\n build_file = Label(\"@crates//crates:BUILD.serde_repr-0.1.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_spanned-1.1.1\",\n sha256 = \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_spanned/1.1.1/download\"],\n strip_prefix = \"serde_spanned-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.serde_spanned-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with-3.21.0\",\n sha256 = \"76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with/3.21.0/download\"],\n strip_prefix = \"serde_with-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_with_macros-3.21.0\",\n sha256 = \"84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_with_macros/3.21.0/download\"],\n strip_prefix = \"serde_with_macros-3.21.0\",\n build_file = Label(\"@crates//crates:BUILD.serde_with_macros-3.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_yaml-0.9.34-deprecated\",\n sha256 = \"6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_yaml/0.9.34+deprecated/download\"],\n strip_prefix = \"serde_yaml-0.9.34+deprecated\",\n build_file = Label(\"@crates//crates:BUILD.serde_yaml-0.9.34+deprecated.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-1.3.0\",\n sha256 = \"0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/1.3.0/download\"],\n strip_prefix = \"shlex-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.shlex-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smol_str-0.3.6\",\n sha256 = \"4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smol_str/0.3.6/download\"],\n strip_prefix = \"smol_str-0.3.6\",\n build_file = Label(\"@crates//crates:BUILD.smol_str-0.3.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__statrs-0.18.0\",\n sha256 = \"2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/statrs/0.18.0/download\"],\n strip_prefix = \"statrs-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.statrs-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strsim-0.11.1\",\n sha256 = \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strsim/0.11.1/download\"],\n strip_prefix = \"strsim-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.strsim-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum-0.28.0\",\n sha256 = \"9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum/0.28.0/download\"],\n strip_prefix = \"strum-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum_macros-0.28.0\",\n sha256 = \"ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum_macros/0.28.0/download\"],\n strip_prefix = \"strum_macros-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum_macros-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-2.0.117\",\n sha256 = \"e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/2.0.117/download\"],\n strip_prefix = \"syn-2.0.117\",\n build_file = Label(\"@crates//crates:BUILD.syn-2.0.117.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__target-lexicon-0.13.5\",\n sha256 = \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/target-lexicon/0.13.5/download\"],\n strip_prefix = \"target-lexicon-0.13.5\",\n build_file = Label(\"@crates//crates:BUILD.target-lexicon-0.13.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tempfile-3.27.0\",\n sha256 = \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tempfile/3.27.0/download\"],\n strip_prefix = \"tempfile-3.27.0\",\n build_file = Label(\"@crates//crates:BUILD.tempfile-3.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__termtree-0.5.1\",\n sha256 = \"8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/termtree/0.5.1/download\"],\n strip_prefix = \"termtree-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.termtree-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__text-size-1.1.1\",\n sha256 = \"f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/text-size/1.1.1/download\"],\n strip_prefix = \"text-size-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.text-size-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-2.0.18\",\n sha256 = \"4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/2.0.18/download\"],\n strip_prefix = \"thiserror-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-2.0.18\",\n sha256 = \"ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/2.0.18/download\"],\n strip_prefix = \"thiserror-impl-2.0.18\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-2.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-0.3.47\",\n sha256 = \"743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time/0.3.47/download\"],\n strip_prefix = \"time-0.3.47\",\n build_file = Label(\"@crates//crates:BUILD.time-0.3.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-core-0.1.8\",\n sha256 = \"7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-core/0.1.8/download\"],\n strip_prefix = \"time-core-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.time-core-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinytemplate-1.2.1\",\n sha256 = \"be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinytemplate/1.2.1/download\"],\n strip_prefix = \"tinytemplate-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.tinytemplate-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec-1.11.0\",\n sha256 = \"3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec/1.11.0/download\"],\n strip_prefix = \"tinyvec-1.11.0\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec-1.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec_macros-0.1.1\",\n sha256 = \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec_macros/0.1.1/download\"],\n strip_prefix = \"tinyvec_macros-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec_macros-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml-0.9.12-spec-1.1.0\",\n sha256 = \"cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml/0.9.12+spec-1.1.0/download\"],\n strip_prefix = \"toml-0.9.12+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml-0.9.12+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_datetime-0.7.5-spec-1.1.0\",\n sha256 = \"92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_datetime/0.7.5+spec-1.1.0/download\"],\n strip_prefix = \"toml_datetime-0.7.5+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_datetime-0.7.5+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_parser-1.1.2-spec-1.1.0\",\n sha256 = \"a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_parser/1.1.2+spec-1.1.0/download\"],\n strip_prefix = \"toml_parser-1.1.2+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_parser-1.1.2+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_writer-1.1.1-spec-1.1.0\",\n sha256 = \"756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_writer/1.1.1+spec-1.1.0/download\"],\n strip_prefix = \"toml_writer-1.1.1+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_writer-1.1.1+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-ident-1.0.24\",\n sha256 = \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-ident/1.0.24/download\"],\n strip_prefix = \"unicode-ident-1.0.24\",\n build_file = Label(\"@crates//crates:BUILD.unicode-ident-1.0.24.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-xid-0.2.6\",\n sha256 = \"ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-xid/0.2.6/download\"],\n strip_prefix = \"unicode-xid-0.2.6\",\n build_file = Label(\"@crates//crates:BUILD.unicode-xid-0.2.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unsafe-libyaml-0.2.11\",\n sha256 = \"673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unsafe-libyaml/0.2.11/download\"],\n strip_prefix = \"unsafe-libyaml-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.unsafe-libyaml-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8parse-0.2.2\",\n sha256 = \"06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8parse/0.2.2/download\"],\n strip_prefix = \"utf8parse-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.utf8parse-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wait-timeout-0.2.1\",\n sha256 = \"09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wait-timeout/0.2.1/download\"],\n strip_prefix = \"wait-timeout-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.wait-timeout-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__walkdir-2.5.0\",\n sha256 = \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/walkdir/2.5.0/download\"],\n strip_prefix = \"walkdir-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.walkdir-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.11.1-wasi-snapshot-preview1\",\n sha256 = \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.11.1+wasi-snapshot-preview1/download\"],\n strip_prefix = \"wasi-0.11.1+wasi-snapshot-preview1\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.11.1+wasi-snapshot-preview1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip2-1.0.2-wasi-0.2.9\",\n sha256 = \"9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip2/1.0.2+wasi-0.2.9/download\"],\n strip_prefix = \"wasip2-1.0.2+wasi-0.2.9\",\n build_file = Label(\"@crates//crates:BUILD.wasip2-1.0.2+wasi-0.2.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip3-0.4.0-wasi-0.3.0-rc-2026-01-06\",\n sha256 = \"5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip3/0.4.0+wasi-0.3.0-rc-2026-01-06/download\"],\n strip_prefix = \"wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06\",\n build_file = Label(\"@crates//crates:BUILD.wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-0.2.105\",\n sha256 = \"da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-0.2.105\",\n sha256 = \"04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-support-0.2.105\",\n sha256 = \"420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro-support/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-macro-support-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-support-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-shared-0.2.105\",\n sha256 = \"76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-shared/0.2.105/download\"],\n strip_prefix = \"wasm-bindgen-shared-0.2.105\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-shared-0.2.105.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-encoder-0.244.0\",\n sha256 = \"990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-encoder/0.244.0/download\"],\n strip_prefix = \"wasm-encoder-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-encoder-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-metadata-0.244.0\",\n sha256 = \"bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-metadata/0.244.0/download\"],\n strip_prefix = \"wasm-metadata-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasm-metadata-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasmparser-0.244.0\",\n sha256 = \"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasmparser/0.244.0/download\"],\n strip_prefix = \"wasmparser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wasmparser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-sys-0.3.82\",\n sha256 = \"3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-sys/0.3.82/download\"],\n strip_prefix = \"web-sys-0.3.82\",\n build_file = Label(\"@crates//crates:BUILD.web-sys-0.3.82.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-util-0.1.11\",\n sha256 = \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-util/0.1.11/download\"],\n strip_prefix = \"winapi-util-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.winapi-util-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.2.1\",\n sha256 = \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.2.1/download\"],\n strip_prefix = \"windows-link-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.59.0\",\n sha256 = \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.59.0/download\"],\n strip_prefix = \"windows-sys-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.61.2\",\n sha256 = \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.61.2/download\"],\n strip_prefix = \"windows-sys-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.52.6\",\n sha256 = \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.52.6/download\"],\n strip_prefix = \"windows-targets-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.52.6\",\n sha256 = \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.52.6\",\n sha256 = \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.52.6\",\n sha256 = \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.52.6\",\n sha256 = \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.52.6\",\n sha256 = \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.52.6/download\"],\n strip_prefix = \"windows_i686_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.52.6\",\n sha256 = \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.52.6\",\n sha256 = \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.52.6\",\n sha256 = \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-0.7.15\",\n sha256 = \"df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/0.7.15/download\"],\n strip_prefix = \"winnow-0.7.15\",\n build_file = Label(\"@crates//crates:BUILD.winnow-0.7.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-1.0.3\",\n sha256 = \"0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/1.0.3/download\"],\n strip_prefix = \"winnow-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.winnow-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-0.51.0\",\n sha256 = \"d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-core-0.51.0\",\n sha256 = \"ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-core/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-core-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-core-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-0.51.0\",\n sha256 = \"b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-rust-macro-0.51.0\",\n sha256 = \"0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen-rust-macro/0.51.0/download\"],\n strip_prefix = \"wit-bindgen-rust-macro-0.51.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-rust-macro-0.51.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-component-0.244.0\",\n sha256 = \"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-component/0.244.0/download\"],\n strip_prefix = \"wit-component-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-component-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-parser-0.244.0\",\n sha256 = \"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-parser/0.244.0/download\"],\n strip_prefix = \"wit-parser-0.244.0\",\n build_file = Label(\"@crates//crates:BUILD.wit-parser-0.244.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yansi-1.0.1\",\n sha256 = \"cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yansi/1.0.1/download\"],\n strip_prefix = \"yansi-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.yansi-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-0.8.46\",\n sha256 = \"5c5030500cb2d66bdfbb4ebc9563be6ce7005a4b5d0f26be0c523870fe372ca6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy/0.8.46/download\"],\n strip_prefix = \"zerocopy-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-derive-0.8.46\",\n sha256 = \"a5f86989a046a79640b9d8867c823349a139367bda96549794fcc3313ce91f4e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy-derive/0.8.46/download\"],\n strip_prefix = \"zerocopy-derive-0.8.46\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-derive-0.8.46.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zmij-1.0.21\",\n sha256 = \"b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zmij/1.0.21/download\"],\n strip_prefix = \"zmij-1.0.21\",\n build_file = Label(\"@crates//crates:BUILD.zmij-1.0.21.bazel\"),\n )\n\n return [\n struct(repo=\"crates__anstyle-1.0.14\", is_dev_dep = False),\n struct(repo=\"crates__append-only-vec-0.1.8\", is_dev_dep = False),\n struct(repo=\"crates__clap-4.6.1\", is_dev_dep = False),\n struct(repo=\"crates__common-path-1.0.0\", is_dev_dep = False),\n struct(repo=\"crates__configparser-3.2.0\", is_dev_dep = False),\n struct(repo=\"crates__console_error_panic_hook-0.1.7\", is_dev_dep = False),\n struct(repo=\"crates__enum_dispatch-0.3.13\", is_dev_dep = False),\n struct(repo=\"crates__fancy-regex-0.18.0\", is_dev_dep = False),\n struct(repo=\"crates__fern-0.7.1\", is_dev_dep = False),\n struct(repo=\"crates__getrandom-0.2.17\", is_dev_dep = False),\n struct(repo=\"crates__hashbrown-0.17.1\", is_dev_dep = False),\n struct(repo=\"crates__ignore-0.4.27\", is_dev_dep = False),\n struct(repo=\"crates__indexmap-2.14.0\", is_dev_dep = False),\n struct(repo=\"crates__itertools-0.15.0\", is_dev_dep = False),\n struct(repo=\"crates__js-sys-0.3.82\", is_dev_dep = False),\n struct(repo=\"crates__lazy-regex-3.6.0\", is_dev_dep = False),\n struct(repo=\"crates__line-index-0.1.2\", is_dev_dep = False),\n struct(repo=\"crates__log-0.4.33\", is_dev_dep = False),\n struct(repo=\"crates__lsp-server-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__lsp-types-0.97.0\", is_dev_dep = False),\n struct(repo=\"crates__mimalloc-0.1.52\", is_dev_dep = False),\n struct(repo=\"crates__nohash-hasher-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__pretty_assertions-1.4.1\", is_dev_dep = False),\n struct(repo=\"crates__pyo3-0.29.0\", is_dev_dep = False),\n struct(repo=\"crates__rayon-1.12.0\", is_dev_dep = False),\n struct(repo=\"crates__regex-1.12.4\", is_dev_dep = False),\n struct(repo=\"crates__regex-automata-0.4.14\", is_dev_dep = False),\n struct(repo=\"crates__serde-1.0.228\", is_dev_dep = False),\n struct(repo=\"crates__serde-wasm-bindgen-0.6.5\", is_dev_dep = False),\n struct(repo=\"crates__serde_json-1.0.150\", is_dev_dep = False),\n struct(repo=\"crates__serde_yaml-0.9.34-deprecated\", is_dev_dep = False),\n struct(repo=\"crates__smol_str-0.3.6\", is_dev_dep = False),\n struct(repo=\"crates__strum-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__strum_macros-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__thiserror-2.0.18\", is_dev_dep = False),\n struct(repo=\"crates__toml-0.9.12-spec-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__walkdir-2.5.0\", is_dev_dep = False),\n struct(repo=\"crates__wasm-bindgen-0.2.105\", is_dev_dep = False),\n struct(repo = \"crates__assert_cmd-2.2.2\", is_dev_dep = True),\n struct(repo = \"crates__clap-markdown-0.1.5\", is_dev_dep = True),\n struct(repo = \"crates__codspeed-criterion-compat-4.4.1\", is_dev_dep = True),\n struct(repo = \"crates__expect-test-1.5.1\", is_dev_dep = True),\n struct(repo = \"crates__glob-0.3.3\", is_dev_dep = True),\n struct(repo = \"crates__minijinja-2.21.0\", is_dev_dep = True),\n struct(repo = \"crates__serde_with-3.21.0\", is_dev_dep = True),\n struct(repo = \"crates__tempfile-3.27.0\", is_dev_dep = True),\n ]\n" } } }, @@ -2740,7 +2740,7 @@ "https://static.crates.io/crates/aho-corasick/1.1.4/download" ], "strip_prefix": "aho-corasick-1.1.4", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"aho_corasick\",\n deps = [\n \"@crates__memchr-2.8.0//:memchr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"perf-literal\",\n \"std\",\n ] + select({\n \"@rules_rust//rust/platform:aarch64-apple-darwin\": [\n \"default\", # aarch64-apple-darwin\n ],\n \"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\": [\n \"default\", # aarch64-unknown-linux-gnu\n ],\n \"@rules_rust//rust/platform:x86_64-pc-windows-msvc\": [\n \"default\", # x86_64-pc-windows-msvc\n ],\n \"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu\n ],\n \"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu, x86_64-unknown-nixos-gnu\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=aho-corasick\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@rules_rust//rust/platform:aarch64-apple-darwin\": [],\n \"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:wasm32-unknown-unknown\": [],\n \"@rules_rust//rust/platform:wasm32-wasip1\": [],\n \"@rules_rust//rust/platform:x86_64-pc-windows-msvc\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.4\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"aho_corasick\",\n deps = [\n \"@crates__memchr-2.8.0//:memchr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"perf-literal\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=aho-corasick\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@rules_rust//rust/platform:aarch64-apple-darwin\": [],\n \"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:wasm32-unknown-unknown\": [],\n \"@rules_rust//rust/platform:wasm32-wasip1\": [],\n \"@rules_rust//rust/platform:x86_64-pc-windows-msvc\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.4\",\n)\n" } }, "crates__allocator-api2-0.2.21": { @@ -4040,7 +4040,7 @@ "https://static.crates.io/crates/memchr/2.8.0/download" ], "strip_prefix": "memchr-2.8.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"memchr\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"std\",\n ] + select({\n \"@rules_rust//rust/platform:aarch64-apple-darwin\": [\n \"default\", # aarch64-apple-darwin\n ],\n \"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\": [\n \"default\", # aarch64-unknown-linux-gnu\n ],\n \"@rules_rust//rust/platform:x86_64-pc-windows-msvc\": [\n \"default\", # x86_64-pc-windows-msvc\n ],\n \"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu\n ],\n \"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu, x86_64-unknown-nixos-gnu\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=memchr\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@rules_rust//rust/platform:aarch64-apple-darwin\": [],\n \"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:wasm32-unknown-unknown\": [],\n \"@rules_rust//rust/platform:wasm32-wasip1\": [],\n \"@rules_rust//rust/platform:x86_64-pc-windows-msvc\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.8.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'sqruff'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"memchr\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=memchr\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@rules_rust//rust/platform:aarch64-apple-darwin\": [],\n \"@rules_rust//rust/platform:aarch64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:wasm32-unknown-unknown\": [],\n \"@rules_rust//rust/platform:wasm32-wasip1\": [],\n \"@rules_rust//rust/platform:x86_64-pc-windows-msvc\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-linux-gnu\": [],\n \"@rules_rust//rust/platform:x86_64-unknown-nixos-gnu\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.8.0\",\n)\n" } }, "crates__memo-map-0.3.3": {