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

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

use super::require_function_arg;

fn environment_name(arg: &ParseNode) -> Result<String, ParseError> {
    let body = match arg {
        ParseNode::OrdGroup { body, .. } => body,
        _ => {
            return Err(ParseError::InvalidArgument {
                message: "Invalid environment name".to_string(),
                loc: None,
            })
        }
    };
    let mut builder = String::new();
    for node in body {
        match node {
            ParseNode::TextOrd { text, .. } => builder.push_str(text),
            _ => {
                return Err(ParseError::InvalidArgument {
                    message: "Invalid environment name".to_string(),
                    loc: None,
                })
            }
        }
    }
    Ok(builder)
}

pub(crate) fn begin_end_spec() -> FunctionSpec {
    FunctionSpec {
        names: vec!["\\begin".to_string(), "\\end".to_string()],
        num_args: 1,
        arg_types: vec![ArgType::TextArg],
        handler: Some(environment_handler),
        ..Default::default()
    }
}

fn environment_handler(
    parser: &mut dyn FunctionParser,
    context: &FunctionContext,
    args: &[ParseNode],
    _opt_args: &[Option<ParseNode>],
) -> Result<ParseNode, ParseError> {
    let name = environment_name(&require_function_arg(args, 0, &context.func_name)?)?;
    if context.func_name == "\\begin" {
        parser.parse_environment(&name)
    } else {
        Ok(ParseNode::EnvironmentEnd {
            mode: context.mode,
            name,
        })
    }
}

pub(crate) fn hline_spec() -> FunctionSpec {
    FunctionSpec {
        names: vec!["\\hline".to_string(), "\\hdashline".to_string()],
        allowed_in_text: true,
        handler: Some(hline_handler),
        ..Default::default()
    }
}

fn hline_handler(
    _parser: &mut dyn FunctionParser,
    context: &FunctionContext,
    _args: &[ParseNode],
    _opt_args: &[Option<ParseNode>],
) -> Result<ParseNode, ParseError> {
    Err(ParseError::InvalidArgument {
        message: format!("{} valid only within array environment", context.func_name),
        loc: None,
    })
}