typst-0.3.2.0: test/out/math/delimited-02.out

--- parse tree ---
[ Code
    "test/typ/math/delimited-02.typ"
    ( line 1 , column 2 )
    (Let
       (BasicBind (Just (Identifier "test")))
       (FuncExpr
          [ NormalParam (Identifier "x") , NormalParam (Identifier "y") ]
          (Block
             (CodeBlock
                [ If
                    [ ( Equals (Ident (Identifier "x")) (Ident (Identifier "y"))
                      , Block (Content [ Text "\9989" ])
                      )
                    , ( Literal (Boolean True)
                      , Block
                          (Content
                             [ Text "\10060"
                             , Text "("
                             , Code
                                 "test/typ/math/delimited-02.typ"
                                 ( line 1 , column 47 )
                                 (FuncCall
                                    (Ident (Identifier "repr"))
                                    [ NormalArg (Ident (Identifier "x")) ])
                             , Space
                             , Text "/"
                             , Text "="
                             , Space
                             , Code
                                 "test/typ/math/delimited-02.typ"
                                 ( line 1 , column 59 )
                                 (FuncCall
                                    (Ident (Identifier "repr"))
                                    [ NormalArg (Ident (Identifier "y")) ])
                             , Text ")"
                             ])
                      )
                    ]
                ]))))
, SoftBreak
, Comment
, Equation
    True
    [ MGroup
        (Just "[")
        (Just "]")
        [ MGroup (Just "|") (Just "|") [ MFrac (Text "a") (Text "b") ] ]
    , Code
        "test/typ/math/delimited-02.typ"
        ( line 3 , column 11 )
        (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
    , Code
        "test/typ/math/delimited-02.typ"
        ( line 3 , column 14 )
        (FuncCall
           (Ident (Identifier "lr"))
           [ BlockArg
               [ MGroup
                   (Just "|") (Just "|") [ Text "]" , MFrac (Text "a") (Text "b") ]
               , Text "]"
               ]
           ])
    , Code
        "test/typ/math/delimited-02.typ"
        ( line 3 , column 26 )
        (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
    , MGroup
        (Just "[") Nothing [ MFrac (Text "a") (Text "b") , Text ")" ]
    ]
, SoftBreak
, Equation
    True
    [ Code
        "test/typ/math/delimited-02.typ"
        ( line 4 , column 3 )
        (FuncCall
           (Ident (Identifier "lr"))
           [ BlockArg
               [ MGroup
                   (Just "|")
                   (Just "|")
                   [ Text "]"
                   , Text "1"
                   , Text ","
                   , Text "2"
                   , Text "["
                   , Text "+"
                   , MFrac (Text "1") (Text "2")
                   ]
               ]
           ])
    ]
, ParBreak
]
--- evaluated ---
{ text(body: [
]), 
  math.equation(block: true, 
                body: { math.lr(body: ({ [[], 
                                         math.lr(body: ({ [|], 
                                                          math.frac(denom: text(body: [b]), 
                                                                    num: text(body: [a])), 
                                                          [|] })), 
                                         []] })), 
                        text(body: [≠]), 
                        math.lr(body: ({ math.lr(body: ({ [|], 
                                                          text(body: []]), 
                                                          math.frac(denom: text(body: [b]), 
                                                                    num: text(body: [a])), 
                                                          [|] })), 
                                         text(body: []]) })), 
                        text(body: [≠]), 
                        text(body: [[]), 
                        math.frac(denom: text(body: [b]), 
                                  num: text(body: [a])), 
                        text(body: [)]) }, 
                numbering: none), 
  text(body: [
]), 
  math.equation(block: true, 
                body: math.lr(body: (math.lr(body: ({ [|], 
                                                      text(body: []]), 
                                                      text(body: [1]), 
                                                      text(body: [,]), 
                                                      text(body: [2]), 
                                                      text(body: [[]), 
                                                      text(body: [+]), 
                                                      math.frac(denom: text(body: [2]), 
                                                                num: text(body: [1])), 
                                                      [|] })))), 
                numbering: none), 
  parbreak() }