getzola · cestef · Feb 7, 2025 · Feb 7, 2025 · Feb 7, 2025 · Feb 7, 2025
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/components/config/src/config/markup.rs b/components/config/src/config/markup.rs
@@ -1,11 +1,11 @@
-use std::{path::Path, sync::Arc};
+use std::{fmt, path::Path, sync::Arc};
 
 use libs::syntect::{
     highlighting::{Theme, ThemeSet},
     html::css_for_theme_with_class_style,
     parsing::{SyntaxSet, SyntaxSetBuilder},
 };
-use serde::{Deserialize, Serialize};
+use serde::{de, Deserialize, Deserializer, Serialize};
 
 use errors::{bail, Result};
 use utils::types::InsertAnchor;
@@ -23,6 +23,142 @@ pub struct ThemeCss {
     pub filename: String,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum MathRenderingEngine {
+    #[default]
+    None,
+    Typst,
+    Katex,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default, Hash)]
+#[serde(rename_all = "lowercase")]
+pub enum ImageFormat {
+    #[default]
+    Svg,
+    Webp,
+}
+
+struct BoolWithPathVisitor;
+
+impl<'de> de::Visitor<'de> for BoolWithPathVisitor {
+    type Value = BoolWithPath;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a boolean or string")
+    }
+
+    fn visit_bool<E>(self, value: bool) -> Result<BoolWithPath, E>
+    where
+        E: de::Error,
+    {
+        Ok(if value { BoolWithPath::True(None) } else { BoolWithPath::False })
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<BoolWithPath, E>
+    where
+        E: de::Error,
+    {
+        Ok(BoolWithPath::True(Some(value.to_string())))
+    }
+
+    fn visit_string<E>(self, value: String) -> Result<BoolWithPath, E>
+    where
+        E: de::Error,
+    {
+        Ok(BoolWithPath::True(Some(value)))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Default, Hash)]
+pub enum BoolWithPath {
+    #[default]
+    False,
+    True(Option<String>),
+}
+
+impl<'de> Deserialize<'de> for BoolWithPath {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_any(BoolWithPathVisitor)
+    }
+}
+
+impl Serialize for BoolWithPath {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            BoolWithPath::False => serializer.serialize_bool(false),
+            BoolWithPath::True(None) => serializer.serialize_bool(true),
+            BoolWithPath::True(Some(s)) => serializer.serialize_str(s),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Default)]
+pub struct MathRenderer {
+    pub engine: MathRenderingEngine,
+    pub svgo: BoolWithPath,
+    pub css: Option<String>,
+    pub addon: Option<String>,
+    pub format: ImageFormat,
+}
+
+impl<'de> Deserialize<'de> for MathRenderer {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // Helper struct that mirrors MathRenderer
+        #[derive(Deserialize)]
+        struct MathRendererHelper {
+            #[serde(default)]
+            engine: MathRenderingEngine,
+            #[serde(default)]
+            svgo: BoolWithPath,
+            css: Option<String>,
+            addon: Option<String>,
+            #[serde(default)]
+            format: ImageFormat,
+        }
+
+        #[derive(Deserialize)]
+        #[serde(untagged)]
+        enum MathRendererConfig {
+            // String case: math = "engine"
+            Engine(MathRenderingEngine),
+            // Table case with full configuration
+            Full(MathRendererHelper),
+        }
+
+        // Parse using the helper type
+        let config = MathRendererConfig::deserialize(deserializer)?;
+
+        // Convert to MathRenderer
+        match config {
+            MathRendererConfig::Engine(engine) => Ok(MathRenderer {
+                engine,
+                svgo: BoolWithPath::default(),
+                css: None,
+                addon: None,
+                format: ImageFormat::Svg,
+            }),
+            MathRendererConfig::Full(helper) => Ok(MathRenderer {
+                engine: helper.engine,
+                svgo: helper.svgo,
+                css: helper.css,
+                addon: helper.addon,
+                format: helper.format,
+            }),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(default)]
 pub struct Markdown {
@@ -67,6 +203,12 @@ pub struct Markdown {
     pub insert_anchor_links: InsertAnchor,
     /// Whether to enable GitHub-style alerts
     pub github_alerts: bool,
+    /// Whether to enable math rendering in markdown files
+    pub math: MathRenderer,
+    /// Whether to cache the rendered math
+    pub cache: BoolWithPath,
+    /// Whether to enable GitHub-style alerts
+    pub github_alerts: bool,
 }
 
 impl Markdown {
@@ -243,6 +385,9 @@ impl Default for Markdown {
             lazy_async_image: false,
             insert_anchor_links: InsertAnchor::None,
             github_alerts: false,
+            math: MathRenderer::default(),
+            cache: BoolWithPath::True(None),
+            github_alerts: false,
         }
     }
 }
diff --git a/components/config/src/highlighting.rs b/components/config/src/highlighting.rs
@@ -34,6 +34,17 @@ pub struct SyntaxAndTheme<'config> {
     pub source: HighlightSource,
 }
 
