katex-parser 0.1.0

A port of the KaTeX parser: lexing and parsing LaTeX math expressions with macro expansion into a typed AST, plus a Unicode rendering backend
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::ast::ParseNode;
use crate::error::ParseError;
use crate::function_registry::{ArgType, FunctionContext, FunctionParser, FunctionSpec};

use super::{normalize_argument, require_function_arg};

pub(crate) fn accent_spec() -> FunctionSpec {
    FunctionSpec {
        names: vec![
            "\\acute".to_string(),
            "\\grave".to_string(),
            "\\ddot".to_string(),
            "\\tilde".to_string(),
            "\\bar".to_string(),
            "\\breve".to_string(),
            "\\check".to_string(),
            "\\hat".to_string(),
            "\\vec".to_string(),
            "\\dot".to_string(),
            "\\mathring".to_string(),
            "\\widecheck".to_string(),
            "\\widehat".to_string(),
            "\\widetilde".to_string(),
            "\\overrightarrow".to_string(),
            "\\overleftarrow".to_string(),
            "\\Overrightarrow".to_string(),
            "\\overleftrightarrow".to_string(),
            "\\overgroup".to_string(),
            "\\overlinesegment".to_string(),
            "\\overleftharpoon".to_string(),
            "\\overrightharpoon".to_string(),
        ],
        num_args: 1,
        handler: Some(accent_handler),
        ..Default::default()
    }
}

fn is_non_stretchy_accent(func_name: &str) -> bool {
    matches!(
        func_name,
        "\\acute"
            | "\\grave"
            | "\\ddot"
            | "\\tilde"
            | "\\bar"
            | "\\breve"
            | "\\check"
            | "\\hat"
            | "\\vec"
            | "\\dot"
            | "\\mathring"
    )
}

fn accent_handler(
    _parser: &mut dyn FunctionParser,
    context: &FunctionContext,
    args: &[ParseNode],
    _opt_args: &[Option<ParseNode>],
) -> Result<ParseNode, ParseError> {
    let is_stretchy = !is_non_stretchy_accent(&context.func_name);
    Ok(ParseNode::Accent {
        mode: context.mode,
        loc: None,
        label: context.func_name.clone(),
        is_stretchy,
        is_shifty: !is_stretchy
            || context.func_name == "\\widehat"
            || context.func_name == "\\widetilde"
            || context.func_name == "\\widecheck",
        base: Box::new(normalize_argument(require_function_arg(
            args,
            0,
            &context.func_name,
        )?)),
    })
}

pub(crate) fn text_accent_spec() -> FunctionSpec {
    FunctionSpec {
        names: vec![
            "\\'".to_string(),
            "\\`".to_string(),
            "\\^".to_string(),
            "\\~".to_string(),
            "\\=".to_string(),
            "\\u".to_string(),
            "\\.".to_string(),
            "\\\"".to_string(),
            "\\c".to_string(),
            "\\r".to_string(),
            "\\H".to_string(),
            "\\v".to_string(),
            "\\textcircled".to_string(),
        ],
        num_args: 1,
        arg_types: vec![ArgType::PrimitiveArg],
        allowed_in_text: true,
        handler: Some(text_accent_handler),
        ..Default::default()
    }
}

fn text_accent_handler(
    parser: &mut dyn FunctionParser,
    context: &FunctionContext,
    args: &[ParseNode],
    _opt_args: &[Option<ParseNode>],
) -> Result<ParseNode, ParseError> {
    let mode = if context.mode == crate::ast::Mode::Math {
        parser.report_nonstrict(
            "mathVsTextAccents",
            &format!(
                "LaTeX's accent {} works only in text mode",
                context.func_name
            ),
            context.token.as_ref(),
        )?;
        crate::ast::Mode::Text
    } else {
        context.mode
    };
    Ok(ParseNode::Accent {
        mode,
        loc: None,
        label: context.func_name.clone(),
        is_stretchy: false,
        is_shifty: true,
        base: Box::new(require_function_arg(args, 0, &context.func_name)?),
    })
}