pub use lumis_core::languages::{available_languages, Language, LanguageParseError};
use crate::vendor::tree_sitter_highlight::HighlightConfiguration;
use lumis_core::highlights::HIGHLIGHT_NAMES;
use std::sync::LazyLock;
unsafe extern "C" {
#[cfg(feature = "lang-angular")]
fn tree_sitter_angular() -> *const ();
#[cfg(feature = "lang-astro")]
fn tree_sitter_astro() -> *const ();
#[cfg(feature = "lang-caddy")]
fn tree_sitter_caddy() -> *const ();
#[cfg(feature = "lang-clojure")]
fn tree_sitter_clojure() -> *const ();
#[cfg(feature = "lang-commonlisp")]
fn tree_sitter_commonlisp() -> *const ();
#[cfg(feature = "lang-csv")]
fn tree_sitter_csv() -> *const ();
#[cfg(feature = "lang-dart")]
fn tree_sitter_dart() -> *const ();
#[cfg(feature = "lang-dockerfile")]
fn tree_sitter_dockerfile() -> *const ();
#[cfg(feature = "lang-eex")]
fn tree_sitter_eex() -> *const ();
#[cfg(feature = "lang-fish")]
fn tree_sitter_fish() -> *const ();
#[cfg(feature = "lang-gleam")]
fn tree_sitter_gleam() -> *const ();
#[cfg(feature = "lang-glimmer")]
fn tree_sitter_glimmer() -> *const ();
#[cfg(feature = "lang-graphql")]
fn tree_sitter_graphql() -> *const ();
#[cfg(feature = "lang-hcl")]
fn tree_sitter_hcl() -> *const ();
#[cfg(feature = "lang-http")]
fn tree_sitter_http() -> *const ();
#[cfg(feature = "lang-iex")]
fn tree_sitter_iex() -> *const ();
#[cfg(feature = "lang-kotlin")]
fn tree_sitter_kotlin() -> *const ();
#[cfg(feature = "lang-latex")]
fn tree_sitter_latex() -> *const ();
#[cfg(feature = "lang-liquid")]
fn tree_sitter_liquid() -> *const ();
#[cfg(feature = "lang-llvm")]
fn tree_sitter_llvm() -> *const ();
#[cfg(feature = "lang-make")]
fn tree_sitter_make() -> *const ();
#[cfg(feature = "lang-markdown")]
fn tree_sitter_markdown() -> *const ();
#[cfg(feature = "lang-markdown-inline")]
fn tree_sitter_markdown_inline() -> *const ();
#[cfg(feature = "lang-perl")]
fn tree_sitter_perl() -> *const ();
#[cfg(feature = "lang-scss")]
fn tree_sitter_scss() -> *const ();
#[cfg(feature = "lang-surface")]
fn tree_sitter_surface() -> *const ();
#[cfg(feature = "lang-typst")]
fn tree_sitter_typst() -> *const ();
#[cfg(feature = "lang-nushell")]
fn tree_sitter_nu() -> *const ();
#[cfg(feature = "lang-vim")]
fn tree_sitter_vim() -> *const ();
#[cfg(feature = "lang-vue")]
fn tree_sitter_vue() -> *const ();
#[cfg(feature = "lang-wat")]
fn tree_sitter_wat() -> *const ();
}
include!(concat!(env!("OUT_DIR"), "/queries_constants.rs"));
pub(crate) trait LanguageConfig {
fn config(&self) -> &'static HighlightConfiguration;
}
impl LanguageConfig for Language {
fn config(&self) -> &'static HighlightConfiguration {
match self {
#[cfg(feature = "lang-angular")]
Language::Angular => &ANGULAR_CONFIG,
#[cfg(feature = "lang-asm")]
Language::Assembly => &ASM_CONFIG,
#[cfg(feature = "lang-astro")]
Language::Astro => &ASTRO_CONFIG,
#[cfg(feature = "lang-bash")]
Language::Bash => &BASH_CONFIG,
#[cfg(feature = "lang-c")]
Language::C => &C_CONFIG,
#[cfg(feature = "lang-caddy")]
Language::Caddy => &CADDY_CONFIG,
#[cfg(feature = "lang-clojure")]
Language::Clojure => &CLOJURE_CONFIG,
#[cfg(feature = "lang-comment")]
Language::Comment => &COMMENT_CONFIG,
#[cfg(feature = "lang-commonlisp")]
Language::CommonLisp => &COMMONLISP_CONFIG,
#[cfg(feature = "lang-cmake")]
Language::CMake => &CMAKE_CONFIG,
#[cfg(feature = "lang-csharp")]
Language::CSharp => &CSHARP_CONFIG,
#[cfg(feature = "lang-csv")]
Language::CSV => &CSV_CONFIG,
#[cfg(feature = "lang-cpp")]
Language::CPlusPlus => &CPP_CONFIG,
#[cfg(feature = "lang-css")]
Language::CSS => &CSS_CONFIG,
#[cfg(feature = "lang-dart")]
Language::Dart => &DART_CONFIG,
Language::Diff => &DIFF_CONFIG,
#[cfg(feature = "lang-dockerfile")]
Language::Dockerfile => &DOCKERFILE_CONFIG,
#[cfg(feature = "lang-eex")]
Language::EEx => &EEX_CONFIG,
#[cfg(feature = "lang-ejs")]
Language::EJS => &EJS_CONFIG,
#[cfg(feature = "lang-erb")]
Language::ERB => &ERB_CONFIG,
#[cfg(feature = "lang-elixir")]
Language::Elixir => &ELIXIR_CONFIG,
#[cfg(feature = "lang-elm")]
Language::Elm => &ELM_CONFIG,
#[cfg(feature = "lang-erlang")]
Language::Erlang => &ERLANG_CONFIG,
#[cfg(feature = "lang-fish")]
Language::Fish => &FISH_CONFIG,
#[cfg(feature = "lang-fsharp")]
Language::FSharp => &FSHARP_CONFIG,
#[cfg(feature = "lang-gleam")]
Language::Gleam => &GLEAM_CONFIG,
#[cfg(feature = "lang-glimmer")]
Language::Glimmer => &GLIMMER_CONFIG,
#[cfg(feature = "lang-go")]
Language::Go => &GO_CONFIG,
#[cfg(feature = "lang-graphql")]
Language::GraphQL => &GRAPHQL_CONFIG,
#[cfg(feature = "lang-haskell")]
Language::Haskell => &HASKELL_CONFIG,
#[cfg(feature = "lang-hcl")]
Language::HCL => &HCL_CONFIG,
#[cfg(feature = "lang-heex")]
Language::HEEx => &HEEX_CONFIG,
#[cfg(feature = "lang-html")]
Language::HTML => &HTML_CONFIG,
#[cfg(feature = "lang-http")]
Language::HTTP => &HTTP_CONFIG,
#[cfg(feature = "lang-iex")]
Language::IEx => &IEX_CONFIG,
#[cfg(feature = "lang-java")]
Language::Java => &JAVA_CONFIG,
#[cfg(feature = "lang-javascript")]
Language::JavaScript => &JAVASCRIPT_CONFIG,
#[cfg(feature = "lang-json")]
Language::JSON => &JSON_CONFIG,
#[cfg(feature = "lang-kotlin")]
Language::Kotlin => &KOTLIN_CONFIG,
#[cfg(feature = "lang-latex")]
Language::LaTeX => &LATEX_CONFIG,
#[cfg(feature = "lang-liquid")]
Language::Liquid => &LIQUID_CONFIG,
#[cfg(feature = "lang-llvm")]
Language::Llvm => &LLVM_CONFIG,
#[cfg(feature = "lang-lua")]
Language::Lua => &LUA_CONFIG,
#[cfg(feature = "lang-objc")]
Language::ObjC => &OBJC_CONFIG,
#[cfg(feature = "lang-ocaml")]
Language::OCaml => &OCAML_CONFIG,
#[cfg(feature = "lang-ocaml")]
Language::OCamlInterface => &OCAML_INTERFACE_CONFIG,
#[cfg(feature = "lang-make")]
Language::Make => &MAKE_CONFIG,
#[cfg(feature = "lang-markdown")]
Language::Markdown => &MARKDOWN_CONFIG,
#[cfg(feature = "lang-markdown-inline")]
Language::MarkdownInline => &MARKDOWN_INLINE_CONFIG,
#[cfg(feature = "lang-nix")]
Language::Nix => &NIX_CONFIG,
#[cfg(feature = "lang-nushell")]
Language::Nushell => &NUSHELL_CONFIG,
#[cfg(feature = "lang-perl")]
Language::Perl => &PERL_CONFIG,
#[cfg(feature = "lang-php")]
Language::Php => &PHP_CONFIG,
#[cfg(feature = "lang-powershell")]
Language::PowerShell => &POWERSHELL_CONFIG,
#[cfg(feature = "lang-protobuf")]
Language::ProtoBuf => &PROTO_BUF_CONFIG,
#[cfg(feature = "lang-python")]
Language::Python => &PYTHON_CONFIG,
#[cfg(feature = "lang-r")]
Language::R => &R_CONFIG,
#[cfg(feature = "lang-regex")]
Language::Regex => ®EX_CONFIG,
#[cfg(feature = "lang-ruby")]
Language::Ruby => &RUBY_CONFIG,
#[cfg(feature = "lang-rust")]
Language::Rust => &RUST_CONFIG,
#[cfg(feature = "lang-scala")]
Language::Scala => &SCALA_CONFIG,
#[cfg(feature = "lang-scss")]
Language::SCSS => &SCSS_CONFIG,
#[cfg(feature = "lang-sql")]
Language::SQL => &SQL_CONFIG,
#[cfg(feature = "lang-surface")]
Language::Surface => &SURFACE_CONFIG,
#[cfg(feature = "lang-svelte")]
Language::Svelte => &SVELTE_CONFIG,
#[cfg(feature = "lang-swift")]
Language::Swift => &SWIFT_CONFIG,
#[cfg(feature = "lang-toml")]
Language::Toml => &TOML_CONFIG,
#[cfg(feature = "lang-typescript")]
Language::TypeScript => &TYPESCRIPT_CONFIG,
#[cfg(feature = "lang-tsx")]
Language::Tsx => &TSX_CONFIG,
#[cfg(feature = "lang-typst")]
Language::Typst => &TYPST_CONFIG,
#[cfg(feature = "lang-vim")]
Language::Vim => &VIM_CONFIG,
#[cfg(feature = "lang-vue")]
Language::Vue => &VUE_CONFIG,
#[cfg(feature = "lang-wat")]
Language::Wat => &WAT_CONFIG,
#[cfg(feature = "lang-xml")]
Language::XML => &XML_CONFIG,
#[cfg(feature = "lang-yaml")]
Language::YAML => &YAML_CONFIG,
#[cfg(feature = "lang-zig")]
Language::Zig => &ZIG_CONFIG,
_ => &PLAIN_TEXT_CONFIG,
}
}
}
#[cfg(feature = "lang-angular")]
static ANGULAR_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_angular) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"angular",
ANGULAR_HIGHLIGHTS,
ANGULAR_INJECTIONS,
ANGULAR_LOCALS,
)
.expect("failed to create angular highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-asm")]
static ASM_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_asm::LANGUAGE),
"asm",
ASM_HIGHLIGHTS,
ASM_INJECTIONS,
ASM_LOCALS,
)
.expect("failed to create asm highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-astro")]
static ASTRO_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_astro) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"astro",
ASTRO_HIGHLIGHTS,
ASTRO_INJECTIONS,
ASTRO_LOCALS,
)
.expect("failed to create astro highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-bash")]
static BASH_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_bash::LANGUAGE),
"bash",
BASH_HIGHLIGHTS,
BASH_INJECTIONS,
BASH_LOCALS,
)
.expect("failed to create bash highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-c")]
static C_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_c::LANGUAGE),
"c",
C_HIGHLIGHTS,
C_INJECTIONS,
C_LOCALS,
)
.expect("failed to create c highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-caddy")]
static CADDY_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_caddy) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"caddy",
CADDY_HIGHLIGHTS,
CADDY_INJECTIONS,
CADDY_LOCALS,
)
.expect("failed to create caddy highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-clojure")]
static CLOJURE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_clojure) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"clojure",
CLOJURE_HIGHLIGHTS,
CLOJURE_INJECTIONS,
CLOJURE_LOCALS,
)
.expect("failed to create clojure highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-comment")]
static COMMENT_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_comment::LANGUAGE),
"comment",
COMMENT_HIGHLIGHTS,
COMMENT_INJECTIONS,
COMMENT_LOCALS,
)
.expect("failed to create comment highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-commonlisp")]
static COMMONLISP_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_commonlisp) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"common_lisp",
COMMONLISP_HIGHLIGHTS,
COMMONLISP_INJECTIONS,
COMMONLISP_LOCALS,
)
.expect("failed to create common_lisp highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-cmake")]
static CMAKE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_cmake::LANGUAGE),
"cmake",
CMAKE_HIGHLIGHTS,
CMAKE_INJECTIONS,
CMAKE_LOCALS,
)
.expect("failed to create cmake highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-csharp")]
static CSHARP_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_c_sharp::LANGUAGE),
"csharp",
C_SHARP_HIGHLIGHTS,
C_SHARP_INJECTIONS,
C_SHARP_LOCALS,
)
.expect("failed to create csharp highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-csv")]
static CSV_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_csv) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"csv",
CSV_HIGHLIGHTS,
CSV_INJECTIONS,
CSV_LOCALS,
)
.expect("failed to create csv highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-dart")]
static DART_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_dart) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"dart",
DART_HIGHLIGHTS,
DART_INJECTIONS,
DART_LOCALS,
)
.expect("failed to create dart highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-cpp")]
static CPP_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_cpp::LANGUAGE),
"cpp",
CPP_HIGHLIGHTS,
CPP_INJECTIONS,
CPP_LOCALS,
)
.expect("failed to create cpp highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-css")]
static CSS_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_css::LANGUAGE),
"css",
CSS_HIGHLIGHTS,
CSS_INJECTIONS,
CSS_LOCALS,
)
.expect("failed to create css highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
static DIFF_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_diff::LANGUAGE),
"diff",
DIFF_HIGHLIGHTS,
DIFF_INJECTIONS,
DIFF_LOCALS,
)
.expect("failed to create diff highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-dockerfile")]
static DOCKERFILE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_dockerfile) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"dockerfile",
DOCKERFILE_HIGHLIGHTS,
DOCKERFILE_INJECTIONS,
DOCKERFILE_LOCALS,
)
.expect("failed to create dockerfile highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-eex")]
static EEX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_eex) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"eex",
EEX_HIGHLIGHTS,
EEX_INJECTIONS,
EEX_LOCALS,
)
.expect("failed to create eex highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-fish")]
static FISH_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_fish) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"fish",
FISH_HIGHLIGHTS,
FISH_INJECTIONS,
FISH_LOCALS,
)
.expect("failed to create fish highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-ejs")]
static EJS_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_embedded_template::LANGUAGE),
"ejs",
EMBEDDED_TEMPLATE_HIGHLIGHTS,
EMBEDDED_TEMPLATE_INJECTIONS,
EMBEDDED_TEMPLATE_LOCALS,
)
.expect("failed to create ejs highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-erb")]
static ERB_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_embedded_template::LANGUAGE),
"erb",
EMBEDDED_TEMPLATE_HIGHLIGHTS,
EMBEDDED_TEMPLATE_INJECTIONS,
EMBEDDED_TEMPLATE_LOCALS,
)
.expect("failed to create erb highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-elixir")]
static ELIXIR_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_elixir::LANGUAGE),
"elixir",
ELIXIR_HIGHLIGHTS,
ELIXIR_INJECTIONS,
ELIXIR_LOCALS,
)
.expect("failed to create elixir highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-elm")]
static ELM_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_elm::LANGUAGE),
"elm",
ELM_HIGHLIGHTS,
ELM_INJECTIONS,
ELM_LOCALS,
)
.expect("failed to create elm highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-erlang")]
static ERLANG_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_erlang::LANGUAGE),
"erlang",
ERLANG_HIGHLIGHTS,
ERLANG_INJECTIONS,
ERLANG_LOCALS,
)
.expect("failed to create erlang highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-fsharp")]
static FSHARP_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_fsharp::LANGUAGE_FSHARP),
"fsharp",
FSHARP_HIGHLIGHTS,
FSHARP_INJECTIONS,
FSHARP_LOCALS,
)
.expect("failed to create fsharp highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-gleam")]
static GLEAM_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_gleam) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"gleam",
GLEAM_HIGHLIGHTS,
GLEAM_INJECTIONS,
GLEAM_LOCALS,
)
.expect("failed to create gleam highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-glimmer")]
static GLIMMER_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_glimmer) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"glimmer",
GLIMMER_HIGHLIGHTS,
GLIMMER_INJECTIONS,
GLIMMER_LOCALS,
)
.expect("failed to create glimmer highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-go")]
static GO_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_go::LANGUAGE),
"go",
GO_HIGHLIGHTS,
GO_INJECTIONS,
GO_LOCALS,
)
.expect("failed to create go highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-graphql")]
static GRAPHQL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_graphql) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"graphql",
GRAPHQL_HIGHLIGHTS,
GRAPHQL_INJECTIONS,
GRAPHQL_LOCALS,
)
.expect("failed to create graphql highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-haskell")]
static HASKELL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_haskell::LANGUAGE),
"haskell",
HASKELL_HIGHLIGHTS,
HASKELL_INJECTIONS,
HASKELL_LOCALS,
)
.expect("failed to create haskell highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-hcl")]
static HCL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_hcl) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"hcl",
HCL_HIGHLIGHTS,
HCL_INJECTIONS,
HCL_LOCALS,
)
.expect("failed to create hcl highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-heex")]
static HEEX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_heex::LANGUAGE),
"heex",
HEEX_HIGHLIGHTS,
HEEX_INJECTIONS,
HEEX_LOCALS,
)
.expect("failed to create heex highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-html")]
static HTML_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_html::LANGUAGE),
"html",
HTML_HIGHLIGHTS,
HTML_INJECTIONS,
HTML_LOCALS,
)
.expect("failed to create html highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-http")]
static HTTP_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_http) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"http",
HTTP_HIGHLIGHTS,
HTTP_INJECTIONS,
HTTP_LOCALS,
)
.expect("failed to create http highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-iex")]
static IEX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_iex) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"iex",
IEX_HIGHLIGHTS,
IEX_INJECTIONS,
IEX_LOCALS,
)
.expect("failed to create iex highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-java")]
static JAVA_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_java::LANGUAGE),
"java",
JAVA_HIGHLIGHTS,
JAVA_INJECTIONS,
JAVA_LOCALS,
)
.expect("failed to create java highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-javascript")]
static JAVASCRIPT_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_javascript::LANGUAGE),
"javascript",
JAVASCRIPT_HIGHLIGHTS,
JAVASCRIPT_INJECTIONS,
JAVASCRIPT_LOCALS,
)
.expect("failed to create javascript highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-json")]
static JSON_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_json::LANGUAGE),
"json",
JSON_HIGHLIGHTS,
JSON_INJECTIONS,
JSON_LOCALS,
)
.expect("failed to create json highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-kotlin")]
static KOTLIN_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_kotlin) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"kotlin",
KOTLIN_HIGHLIGHTS,
KOTLIN_INJECTIONS,
KOTLIN_LOCALS,
)
.expect("failed to create kotlin highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-latex")]
static LATEX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_latex) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"latex",
LATEX_HIGHLIGHTS,
LATEX_INJECTIONS,
LATEX_LOCALS,
)
.expect("failed to create latex highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-liquid")]
static LIQUID_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_liquid) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"liquid",
LIQUID_HIGHLIGHTS,
LIQUID_INJECTIONS,
LIQUID_LOCALS,
)
.expect("failed to create liquid highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-llvm")]
static LLVM_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_llvm) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"llvm",
LLVM_HIGHLIGHTS,
LLVM_INJECTIONS,
LLVM_LOCALS,
)
.expect("failed to create llvm highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-lua")]
static LUA_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_lua::LANGUAGE),
"lua",
LUA_HIGHLIGHTS,
LUA_INJECTIONS,
LUA_LOCALS,
)
.expect("failed to create lua highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-objc")]
static OBJC_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_objc::LANGUAGE),
"objc",
OBJC_HIGHLIGHTS,
OBJC_INJECTIONS,
OBJC_LOCALS,
)
.expect("failed to create objc highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-ocaml")]
static OCAML_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_ocaml::LANGUAGE_OCAML),
"ocaml",
OCAML_HIGHLIGHTS,
OCAML_INJECTIONS,
OCAML_LOCALS,
)
.expect("failed to create ocaml highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-ocaml")]
static OCAML_INTERFACE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_ocaml::LANGUAGE_OCAML_INTERFACE),
"ocaml_interface",
OCAML_INTERFACE_HIGHLIGHTS,
OCAML_INTERFACE_INJECTIONS,
OCAML_INTERFACE_LOCALS,
)
.expect("failed to create ocam_interface highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-make")]
static MAKE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_make) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"make",
MAKE_HIGHLIGHTS,
MAKE_INJECTIONS,
MAKE_LOCALS,
)
.expect("failed to create make highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-markdown")]
static MARKDOWN_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_markdown) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"markdown",
MARKDOWN_HIGHLIGHTS,
MARKDOWN_INJECTIONS,
MARKDOWN_LOCALS,
)
.expect("failed to create markdown highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-markdown-inline")]
static MARKDOWN_INLINE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn =
unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_markdown_inline) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"markdown_inline",
MARKDOWN_INLINE_HIGHLIGHTS,
MARKDOWN_INLINE_INJECTIONS,
MARKDOWN_INLINE_LOCALS,
)
.expect("failed to create markdown highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-nix")]
static NIX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_nix::LANGUAGE),
"nix",
NIX_HIGHLIGHTS,
NIX_INJECTIONS,
NIX_LOCALS,
)
.expect("failed to create nix configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-nushell")]
static NUSHELL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_nu) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"nu",
NU_HIGHLIGHTS,
NU_INJECTIONS,
NU_LOCALS,
)
.expect("failed to create nushell highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-perl")]
static PERL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_perl) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"perl",
PERL_HIGHLIGHTS,
PERL_INJECTIONS,
PERL_LOCALS,
)
.expect("failed to create perl highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-php")]
static PHP_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_php::LANGUAGE_PHP_ONLY),
"php",
PHP_ONLY_HIGHLIGHTS,
PHP_ONLY_INJECTIONS,
PHP_ONLY_LOCALS,
)
.expect("failed to create php highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-powershell")]
static POWERSHELL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_powershell::LANGUAGE),
"poweshell",
POWERSHELL_HIGHLIGHTS,
POWERSHELL_INJECTIONS,
POWERSHELL_LOCALS,
)
.expect("failed to create poweshell highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-protobuf")]
static PROTO_BUF_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_proto::LANGUAGE),
"protobuf",
PROTO_HIGHLIGHTS,
PROTO_INJECTIONS,
PROTO_LOCALS,
)
.expect("failed to create protobuf highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
static PLAIN_TEXT_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_diff::LANGUAGE),
"plaintext",
"",
"",
"",
)
.expect("failed to create plaintext highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-python")]
static PYTHON_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_python::LANGUAGE),
"python",
PYTHON_HIGHLIGHTS,
PYTHON_INJECTIONS,
PYTHON_LOCALS,
)
.expect("failed to create python highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-r")]
static R_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_r::LANGUAGE),
"r",
R_HIGHLIGHTS,
R_INJECTIONS,
R_LOCALS,
)
.expect("failed to create r highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-regex")]
static REGEX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_regex::LANGUAGE),
"regex",
REGEX_HIGHLIGHTS,
REGEX_INJECTIONS,
REGEX_LOCALS,
)
.expect("failed to create regex highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-ruby")]
static RUBY_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_ruby::LANGUAGE),
"ruby",
RUBY_HIGHLIGHTS,
RUBY_INJECTIONS,
RUBY_LOCALS,
)
.expect("failed to create ruby highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-rust")]
static RUST_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_rust::LANGUAGE),
"rust",
RUST_HIGHLIGHTS,
RUST_INJECTIONS,
RUST_LOCALS,
)
.expect("failed to create rust highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-scala")]
static SCALA_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_scala::LANGUAGE),
"scala",
SCALA_HIGHLIGHTS,
SCALA_INJECTIONS,
SCALA_LOCALS,
)
.expect("failed to create scala highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-scss")]
static SCSS_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_scss) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"scss",
SCSS_HIGHLIGHTS,
SCSS_INJECTIONS,
SCSS_LOCALS,
)
.expect("failed to create scss highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-sql")]
static SQL_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_sequel::LANGUAGE),
"sql",
SQL_HIGHLIGHTS,
SQL_INJECTIONS,
SQL_LOCALS,
)
.expect("failed to create sql highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-surface")]
static SURFACE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_surface) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"surface",
SURFACE_HIGHLIGHTS,
SURFACE_INJECTIONS,
SURFACE_LOCALS,
)
.expect("failed to create surface highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-svelte")]
static SVELTE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_svelte_ng::LANGUAGE),
"svelte",
SVELTE_HIGHLIGHTS,
SVELTE_INJECTIONS,
SVELTE_LOCALS,
)
.expect("failed to create svelte highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-swift")]
static SWIFT_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_swift::LANGUAGE),
"swift",
SWIFT_HIGHLIGHTS,
SWIFT_INJECTIONS,
SWIFT_LOCALS,
)
.expect("failed to create swift highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-toml")]
static TOML_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_toml_ng::LANGUAGE),
"toml",
TOML_HIGHLIGHTS,
TOML_INJECTIONS,
TOML_LOCALS,
)
.expect("failed to create toml highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-typescript")]
static TYPESCRIPT_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_typescript::LANGUAGE_TYPESCRIPT),
"typescript",
TYPESCRIPT_HIGHLIGHTS,
TYPESCRIPT_INJECTIONS,
TYPESCRIPT_LOCALS,
)
.expect("failed to create typescript highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-tsx")]
static TSX_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_typescript::LANGUAGE_TSX),
"tsx",
TSX_HIGHLIGHTS,
TSX_INJECTIONS,
TSX_LOCALS,
)
.expect("failed to create tsx highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-typst")]
static TYPST_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_typst) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"typst",
TYPST_HIGHLIGHTS,
TYPST_INJECTIONS,
TYPST_LOCALS,
)
.expect("failed to create typst highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-vim")]
static VIM_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_vim) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"vim",
VIM_HIGHLIGHTS,
VIM_INJECTIONS,
VIM_LOCALS,
)
.expect("failed to create vim highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-vue")]
static VUE_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_vue) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"vue",
VUE_HIGHLIGHTS,
VUE_INJECTIONS,
VUE_LOCALS,
)
.expect("failed to create vue highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-wat")]
static WAT_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let language_fn = unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_wat) };
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(language_fn),
"wat",
WAT_HIGHLIGHTS,
WAT_INJECTIONS,
WAT_LOCALS,
)
.expect("failed to create wat highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-xml")]
static XML_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_xml::LANGUAGE_XML),
"xml",
XML_HIGHLIGHTS,
XML_INJECTIONS,
XML_LOCALS,
)
.expect("failed to create xml highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-yaml")]
static YAML_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_yaml::LANGUAGE),
"yaml",
YAML_HIGHLIGHTS,
YAML_INJECTIONS,
YAML_LOCALS,
)
.expect("failed to create yaml highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(feature = "lang-zig")]
static ZIG_CONFIG: LazyLock<HighlightConfiguration> = LazyLock::new(|| {
let mut config = HighlightConfiguration::new(
tree_sitter::Language::new(tree_sitter_zig::LANGUAGE),
"zig",
ZIG_HIGHLIGHTS,
ZIG_INJECTIONS,
ZIG_LOCALS,
)
.expect("failed to create zig highlight configuration");
config.configure(&HIGHLIGHT_NAMES);
config
});
#[cfg(test)]
mod tests {
use super::*;
use crate::vendor::tree_sitter_highlight::Highlighter;
use serde::Deserialize;
use std::{fs, path::PathBuf};
#[derive(Debug, Deserialize)]
struct GuessCase {
name: String,
input: Option<String>,
source: String,
expected: String,
}
#[test]
fn test_match_exact_name() {
let lang = Language::guess(Some("elixir"), "");
assert_eq!(lang.name(), "Elixir");
let lang = Language::guess(Some("Elixir"), "");
assert_eq!(lang.name(), "Elixir");
}
#[test]
fn test_match_filename() {
let lang = Language::guess(Some("app.ex"), "");
assert_eq!(lang.name(), "Elixir");
}
#[test]
fn test_match_extension() {
let lang = Language::guess(Some(".ex"), "");
assert_eq!(lang.name(), "Elixir");
}
#[test]
fn test_match_path_with_extension() {
let lang = Language::guess(Some("lib/app.ex"), "");
assert_eq!(lang.name(), "Elixir");
}
#[test]
fn test_no_match_fallbacks_to_plain_text() {
let lang = Language::guess(Some("none"), "");
assert_eq!(lang.name(), "Plain Text");
}
fn samples_dir() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../samples")
}
fn guess_cases() -> Vec<GuessCase> {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("../../fixtures/language-guess-cases.json");
serde_json::from_str(&fs::read_to_string(path).expect("guess cases should exist"))
.expect("guess cases should be valid json")
}
#[test]
fn shared_guess_cases_match_expected_results() {
for case in guess_cases() {
let language = Language::guess(case.input.as_deref(), &case.source);
assert_eq!(
language.id_name(),
case.expected,
"case failed: {}",
case.name
);
}
}
fn assert_language_sample_highlights(lang: Language, expected_name: &str, sample_file: &str) {
let config = lang.config();
let source =
fs::read_to_string(samples_dir().join(sample_file)).expect("sample should exist");
assert_eq!(lang.name(), expected_name);
let mut highlighter = Highlighter::new();
let events = highlighter
.highlight(config, source.as_bytes(), None, |injected| {
injected
.parse::<Language>()
.ok()
.map(|language| language.config())
})
.expect("highlight should start");
let rendered = events
.collect::<Result<Vec<_>, _>>()
.expect("highlight should finish");
assert!(
!rendered.is_empty(),
"expected highlight events for {sample_file}"
);
}
macro_rules! language_sample_tests {
($($(#[$meta:meta])* $name:ident => ($lang:expr, $expected:literal, $sample:literal);)+) => {
$(
#[test]
$(#[$meta])*
fn $name() {
assert_language_sample_highlights($lang, $expected, $sample);
}
)+
};
}
language_sample_tests! {
#[cfg(feature = "lang-angular")]
test_angular_config_loads => (Language::Angular, "Angular", "angular.angular");
#[cfg(feature = "lang-asm")]
test_asm_config_loads => (Language::Assembly, "Assembly", "assembly.s");
#[cfg(feature = "lang-astro")]
test_astro_config_loads => (Language::Astro, "Astro", "astro.astro");
#[cfg(feature = "lang-bash")]
test_bash_config_loads => (Language::Bash, "Bash", "bash.sh");
#[cfg(feature = "lang-c")]
test_c_config_loads => (Language::C, "C", "c.c");
#[cfg(feature = "lang-caddy")]
test_caddy_config_loads => (Language::Caddy, "Caddy", "caddy.caddyfile");
#[cfg(feature = "lang-clojure")]
test_clojure_config_loads => (Language::Clojure, "Clojure", "clojure.clj");
#[cfg(feature = "lang-cmake")]
test_cmake_config_loads => (Language::CMake, "CMake", "cmake.cmake");
#[cfg(feature = "lang-comment")]
test_comment_config_loads => (Language::Comment, "Comment", "comment.txt");
#[cfg(feature = "lang-commonlisp")]
test_commonlisp_config_loads => (Language::CommonLisp, "Common Lisp", "commonlisp.lisp");
#[cfg(feature = "lang-cpp")]
test_cpp_config_loads => (Language::CPlusPlus, "C++", "cpp.cpp");
#[cfg(feature = "lang-csharp")]
test_csharp_config_loads => (Language::CSharp, "C#", "csharp.cs");
#[cfg(feature = "lang-css")]
test_css_config_loads => (Language::CSS, "CSS", "css.css");
#[cfg(feature = "lang-csv")]
test_csv_config_loads => (Language::CSV, "CSV", "csv.csv");
#[cfg(feature = "lang-dart")]
test_dart_config_loads => (Language::Dart, "Dart", "dart.dart");
test_diff_config_loads => (Language::Diff, "Diff", "diff.diff");
#[cfg(feature = "lang-dockerfile")]
test_dockerfile_config_loads => (Language::Dockerfile, "Dockerfile", "dockerfile.dockerfile");
#[cfg(feature = "lang-eex")]
test_eex_config_loads => (Language::EEx, "Eex", "eex.eex");
#[cfg(feature = "lang-ejs")]
test_ejs_config_loads => (Language::EJS, "EJS", "ejs.ejs");
#[cfg(feature = "lang-erb")]
test_erb_config_loads => (Language::ERB, "ERB", "erb.erb");
#[cfg(feature = "lang-elixir")]
test_elixir_config_loads => (Language::Elixir, "Elixir", "elixir.ex");
#[cfg(feature = "lang-elm")]
test_elm_config_loads => (Language::Elm, "Elm", "elm.elm");
#[cfg(feature = "lang-erlang")]
test_erlang_config_loads => (Language::Erlang, "Erlang", "erlang.erl");
#[cfg(feature = "lang-fish")]
test_fish_config_loads => (Language::Fish, "Fish", "fish.fish");
#[cfg(feature = "lang-fsharp")]
test_fsharp_config_loads => (Language::FSharp, "F#", "fsharp.fs");
#[cfg(feature = "lang-gleam")]
test_gleam_config_loads => (Language::Gleam, "Gleam", "gleam.gleam");
#[cfg(feature = "lang-glimmer")]
test_glimmer_config_loads => (Language::Glimmer, "Glimmer", "glimmer.hbs");
#[cfg(feature = "lang-go")]
test_go_config_loads => (Language::Go, "Go", "go.go");
#[cfg(feature = "lang-graphql")]
test_graphql_config_loads => (Language::GraphQL, "GraphQL", "graphql.graphql");
#[cfg(feature = "lang-haskell")]
test_haskell_config_loads => (Language::Haskell, "Haskell", "haskell.hs");
#[cfg(feature = "lang-hcl")]
test_hcl_config_loads => (Language::HCL, "HCL", "hcl.hcl");
#[cfg(feature = "lang-heex")]
test_heex_config_loads => (Language::HEEx, "HEEx", "heex.heex");
#[cfg(feature = "lang-html")]
test_html_config_loads => (Language::HTML, "HTML", "html.html");
#[cfg(feature = "lang-http")]
test_http_config_loads => (Language::HTTP, "HTTP", "http.http");
#[cfg(feature = "lang-iex")]
test_iex_config_loads => (Language::IEx, "IEx", "iex.iex");
#[cfg(feature = "lang-java")]
test_java_config_loads => (Language::Java, "Java", "java.java");
#[cfg(feature = "lang-javascript")]
test_javascript_config_loads => (Language::JavaScript, "JavaScript", "javascript.js");
#[cfg(feature = "lang-json")]
test_json_config_loads => (Language::JSON, "JSON", "json.json");
#[cfg(feature = "lang-kotlin")]
test_kotlin_config_loads => (Language::Kotlin, "Kotlin", "kotlin.kt");
#[cfg(feature = "lang-latex")]
test_latex_config_loads => (Language::LaTeX, "LaTeX", "latex.tex");
#[cfg(feature = "lang-liquid")]
test_liquid_config_loads => (Language::Liquid, "Liquid", "liquid.liquid");
#[cfg(feature = "lang-llvm")]
test_llvm_config_loads => (Language::Llvm, "LLVM", "llvm.ll");
#[cfg(feature = "lang-lua")]
test_lua_config_loads => (Language::Lua, "Lua", "lua.lua");
#[cfg(feature = "lang-make")]
test_make_config_loads => (Language::Make, "Make", "make.mk");
#[cfg(feature = "lang-markdown")]
test_markdown_config_loads => (Language::Markdown, "Markdown", "markdown.md");
#[cfg(feature = "lang-markdown-inline")]
test_markdown_inline_config_loads => (Language::MarkdownInline, "Markdown Inline", "markdown_inline.txt");
#[cfg(feature = "lang-nix")]
test_nix_config_loads => (Language::Nix, "Nix", "nix.nix");
#[cfg(feature = "lang-nushell")]
test_nushell_config_loads => (Language::Nushell, "Nushell", "nushell.nu");
#[cfg(feature = "lang-objc")]
test_objc_config_loads => (Language::ObjC, "Objective-C", "objc.m");
#[cfg(feature = "lang-ocaml")]
test_ocaml_config_loads => (Language::OCaml, "OCaml", "ocaml.ml");
#[cfg(feature = "lang-ocaml")]
test_ocaml_interface_config_loads => (Language::OCamlInterface, "OCaml Interface", "ocamlinterface.mli");
#[cfg(feature = "lang-perl")]
test_perl_config_loads => (Language::Perl, "Perl", "perl.pm");
#[cfg(feature = "lang-php")]
test_php_config_loads => (Language::Php, "PHP", "php.php");
test_plaintext_config_loads => (Language::PlainText, "Plain Text", "plaintext.txt");
#[cfg(feature = "lang-powershell")]
test_powershell_config_loads => (Language::PowerShell, "PowerShell", "powershell.ps1");
#[cfg(feature = "lang-protobuf")]
test_protobuf_config_loads => (Language::ProtoBuf, "Protocol Buffer", "protobuf.proto");
#[cfg(feature = "lang-python")]
test_python_config_loads => (Language::Python, "Python", "python.py");
#[cfg(feature = "lang-r")]
test_r_config_loads => (Language::R, "R", "r.r");
#[cfg(feature = "lang-regex")]
test_regex_config_loads => (Language::Regex, "Regex", "regex.regex");
#[cfg(feature = "lang-ruby")]
test_ruby_config_loads => (Language::Ruby, "Ruby", "ruby.rb");
#[cfg(feature = "lang-rust")]
test_rust_config_loads => (Language::Rust, "Rust", "rust.rs");
#[cfg(feature = "lang-scala")]
test_scala_config_loads => (Language::Scala, "Scala", "scala.scala");
#[cfg(feature = "lang-scss")]
test_scss_config_loads => (Language::SCSS, "SCSS", "scss.scss");
#[cfg(feature = "lang-sql")]
test_sql_config_loads => (Language::SQL, "SQL", "sql.sql");
#[cfg(feature = "lang-surface")]
test_surface_config_loads => (Language::Surface, "Surface", "surface.sface");
#[cfg(feature = "lang-svelte")]
test_svelte_config_loads => (Language::Svelte, "Svelte", "svelte.svelte");
#[cfg(feature = "lang-swift")]
test_swift_config_loads => (Language::Swift, "Swift", "swift.swift");
#[cfg(feature = "lang-toml")]
test_toml_config_loads => (Language::Toml, "TOML", "toml.toml");
#[cfg(feature = "lang-tsx")]
test_tsx_config_loads => (Language::Tsx, "TSX", "tsx.tsx");
#[cfg(feature = "lang-typescript")]
test_typescript_config_loads => (Language::TypeScript, "TypeScript", "typescript.ts");
#[cfg(feature = "lang-typst")]
test_typst_config_loads => (Language::Typst, "Typst", "typst.typ");
#[cfg(feature = "lang-vim")]
test_vim_config_loads => (Language::Vim, "Vim", "vim.vim");
#[cfg(feature = "lang-vue")]
test_vue_config_loads => (Language::Vue, "Vue", "vue.vue");
#[cfg(feature = "lang-wat")]
test_wat_config_loads => (Language::Wat, "WAT", "wat.wat");
#[cfg(feature = "lang-xml")]
test_xml_config_loads => (Language::XML, "XML", "xml.xml");
#[cfg(feature = "lang-yaml")]
test_yaml_config_loads => (Language::YAML, "YAML", "yaml.yml");
#[cfg(feature = "lang-zig")]
test_zig_config_loads => (Language::Zig, "Zig", "zig.zig");
}
#[test]
fn test_available_languages() {
let languages = available_languages();
for (id_name, (friendly_name, _extensions)) in languages {
assert!(!id_name.is_empty());
assert!(!friendly_name.is_empty());
}
}
}