+impl Default for SyntaxAndTheme<'_> {
+    fn default() -> Self {
+        SyntaxAndTheme {
+            syntax: SYNTAX_SET.find_syntax_plain_text(),
+            syntax_set: &SYNTAX_SET as &SyntaxSet,
+            theme: None,
+            source: HighlightSource::Plain,
+        }
+    }
+}
+
 pub fn resolve_syntax_and_theme<'config>(
     language: Option<&'_ str>,
     config: &'config Config,

diff --git a/components/config/src/lib.rs b/components/config/src/lib.rs
@@ -8,6 +8,7 @@ pub use crate::config::{
     languages::LanguageOptions,
     link_checker::LinkChecker,
     link_checker::LinkCheckerLevel,
+    markup::{BoolWithPath, ImageFormat, MathRenderingEngine},
     search::{IndexFormat, Search},
     slugify::Slugify,
     taxonomies::TaxonomyConfig,

diff --git a/components/content/src/page.rs b/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: Option<Arc<Caches>>,
     ) -> Result<()> {
         let mut context = RenderContext::new(
             tera,
@@ -220,9 +224,16 @@ 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,
+            self.file.colocated_path.as_ref(),
+            &self.file.components,
+        );
+
         context.tera_context.insert("page", &SerializingPage::new(self, None, false));
 
         let res = render_content(&self.raw_content, &context)
@@ -330,6 +341,7 @@ Hello world"#;
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            None,
         )
         .unwrap();
 
@@ -358,6 +370,7 @@ Hello world"#;
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            None,
         )
         .unwrap();
 
@@ -528,6 +541,7 @@ Hello world
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            None,
         )
         .unwrap();
         assert_eq!(page.summary, Some("<p>Hello world</p>".to_string()));
@@ -562,6 +576,7 @@ And here's another. [^3]
             &config,
             InsertAnchor::None,
             &HashMap::new(),
+            None,
         )
         .unwrap();
         assert_eq!(

diff --git a/components/content/src/section.rs b/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: Option<Arc<Caches>>,
     ) -> Result<()> {
         let mut context = RenderContext::new(
             tera,
@@ -158,9 +161,15 @@ 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,
+            self.file.colocated_path.as_ref(),
+            &self.components,
+        );
         context
             .tera_context
             .insert("section", &SerializingSection::new(self, SectionSerMode::ForMarkdown));

diff --git a/components/markdown/Cargo.toml b/components/markdown/Cargo.toml
@@ -14,6 +14,21 @@ config = { path = "../config" }
 console = { path = "../console" }
 libs = { path = "../libs" }
 
+typst = "0.13.1"
+typst-assets = { version = "0.13.1", features = ["fonts"] }
+typst-svg = "0.13.1"
+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"
diff --git a/components/markdown/benches/all.rs b/components/markdown/benches/all.rs
@@ -95,6 +95,7 @@ fn bench_render_content_with_highlighting(b: &mut test::Bencher) {
         current_page_permalink,
         &permalinks_ctx,
         InsertAnchor::None,
+        None,
     );
     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,
+        None,
     );
     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,
+        None,
     );
 
     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,
+        None,
     );
 
     b.iter(|| render_content(&content2, &context).unwrap());