feat(markdown): math rendering with typst

Author: cestef

Diff for: Cargo.lock

@@ -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,15 @@ 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>,
+    /// Whether to enable automatic dark mode switching based on "prefers-color-scheme" for math
+    /// Injected CSS path for light mode
+    pub math_css: Option<String>,
 }
 
 impl Markdown {
@@ -240,6 +258,10 @@ 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,
         }
     }
 }

Diff for: components/config/src/config/markup.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,

Diff for: components/config/src/lib.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!(

Diff for: components/content/src/page.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));

Diff for: components/content/src/section.rs

@@ -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"
@@ -21,14 +36,19 @@ nom-bibtex = "0.5"
 num-format = "0.4"
 once_cell = "1"
 percent-encoding = "2"
-pulldown-cmark = { version = "0.12.2", default-features = false, features = ["html", "simd"] }
+pulldown-cmark = { version = "0.12.2", default-features = false, features = [
+    "html",
+    "simd",
+] }
 pulldown-cmark-escape = { version = "0.11", default-features = false }
 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"

Diff for: components/libs/Cargo.toml

@@ -14,6 +14,18 @@ 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"
 [dev-dependencies]
 templates = { path = "../templates" }
 insta = "1.12.0"

Diff for: components/markdown/Cargo.toml

@@ -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());

Diff for: components/markdown/benches/all.rs

@@ -0,0 +1,100 @@
+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>,
+{
+    /// 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(())
+    }
+}

Diff for: components/markdown/src/cache.rs

@@ -85,7 +85,7 @@ pub struct CodeBlock<'config> {
 
 impl<'config> CodeBlock<'config> {
     pub fn new<'fence_info>(
-        fence: FenceSettings<'fence_info>,
+        fence: &FenceSettings<'fence_info>,
         config: &'config Config,
         // path to the current file if there is one, to point where the error is
         path: Option<&'config str>,
@@ -118,8 +118,8 @@ impl<'config> CodeBlock<'config> {
                 highlighter,
                 line_numbers: fence.line_numbers,
                 line_number_start: fence.line_number_start,
-                highlight_lines: fence.highlight_lines,
-                hide_lines: fence.hide_lines,
+                highlight_lines: fence.highlight_lines.clone(),
+                hide_lines: fence.hide_lines.clone(),
             },
             html_start,
         ))