feat(markdown): add support for math rendering with typst and katex

components/config/src/config/markup.rs

@@ -23,6 +23,15 @@ pub struct ThemeCss {
     pub filename: String,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum MathRendering {
+    #[default]
+    None,
+    Typst,
+    KaTeX,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(default)]
 pub struct Markdown {
@@ -65,6 +74,19 @@ pub struct Markdown {
     /// Whether to insert a link for each header like the ones you can see in this site if you hover one
     /// The default template can be overridden by creating a `anchor-link.html` in the `templates` directory
     pub insert_anchor_links: InsertAnchor,
+    /// Whether to enable math rendering in markdown files
+    pub math: MathRendering,
+    /// Whether to optimize generated math SVGs with svgo
+    pub math_svgo: bool,
+    /// Svgo configuration file path
+    pub math_svgo_config: Option<String>,
+    /// Injected CSS path for math rendering
+    pub math_css: Option<String>,
+    /// The directory where the cache for the math rendering and other stuff will be stored
+    pub cache_dir: Option<String>,
+    /// Whether to cache the rendered math
+    #[serde(skip)]
+    pub cache: bool,
 }
 
 impl Markdown {
@@ -240,6 +262,12 @@ impl Default for Markdown {
             extra_theme_set: Arc::new(None),
             lazy_async_image: false,
             insert_anchor_links: InsertAnchor::None,
+            math: MathRendering::default(),
+            math_svgo: false,
+            math_css: None,
+            math_svgo_config: None,
+            cache_dir: None,
+            cache: true,
         }
     }
 }

components/config/src/lib.rs

@@ -8,6 +8,7 @@ pub use crate::config::{
     languages::LanguageOptions,
     link_checker::LinkChecker,
     link_checker::LinkCheckerLevel,
+    markup::MathRendering,
     search::{IndexFormat, Search},
     slugify::Slugify,
     taxonomies::TaxonomyConfig,

components/content/src/page.rs

@@ -1,13 +1,16 @@
 /// A page, can be a blog post or a basic page
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use libs::once_cell::sync::Lazy;
 use libs::regex::Regex;
 use libs::tera::{Context as TeraContext, Tera};
 
 use config::Config;
 use errors::{Context, Result};
+use markdown::context::Caches;
+
 use markdown::{render_content, RenderContext};
 use utils::slugs::slugify_paths;
 use utils::table_of_contents::Heading;
@@ -212,6 +215,7 @@ impl Page {
         config: &Config,
         anchor_insert: InsertAnchor,
         shortcode_definitions: &HashMap<String, ShortcodeDefinition>,
+        caches: Arc<Caches>,
     ) -> Result<()> {
         let mut context = RenderContext::new(
             tera,
@@ -220,9 +224,12 @@ impl Page {
             &self.permalink,
             permalinks,
             anchor_insert,
+            caches,
         );
         context.set_shortcode_definitions(shortcode_definitions);
         context.set_current_page_path(&self.file.relative);
+        context.set_parent_absolute(&self.file.parent);
+
         context.tera_context.insert("page", &SerializingPage::new(self, None, false));
 
         let res = render_content(&self.raw_content, &context)
@@ -300,8 +307,10 @@ mod tests {
     use std::fs::{create_dir, File};
     use std::io::Write;
     use std::path::{Path, PathBuf};
+    use std::sync::Arc;
 
     use libs::globset::{Glob, GlobSetBuilder};
+    use markdown::context::Caches;
     use tempfile::tempdir;
     use templates::ZOLA_TERA;
 
@@ -329,6 +338,7 @@ Hello world"#;
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            Arc::new(Caches::default()),
         )
         .unwrap();
 
@@ -357,6 +367,7 @@ Hello world"#;
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            Arc::new(Caches::default()),
         )
         .unwrap();
 
@@ -527,6 +538,7 @@ Hello world
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            Arc::new(Caches::default()),
         )
         .unwrap();
         assert_eq!(page.summary, Some("<p>Hello world</p>".to_string()));
@@ -561,6 +573,7 @@ And here's another. [^3]
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            Arc::new(Caches::default()),
         )
         .unwrap();
         assert_eq!(

components/content/src/section.rs

@@ -1,10 +1,12 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use libs::tera::{Context as TeraContext, Tera};
 
 use config::Config;
 use errors::{Context, Result};
+use markdown::context::Caches;
 use markdown::{render_content, RenderContext};
 use utils::fs::read_file;
 use utils::net::is_external_link;
@@ -150,6 +152,7 @@ impl Section {
         tera: &Tera,
         config: &Config,
         shortcode_definitions: &HashMap<String, ShortcodeDefinition>,
+        caches: Arc<Caches>,
     ) -> Result<()> {
         let mut context = RenderContext::new(
             tera,
@@ -158,9 +161,11 @@ impl Section {
             &self.permalink,
             permalinks,
             self.meta.insert_anchor_links.unwrap_or(config.markdown.insert_anchor_links),
+            caches,
         );
         context.set_shortcode_definitions(shortcode_definitions);
         context.set_current_page_path(&self.file.relative);
+        context.set_parent_absolute(&self.file.parent);
         context
             .tera_context
             .insert("section", &SerializingSection::new(self, SectionSerMode::ForMarkdown));

components/libs/Cargo.toml

@@ -9,7 +9,22 @@ ammonia = "4"
 atty = "0.2.11"
 base64 = "0.22"
 csv = "1"
-elasticlunr-rs = { version = "3.0.2", features = ["da", "no", "de", "du", "es", "fi", "fr", "hu", "it", "pt", "ro", "ru", "sv", "tr"] }
+elasticlunr-rs = { version = "3.0.2", features = [
+    "da",
+    "no",
+    "de",
+    "du",
+    "es",
+    "fi",
+    "fr",
+    "hu",
+    "it",
+    "pt",
+    "ro",
+    "ru",
+    "sv",
+    "tr",
+] }
 filetime = "0.2"
 gh-emoji = "1"
 glob = "0.3"
@@ -27,8 +42,10 @@ quickxml_to_serde = "0.6"
 rayon = "1"
 regex = "1"
 relative-path = "1"
-reqwest = { version = "0.12", default-features = false, features = ["blocking"] }
-grass = {version = "0.13", default-features = false, features = ["random"]}
+reqwest = { version = "0.12", default-features = false, features = [
+    "blocking",
+] }
+grass = { version = "0.13", default-features = false, features = ["random"] }
 serde_json = "1"
 serde_yaml = "0.9"
 sha2 = "0.10"

components/markdown/Cargo.toml

@@ -14,6 +14,21 @@ config = { path = "../config" }
 console = { path = "../console" }
 libs = { path = "../libs" }
 
+typst = "0.12.0"
+typst-assets = { version = "0.12.0", features = ["fonts"] }
+typst-svg = "0.12.0"
+time = { version = "0.3.37", features = ["local-offset"] }
+flate2 = "1.0.35"
+tar = "0.4.43"
+ttf-parser = "0.25.1"
+urlencoding = "2.1.3"
+bincode = "1.3.3"
+serde = { version = "1.0.130", features = ["derive"] }
+dashmap = { version = "6.1.0", features = ["serde"] }
+twox-hash = "2.1.0"
+dirs = "6.0.0"
+katex = { version = "0.4.6", default-features = false, features = ["duktape"] }
+
 [dev-dependencies]
 templates = { path = "../templates" }
 insta = "1.12.0"

components/markdown/benches/all.rs

@@ -1,11 +1,11 @@
 #![feature(test)]
 extern crate test;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 use config::Config;
 use libs::tera::Tera;
-use markdown::{render_content, RenderContext};
+use markdown::{context::Caches, render_content, RenderContext};
 use utils::types::InsertAnchor;
 
 const CONTENT: &str = r#"
@@ -95,6 +95,7 @@ fn bench_render_content_with_highlighting(b: &mut test::Bencher) {
         current_page_permalink,
         &permalinks_ctx,
         InsertAnchor::None,
+        Arc::new(Caches::default()),
     );
     let shortcode_def = utils::templates::get_shortcodes(&tera);
     context.set_shortcode_definitions(&shortcode_def);
@@ -116,6 +117,7 @@ fn bench_render_content_without_highlighting(b: &mut test::Bencher) {
         current_page_permalink,
         &permalinks_ctx,
         InsertAnchor::None,
+        Arc::new(Caches::default()),
     );
     let shortcode_def = utils::templates::get_shortcodes(&tera);
     context.set_shortcode_definitions(&shortcode_def);
@@ -137,6 +139,7 @@ fn bench_render_content_no_shortcode(b: &mut test::Bencher) {
         current_page_permalink,
         &permalinks_ctx,
         InsertAnchor::None,
+        Arc::new(Caches::default()),
     );
 
     b.iter(|| render_content(&content2, &context).unwrap());
@@ -159,6 +162,7 @@ fn bench_render_content_with_emoji(b: &mut test::Bencher) {
         current_page_permalink,
         &permalinks_ctx,
         InsertAnchor::None,
+        Arc::new(Caches::default()),
     );
 
     b.iter(|| render_content(&content2, &context).unwrap());

components/markdown/src/cache.rs

@@ -0,0 +1,105 @@
+use bincode;
+use dashmap::DashMap;
+use serde::{Deserialize, Serialize};
+use std::fs::{self, File, OpenOptions};
+use std::hash::Hash;
+
+use std::io::{self, Read, Write};
+use std::path::{Path, PathBuf};
+
+/// Generic cache using DashMap, storing data in a binary file
+#[derive(Debug)]
+pub struct GenericCache<K, V>
+where
+    K: Eq + Hash + Serialize + for<'de> Deserialize<'de>,
+    V: Serialize + for<'de> Deserialize<'de>,
+{
+    cache_file: PathBuf,
+    cache: DashMap<K, V>,
+}
+
+impl<K, V> GenericCache<K, V>
+where
+    K: Eq + Hash + Serialize + for<'de> Deserialize<'de>,
+    V: Serialize + for<'de> Deserialize<'de>,
+{
+    /// Get the directory where the cache is stored
+    pub fn dir(&self) -> &Path {
+        self.cache_file.parent().unwrap()
+    }
+
+    /// Create a new cache for a specific type
+    pub fn new(base_cache_dir: &Path, filename: &str) -> crate::Result<Self> {
+        // Create the base cache directory
+        fs::create_dir_all(base_cache_dir)?;
+
+        // Full path to the cache file
+        let cache_file = base_cache_dir.join(filename);
+
+        // Attempt to load existing cache
+        let cache = match Self::read_cache(&cache_file) {
+            Ok(loaded_cache) => {
+                println!("Loaded cache from {:?} ({:?})", cache_file, loaded_cache.len());
+                loaded_cache
+            }
+            Err(e) => {
+                println!("Failed to load cache: {}", e);
+                DashMap::new()
+            }
+        };
+
+        Ok(Self { cache_file, cache })
+    }
+
+    /// Read cache from file
+    fn read_cache(cache_file: &Path) -> io::Result<DashMap<K, V>> {
+        if !cache_file.exists() {
+            return Ok(DashMap::new());
+        }
+
+        let mut file = File::open(cache_file)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+
+        bincode::deserialize(&buffer).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    }
+
+    /// Write cache to file
+    pub fn write(&self) -> io::Result<()> {
+        let serialized = bincode::serialize(&self.cache)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        let mut file =
+            OpenOptions::new().write(true).create(true).truncate(true).open(&self.cache_file)?;
+
+        file.write_all(&serialized)?;
+        Ok(())
+    }
+
+    /// Get a reference to the underlying DashMap
+    pub fn inner(&self) -> &DashMap<K, V> {
+        &self.cache
+    }
+
+    pub fn get(&self, key: &K) -> Option<V>
+    where
+        V: Clone,
+    {
+        self.cache.get(key).map(|r| r.value().clone())
+    }
+
+    pub fn insert(&self, key: K, value: V) {
+        self.cache.insert(key, value);
+    }
+
+    /// Clear the cache and remove the file
+    pub fn clear(&self) -> crate::Result<()> {
+        self.cache.clear();
+
+        if self.cache_file.exists() {
+            fs::remove_file(&self.cache_file)?;
+        }
+
+        Ok(())
+    }
+}