katex-rs 0.2.4

A Rust implementation of KaTeX - Fast math typesetting for anywhere, more than just the web.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Ordgroup function implementations for KaTeX Rust
//!
//! This module handles ordered groups of mathematical expressions,
//! migrated from KaTeX's ordgroup.js.

use crate::build_common::make_span;
use crate::define_function::{FunctionDefSpec, FunctionPropSpec};
use crate::dom_tree::HtmlDomNode;
use crate::mathml_tree::MathDomNode;
use crate::options::Options;
use crate::parser::parse_node::{AnyParseNode, NodeType, ParseNodeOrdGroup};
use crate::types::{ParseError, ParseErrorKind};
use crate::{KatexContext, build_html, build_mathml, make_fragment};

/// Registers ordgroup functions in the KaTeX context
pub fn define_ordgroup(ctx: &mut KatexContext) {
    ctx.define_function(FunctionDefSpec {
        node_type: Some(NodeType::OrdGroup),
        names: &["ordgroup"],
        props: FunctionPropSpec::default(),
        handler: Some(|context, args, _opt_args| {
            let body = args[0].clone();
            let semisimple = context.func_name == "ordgroup"; // For now, assume ordgroup is semisimple

            Ok(AnyParseNode::OrdGroup(ParseNodeOrdGroup {
                mode: context.parser.mode,
                loc: context.loc(),
                body: vec![body],
                semisimple: Some(semisimple),
            }))
        }),
        html_builder: Some(html_builder),
        mathml_builder: Some(mathml_builder),
    });
}

/// HTML builder for ordgroup nodes
fn html_builder(
    node: &AnyParseNode,
    options: &Options,
    ctx: &KatexContext,
) -> Result<HtmlDomNode, ParseError> {
    let AnyParseNode::OrdGroup(group) = node else {
        return Err(ParseError::new(ParseErrorKind::ExpectedNode {
            node: NodeType::OrdGroup,
        }));
    };

    if group.semisimple.unwrap_or(false) {
        let body = build_html::build_expression(
            ctx,
            &group.body,
            options,
            build_html::GroupType::False,
            (None, None),
        )?;
        Ok(make_fragment(body).into())
    } else {
        // Use makeSpan with "mord" class
        let body = build_html::build_expression(
            ctx,
            &group.body,
            options,
            build_html::GroupType::True,
            (None, None),
        )?;
        let span = make_span("mord", body, Some(options), None);
        Ok(span.into())
    }
}

/// MathML builder for ordgroup nodes
fn mathml_builder(
    node: &AnyParseNode,
    options: &Options,
    ctx: &KatexContext,
) -> Result<MathDomNode, ParseError> {
    let AnyParseNode::OrdGroup(group) = node else {
        return Err(ParseError::new(ParseErrorKind::ExpectedNode {
            node: NodeType::OrdGroup,
        }));
    };

    let body = build_mathml::build_expression_row(ctx, &group.body, options, Some(true))?;
    Ok(body)
}